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

Interface LBiLongConsumer

All Superinterfaces:

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

All Known Subinterfaces:

LBiLongConsumer.LLong1Long0Cons

All Known Implementing Classes:

LBiLongConsumer.LBiLongConsumerSingle

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

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

Type: consumer

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

Co-domain: none

Nested Class Summary

Nested Classes

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

acceptX

void acceptX(long a1,
             long a2)
      throws Throwable

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

Throws:

Throwable

tupleAccept

default LTuple.Void tupleAccept(LLongPair args)

handlingAccept

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

Function call that handles exceptions according to the instructions.

handling

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

accept

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

trying

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

accept

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

trying

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

acceptThen

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

tryingThen

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

nestingAccept

default void nestingAccept(long a1,
                           long a2)

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

shovingAccept

default void shovingAccept(long a1,
                           long a2)

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

handlingAccept

static void handlingAccept(long a1,
                           long a2,
                           LBiLongConsumer func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryAccept

static void tryAccept(long a1,
                      long a2,
                      LBiLongConsumer func)

tryAccept

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

tryAccept

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

tryAcceptThen

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

failSafeAccept

default void failSafeAccept(long a1,
                            long a2,
                            @Nonnull
                            LBiLongConsumer failSafe)

failSafeAccept

static void failSafeAccept(long a1,
                           long a2,
                           LBiLongConsumer func,
                           @Nonnull
                           LBiLongConsumer failSafe)

failSafe

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

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     long a1,
                     long a2,
                     LBiLongConsumer func)

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

times

static void times(int max_i,
                  long a1,
                  long a2,
                  LBiLongConsumer func)

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

lShrink

default LLongConsumer lShrink(LLongUnaryOperator left)

lShrinkc

default LLongConsumer lShrinkc(long a1)

lShrinked

static LLongConsumer lShrinked(LLongUnaryOperator left,
                               LBiLongConsumer func)

lShrinkedc

static LLongConsumer lShrinkedc(long a1,
                                LBiLongConsumer func)

rShrink

default LLongConsumer rShrink(LLongUnaryOperator right)

rShrinkc

default LLongConsumer rShrinkc(long a2)

rShrinked

static LLongConsumer rShrinked(LLongUnaryOperator right,
                               LBiLongConsumer func)

rShrinkedc

static LLongConsumer rShrinkedc(long a2,
                                LBiLongConsumer func)

uncurry

static LBiLongConsumer uncurry(LLongFunction<LLongConsumer> func)

capture

default LAction capture(long a1,
                        long a2)

Captures arguments but delays the evaluation.

accept1st

@Nonnull
static LBiLongConsumer accept1st(@Nonnull
                                           LLongConsumer func)

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

accept2nd

@Nonnull
static LBiLongConsumer accept2nd(@Nonnull
                                           LLongConsumer func)

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

biLongCons

@Nonnull
static LBiLongConsumer biLongCons(@Nonnull
                                            LBiLongConsumer lambda)

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

recursive

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

biLongConsThrowing

@Nonnull
static LBiLongConsumer biLongConsThrowing(@Nonnull
                                                    ExF<Throwable> exF)

biLongConsThrowing

@Nonnull
static LBiLongConsumer biLongConsThrowing(String message,
                                                    @Nonnull
                                                    ExMF<Throwable> exF)

long1Long0Cons

@Nonnull
static LBiLongConsumer.LLong1Long0Cons long1Long0Cons(@Nonnull
                                                                LBiLongConsumer.LLong1Long0Cons 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(long a1,
                 long a2,
                 @Nonnull
                 LBiLongConsumer lambda)

safe

@Nonnull
static LBiLongConsumer safe()

Safe instance.

safeSupplier

@Nonnull
static LSupplier<LBiLongConsumer> safeSupplier()

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

safe

@Nonnull
static LBiLongConsumer safe(@Nullable
                                      LBiLongConsumer other)

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

safeSupplier

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

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

compose

@Nonnull
default LBiLongConsumer compose(@Nonnull
                                          LLongUnaryOperator before1,
                                          @Nonnull
                                          LLongUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LBiLongConsumer composed(@Nonnull
                                LLongUnaryOperator before1,
                                @Nonnull
                                LLongUnaryOperator before2,
                                LBiLongConsumer after)

biLongConsCompose

@Nonnull
default <V1,V2> LBiConsumer<V1,V2> biLongConsCompose(@Nonnull
                                                               LToLongFunction<? super V1> before1,
                                                               @Nonnull
                                                               LToLongFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

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

andThen

@Nonnull
default LBiLongConsumer andThen(@Nonnull
                                          LBiLongConsumer after)

Combines two LBiLongConsumer together in a order.

doNothing

static void doNothing(long a1,
                      long a2)

Does nothing (LBiLongConsumer)

forEach

static <C1,C2> int forEach(IndexedRead<C1,aType.aLong> ia1,
                           C1 source1,
                           IndexedRead<C2,aType.aLong> ia2,
                           C2 source2,
                           LBiLongConsumer 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.aLong> sa1,
                              C1 source1,
                              IndexedRead<C2,aType.aLong> ia2,
                              C2 source2,
                              LBiLongConsumer 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.aLong> ia1,
                              C1 source1,
                              SequentialRead<C2,I2,aType.aLong> sa2,
                              C2 source2,
                              LBiLongConsumer 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.aLong> sa1,
                                 C1 source1,
                                 SequentialRead<C2,I2,aType.aLong> sa2,
                                 C2 source2,
                                 LBiLongConsumer 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.

indexed1stForEach

static <C2> long indexed1stForEach(IndexedRead<C2,aType.aLong> ia2,
                                   C2 source2,
                                   LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer (with index). Thread safety, fail-fast, fail-safety of this method is not expected.

indexed1stIterate

static <C2,I2> long indexed1stIterate(SequentialRead<C2,I2,aType.aLong> sa2,
                                      C2 source2,
                                      LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer (with index). Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.

indexed2ndForEach

static <C1> long indexed2ndForEach(IndexedRead<C1,aType.aLong> ia1,
                                   C1 source1,
                                   LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer (with index). Thread safety, fail-fast, fail-safety of this method is not expected.

indexed2ndIterate

static <C1,I1> long indexed2ndIterate(SequentialRead<C1,I1,aType.aLong> sa1,
                                      C1 source1,
                                      LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer (with index). Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.

targetedForEach

static <C2> long targetedForEach(long a1,
                                 IndexedRead<C2,aType.aLong> ia2,
                                 C2 source2,
                                 LBiLongConsumer 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> long targetedIterate(long a1,
                                    SequentialRead<C2,I2,aType.aLong> sa2,
                                    C2 source2,
                                    LBiLongConsumer 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.