List of usage examples for org.apache.commons.lang3.tuple Triple of
public static <L, M, R> Triple<L, M, R> of(final L left, final M middle, final R right)
Obtains an immutable triple of from three objects inferring the generic types.
This factory allows the triple to be created using inference to obtain the generic types.
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiFloatToCharFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiFloatToCharFunction}. Whenever it is called, the mapping * between the input parameters and the return value is preserved in a cache, making subsequent calls returning the * memoized value instead of computing the return value again. * <p>/*from ww w . j a va 2 s .com*/ * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiFloatToCharFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiFloatToCharFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Float, Float>, Character> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiFloatToCharFunction<T> & Memoized) (t, value1, value2) -> { final char returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsChar(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiShortToCharFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiShortToCharFunction}. Whenever it is called, the mapping * between the input parameters and the return value is preserved in a cache, making subsequent calls returning the * memoized value instead of computing the return value again. * <p>/* ww w . j a v a 2 s . com*/ * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiShortToCharFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiShortToCharFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Short, Short>, Character> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiShortToCharFunction<T> & Memoized) (t, value1, value2) -> { final char returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsChar(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiByteToFloatFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiByteToFloatFunction}. Whenever it is called, the mapping * between the input parameters and the return value is preserved in a cache, making subsequent calls returning the * memoized value instead of computing the return value again. * <p>/*w w w . ja va 2s . c om*/ * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiByteToFloatFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiByteToFloatFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Byte, Byte>, Float> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiByteToFloatFunction<T> & Memoized) (t, value1, value2) -> { final float returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsFloat(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiByteToShortFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiByteToShortFunction}. Whenever it is called, the mapping * between the input parameters and the return value is preserved in a cache, making subsequent calls returning the * memoized value instead of computing the return value again. * <p>/*from w w w . j a va 2 s. c o m*/ * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiByteToShortFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiByteToShortFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Byte, Byte>, Short> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiByteToShortFunction<T> & Memoized) (t, value1, value2) -> { final short returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsShort(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiCharToFloatFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiCharToFloatFunction}. Whenever it is called, the mapping * between the input parameters and the return value is preserved in a cache, making subsequent calls returning the * memoized value instead of computing the return value again. * <p>// ww w .ja v a 2 s . c om * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiCharToFloatFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiCharToFloatFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Character, Character>, Float> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiCharToFloatFunction<T> & Memoized) (t, value1, value2) -> { final float returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsFloat(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiCharToShortFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiCharToShortFunction}. Whenever it is called, the mapping * between the input parameters and the return value is preserved in a cache, making subsequent calls returning the * memoized value instead of computing the return value again. * <p>//from ww w . j ava2 s. co m * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiCharToShortFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiCharToShortFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Character, Character>, Short> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiCharToShortFunction<T> & Memoized) (t, value1, value2) -> { final short returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsShort(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.operator.ternary.ThrowableCharTernaryOperator.java
/** * Returns a memoized (caching) version of this {@link ThrowableCharTernaryOperator}. Whenever it is called, the * mapping between the input parameters and the return value is preserved in a cache, making subsequent calls * returning the memoized value instead of computing the return value again. * <p>/*from ww w. j av a 2s.c o m*/ * Unless the operator and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ThrowableCharTernaryOperator}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized operator, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized operator can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ThrowableCharTernaryOperator<X> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<Character, Character, Character>, Character> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ThrowableCharTernaryOperator<X> & Memoized) (value1, value2, value3) -> { final char returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(value1, value2, value3), ThrowableFunction .of(key -> applyAsCharThrows(key.getLeft(), key.getMiddle(), key.getRight()))); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiDoubleToByteFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiDoubleToByteFunction}. Whenever it is called, the * mapping between the input parameters and the return value is preserved in a cache, making subsequent calls * returning the memoized value instead of computing the return value again. * <p>//ww w . j a va 2 s. c o m * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiDoubleToByteFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiDoubleToByteFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Double, Double>, Byte> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiDoubleToByteFunction<T> & Memoized) (t, value1, value2) -> { final byte returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsByte(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiDoubleToCharFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiDoubleToCharFunction}. Whenever it is called, the * mapping between the input parameters and the return value is preserved in a cache, making subsequent calls * returning the memoized value instead of computing the return value again. * <p>/* ww w .ja v a2 s. c om*/ * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiDoubleToCharFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiDoubleToCharFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Double, Double>, Character> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiDoubleToCharFunction<T> & Memoized) (t, value1, value2) -> { final char returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsChar(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiBooleanToDoubleFunction.java
/** * Returns a memoized (caching) version of this {@link ObjBiBooleanToDoubleFunction}. Whenever it is called, the * mapping between the input parameters and the return value is preserved in a cache, making subsequent calls * returning the memoized value instead of computing the return value again. * <p>//from w w w. ja va 2 s . c o m * Unless the function and therefore the used cache will be garbage-collected, it will keep all memoized values * forever. * * @return A memoized (caching) version of this {@code ObjBiBooleanToDoubleFunction}. * @implSpec This implementation does not allow the input parameters or return value to be {@code null} for the * resulting memoized function, as the cache used internally does not permit {@code null} keys or values. * @implNote The returned memoized function can be safely used concurrently from multiple threads which makes it * thread-safe. */ @Nonnull default ObjBiBooleanToDoubleFunction<T> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, Boolean, Boolean>, Double> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (ObjBiBooleanToDoubleFunction<T> & Memoized) (t, value1, value2) -> { final double returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, value1, value2), key -> applyAsDouble(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }