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

Interface LBiByteConsumer

All Superinterfaces:

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

All Known Subinterfaces:

LBiByteConsumer.LByte1Byte0Cons

All Known Implementing Classes:

LBiByteConsumer.LBiByteConsumerSingle

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

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

Type: consumer

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

Co-domain: none

Nested Class Summary

Nested Classes

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

acceptX

void acceptX(byte a1,
             byte a2)
      throws Throwable

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

Throws:

Throwable

tupleAccept

default LTuple.Void tupleAccept(LBytePair args)

handlingAccept

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

Function call that handles exceptions according to the instructions.

handling

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

accept

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

trying

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

accept

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

trying

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

acceptThen

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

tryingThen

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

nestingAccept

default void nestingAccept(byte a1,
                           byte a2)

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

shovingAccept

default void shovingAccept(byte a1,
                           byte a2)

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

handlingAccept

static void handlingAccept(byte a1,
                           byte a2,
                           LBiByteConsumer func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static void tryAccept(byte a1,
                      byte a2,
                      LBiByteConsumer func)

tryAccept

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

tryAccept

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

tryAcceptThen

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

failSafeAccept

default void failSafeAccept(byte a1,
                            byte a2,
                            @Nonnull
                            LBiByteConsumer failSafe)

failSafeAccept

static void failSafeAccept(byte a1,
                           byte a2,
                           LBiByteConsumer func,
                           @Nonnull
                           LBiByteConsumer failSafe)

failSafe

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

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     byte a1,
                     byte a2,
                     LBiByteConsumer func)

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

times

static void times(int max_i,
                  byte a1,
                  byte a2,
                  LBiByteConsumer func)

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

lShrink

default LByteConsumer lShrink(LByteUnaryOperator left)

lShrinkc

default LByteConsumer lShrinkc(byte a1)

lShrinked

static LByteConsumer lShrinked(LByteUnaryOperator left,
                               LBiByteConsumer func)

lShrinkedc

static LByteConsumer lShrinkedc(byte a1,
                                LBiByteConsumer func)

rShrink

default LByteConsumer rShrink(LByteUnaryOperator right)

rShrinkc

default LByteConsumer rShrinkc(byte a2)

rShrinked

static LByteConsumer rShrinked(LByteUnaryOperator right,
                               LBiByteConsumer func)

rShrinkedc

static LByteConsumer rShrinkedc(byte a2,
                                LBiByteConsumer func)

uncurry

static LBiByteConsumer uncurry(LByteFunction<LByteConsumer> func)

capture

default LAction capture(byte a1,
                        byte a2)

Captures arguments but delays the evaluation.

accept1st

@Nonnull
static LBiByteConsumer accept1st(@Nonnull
                                           LByteConsumer func)

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

accept2nd

@Nonnull
static LBiByteConsumer accept2nd(@Nonnull
                                           LByteConsumer func)

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

biByteCons

@Nonnull
static LBiByteConsumer biByteCons(@Nonnull
                                            LBiByteConsumer lambda)

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

recursive

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

biByteConsThrowing

@Nonnull
static LBiByteConsumer biByteConsThrowing(@Nonnull
                                                    ExF<Throwable> exF)

biByteConsThrowing

@Nonnull
static LBiByteConsumer biByteConsThrowing(String message,
                                                    @Nonnull
                                                    ExMF<Throwable> exF)

byte1Byte0Cons

@Nonnull
static LBiByteConsumer.LByte1Byte0Cons byte1Byte0Cons(@Nonnull
                                                                LBiByteConsumer.LByte1Byte0Cons 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(byte a1,
                 byte a2,
                 @Nonnull
                 LBiByteConsumer lambda)

safe

@Nonnull
static LBiByteConsumer safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LBiByteConsumer> safeSupplier()

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

safe

@Nonnull
static LBiByteConsumer safe(@Nullable
                                      LBiByteConsumer other)

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

safeSupplier

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

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

compose

@Nonnull
default LBiByteConsumer compose(@Nonnull
                                          LByteUnaryOperator before1,
                                          @Nonnull
                                          LByteUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LBiByteConsumer composed(@Nonnull
                                LByteUnaryOperator before1,
                                @Nonnull
                                LByteUnaryOperator before2,
                                LBiByteConsumer after)

biByteConsCompose

@Nonnull
default <V1,V2> LBiConsumer<V1,V2> biByteConsCompose(@Nonnull
                                                               LToByteFunction<? super V1> before1,
                                                               @Nonnull
                                                               LToByteFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

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

andThen

@Nonnull
default LBiByteConsumer andThen(@Nonnull
                                          LBiByteConsumer after)

Combines two LBiByteConsumer together in a order.

doNothing

static void doNothing(byte a1,
                      byte a2)

Does nothing (LBiByteConsumer)

forEach

static <C1,C2> int forEach(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. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

static <C1,I1,C2> int iterate(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. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

static <C1,C2,I2> int iterate(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. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

static <C1,I1,C2,I2> int iterate(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. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.

targetedForEach

static <C2> byte targetedForEach(byte a1,
                                 IndexedRead<C2,aType.aByte> ia2,
                                 C2 source2,
                                 LBiByteConsumer 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> byte targetedIterate(byte a1,
                                    SequentialRead<C2,I2,aType.aByte> sa2,
                                    C2 source2,
                                    LBiByteConsumer 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.