Uses of Interface
eu.lunisolar.magma.func.predicate.LTriPredicate

Packages that use LTriPredicate

Package	Description
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.ternary
eu.lunisolar.magma.func.predicate

Uses of LTriPredicate in eu.lunisolar.magma.func.function

Methods in eu.lunisolar.magma.func.function that return LTriPredicate

Modifier and Type	Method and Description
default LTriPredicate<T1,T2,T3>	LTriFunction.thenToBool(LPredicate<? super R> after) Combines two functions together in a order.

Uses of LTriPredicate in eu.lunisolar.magma.func.function.to

Methods in eu.lunisolar.magma.func.function.to that return LTriPredicate

Modifier and Type	Method and Description
default LTriPredicate<T1,T2,T3>	LToIntTriFunction.thenToBool(LIntPredicate after) Combines two functions together in a order.

Uses of LTriPredicate in eu.lunisolar.magma.func.operator.ternary

Methods in eu.lunisolar.magma.func.operator.ternary that return LTriPredicate

Modifier and Type	Method and Description
static <V1,V2,V3> LTriPredicate<V1,V2,V3>	LLogicalTernaryOperator.composed(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3, LLogicalTernaryOperator after)
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LLogicalTernaryOperator.logicalTernaryOpCompose(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default LTriPredicate<T,T,T>	LTernaryOperator.thenToBool(LPredicate<? super T> after) Combines two functions together in a order.

Uses of LTriPredicate in eu.lunisolar.magma.func.predicate

Subinterfaces of LTriPredicate in eu.lunisolar.magma.func.predicate

Modifier and Type	Interface and Description
static interface	LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> Permutation of LTriPredicate for method references.
static interface	LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> Permutation of LTriPredicate for method references.
static interface	LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> Permutation of LTriPredicate for method references.
static interface	LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> Permutation of LTriPredicate for method references.
static interface	LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> Permutation of LTriPredicate for method references.

Classes in eu.lunisolar.magma.func.predicate that implement LTriPredicate

Modifier and Type	Class and Description
static class	LTriPredicate.LTriPredicateSingle<T1,T2,T3>

Methods in eu.lunisolar.magma.func.predicate that return LTriPredicate

Modifier and Type	Method and Description
default LTriPredicate<T1,T2,T3>	LTriPredicate.and(LTriPredicate<? super T1,? super T2,? super T3> other) Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBoolPredicate.biObjBoolPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.biObjBytePredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjCharPredicate.biObjCharPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.biObjDblPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.biObjFltPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjIntPredicate.biObjIntPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.biObjLongPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.biObjSrtPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LTriPredicate<T1,T2,T3>	LTriPredicate.boolToTriPred(LLogicalOperator after) Combines two functions together in a order.
default <V2,V3,V4> LTriPredicate<V2,V3,V4>	LTriPredicate.cast() Cast that replace generics.
static <V2,V3,V4,T1,T2,T3> LTriPredicate<V2,V3,V4>	LTriPredicate.cast(LTriPredicate<T1,T2,T3> function) Cast that replace generics.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LTriPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntBoolPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LObjIntBoolPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntBytePredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LObjIntBytePredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntCharPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LObjIntCharPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntDblPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LObjIntDblPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntFltPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LObjIntFltPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjBiIntPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LObjBiIntPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntLongPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LObjIntLongPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3, LObjIntSrtPredicate<T> after)
static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3>	LTriPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriPredicate<T1,T2,T3> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBoolPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjBytePredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjBytePredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjCharPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjIntPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjLongPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjSrtPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtPredicate<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LObjIntObjPredicate.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LObjIntObjPredicate<T1,T2> after)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.constant(boolean r) Creates function that always returns the same value.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.failSafe(LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)
default LTriPredicate<T1,T2,T3>	LTriPredicate.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.isEqual(T1 v1, T2 v2, T3 v3) Creates predicate that evaluates if an object is equal with the argument one.
default LTriPredicate<T1,T2,T3>	LTriPredicate.negate() Returns a predicate that represents the logical negation of this predicate.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjBiIntPredicate.objBiIntPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntBoolPredicate.objIntBoolPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntBytePredicate.objIntBytePredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntCharPredicate.objIntCharPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntDblPredicate.objIntDblPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntFltPredicate.objIntFltPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntLongPredicate.objIntLongPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntObjPredicate.objIntObjPredCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntSrtPredicate.objIntSrtPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LTriPredicate<T1,T2,T3>	LTriPredicate.or(LTriPredicate<? super T1,? super T2,? super T3> other) Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.recursive(LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.safe() Safe instance.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.safe(LTriPredicate<T1,T2,T3> other) Safe wrapping.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.test1st(LPredicate<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.test2nd(LPredicate<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.test3rd(LPredicate<T3> func) Captures single parameter function into this interface where only 3rd parameter will be used.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.triPred(LTriPredicate<T1,T2,T3> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.triPredThrowing(ExF<Throwable> exF)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.triPredThrowing(String message, ExMF<Throwable> exF)
default LTriPredicate<T1,T2,T3>	LTriPredicate.trying(ExWF<RuntimeException> exF)
default LTriPredicate<T1,T2,T3>	LTriPredicate.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LTriPredicate<T1,T2,T3>	LTriPredicate.tryingThen(LPredicate<Throwable> handler)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func)
default LTriPredicate	LTriPredicate.untyped() Cast that removes generics.
LTriPredicate<T1,T2,T3>	LTriPredicate.LTriPredicateSingle.value()
default LTriPredicate<T1,T2,T3>	LTriPredicate.xor(LTriPredicate<? super T1,? super T2,? super T3> other) Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

Methods in eu.lunisolar.magma.func.predicate that return types with arguments of type LTriPredicate

Modifier and Type	Method and Description
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>>	LTriPredicate.safeSupplier() Safe instance supplier.
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>>	LTriPredicate.safeSupplier(LSupplier<LTriPredicate<T1,T2,T3>> supplier) Safe supplier.

Methods in eu.lunisolar.magma.func.predicate with parameters of type LTriPredicate

Modifier and Type	Method and Description
default LTriPredicate<T1,T2,T3>	LTriPredicate.and(LTriPredicate<? super T1,? super T2,? super T3> other) Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
static <T1,T2,T3> boolean	LTriPredicate.call(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> lambda)
static <V2,V3,V4,T1,T2,T3> LTriPredicate<V2,V3,V4>	LTriPredicate.cast(LTriPredicate<T1,T2,T3> function) Cast that replace generics.
static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3>	LTriPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriPredicate<T1,T2,T3> after)
static <T1,T2,T3> boolean	LTriPredicate.doIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> predicate, LAction action)
static <T1,T2,T3> boolean	LTriPredicate.doIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> predicate, LTriConsumer<? super T1,? super T2,? super T3> consumer)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.failSafe(LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.failSafe(LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)
default boolean	LTriPredicate.failSafeTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> boolean	LTriPredicate.failSafeTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> boolean	LTriPredicate.failSafeTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> void	LTriPredicate.fromTill(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func) From-To.
static <T1,T2,T3> void	LTriPredicate.fromTo(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func) From-To.
static <T1,T2,T3> boolean	LTriPredicate.handlingTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T2,T3,T1> LBiPredicate<T2,T3>	LTriPredicate.lShrinked(LBiFunction<T2,T3,T1> left, LTriPredicate<T1,T2,T3> func)
static <T2,T3,T1> LBiPredicate<T2,T3>	LTriPredicate.lShrinkedc(T1 a1, LTriPredicate<T1,T2,T3> func)
default LTriPredicate<T1,T2,T3>	LTriPredicate.or(LTriPredicate<? super T1,? super T2,? super T3> other) Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
static <T1,T2,T3> LBiPredicate<T1,T2>	LTriPredicate.rShrinked(LBiFunction<T1,T2,T3> right, LTriPredicate<T1,T2,T3> func)
static <T1,T2,T3> LBiPredicate<T1,T2>	LTriPredicate.rShrinkedc(T3 a3, LTriPredicate<T1,T2,T3> func)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.safe(LTriPredicate<T1,T2,T3> other) Safe wrapping.
static <T1,T2,T3> void	LTriPredicate.throwIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)
static <T1,T2,T3> void	LTriPredicate.throwIfNot(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)
static <T1,T2,T3> void	LTriPredicate.times(int max_i, T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func) From-To.
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.triPred(LTriPredicate<T1,T2,T3> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2,T3> boolean	LTriPredicate.tryTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func)
static <T1,T2,T3> boolean	LTriPredicate.tryTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, ExWF<RuntimeException> exF)
static <T1,T2,T3> boolean	LTriPredicate.tryTest(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2,T3> boolean	LTriPredicate.tryTestThen(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> func, LPredicate<Throwable> handler)
default LTriPredicate<T1,T2,T3>	LTriPredicate.xor(LTriPredicate<? super T1,? super T2,? super T3> other) Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

Method parameters in eu.lunisolar.magma.func.predicate with type arguments of type LTriPredicate

Modifier and Type	Method and Description
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.recursive(LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)
static <T1,T2,T3> LTriPredicate<T1,T2,T3>	LTriPredicate.recursive(LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>>	LTriPredicate.safeSupplier(LSupplier<LTriPredicate<T1,T2,T3>> supplier) Safe supplier.