eu.lunisolar.magma.func.consumer.primitives.bi

Interface LBiBoolConsumer

All Superinterfaces:

Codomain<aType.aVoid>, Domain, Domain2<aType.aBool,aType.aBool>, Formattable, MetaConsumer, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Subinterfaces:

LBiBoolConsumer.LBool1Bool0Cons

All Known Implementing Classes:

LBiBoolConsumer.LBiBoolConsumerSingle

@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

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LBiBoolConsumer.LBiBoolConsumerSingle
static interface	LBiBoolConsumer.LBool1Bool0Cons Permutation of LBiBoolConsumer for method references.

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

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> 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.
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)

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaConsumer

isConsumer

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isAction, isFunction, isOperator, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

accept

default void accept(boolean a1,
                    boolean a2)

acceptX

void acceptX(boolean a1,
             boolean a2)
      throws Throwable

Implement this, but call accept(boolean a1,boolean a2)

Throws:

Throwable

tupleAccept

default LTuple.Void tupleAccept(LBoolPair args)

handlingAccept

default void handlingAccept(boolean a1,
                            boolean a2,
                            HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LBiBoolConsumer handling(HandlingInstructions<Throwable,RuntimeException> handling)

accept

default void accept(boolean a1,
                    boolean a2,
                    @Nonnull
                    ExWMF<RuntimeException> exF,
                    @Nonnull
                    String newMessage,
                    @Nullable
                    Object... messageParams)

trying

default LBiBoolConsumer trying(@Nonnull
                               ExWMF<RuntimeException> exF,
                               @Nonnull
                               String newMessage,
                               @Nullable
                               Object... messageParams)

accept

default void accept(boolean a1,
                    boolean a2,
                    @Nonnull
                    ExWF<RuntimeException> exF)

trying

default LBiBoolConsumer trying(@Nonnull
                               ExWF<RuntimeException> exF)

acceptThen

default void acceptThen(boolean a1,
                        boolean a2,
                        @Nonnull
                        LConsumer<Throwable> handler)

tryingThen

default LBiBoolConsumer tryingThen(@Nonnull
                                   LConsumer<Throwable> handler)

nestingAccept

default void nestingAccept(boolean a1,
                           boolean a2)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingAccept

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.

handlingAccept

static void handlingAccept(boolean a1,
                           boolean a2,
                           LBiBoolConsumer func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static void tryAccept(boolean a1,
                      boolean a2,
                      LBiBoolConsumer func)

tryAccept

static void tryAccept(boolean a1,
                      boolean a2,
                      LBiBoolConsumer func,
                      @Nonnull
                      ExWMF<RuntimeException> exF,
                      @Nonnull
                      String newMessage,
                      @Nullable
                      Object... messageParams)

tryAccept

static void tryAccept(boolean a1,
                      boolean a2,
                      LBiBoolConsumer func,
                      @Nonnull
                      ExWF<RuntimeException> exF)

tryAcceptThen

static void tryAcceptThen(boolean a1,
                          boolean a2,
                          LBiBoolConsumer func,
                          @Nonnull
                          LConsumer<Throwable> handler)

failSafeAccept

default void failSafeAccept(boolean a1,
                            boolean a2,
                            @Nonnull
                            LBiBoolConsumer failSafe)

failSafeAccept

static void failSafeAccept(boolean a1,
                           boolean a2,
                           LBiBoolConsumer func,
                           @Nonnull
                           LBiBoolConsumer failSafe)

failSafe

static LBiBoolConsumer failSafe(LBiBoolConsumer func,
                                @Nonnull
                                LBiBoolConsumer failSafe)

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static void fromTo(int min_i,
                   int max_i,
                   boolean a1,
                   boolean a2,
                   LBiBoolConsumer func)

From-To. Intended to be used with non-capturing lambda.

fromTill

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.

times

static void times(int max_i,
                  boolean a1,
                  boolean a2,
                  LBiBoolConsumer func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LBoolConsumer lShrink(LLogicalOperator left)

lShrinkc

default LBoolConsumer lShrinkc(boolean a1)

lShrinked

static LBoolConsumer lShrinked(LLogicalOperator left,
                               LBiBoolConsumer func)

lShrinkedc

static LBoolConsumer lShrinkedc(boolean a1,
                                LBiBoolConsumer func)

rShrink

default LBoolConsumer rShrink(LLogicalOperator right)

rShrinkc

default LBoolConsumer rShrinkc(boolean a2)

rShrinked

static LBoolConsumer rShrinked(LLogicalOperator right,
                               LBiBoolConsumer func)

rShrinkedc

static LBoolConsumer rShrinkedc(boolean a2,
                                LBiBoolConsumer func)

uncurry

static LBiBoolConsumer uncurry(LBoolFunction<LBoolConsumer> func)

capture

default LAction capture(boolean a1,
                        boolean a2)

Captures arguments but delays the evaluation.

accept1st

@Nonnull
static LBiBoolConsumer accept1st(@Nonnull
                                           LBoolConsumer func)

Captures single parameter function into this interface where only 1st parameter will be used.

accept2nd

@Nonnull
static LBiBoolConsumer accept2nd(@Nonnull
                                           LBoolConsumer func)

Captures single parameter function into this interface where only 2nd parameter will be used.

biBoolCons

@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).

recursive

@Nonnull
static LBiBoolConsumer recursive(@Nonnull
                                           LFunction<LBiBoolConsumer,LBiBoolConsumer> selfLambda)

biBoolConsThrowing

@Nonnull
static LBiBoolConsumer biBoolConsThrowing(@Nonnull
                                                    ExF<Throwable> exF)

biBoolConsThrowing

@Nonnull
static LBiBoolConsumer biBoolConsThrowing(String message,
                                                    @Nonnull
                                                    ExMF<Throwable> exF)

bool1Bool0Cons

@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).

call

static void call(boolean a1,
                 boolean a2,
                 @Nonnull
                 LBiBoolConsumer lambda)

safe

@Nonnull
static LBiBoolConsumer safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LBiBoolConsumer> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LBiBoolConsumer safe(@Nullable
                                      LBiBoolConsumer other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@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.

compose

@Nonnull
default LBiBoolConsumer compose(@Nonnull
                                          LLogicalOperator before1,
                                          @Nonnull
                                          LLogicalOperator before2)

Allows to manipulate the domain of the function.

composed

static LBiBoolConsumer composed(@Nonnull
                                LLogicalOperator before1,
                                @Nonnull
                                LLogicalOperator before2,
                                LBiBoolConsumer after)

biBoolConsCompose

@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.

composed

static <V1,V2> LBiConsumer<V1,V2> composed(@Nonnull
                                           LPredicate<? super V1> before1,
                                           @Nonnull
                                           LPredicate<? super V2> before2,
                                           LBiBoolConsumer after)

andThen

@Nonnull
default LBiBoolConsumer andThen(@Nonnull
                                          LBiBoolConsumer after)

Combines two LBiBoolConsumer together in a order.

doNothing

static void doNothing(boolean a1,
                      boolean a2)

Does nothing (LBiBoolConsumer)

forEach

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.

iterate

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.

iterate

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.

iterate

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.

targetedForEach

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.

targetedIterate

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.