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