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