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