@FunctionalInterface public interface LBiBoolConsumer extends MetaConsumer, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain2<aType.aBool,aType.aBool>
Non-throwing functional interface (lambda) LBiBoolConsumer for Java 8.
Type: consumer
Domain (lvl: 2): boolean a1,boolean a2
Co-domain: none
| Modifier and Type | Interface and Description |
|---|---|
static class |
LBiBoolConsumer.LBiBoolConsumerSingle |
static interface |
LBiBoolConsumer.LBool1Bool0Cons
Permutation of LBiBoolConsumer for method references.
|
MetaInterface.NonThrowing, MetaInterface.Throwing<X>| Modifier and Type | Field and Description |
|---|---|
static String |
DESCRIPTION |
| Modifier and Type | Method and Description |
|---|---|
default void |
accept(boolean a1,
boolean a2) |
default void |
accept(boolean a1,
boolean a2,
ExWF<RuntimeException> exF) |
default void |
accept(boolean a1,
boolean a2,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static LBiBoolConsumer |
accept1st(LBoolConsumer func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static LBiBoolConsumer |
accept2nd(LBoolConsumer func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
default void |
acceptThen(boolean a1,
boolean a2,
LConsumer<Throwable> handler) |
void |
acceptX(boolean a1,
boolean a2)
Implement this, but call accept(boolean a1,boolean a2)
|
default LBiBoolConsumer |
andThen(LBiBoolConsumer after)
Combines two LBiBoolConsumer together in a order.
|
static LBiBoolConsumer |
biBoolCons(LBiBoolConsumer lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default <V1,V2> LBiConsumer<V1,V2> |
biBoolConsCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
static LBiBoolConsumer |
biBoolConsThrowing(ExF<Throwable> exF) |
static LBiBoolConsumer |
biBoolConsThrowing(String message,
ExMF<Throwable> exF) |
static LBiBoolConsumer.LBool1Bool0Cons |
bool1Bool0Cons(LBiBoolConsumer.LBool1Bool0Cons lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static void |
call(boolean a1,
boolean a2,
LBiBoolConsumer lambda) |
default LAction |
capture(boolean a1,
boolean a2)
Captures arguments but delays the evaluation.
|
default LBiBoolConsumer |
compose(LLogicalOperator before1,
LLogicalOperator before2)
Allows to manipulate the domain of the function.
|
static LBiBoolConsumer |
composed(LLogicalOperator before1,
LLogicalOperator before2,
LBiBoolConsumer after) |
static <V1,V2> LBiConsumer<V1,V2> |
composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LBiBoolConsumer after) |
static void |
doNothing(boolean a1,
boolean a2)
Does nothing (LBiBoolConsumer)
|
static LBiBoolConsumer |
failSafe(LBiBoolConsumer func,
LBiBoolConsumer failSafe) |
default void |
failSafeAccept(boolean a1,
boolean a2,
LBiBoolConsumer failSafe) |
static void |
failSafeAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
LBiBoolConsumer failSafe) |
static <C1,C2> int |
forEach(IndexedRead<C1,aType.aBool> ia1,
C1 source1,
IndexedRead<C2,aType.aBool> ia2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static void |
fromTill(int min_i,
int max_i,
boolean a1,
boolean a2,
LBiBoolConsumer func)
From-To.
|
static void |
fromTo(int min_i,
int max_i,
boolean a1,
boolean a2,
LBiBoolConsumer func)
From-To.
|
default String |
functionalInterfaceDescription()
Returns description of the functional interface.
|
default LBiBoolConsumer |
handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default void |
handlingAccept(boolean a1,
boolean a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
|
static void |
handlingAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static <C1,C2,I2> int |
iterate(IndexedRead<C1,aType.aBool> ia1,
C1 source1,
SequentialRead<C2,I2,aType.aBool> sa2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,I1,C2> int |
iterate(SequentialRead<C1,I1,aType.aBool> sa1,
C1 source1,
IndexedRead<C2,aType.aBool> ia2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C1,I1,C2,I2> |
iterate(SequentialRead<C1,I1,aType.aBool> sa1,
C1 source1,
SequentialRead<C2,I2,aType.aBool> sa2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer.
|
default LBoolConsumer |
lShrink(LLogicalOperator left) |
default LBoolConsumer |
lShrinkc(boolean a1) |
static LBoolConsumer |
lShrinked(LLogicalOperator left,
LBiBoolConsumer func) |
static LBoolConsumer |
lShrinkedc(boolean a1,
LBiBoolConsumer func) |
default void |
nestingAccept(boolean a1,
boolean a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
|
static LBiBoolConsumer |
recursive(LFunction<LBiBoolConsumer,LBiBoolConsumer> selfLambda) |
default LBoolConsumer |
rShrink(LLogicalOperator right) |
default LBoolConsumer |
rShrinkc(boolean a2) |
static LBoolConsumer |
rShrinked(LLogicalOperator right,
LBiBoolConsumer func) |
static LBoolConsumer |
rShrinkedc(boolean a2,
LBiBoolConsumer func) |
static LBiBoolConsumer |
safe()
Safe instance.
|
static LBiBoolConsumer |
safe(LBiBoolConsumer other)
Safe wrapping.
|
static LSupplier<LBiBoolConsumer> |
safeSupplier()
Safe instance supplier.
|
static LSupplier<LBiBoolConsumer> |
safeSupplier(LSupplier<LBiBoolConsumer> supplier)
Safe supplier.
|
default void |
shovingAccept(boolean a1,
boolean a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
|
static <C2> boolean |
targetedForEach(boolean a1,
IndexedRead<C2,aType.aBool> ia2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static <C2,I2> boolean |
targetedIterate(boolean a1,
SequentialRead<C2,I2,aType.aBool> sa2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer.
|
static void |
times(int max_i,
boolean a1,
boolean a2,
LBiBoolConsumer func)
From-To.
|
static void |
tryAccept(boolean a1,
boolean a2,
LBiBoolConsumer func) |
static void |
tryAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
ExWF<RuntimeException> exF) |
static void |
tryAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static void |
tryAcceptThen(boolean a1,
boolean a2,
LBiBoolConsumer func,
LConsumer<Throwable> handler) |
default LBiBoolConsumer |
trying(ExWF<RuntimeException> exF) |
default LBiBoolConsumer |
trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LBiBoolConsumer |
tryingThen(LConsumer<Throwable> handler) |
default LTuple.Void |
tupleAccept(LBoolPair args) |
static LBiBoolConsumer |
uncurry(LBoolFunction<LBoolConsumer> func) |
isConsumerformatTo, isAction, isFunction, isOperator, isPredicate, isSupplierisThrowingstatic final String DESCRIPTION
default void accept(boolean a1,
boolean a2)
void acceptX(boolean a1,
boolean a2)
throws Throwable
Implement this, but call accept(boolean a1,boolean a2)
Throwabledefault LTuple.Void tupleAccept(LBoolPair args)
default void handlingAccept(boolean a1,
boolean a2,
HandlingInstructions<Throwable,RuntimeException> handling)
Function call that handles exceptions according to the instructions.
default LBiBoolConsumer handling(HandlingInstructions<Throwable,RuntimeException> handling)
default void accept(boolean a1,
boolean a2,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
default LBiBoolConsumer trying(@Nonnull ExWMF<RuntimeException> exF, @Nonnull String newMessage, @Nullable Object... messageParams)
default void accept(boolean a1,
boolean a2,
@Nonnull
ExWF<RuntimeException> exF)
default LBiBoolConsumer trying(@Nonnull ExWF<RuntimeException> exF)
default LBiBoolConsumer tryingThen(@Nonnull LConsumer<Throwable> handler)
default void nestingAccept(boolean a1,
boolean a2)
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default void shovingAccept(boolean a1,
boolean a2)
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static void handlingAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
HandlingInstructions<Throwable,RuntimeException> handling)
static void tryAccept(boolean a1,
boolean a2,
LBiBoolConsumer func)
static void tryAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
@Nonnull
ExWMF<RuntimeException> exF,
@Nonnull
String newMessage,
@Nullable
Object... messageParams)
static void tryAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
@Nonnull
ExWF<RuntimeException> exF)
static void tryAcceptThen(boolean a1,
boolean a2,
LBiBoolConsumer func,
@Nonnull
LConsumer<Throwable> handler)
default void failSafeAccept(boolean a1,
boolean a2,
@Nonnull
LBiBoolConsumer failSafe)
static void failSafeAccept(boolean a1,
boolean a2,
LBiBoolConsumer func,
@Nonnull
LBiBoolConsumer failSafe)
static LBiBoolConsumer failSafe(LBiBoolConsumer func, @Nonnull LBiBoolConsumer failSafe)
@Nonnull default String functionalInterfaceDescription()
Returns description of the functional interface.
functionalInterfaceDescription in interface MetaFunctionalInterfacestatic void fromTo(int min_i,
int max_i,
boolean a1,
boolean a2,
LBiBoolConsumer func)
From-To. Intended to be used with non-capturing lambda.
static void fromTill(int min_i,
int max_i,
boolean a1,
boolean a2,
LBiBoolConsumer func)
From-To. Intended to be used with non-capturing lambda.
static void times(int max_i,
boolean a1,
boolean a2,
LBiBoolConsumer func)
From-To. Intended to be used with non-capturing lambda.
default LBoolConsumer lShrink(LLogicalOperator left)
default LBoolConsumer lShrinkc(boolean a1)
static LBoolConsumer lShrinked(LLogicalOperator left, LBiBoolConsumer func)
static LBoolConsumer lShrinkedc(boolean a1, LBiBoolConsumer func)
default LBoolConsumer rShrink(LLogicalOperator right)
default LBoolConsumer rShrinkc(boolean a2)
static LBoolConsumer rShrinked(LLogicalOperator right, LBiBoolConsumer func)
static LBoolConsumer rShrinkedc(boolean a2, LBiBoolConsumer func)
static LBiBoolConsumer uncurry(LBoolFunction<LBoolConsumer> func)
default LAction capture(boolean a1, boolean a2)
Captures arguments but delays the evaluation.
@Nonnull static LBiBoolConsumer accept1st(@Nonnull LBoolConsumer func)
Captures single parameter function into this interface where only 1st parameter will be used.
@Nonnull static LBiBoolConsumer accept2nd(@Nonnull LBoolConsumer func)
Captures single parameter function into this interface where only 2nd parameter will be used.
@Nonnull static LBiBoolConsumer biBoolCons(@Nonnull LBiBoolConsumer lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
@Nonnull static LBiBoolConsumer recursive(@Nonnull LFunction<LBiBoolConsumer,LBiBoolConsumer> selfLambda)
@Nonnull static LBiBoolConsumer biBoolConsThrowing(@Nonnull ExF<Throwable> exF)
@Nonnull static LBiBoolConsumer biBoolConsThrowing(String message, @Nonnull ExMF<Throwable> exF)
@Nonnull static LBiBoolConsumer.LBool1Bool0Cons bool1Bool0Cons(@Nonnull LBiBoolConsumer.LBool1Bool0Cons lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static void call(boolean a1,
boolean a2,
@Nonnull
LBiBoolConsumer lambda)
@Nonnull static LBiBoolConsumer safe()
Safe instance.
@Nonnull static LSupplier<LBiBoolConsumer> safeSupplier()
Safe instance supplier. Returns supplier of safe() instance.
@Nonnull static LBiBoolConsumer safe(@Nullable LBiBoolConsumer other)
Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.
@Nonnull static LSupplier<LBiBoolConsumer> safeSupplier(@Nullable LSupplier<LBiBoolConsumer> supplier)
Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.
@Nonnull default LBiBoolConsumer compose(@Nonnull LLogicalOperator before1, @Nonnull LLogicalOperator before2)
Allows to manipulate the domain of the function.
static LBiBoolConsumer composed(@Nonnull LLogicalOperator before1, @Nonnull LLogicalOperator before2, LBiBoolConsumer after)
@Nonnull default <V1,V2> LBiConsumer<V1,V2> biBoolConsCompose(@Nonnull LPredicate<? super V1> before1, @Nonnull LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2> composed(@Nonnull LPredicate<? super V1> before1, @Nonnull LPredicate<? super V2> before2, LBiBoolConsumer after)
@Nonnull default LBiBoolConsumer andThen(@Nonnull LBiBoolConsumer after)
Combines two LBiBoolConsumer together in a order.
static void doNothing(boolean a1,
boolean a2)
Does nothing (LBiBoolConsumer)
static <C1,C2> int forEach(IndexedRead<C1,aType.aBool> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,I1,C2> int iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,C2,I2> int iterate(IndexedRead<C1,aType.aBool> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C1,I1,C2,I2> int iterate(SequentialRead<C1,I1,aType.aBool> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
static <C2> boolean targetedForEach(boolean a1,
IndexedRead<C2,aType.aBool> ia2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer. First argument is designated as ‘target’ object. Thread safety, fail-fast, fail-safety of this method is not expected.
static <C2,I2> boolean targetedIterate(boolean a1,
SequentialRead<C2,I2,aType.aBool> sa2,
C2 source2,
LBiBoolConsumer consumer)
For each element (or tuple) from arguments, calls the consumer. First argument is designated as ‘target’ object. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
Copyright © 2019. All rights reserved.