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.BiObjDoubleToByteFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjDoubleToByteFunction}. 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 av a 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 BiObjDoubleToByteFunction}. * @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 BiObjDoubleToByteFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Double>, Byte> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjDoubleToByteFunction<T, U> & Memoized) (t, u, value) -> { final byte returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsByte(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjByteToFloatFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjByteToFloatFunction}. 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 ww . ja v a2 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 BiObjByteToFloatFunction}. * @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 BiObjByteToFloatFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Byte>, Float> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjByteToFloatFunction<T, U> & Memoized) (t, u, value) -> { final float returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsFloat(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjByteToShortFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjByteToShortFunction}. 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 . jav a 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 BiObjByteToShortFunction}. * @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 BiObjByteToShortFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Byte>, Short> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjByteToShortFunction<T, U> & Memoized) (t, u, value) -> { final short returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsShort(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjDoubleToCharFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjDoubleToCharFunction}. 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 av a 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 BiObjDoubleToCharFunction}. * @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 BiObjDoubleToCharFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Double>, Character> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjDoubleToCharFunction<T, U> & Memoized) (t, u, value) -> { final char returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsChar(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjCharToFloatFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjCharToFloatFunction}. 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 va2 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 BiObjCharToFloatFunction}. * @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 BiObjCharToFloatFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Character>, Float> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjCharToFloatFunction<T, U> & Memoized) (t, u, value) -> { final float returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsFloat(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjCharToShortFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjCharToShortFunction}. 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 www . j a va2 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 BiObjCharToShortFunction}. * @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 BiObjCharToShortFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Character>, Short> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjCharToShortFunction<T, U> & Memoized) (t, u, value) -> { final short returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsShort(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjBooleanToFloatFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjBooleanToFloatFunction}. 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 ww.ja v a 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 BiObjBooleanToFloatFunction}. * @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 BiObjBooleanToFloatFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Boolean>, Float> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjBooleanToFloatFunction<T, U> & Memoized) (t, u, value) -> { final float returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsFloat(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjBooleanToShortFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjBooleanToShortFunction}. 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 www . j a v a 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 BiObjBooleanToShortFunction}. * @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 BiObjBooleanToShortFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Boolean>, Short> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjBooleanToShortFunction<T, U> & Memoized) (t, u, value) -> { final short returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsShort(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjIntToDoubleFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjIntToDoubleFunction}. 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 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 BiObjIntToDoubleFunction}. * @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 BiObjIntToDoubleFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Integer>, Double> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjIntToDoubleFunction<T, U> & Memoized) (t, u, value) -> { final double returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsDouble(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjDoubleToLongFunction.java
/** * Returns a memoized (caching) version of this {@link BiObjDoubleToLongFunction}. 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 www . j ava2 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 BiObjDoubleToLongFunction}. * @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 BiObjDoubleToLongFunction<T, U> memoized() { if (isMemoized()) { return this; } else { final Map<Triple<T, U, Double>, Long> cache = new ConcurrentHashMap<>(); final Object lock = new Object(); return (BiObjDoubleToLongFunction<T, U> & Memoized) (t, u, value) -> { final long returnValue; synchronized (lock) { returnValue = cache.computeIfAbsent(Triple.of(t, u, value), key -> applyAsLong(key.getLeft(), key.getMiddle(), key.getRight())); } return returnValue; }; } }