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