@FunctionalInterface public interface LTriPredicate<T1,T2,T3> extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain3<aType.a<T1>,aType.a<T2>,aType.a<T3>>
Non-throwing functional interface (lambda) LTriPredicate for Java 8.
Type: predicate
Domain (lvl: 3): T1 a1,T2 a2,T3 a3
Co-domain: boolean
| 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.
|
static class |
LTriPredicate.LTriPredicateSingle<T1,T2,T3> |
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
| Modifier and Type | Method and Description |
|---|---|
static <T1,T2,T3> boolean |
alwaysFalse(T1 a1,
T2 a2,
T3 a3)
Returns FALSE.
|
static <T1,T2,T3> boolean |
alwaysTrue(T1 a1,
T2 a2,
T3 a3)
Returns TRUE.
|
default LTriPredicate<T1,T2,T3> |
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 <T3,T2,T1> LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> |
biObj1Obj0Pred(LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default LToIntTriFunction<T1,T2,T3> |
boolToToIntTriFunc(LBoolToIntFunction after)
Combines two functions together in a order.
|
default <V> LTriFunction<T1,T2,T3,V> |
boolToTriFunc(LBoolFunction<? extends V> after)
Combines two functions together in a order.
|
default LTriPredicate<T1,T2,T3> |
boolToTriPred(LLogicalOperator after)
Combines two functions together in a order.
|
static <T1,T2,T3> boolean |
call(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> lambda) |
default LBoolSupplier |
capture(T1 a1,
T2 a2,
T3 a3)
Captures arguments but delays the evaluation.
|
default <V2,V3,V4> LTriPredicate<V2,V3,V4> |
cast()
Cast that replace generics.
|
static <V2,V3,V4,T1,T2,T3> |
cast(LTriPredicate<T1,T2,T3> function)
Cast that replace generics.
|
default <V1,V2,V3> LTriPredicate<V1,V2,V3> |
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,T1,T2,T3> |
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> LTriPredicate<T1,T2,T3> |
constant(boolean r)
Creates function that always returns the same value.
|
default boolean |
doApplyAsBoolean(T1 a1,
T2 a2,
T3 a3)
For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
|
default boolean |
doIf(T1 a1,
T2 a2,
T3 a3,
LAction action) |
default boolean |
doIf(T1 a1,
T2 a2,
T3 a3,
LTriConsumer<? super T1,? super T2,? super T3> consumer) |
static <T1,T2,T3> boolean |
doIf(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> predicate,
LAction action) |
static <T1,T2,T3> boolean |
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> |
failSafe(LTriPredicate<T1,T2,T3> func,
LTriPredicate<T1,T2,T3> failSafe) |
default boolean |
failSafeTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> failSafe) |
static <T1,T2,T3> boolean |
failSafeTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
LTriPredicate<T1,T2,T3> failSafe) |
default <C1,C2,C3> void |
filterForEach(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,C2,C3,I3> |
filterIterate(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,C2,I2,C3> |
filterIterate(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,C2,I2,C3,I3> |
filterIterate(IndexedRead<C1,aType.a<T1>> ia1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,I1,C2,C3> |
filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,I1,C2,C3,I3> |
filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
IndexedRead<C2,aType.a<T2>> ia2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,I1,C2,I2,C3> |
filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
IndexedRead<C3,aType.a<T3>> ia3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,I1,C2,I2,C3,I3> |
filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1,
C1 source1,
SequentialRead<C2,I2,aType.a<T2>> sa2,
C2 source2,
SequentialRead<C3,I3,aType.a<T3>> sa3,
C3 source3,
LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
static <T1,T2,T3> void |
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 |
fromTo(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LTriPredicate<T1,T2,T3> |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default boolean |
handlingTest(T1 a1,
T2 a2,
T3 a3,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static <T1,T2,T3> boolean |
handlingTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
isEqual(T1 v1,
T2 v2,
T3 v3)
Creates predicate that evaluates if an object is equal with the argument one.
|
default LBiPredicate<T2,T3> |
lShrink(LBiFunction<T2,T3,T1> left) |
default LBiPredicate<T2,T3> |
lShrinkc(T1 a1) |
static <T2,T3,T1> LBiPredicate<T2,T3> |
lShrinked(LBiFunction<T2,T3,T1> left,
LTriPredicate<T1,T2,T3> func) |
static <T2,T3,T1> LBiPredicate<T2,T3> |
lShrinkedc(T1 a1,
LTriPredicate<T1,T2,T3> func) |
default LTriPredicate<T1,T2,T3> |
negate()
Returns a predicate that represents the logical negation of this predicate.
|
default boolean |
nestingTest(T1 a1,
T2 a2,
T3 a3)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
default boolean |
nonNullTest(T1 a1,
T2 a2,
T3 a3)
Just to mirror the method: Ensures the result is not null
|
static <T1,T3,T2> LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> |
obj0Obj2Obj1Pred(LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T2,T1,T3> LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> |
obj1BiObj2Pred(LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T2,T3,T1> LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> |
obj1Obj2Obj0Pred(LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T3,T1,T2> LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> |
obj2Obj0Obj1Pred(LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default LTriPredicate<T1,T2,T3> |
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> |
recursive(LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda) |
default LBiPredicate<T1,T2> |
rShrink(LBiFunction<T1,T2,T3> right) |
default LBiPredicate<T1,T2> |
rShrinkc(T3 a3) |
static <T1,T2,T3> LBiPredicate<T1,T2> |
rShrinked(LBiFunction<T1,T2,T3> right,
LTriPredicate<T1,T2,T3> func) |
static <T1,T2,T3> LBiPredicate<T1,T2> |
rShrinkedc(T3 a3,
LTriPredicate<T1,T2,T3> func) |
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
safe()
Safe instance.
|
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
safe(LTriPredicate<T1,T2,T3> other)
Safe wrapping.
|
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>> |
safeSupplier()
Safe instance supplier.
|
static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>> |
safeSupplier(LSupplier<LTriPredicate<T1,T2,T3>> supplier)
Safe supplier.
|
default boolean |
shovingTest(T1 a1,
T2 a2,
T3 a3)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
default boolean |
test(T1 a1,
T2 a2,
T3 a3) |
default boolean |
test(T1 a1,
T2 a2,
T3 a3,
ExWF<RuntimeException> exF) |
default boolean |
test(T1 a1,
T2 a2,
T3 a3,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
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> |
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> |
test3rd(LPredicate<T3> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
|
default boolean |
testThen(T1 a1,
T2 a2,
T3 a3,
LPredicate<Throwable> handler) |
boolean |
testX(T1 a1,
T2 a2,
T3 a3)
Implement this, but call test(T1 a1,T2 a2,T3 a3)
|
static <T1,T2,T3> void |
throwIf(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> pred,
ExMF<RuntimeException> factory,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> void |
throwIfNot(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> pred,
ExMF<RuntimeException> factory,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> void |
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> |
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> |
triPredThrowing(ExF<Throwable> exF) |
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
triPredThrowing(String message,
ExMF<Throwable> exF) |
default LTriPredicate<T1,T2,T3> |
trying(ExWF<RuntimeException> exF) |
default LTriPredicate<T1,T2,T3> |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LTriPredicate<T1,T2,T3> |
tryingThen(LPredicate<Throwable> handler) |
static <T1,T2,T3> boolean |
tryTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func) |
static <T1,T2,T3> boolean |
tryTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
ExWF<RuntimeException> exF) |
static <T1,T2,T3> boolean |
tryTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> boolean |
tryTestThen(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
LPredicate<Throwable> handler) |
default boolean |
tupleTest(LTriple<T1,T2,T3> args) |
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func) |
default LTriPredicate |
untyped()
Cast that removes generics.
|
default LTriPredicate<T1,T2,T3> |
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.
|
isPredicateisFunctionformatTo, isAction, isConsumer, isOperator, isSupplierisThrowingisThrowingstatic final String DESCRIPTION
boolean testX(T1 a1, T2 a2, T3 a3) throws Throwable
Implement this, but call test(T1 a1,T2 a2,T3 a3)
Throwabledefault boolean handlingTest(T1 a1, T2 a2, T3 a3, HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LTriPredicate<T1,T2,T3> handling(HandlingInstructions<Throwable,RuntimeException> handling)
default boolean test(T1 a1, T2 a2, T3 a3, @Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default LTriPredicate<T1,T2,T3> trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default LTriPredicate<T1,T2,T3> trying(@Nonnull ExWF<RuntimeException> exF)
default LTriPredicate<T1,T2,T3> tryingThen(@Nonnull LPredicate<Throwable> handler)
default boolean nestingTest(T1 a1, T2 a2, T3 a3)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default boolean shovingTest(T1 a1, T2 a2, T3 a3)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static <T1,T2,T3> boolean handlingTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,T2,T3> boolean tryTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func)
static <T1,T2,T3> boolean tryTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static <T1,T2,T3> boolean tryTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
@Nonnull
ExWF<RuntimeException> exF)
static <T1,T2,T3> boolean tryTestThen(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
@Nonnull
LPredicate<Throwable> handler)
default boolean failSafeTest(T1 a1, T2 a2, T3 a3, @Nonnull LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> boolean failSafeTest(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
@Nonnull
LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> LTriPredicate<T1,T2,T3> failSafe(LTriPredicate<T1,T2,T3> func, @Nonnull LTriPredicate<T1,T2,T3> failSafe)
static <T1,T2,T3> boolean doIf(T1 a1,
T2 a2,
T3 a3,
@Nonnull
LTriPredicate<T1,T2,T3> predicate,
@Nonnull
LAction action)
static <T1,T2,T3> boolean doIf(T1 a1,
T2 a2,
T3 a3,
@Nonnull
LTriPredicate<T1,T2,T3> predicate,
@Nonnull
LTriConsumer<? super T1,? super T2,? super T3> consumer)
default boolean doIf(T1 a1, T2 a2, T3 a3, @Nonnull LTriConsumer<? super T1,? super T2,? super T3> consumer)
static <T1,T2,T3> void throwIf(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> pred,
ExMF<RuntimeException> factory,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static <T1,T2,T3> void throwIfNot(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> pred,
ExMF<RuntimeException> factory,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
default boolean nonNullTest(T1 a1, T2 a2, T3 a3)
Just to mirror the method: Ensures the result is not null
default boolean doApplyAsBoolean(T1 a1, T2 a2, T3 a3)
For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic <T1,T2,T3> void fromTo(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func)
From-To. Intended to be used with non-capturing lambda.
static <T1,T2,T3> void fromTill(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func)
From-To. Intended to be used with non-capturing lambda.
static <T1,T2,T3> void times(int max_i,
T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func)
From-To. Intended to be used with non-capturing lambda.
default LBiPredicate<T2,T3> lShrink(LBiFunction<T2,T3,T1> left)
default LBiPredicate<T2,T3> lShrinkc(T1 a1)
static <T2,T3,T1> LBiPredicate<T2,T3> lShrinked(LBiFunction<T2,T3,T1> left, LTriPredicate<T1,T2,T3> func)
static <T2,T3,T1> LBiPredicate<T2,T3> lShrinkedc(T1 a1, LTriPredicate<T1,T2,T3> func)
default LBiPredicate<T1,T2> rShrink(LBiFunction<T1,T2,T3> right)
default LBiPredicate<T1,T2> rShrinkc(T3 a3)
static <T1,T2,T3> LBiPredicate<T1,T2> rShrinked(LBiFunction<T1,T2,T3> right, LTriPredicate<T1,T2,T3> func)
static <T1,T2,T3> LBiPredicate<T1,T2> rShrinkedc(T3 a3, LTriPredicate<T1,T2,T3> func)
static <T1,T2,T3> LTriPredicate<T1,T2,T3> uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func)
default LTriPredicate untyped()
Cast that removes generics.
default <V2,V3,V4> LTriPredicate<V2,V3,V4> cast()
Cast that replace generics.
static <V2,V3,V4,T1,T2,T3> LTriPredicate<V2,V3,V4> cast(LTriPredicate<T1,T2,T3> function)
Cast that replace generics.
default LBoolSupplier capture(T1 a1, T2 a2, T3 a3)
Captures arguments but delays the evaluation.
static <T1,T2,T3> LTriPredicate<T1,T2,T3> constant(boolean r)
Creates function that always returns the same value.
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> test1st(@Nonnull LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> test2nd(@Nonnull LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> test3rd(@Nonnull LPredicate<T3> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> triPred(@Nonnull 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).
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> recursive(@Nonnull LFunction<LTriPredicate<T1,T2,T3>,LTriPredicate<T1,T2,T3>> selfLambda)
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> triPredThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> triPredThrowing(String message, @Nonnull ExMF<Throwable> exF)
@Nonnull static <T1,T3,T2> LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> obj0Obj2Obj1Pred(@Nonnull LTriPredicate.LObj0Obj2Obj1Pred<T1,T3,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T2,T1,T3> LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> obj1BiObj2Pred(@Nonnull LTriPredicate.LObj1BiObj2Pred<T2,T1,T3> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T2,T3,T1> LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> obj1Obj2Obj0Pred(@Nonnull LTriPredicate.LObj1Obj2Obj0Pred<T2,T3,T1> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T3,T1,T2> LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> obj2Obj0Obj1Pred(@Nonnull LTriPredicate.LObj2Obj0Obj1Pred<T3,T1,T2> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static <T3,T2,T1> LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> biObj1Obj0Pred(@Nonnull LTriPredicate.LBiObj1Obj0Pred<T3,T2,T1> 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 call(T1 a1,
T2 a2,
T3 a3,
@Nonnull
LTriPredicate<T1,T2,T3> lambda)
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> safe()
Safe instance. That always returns the same value (as alwaysFalse).
@Nonnull static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> safe(@Nullable LTriPredicate<T1,T2,T3> other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static <T1,T2,T3> LSupplier<LTriPredicate<T1,T2,T3>> safeSupplier(@Nullable LSupplier<LTriPredicate<T1,T2,T3>> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default LTriPredicate<T1,T2,T3> negate()
Returns a predicate that represents the logical negation of this predicate.
java.util.function.Predicate#negate}@Nonnull default LTriPredicate<T1,T2,T3> and(@Nonnull 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.
java.util.function.Predicate#and()}@Nonnull default LTriPredicate<T1,T2,T3> or(@Nonnull 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.
java.util.function.Predicate#or}@Nonnull default LTriPredicate<T1,T2,T3> xor(@Nonnull 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.
java.util.function.Predicate#or}@Nonnull static <T1,T2,T3> LTriPredicate<T1,T2,T3> isEqual(T1 v1, T2 v2, T3 v3)
Creates predicate that evaluates if an object is equal with the argument one.
java.util.function.Predicate#isEqual()@Nonnull default <V1,V2,V3> LTriPredicate<V1,V2,V3> compose(@Nonnull LFunction<? super V1,? extends T1> before1, @Nonnull LFunction<? super V2,? extends T2> before2, @Nonnull LFunction<? super V3,? extends T3> before3)
Allows to manipulate the domain of the function.
static <V1,V2,V3,T1,T2,T3> LTriPredicate<V1,V2,V3> composed(@Nonnull LFunction<? super V1,? extends T1> before1, @Nonnull LFunction<? super V2,? extends T2> before2, @Nonnull LFunction<? super V3,? extends T3> before3, LTriPredicate<T1,T2,T3> after)
@Nonnull default <V> LTriFunction<T1,T2,T3,V> boolToTriFunc(@Nonnull LBoolFunction<? extends V> after)
Combines two functions together in a order.
@Nonnull default LToIntTriFunction<T1,T2,T3> boolToToIntTriFunc(@Nonnull LBoolToIntFunction after)
Combines two functions together in a order.
@Nonnull default LTriPredicate<T1,T2,T3> boolToTriPred(@Nonnull LLogicalOperator after)
Combines two functions together in a order.
static <T1,T2,T3> boolean alwaysTrue(T1 a1,
T2 a2,
T3 a3)
Returns TRUE.
static <T1,T2,T3> boolean alwaysFalse(T1 a1,
T2 a2,
T3 a3)
Returns FALSE.
default <C1,C2,C3> void filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2,C3> void filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,C2,I2,C3> void filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2,I2,C3> void filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,C2,C3,I3> void filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2,C3,I3> void filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,C2,I2,C3,I3> void filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.
default <C1,I1,C2,I2,C3,I3> void filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
Copyright © 2019. All rights reserved.