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

Interface LBiCharConsumer

All Superinterfaces:

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

All Known Subinterfaces:

LBiCharConsumer.LChar1Char0Cons

All Known Implementing Classes:

LBiCharConsumer.LBiCharConsumerSingle

@FunctionalInterface
public interface LBiCharConsumer
extends MetaConsumer, MetaInterface.NonThrowing, Codomain<aType.aVoid>, Domain2<aType.aChar,aType.aChar>

Non-throwing functional interface (lambda) LBiCharConsumer for Java 8.

Type: consumer

Domain (lvl: 2): char a1,char a2

Co-domain: none

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LBiCharConsumer.LBiCharConsumerSingle
static interface	LBiCharConsumer.LChar1Char0Cons Permutation of LBiCharConsumer 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(char a1, char a2)
default void	accept(char a1, char a2, ExWF<RuntimeException> exF)
default void	accept(char a1, char a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static LBiCharConsumer	accept1st(LCharConsumer func) Captures single parameter function into this interface where only 1st parameter will be used.
static LBiCharConsumer	accept2nd(LCharConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
default void	acceptThen(char a1, char a2, LConsumer<Throwable> handler)
void	acceptX(char a1, char a2) Implement this, but call accept(char a1,char a2)
default LBiCharConsumer	andThen(LBiCharConsumer after) Combines two LBiCharConsumer together in a order.
static LBiCharConsumer	biCharCons(LBiCharConsumer 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>	biCharConsCompose(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LBiCharConsumer	biCharConsThrowing(ExF<Throwable> exF)
static LBiCharConsumer	biCharConsThrowing(String message, ExMF<Throwable> exF)
static void	call(char a1, char a2, LBiCharConsumer lambda)
default LAction	capture(char a1, char a2) Captures arguments but delays the evaluation.
static LBiCharConsumer.LChar1Char0Cons	char1Char0Cons(LBiCharConsumer.LChar1Char0Cons lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default LBiCharConsumer	compose(LCharUnaryOperator before1, LCharUnaryOperator before2) Allows to manipulate the domain of the function.
static LBiCharConsumer	composed(LCharUnaryOperator before1, LCharUnaryOperator before2, LBiCharConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	composed(LToCharFunction<? super V1> before1, LToCharFunction<? super V2> before2, LBiCharConsumer after)
static void	doNothing(char a1, char a2) Does nothing (LBiCharConsumer)
static LBiCharConsumer	failSafe(LBiCharConsumer func, LBiCharConsumer failSafe)
default void	failSafeAccept(char a1, char a2, LBiCharConsumer failSafe)
static void	failSafeAccept(char a1, char a2, LBiCharConsumer func, LBiCharConsumer failSafe)
static <C1,C2> int	forEach(IndexedRead<C1,aType.aChar> ia1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LBiCharConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	fromTill(int min_i, int max_i, char a1, char a2, LBiCharConsumer func) From-To.
static void	fromTo(int min_i, int max_i, char a1, char a2, LBiCharConsumer func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LBiCharConsumer	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default void	handlingAccept(char a1, char a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static void	handlingAccept(char a1, char a2, LBiCharConsumer func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C1,C2,I2> int	iterate(IndexedRead<C1,aType.aChar> ia1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LBiCharConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2> int	iterate(SequentialRead<C1,I1,aType.aChar> sa1, C1 source1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LBiCharConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2> int	iterate(SequentialRead<C1,I1,aType.aChar> sa1, C1 source1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LBiCharConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
default LCharConsumer	lShrink(LCharUnaryOperator left)
default LCharConsumer	lShrinkc(char a1)
static LCharConsumer	lShrinked(LCharUnaryOperator left, LBiCharConsumer func)
static LCharConsumer	lShrinkedc(char a1, LBiCharConsumer func)
default void	nestingAccept(char a1, char a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
static LBiCharConsumer	recursive(LFunction<LBiCharConsumer,LBiCharConsumer> selfLambda)
default LCharConsumer	rShrink(LCharUnaryOperator right)
default LCharConsumer	rShrinkc(char a2)
static LCharConsumer	rShrinked(LCharUnaryOperator right, LBiCharConsumer func)
static LCharConsumer	rShrinkedc(char a2, LBiCharConsumer func)
static LBiCharConsumer	safe() Safe instance.
static LBiCharConsumer	safe(LBiCharConsumer other) Safe wrapping.
static LSupplier<LBiCharConsumer>	safeSupplier() Safe instance supplier.
static LSupplier<LBiCharConsumer>	safeSupplier(LSupplier<LBiCharConsumer> supplier) Safe supplier.
default void	shovingAccept(char a1, char a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
static <C2> char	targetedForEach(char a1, IndexedRead<C2,aType.aChar> ia2, C2 source2, LBiCharConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static <C2,I2> char	targetedIterate(char a1, SequentialRead<C2,I2,aType.aChar> sa2, C2 source2, LBiCharConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	times(int max_i, char a1, char a2, LBiCharConsumer func) From-To.
static void	tryAccept(char a1, char a2, LBiCharConsumer func)
static void	tryAccept(char a1, char a2, LBiCharConsumer func, ExWF<RuntimeException> exF)
static void	tryAccept(char a1, char a2, LBiCharConsumer func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static void	tryAcceptThen(char a1, char a2, LBiCharConsumer func, LConsumer<Throwable> handler)
default LBiCharConsumer	trying(ExWF<RuntimeException> exF)
default LBiCharConsumer	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBiCharConsumer	tryingThen(LConsumer<Throwable> handler)
default LTuple.Void	tupleAccept(LCharPair args)
static LBiCharConsumer	uncurry(LCharFunction<LCharConsumer> 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(char a1,
                    char a2)

acceptX

void acceptX(char a1,
             char a2)
      throws Throwable

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

Throws:

Throwable

tupleAccept

default LTuple.Void tupleAccept(LCharPair args)

handlingAccept

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

Function call that handles exceptions according to the instructions.

handling

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

accept

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

trying

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

accept

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

trying

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

acceptThen

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

tryingThen

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

nestingAccept

default void nestingAccept(char a1,
                           char a2)

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

shovingAccept

default void shovingAccept(char a1,
                           char a2)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingAccept

static void handlingAccept(char a1,
                           char a2,
                           LBiCharConsumer func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static void tryAccept(char a1,
                      char a2,
                      LBiCharConsumer func)

tryAccept

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

tryAccept

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

tryAcceptThen

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

failSafeAccept

default void failSafeAccept(char a1,
                            char a2,
                            @Nonnull
                            LBiCharConsumer failSafe)

failSafeAccept

static void failSafeAccept(char a1,
                           char a2,
                           LBiCharConsumer func,
                           @Nonnull
                           LBiCharConsumer failSafe)

failSafe

static LBiCharConsumer failSafe(LBiCharConsumer func,
                                @Nonnull
                                LBiCharConsumer 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,
                   char a1,
                   char a2,
                   LBiCharConsumer func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     char a1,
                     char a2,
                     LBiCharConsumer func)

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

times

static void times(int max_i,
                  char a1,
                  char a2,
                  LBiCharConsumer func)

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

lShrink

default LCharConsumer lShrink(LCharUnaryOperator left)

lShrinkc

default LCharConsumer lShrinkc(char a1)

lShrinked

static LCharConsumer lShrinked(LCharUnaryOperator left,
                               LBiCharConsumer func)

lShrinkedc

static LCharConsumer lShrinkedc(char a1,
                                LBiCharConsumer func)

rShrink

default LCharConsumer rShrink(LCharUnaryOperator right)

rShrinkc

default LCharConsumer rShrinkc(char a2)

rShrinked

static LCharConsumer rShrinked(LCharUnaryOperator right,
                               LBiCharConsumer func)

rShrinkedc

static LCharConsumer rShrinkedc(char a2,
                                LBiCharConsumer func)

uncurry

static LBiCharConsumer uncurry(LCharFunction<LCharConsumer> func)

capture

default LAction capture(char a1,
                        char a2)

Captures arguments but delays the evaluation.

accept1st

@Nonnull
static LBiCharConsumer accept1st(@Nonnull
                                           LCharConsumer func)

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

accept2nd

@Nonnull
static LBiCharConsumer accept2nd(@Nonnull
                                           LCharConsumer func)

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

biCharCons

@Nonnull
static LBiCharConsumer biCharCons(@Nonnull
                                            LBiCharConsumer lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

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

biCharConsThrowing

@Nonnull
static LBiCharConsumer biCharConsThrowing(@Nonnull
                                                    ExF<Throwable> exF)

biCharConsThrowing

@Nonnull
static LBiCharConsumer biCharConsThrowing(String message,
                                                    @Nonnull
                                                    ExMF<Throwable> exF)

char1Char0Cons

@Nonnull
static LBiCharConsumer.LChar1Char0Cons char1Char0Cons(@Nonnull
                                                                LBiCharConsumer.LChar1Char0Cons 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(char a1,
                 char a2,
                 @Nonnull
                 LBiCharConsumer lambda)

safe

@Nonnull
static LBiCharConsumer safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LBiCharConsumer> safeSupplier()

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

safe

@Nonnull
static LBiCharConsumer safe(@Nullable
                                      LBiCharConsumer other)

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

safeSupplier

@Nonnull
static LSupplier<LBiCharConsumer> safeSupplier(@Nullable
                                                         LSupplier<LBiCharConsumer> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

compose

@Nonnull
default LBiCharConsumer compose(@Nonnull
                                          LCharUnaryOperator before1,
                                          @Nonnull
                                          LCharUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LBiCharConsumer composed(@Nonnull
                                LCharUnaryOperator before1,
                                @Nonnull
                                LCharUnaryOperator before2,
                                LBiCharConsumer after)

biCharConsCompose

@Nonnull
default <V1,V2> LBiConsumer<V1,V2> biCharConsCompose(@Nonnull
                                                               LToCharFunction<? super V1> before1,
                                                               @Nonnull
                                                               LToCharFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

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

andThen

@Nonnull
default LBiCharConsumer andThen(@Nonnull
                                          LBiCharConsumer after)

Combines two LBiCharConsumer together in a order.

doNothing

static void doNothing(char a1,
                      char a2)

Does nothing (LBiCharConsumer)

forEach

static <C1,C2> int forEach(IndexedRead<C1,aType.aChar> ia1,
                           C1 source1,
                           IndexedRead<C2,aType.aChar> ia2,
                           C2 source2,
                           LBiCharConsumer 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.aChar> sa1,
                              C1 source1,
                              IndexedRead<C2,aType.aChar> ia2,
                              C2 source2,
                              LBiCharConsumer 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.aChar> ia1,
                              C1 source1,
                              SequentialRead<C2,I2,aType.aChar> sa2,
                              C2 source2,
                              LBiCharConsumer 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.aChar> sa1,
                                 C1 source1,
                                 SequentialRead<C2,I2,aType.aChar> sa2,
                                 C2 source2,
                                 LBiCharConsumer 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> char targetedForEach(char a1,
                                 IndexedRead<C2,aType.aChar> ia2,
                                 C2 source2,
                                 LBiCharConsumer 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> char targetedIterate(char a1,
                                    SequentialRead<C2,I2,aType.aChar> sa2,
                                    C2 source2,
                                    LBiCharConsumer 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.