Uses of Interface
eu.lunisolar.magma.func.consumer.primitives.bi.LBiIntConsumer

Packages that use LBiIntConsumer

Package	Description
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.predicate

Uses of LBiIntConsumer in eu.lunisolar.magma.func.consumer.primitives.bi

Subinterfaces of LBiIntConsumer in eu.lunisolar.magma.func.consumer.primitives.bi

Modifier and Type	Interface and Description
static interface	LBiIntConsumer.LInt1Int0Cons Permutation of LBiIntConsumer for method references.

Classes in eu.lunisolar.magma.func.consumer.primitives.bi that implement LBiIntConsumer

Modifier and Type	Class and Description
static class	LBiIntConsumer.LBiIntConsumerSingle

Methods in eu.lunisolar.magma.func.consumer.primitives.bi that return LBiIntConsumer

Modifier and Type	Method and Description
static LBiIntConsumer	LBiIntConsumer.accept1st(LIntConsumer func) Captures single parameter function into this interface where only 1st parameter will be used.
static LBiIntConsumer	LBiIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
default LBiIntConsumer	LBiIntConsumer.andThen(LBiIntConsumer after) Combines two LBiIntConsumer together in a order.
static LBiIntConsumer	LBiIntConsumer.biIntCons(LBiIntConsumer lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static LBiIntConsumer	LBiIntConsumer.biIntConsThrowing(ExF<Throwable> exF)
static LBiIntConsumer	LBiIntConsumer.biIntConsThrowing(String message, ExMF<Throwable> exF)
default LBiIntConsumer	LBiIntConsumer.compose(LIntUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
static LBiIntConsumer	LBiIntConsumer.composed(LIntUnaryOperator before1, LIntUnaryOperator before2, LBiIntConsumer after)
static LBiIntConsumer	LBiIntConsumer.failSafe(LBiIntConsumer func, LBiIntConsumer failSafe)
default LBiIntConsumer	LBiIntConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static LBiIntConsumer	LBiIntConsumer.recursive(LFunction<LBiIntConsumer,LBiIntConsumer> selfLambda)
static LBiIntConsumer	LBiIntConsumer.safe() Safe instance.
static LBiIntConsumer	LBiIntConsumer.safe(LBiIntConsumer other) Safe wrapping.
default LBiIntConsumer	LBiIntConsumer.trying(ExWF<RuntimeException> exF)
default LBiIntConsumer	LBiIntConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBiIntConsumer	LBiIntConsumer.tryingThen(LConsumer<Throwable> handler)
static LBiIntConsumer	LBiIntConsumer.uncurry(LIntFunction<LIntConsumer> func)
LBiIntConsumer	LBiIntConsumer.LBiIntConsumerSingle.value()

Methods in eu.lunisolar.magma.func.consumer.primitives.bi that return types with arguments of type LBiIntConsumer

Modifier and Type	Method and Description
static LSupplier<LBiIntConsumer>	LBiIntConsumer.safeSupplier() Safe instance supplier.
static LSupplier<LBiIntConsumer>	LBiIntConsumer.safeSupplier(LSupplier<LBiIntConsumer> supplier) Safe supplier.

Methods in eu.lunisolar.magma.func.consumer.primitives.bi with parameters of type LBiIntConsumer

Modifier and Type	Method and Description
default LBiIntConsumer	LBiIntConsumer.andThen(LBiIntConsumer after) Combines two LBiIntConsumer together in a order.
static LBiIntConsumer	LBiIntConsumer.biIntCons(LBiIntConsumer lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static void	LBiIntConsumer.call(int a1, int a2, LBiIntConsumer lambda)
static LBiIntConsumer	LBiIntConsumer.composed(LIntUnaryOperator before1, LIntUnaryOperator before2, LBiIntConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiIntConsumer.composed(LToIntFunction<? super V1> before1, LToIntFunction<? super V2> before2, LBiIntConsumer after)
static LBiIntConsumer	LBiIntConsumer.failSafe(LBiIntConsumer func, LBiIntConsumer failSafe)
default void	LBiIntConsumer.failSafeAccept(int a1, int a2, LBiIntConsumer failSafe)
static void	LBiIntConsumer.failSafeAccept(int a1, int a2, LBiIntConsumer func, LBiIntConsumer failSafe)
static <C1,C2> int	LBiIntConsumer.forEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	LBiIntConsumer.fromTill(int min_i, int max_i, int a1, int a2, LBiIntConsumer func) From-To.
static void	LBiIntConsumer.fromTo(int min_i, int max_i, int a1, int a2, LBiIntConsumer func) From-To.
static void	LBiIntConsumer.handlingAccept(int a1, int a2, LBiIntConsumer func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C2> int	LBiIntConsumer.indexed1stForEach(IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C2,I2> int	LBiIntConsumer.indexed1stIterate(SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1> int	LBiIntConsumer.indexed2ndForEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1> int	LBiIntConsumer.indexed2ndIterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C2,I2> int	LBiIntConsumer.iterate(IndexedRead<C1,aType.aInt> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2> int	LBiIntConsumer.iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2> int	LBiIntConsumer.iterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static LIntConsumer	LBiIntConsumer.lShrinked(LIntUnaryOperator left, LBiIntConsumer func)
static LIntConsumer	LBiIntConsumer.lShrinkedc(int a1, LBiIntConsumer func)
static LIntConsumer	LBiIntConsumer.rShrinked(LIntUnaryOperator right, LBiIntConsumer func)
static LIntConsumer	LBiIntConsumer.rShrinkedc(int a2, LBiIntConsumer func)
static LBiIntConsumer	LBiIntConsumer.safe(LBiIntConsumer other) Safe wrapping.
static <C2> int	LBiIntConsumer.targetedForEach(int a1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static <C2,I2> int	LBiIntConsumer.targetedIterate(int a1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer.
static void	LBiIntConsumer.times(int max_i, int a1, int a2, LBiIntConsumer func) From-To.
static void	LBiIntConsumer.tryAccept(int a1, int a2, LBiIntConsumer func)
static void	LBiIntConsumer.tryAccept(int a1, int a2, LBiIntConsumer func, ExWF<RuntimeException> exF)
static void	LBiIntConsumer.tryAccept(int a1, int a2, LBiIntConsumer func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static void	LBiIntConsumer.tryAcceptThen(int a1, int a2, LBiIntConsumer func, LConsumer<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.consumer.primitives.bi with type arguments of type LBiIntConsumer

Modifier and Type	Method and Description
static LBiIntConsumer	LBiIntConsumer.recursive(LFunction<LBiIntConsumer,LBiIntConsumer> selfLambda)
static LBiIntConsumer	LBiIntConsumer.recursive(LFunction<LBiIntConsumer,LBiIntConsumer> selfLambda)
static LSupplier<LBiIntConsumer>	LBiIntConsumer.safeSupplier(LSupplier<LBiIntConsumer> supplier) Safe supplier.

Uses of LBiIntConsumer in eu.lunisolar.magma.func.consumer.primitives.obj

Methods in eu.lunisolar.magma.func.consumer.primitives.obj that return LBiIntConsumer

Modifier and Type	Method and Description
default LBiIntConsumer	LTieIntConsumer.lShrink(LBiIntFunction<T> left)
default LBiIntConsumer	LTieIntConsumer.lShrinkc(T a1)
static <T> LBiIntConsumer	LTieIntConsumer.lShrinked(LBiIntFunction<T> left, LTieIntConsumer<T> func)
static <T> LBiIntConsumer	LTieIntConsumer.lShrinkedc(T a1, LTieIntConsumer<T> func)

Uses of LBiIntConsumer in eu.lunisolar.magma.func.function.from

Methods in eu.lunisolar.magma.func.function.from that return LBiIntConsumer

Modifier and Type	Method and Description
default LBiIntConsumer	LBiIntFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.function.from with parameters of type LBiIntConsumer

Modifier and Type	Method and Description
default LBiIntFunction<R>	LBiIntFunction.before(LBiIntConsumer before)

Uses of LBiIntConsumer in eu.lunisolar.magma.func.predicate

Methods in eu.lunisolar.magma.func.predicate with parameters of type LBiIntConsumer

Modifier and Type	Method and Description
default boolean	LBiIntPredicate.doIf(int a1, int a2, LBiIntConsumer consumer)
static boolean	LBiIntPredicate.doIf(int a1, int a2, LBiIntPredicate predicate, LBiIntConsumer consumer)
default <C1,C2> void	LBiIntPredicate.filterForEach(IndexedRead<C1,aType.aInt> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2> void	LBiIntPredicate.filterIterate(IndexedRead<C1,aType.aInt> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2> void	LBiIntPredicate.filterIterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2> void	LBiIntPredicate.filterIterate(SequentialRead<C1,I1,aType.aInt> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LBiIntConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.