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