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