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