@FunctionalInterface public interface LBiIntPredicate extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain2<aType.aInt,aType.aInt>
Non-throwing functional interface (lambda) LBiIntPredicate for Java 8.
Type: predicate
Domain (lvl: 2): int a1,int a2
Co-domain: boolean
| Modifier and Type | Interface and Description |
|---|---|
static class |
LBiIntPredicate.LBiIntPredicateSingle |
static interface |
LBiIntPredicate.LInt1Int0Pred
Permutation of LBiIntPredicate for method references.
|
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
alwaysFalse(int a1,
int a2)
Returns FALSE.
|
static boolean |
alwaysTrue(int a1,
int a2)
Returns TRUE.
|
default LBiIntPredicate |
and(LBiIntPredicate other)
Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
|
static LBiIntPredicate |
biIntPred(LBiIntPredicate lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default <V1,V2> LBiPredicate<V1,V2> |
biIntPredCompose(LToIntFunction<? super V1> before1,
LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
|
static LBiIntPredicate |
biIntPredThrowing(ExF<Throwable> exF) |
static LBiIntPredicate |
biIntPredThrowing(String message,
ExMF<Throwable> exF) |
default <V> LBiIntFunction<V> |
boolToBiIntFunc(LBoolFunction<? extends V> after)
Combines two functions together in a order.
|
default LBiIntPredicate |
boolToBiIntPred(LLogicalOperator after)
Combines two functions together in a order.
|
default LIntBinaryOperator |
boolToIntBinaryOp(LBoolToIntFunction after)
Combines two functions together in a order.
|
static boolean |
call(int a1,
int a2,
LBiIntPredicate lambda) |
default LBoolSupplier |
capture(int a1,
int a2)
Captures arguments but delays the evaluation.
|
default LBiIntPredicate |
compose(LIntUnaryOperator before1,
LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
|
static LBiIntPredicate |
composed(LIntUnaryOperator before1,
LIntUnaryOperator before2,
LBiIntPredicate after) |
static <V1,V2> LBiPredicate<V1,V2> |
composed(LToIntFunction<? super V1> before1,
LToIntFunction<? super V2> before2,
LBiIntPredicate after) |
static LBiIntPredicate |
constant(boolean r)
Creates function that always returns the same value.
|
default boolean |
doApplyAsBoolean(int a1,
int a2)
For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
|
default boolean |
doIf(int a1,
int a2,
LAction action) |
default boolean |
doIf(int a1,
int a2,
LBiIntConsumer consumer) |
static boolean |
doIf(int a1,
int a2,
LBiIntPredicate predicate,
LAction action) |
static boolean |
doIf(int a1,
int a2,
LBiIntPredicate predicate,
LBiIntConsumer consumer) |
default <V> boolean |
doIf(V a1,
int a2,
int a3,
LTieIntConsumer<V> consumer) |
default <V> int |
doIf(V a1,
int a2,
int a3,
LTieIntFunction<V> consumer)
2
|
default <V> boolean |
doIfReverse(V a1,
int a2,
int a3,
LTieIntConsumer<? super V> consumer) |
default <V> int |
doIfReverse(V a1,
int a2,
int a3,
LTieIntFunction<? super V> consumer) |
static LBiIntPredicate |
failSafe(LBiIntPredicate func,
LBiIntPredicate failSafe) |
default boolean |
failSafeTest(int a1,
int a2,
LBiIntPredicate failSafe) |
static boolean |
failSafeTest(int a1,
int a2,
LBiIntPredicate func,
LBiIntPredicate failSafe) |
default <C1,C2> void |
filterForEach(IndexedRead<C1,aType.aInt> ia1,
C1 source1,
IndexedRead<C2,aType.aInt> ia2,
C2 source2,
LBiIntConsumer consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,C2,I2> void |
filterIterate(IndexedRead<C1,aType.aInt> ia1,
C1 source1,
SequentialRead<C2,I2,aType.aInt> sa2,
C2 source2,
LBiIntConsumer consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,I1,C2> void |
filterIterate(SequentialRead<C1,I1,aType.aInt> sa1,
C1 source1,
IndexedRead<C2,aType.aInt> ia2,
C2 source2,
LBiIntConsumer consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
default <C1,I1,C2,I2> |
filterIterate(SequentialRead<C1,I1,aType.aInt> sa1,
C1 source1,
SequentialRead<C2,I2,aType.aInt> sa2,
C2 source2,
LBiIntConsumer consumer)
For each element (or tuple) from arguments, calls the consumer if predicate test passes.
|
static void |
fromTill(int min_i,
int max_i,
int a1,
int a2,
LBiIntPredicate func)
From-To.
|
static void |
fromTo(int min_i,
int max_i,
int a1,
int a2,
LBiIntPredicate func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LBiIntPredicate |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default boolean |
handlingTest(int a1,
int a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static boolean |
handlingTest(int a1,
int a2,
LBiIntPredicate func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static LBiIntPredicate.LInt1Int0Pred |
int1Int0Pred(LBiIntPredicate.LInt1Int0Pred lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static LBiIntPredicate |
isEqual(int v1,
int v2)
Creates predicate that evaluates if an object is equal with the argument one.
|
default LIntPredicate |
lShrink(LIntUnaryOperator left) |
default LIntPredicate |
lShrinkc(int a1) |
static LIntPredicate |
lShrinked(LIntUnaryOperator left,
LBiIntPredicate func) |
static LIntPredicate |
lShrinkedc(int a1,
LBiIntPredicate func) |
default LBiIntPredicate |
negate()
Returns a predicate that represents the logical negation of this predicate.
|
default boolean |
nestingTest(int a1,
int a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
default boolean |
nonNullTest(int a1,
int a2)
Just to mirror the method: Ensures the result is not null
|
default LBiIntPredicate |
or(LBiIntPredicate other)
Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
|
static LBiIntPredicate |
recursive(LFunction<LBiIntPredicate,LBiIntPredicate> selfLambda) |
default LIntPredicate |
rShrink(LIntUnaryOperator right) |
default LIntPredicate |
rShrinkc(int a2) |
static LIntPredicate |
rShrinked(LIntUnaryOperator right,
LBiIntPredicate func) |
static LIntPredicate |
rShrinkedc(int a2,
LBiIntPredicate func) |
static LBiIntPredicate |
safe()
Safe instance.
|
static LBiIntPredicate |
safe(LBiIntPredicate other)
Safe wrapping.
|
static LSupplier<LBiIntPredicate> |
safeSupplier()
Safe instance supplier.
|
static LSupplier<LBiIntPredicate> |
safeSupplier(LSupplier<LBiIntPredicate> supplier)
Safe supplier.
|
default boolean |
shovingTest(int a1,
int a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
default boolean |
test(int a1,
int a2) |
default boolean |
test(int a1,
int a2,
ExWF<RuntimeException> exF) |
default boolean |
test(int a1,
int a2,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static LBiIntPredicate |
test1st(LIntPredicate func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static LBiIntPredicate |
test2nd(LIntPredicate func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
default boolean |
testThen(int a1,
int a2,
LPredicate<Throwable> handler) |
boolean |
testX(int a1,
int a2)
Implement this, but call test(int a1,int a2)
|
static void |
throwIf(int a1,
int a2,
LBiIntPredicate pred,
ExMF<RuntimeException> factory,
String newMessage,
Object... messageParams) |
static void |
throwIfNot(int a1,
int a2,
LBiIntPredicate pred,
ExMF<RuntimeException> factory,
String newMessage,
Object... messageParams) |
static void |
times(int max_i,
int a1,
int a2,
LBiIntPredicate func)
From-To.
|
default LBiIntPredicate |
trying(ExWF<RuntimeException> exF) |
default LBiIntPredicate |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LBiIntPredicate |
tryingThen(LPredicate<Throwable> handler) |
static boolean |
tryTest(int a1,
int a2,
LBiIntPredicate func) |
static boolean |
tryTest(int a1,
int a2,
LBiIntPredicate func,
ExWF<RuntimeException> exF) |
static boolean |
tryTest(int a1,
int a2,
LBiIntPredicate func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static boolean |
tryTestThen(int a1,
int a2,
LBiIntPredicate func,
LPredicate<Throwable> handler) |
default boolean |
tupleTest(LIntPair args) |
static LBiIntPredicate |
uncurry(LIntFunction<LIntPredicate> func) |
default LBiIntPredicate |
xor(LBiIntPredicate 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
default boolean test(int a1,
int a2)
boolean testX(int a1,
int a2)
throws Throwable
Implement this, but call test(int a1,int a2)
Throwabledefault boolean tupleTest(LIntPair args)
default boolean handlingTest(int a1,
int a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LBiIntPredicate handling(HandlingInstructions<Throwable,RuntimeException> handling)
default boolean test(int a1,
int a2,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
default LBiIntPredicate trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default boolean test(int a1,
int a2,
@Nonnull
ExWF<RuntimeException> exF)
default LBiIntPredicate trying(@Nonnull ExWF<RuntimeException> exF)
default boolean testThen(int a1,
int a2,
@Nonnull
LPredicate<Throwable> handler)
default LBiIntPredicate tryingThen(@Nonnull LPredicate<Throwable> handler)
default boolean nestingTest(int a1,
int a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default boolean shovingTest(int a1,
int a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static boolean handlingTest(int a1,
int a2,
LBiIntPredicate func,
HandlingInstructions<Throwable,RuntimeException> handling)
static boolean tryTest(int a1,
int a2,
LBiIntPredicate func)
static boolean tryTest(int a1,
int a2,
LBiIntPredicate func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static boolean tryTest(int a1,
int a2,
LBiIntPredicate func,
@Nonnull
ExWF<RuntimeException> exF)
static boolean tryTestThen(int a1,
int a2,
LBiIntPredicate func,
@Nonnull
LPredicate<Throwable> handler)
default boolean failSafeTest(int a1,
int a2,
@Nonnull
LBiIntPredicate failSafe)
static boolean failSafeTest(int a1,
int a2,
LBiIntPredicate func,
@Nonnull
LBiIntPredicate failSafe)
static LBiIntPredicate failSafe(LBiIntPredicate func, @Nonnull LBiIntPredicate failSafe)
default boolean doIf(int a1,
int a2,
LAction action)
static boolean doIf(int a1,
int a2,
@Nonnull
LBiIntPredicate predicate,
@Nonnull
LAction action)
static boolean doIf(int a1,
int a2,
@Nonnull
LBiIntPredicate predicate,
@Nonnull
LBiIntConsumer consumer)
default boolean doIf(int a1,
int a2,
@Nonnull
LBiIntConsumer consumer)
static void throwIf(int a1,
int a2,
LBiIntPredicate pred,
ExMF<RuntimeException> factory,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static void throwIfNot(int a1,
int a2,
LBiIntPredicate pred,
ExMF<RuntimeException> factory,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
default boolean nonNullTest(int a1,
int a2)
Just to mirror the method: Ensures the result is not null
default boolean doApplyAsBoolean(int a1,
int a2)
For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacedefault <V> boolean doIf(V a1,
int a2,
int a3,
LTieIntConsumer<V> consumer)
default <V> boolean doIfReverse(V a1,
int a2,
int a3,
LTieIntConsumer<? super V> consumer)
default <V> int doIfReverse(V a1,
int a2,
int a3,
LTieIntFunction<? super V> consumer)
default <V> int doIf(V a1,
int a2,
int a3,
LTieIntFunction<V> consumer)
2
static void fromTo(int min_i,
int max_i,
int a1,
int a2,
LBiIntPredicate func)
From-To. Intended to be used with non-capturing lambda.
static void fromTill(int min_i,
int max_i,
int a1,
int a2,
LBiIntPredicate func)
From-To. Intended to be used with non-capturing lambda.
static void times(int max_i,
int a1,
int a2,
LBiIntPredicate func)
From-To. Intended to be used with non-capturing lambda.
default LIntPredicate lShrink(LIntUnaryOperator left)
default LIntPredicate lShrinkc(int a1)
static LIntPredicate lShrinked(LIntUnaryOperator left, LBiIntPredicate func)
static LIntPredicate lShrinkedc(int a1, LBiIntPredicate func)
default LIntPredicate rShrink(LIntUnaryOperator right)
default LIntPredicate rShrinkc(int a2)
static LIntPredicate rShrinked(LIntUnaryOperator right, LBiIntPredicate func)
static LIntPredicate rShrinkedc(int a2, LBiIntPredicate func)
static LBiIntPredicate uncurry(LIntFunction<LIntPredicate> func)
default LBoolSupplier capture(int a1, int a2)
Captures arguments but delays the evaluation.
static LBiIntPredicate constant(boolean r)
Creates function that always returns the same value.
@Nonnull static LBiIntPredicate test1st(@Nonnull LIntPredicate func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static LBiIntPredicate test2nd(@Nonnull LIntPredicate func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static LBiIntPredicate biIntPred(@Nonnull LBiIntPredicate lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static LBiIntPredicate recursive(@Nonnull LFunction<LBiIntPredicate,LBiIntPredicate> selfLambda)
@Nonnull static LBiIntPredicate biIntPredThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static LBiIntPredicate biIntPredThrowing(String message, @Nonnull ExMF<Throwable> exF)
@Nonnull static LBiIntPredicate.LInt1Int0Pred int1Int0Pred(@Nonnull LBiIntPredicate.LInt1Int0Pred lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static boolean call(int a1,
int a2,
@Nonnull
LBiIntPredicate lambda)
@Nonnull static LBiIntPredicate safe()
Safe instance. That always returns the same value (as alwaysFalse).
@Nonnull static LSupplier<LBiIntPredicate> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static LBiIntPredicate safe(@Nullable LBiIntPredicate other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static LSupplier<LBiIntPredicate> safeSupplier(@Nullable LSupplier<LBiIntPredicate> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default LBiIntPredicate negate()
Returns a predicate that represents the logical negation of this predicate.
java.util.function.Predicate#negate}@Nonnull default LBiIntPredicate and(@Nonnull LBiIntPredicate 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 LBiIntPredicate or(@Nonnull LBiIntPredicate 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 LBiIntPredicate xor(@Nonnull LBiIntPredicate 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 LBiIntPredicate isEqual(int v1, int v2)
Creates predicate that evaluates if an object is equal with the argument one.
java.util.function.Predicate#isEqual()@Nonnull default LBiIntPredicate compose(@Nonnull LIntUnaryOperator before1, @Nonnull LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
static LBiIntPredicate composed(@Nonnull LIntUnaryOperator before1, @Nonnull LIntUnaryOperator before2, LBiIntPredicate after)
@Nonnull default <V1,V2> LBiPredicate<V1,V2> biIntPredCompose(@Nonnull LToIntFunction<? super V1> before1, @Nonnull LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
static <V1,V2> LBiPredicate<V1,V2> composed(@Nonnull LToIntFunction<? super V1> before1, @Nonnull LToIntFunction<? super V2> before2, LBiIntPredicate after)
@Nonnull default <V> LBiIntFunction<V> boolToBiIntFunc(@Nonnull LBoolFunction<? extends V> after)
Combines two functions together in a order.
@Nonnull default LIntBinaryOperator boolToIntBinaryOp(@Nonnull LBoolToIntFunction after)
Combines two functions together in a order.
@Nonnull default LBiIntPredicate boolToBiIntPred(@Nonnull LLogicalOperator after)
Combines two functions together in a order.
static boolean alwaysTrue(int a1,
int a2)
Returns TRUE.
static boolean alwaysFalse(int a1,
int a2)
Returns FALSE.
default <C1,C2> void filterForEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer 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> void filterIterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer 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> void filterIterate(IndexedRead<C1,aType.aInt> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer 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> void filterIterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer 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.