Uses of Interface
eu.lunisolar.magma.func.consumer.LTriConsumer

Packages that use LTriConsumer

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

Uses of LTriConsumer in eu.lunisolar.magma.func.consumer

Subinterfaces of LTriConsumer in eu.lunisolar.magma.func.consumer

Modifier and Type	Interface and Description
static interface	LTriConsumer.LBiObj1Obj0Cons<T3,T2,T1> Permutation of LTriConsumer for method references.
static interface	LTriConsumer.LObj0Obj2Obj1Cons<T1,T3,T2> Permutation of LTriConsumer for method references.
static interface	LTriConsumer.LObj1BiObj2Cons<T2,T1,T3> Permutation of LTriConsumer for method references.
static interface	LTriConsumer.LObj1Obj2Obj0Cons<T2,T3,T1> Permutation of LTriConsumer for method references.
static interface	LTriConsumer.LObj2Obj0Obj1Cons<T3,T1,T2> Permutation of LTriConsumer for method references.

Classes in eu.lunisolar.magma.func.consumer that implement LTriConsumer

Modifier and Type	Class and Description
static class	LTriConsumer.LTriConsumerSingle<T1,T2,T3>

Methods in eu.lunisolar.magma.func.consumer that return LTriConsumer

Modifier and Type	Method and Description
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.accept1st(LConsumer<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.accept2nd(LConsumer<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.accept3rd(LConsumer<T3> func) Captures single parameter function into this interface where only 3rd parameter will be used.
default LTriConsumer<T1,T2,T3>	LTriConsumer.andThen(LTriConsumer<? super T1,? super T2,? super T3> after) Combines two LTriConsumer<T1,T2,T3> together in a order.
default <V2,V3,V4> LTriConsumer<V2,V3,V4>	LTriConsumer.cast() Cast that replace generics.
static <V2,V3,V4,T1,T2,T3> LTriConsumer<V2,V3,V4>	LTriConsumer.cast(LTriConsumer<T1,T2,T3> function) Cast that replace generics.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTriConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T1,T2,T3> LTriConsumer<V1,V2,V3>	LTriConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriConsumer<T1,T2,T3> after)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.failSafe(LTriConsumer<T1,T2,T3> func, LTriConsumer<T1,T2,T3> failSafe)
default LTriConsumer<T1,T2,T3>	LTriConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.recursive(LFunction<LTriConsumer<T1,T2,T3>,LTriConsumer<T1,T2,T3>> selfLambda)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.safe() Safe instance.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.safe(LTriConsumer<T1,T2,T3> other) Safe wrapping.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.triCons(LTriConsumer<T1,T2,T3> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.triConsThrowing(ExF<Throwable> exF)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.triConsThrowing(String message, ExMF<Throwable> exF)
default LTriConsumer<T1,T2,T3>	LTriConsumer.trying(ExWF<RuntimeException> exF)
default LTriConsumer<T1,T2,T3>	LTriConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LTriConsumer<T1,T2,T3>	LTriConsumer.tryingThen(LConsumer<Throwable> handler)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.uncurry(LFunction<T1,LFunction<T2,LConsumer<T3>>> func)
default LTriConsumer	LTriConsumer.untyped() Cast that removes generics.
LTriConsumer<T1,T2,T3>	LTriConsumer.LTriConsumerSingle.value()

Methods in eu.lunisolar.magma.func.consumer that return types with arguments of type LTriConsumer

Modifier and Type	Method and Description
static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>>	LTriConsumer.safeSupplier() Safe instance supplier.
static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>>	LTriConsumer.safeSupplier(LSupplier<LTriConsumer<T1,T2,T3>> supplier) Safe supplier.

Methods in eu.lunisolar.magma.func.consumer with parameters of type LTriConsumer

Modifier and Type	Method and Description
default LTriConsumer<T1,T2,T3>	LTriConsumer.andThen(LTriConsumer<? super T1,? super T2,? super T3> after) Combines two LTriConsumer<T1,T2,T3> together in a order.
static <T1,T2,T3> void	LTriConsumer.call(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> lambda)
static <V2,V3,V4,T1,T2,T3> LTriConsumer<V2,V3,V4>	LTriConsumer.cast(LTriConsumer<T1,T2,T3> function) Cast that replace generics.
static <V1,V2,V3,T1,T2,T3> LTriConsumer<V1,V2,V3>	LTriConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LFunction<? super V3,? extends T3> before3, LTriConsumer<T1,T2,T3> after)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.failSafe(LTriConsumer<T1,T2,T3> func, LTriConsumer<T1,T2,T3> failSafe)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.failSafe(LTriConsumer<T1,T2,T3> func, LTriConsumer<T1,T2,T3> failSafe)
default void	LTriConsumer.failSafeAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> failSafe)
static <T1,T2,T3> void	LTriConsumer.failSafeAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, LTriConsumer<T1,T2,T3> failSafe)
static <T1,T2,T3> void	LTriConsumer.failSafeAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, LTriConsumer<T1,T2,T3> failSafe)
static <C1,C2,C3,T1,T2,T3> int	LTriConsumer.forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,T2,T3> void	LTriConsumer.fromTill(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func) From-To.
static <T1,T2,T3> void	LTriConsumer.fromTo(int min_i, int max_i, T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func) From-To.
static <T1,T2,T3> void	LTriConsumer.handlingAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C1,C2,C3,I3,T1,T2,T3> int	LTriConsumer.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,C2,I2,C3,T1,T2,T3> int	LTriConsumer.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,C2,I2,C3,I3,T1,T2,T3> int	LTriConsumer.iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,C3,T1,T2,T3> int	LTriConsumer.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,C3,I3,T1,T2,T3> int	LTriConsumer.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,C3,T1,T2,T3> int	LTriConsumer.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,C3,I3,T1,T2,T3> int	LTriConsumer.iterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T2,T3,T1> LBiConsumer<T2,T3>	LTriConsumer.lShrinked(LBiFunction<T2,T3,T1> left, LTriConsumer<T1,T2,T3> func)
static <T2,T3,T1> LBiConsumer<T2,T3>	LTriConsumer.lShrinkedc(T1 a1, LTriConsumer<T1,T2,T3> func)
static <C,T,T1,T2> T	LTriConsumer.pairForEach(T target, IndexedRead<C,aType.a<? extends Object>> ia, C s, LTriConsumer<T,T1,T2> consumer)
static <C,I,T,T1,T2> T	LTriConsumer.pairIterate(T target, SequentialRead<C,I,aType.a<? extends Object>> sa, C s, LTriConsumer<T,T1,T2> consumer)
static <T1,T2,T3> LBiConsumer<T1,T2>	LTriConsumer.rShrinked(LBiFunction<T1,T2,T3> right, LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> LBiConsumer<T1,T2>	LTriConsumer.rShrinkedc(T3 a3, LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.safe(LTriConsumer<T1,T2,T3> other) Safe wrapping.
static <T1,C2,C3,T2,T3> T1	LTriConsumer.targetedForEach(T1 a1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,C3,I3,T2,T3> T1	LTriConsumer.targetedIterate(T1 a1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,I2,C3,T2,T3> T1	LTriConsumer.targetedIterate(T1 a1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,C2,I2,C3,I3,T2,T3> T1	LTriConsumer.targetedIterate(T1 a1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T1,T2,T3> void	LTriConsumer.times(int max_i, T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func) From-To.
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.triCons(LTriConsumer<T1,T2,T3> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2,T3> void	LTriConsumer.tryAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func)
static <T1,T2,T3> void	LTriConsumer.tryAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, ExWF<RuntimeException> exF)
static <T1,T2,T3> void	LTriConsumer.tryAccept(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2,T3> void	LTriConsumer.tryAcceptThen(T1 a1, T2 a2, T3 a3, LTriConsumer<T1,T2,T3> func, LConsumer<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.consumer with type arguments of type LTriConsumer

Modifier and Type	Method and Description
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.recursive(LFunction<LTriConsumer<T1,T2,T3>,LTriConsumer<T1,T2,T3>> selfLambda)
static <T1,T2,T3> LTriConsumer<T1,T2,T3>	LTriConsumer.recursive(LFunction<LTriConsumer<T1,T2,T3>,LTriConsumer<T1,T2,T3>> selfLambda)
static <T1,T2,T3> LSupplier<LTriConsumer<T1,T2,T3>>	LTriConsumer.safeSupplier(LSupplier<LTriConsumer<T1,T2,T3>> supplier) Safe supplier.

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

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

Modifier and Type	Method and Description
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjBoolConsumer.biObjBoolConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.biObjByteConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjCharConsumer.biObjCharConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjDblConsumer.biObjDblConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.biObjFltConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjIntConsumer.biObjIntConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.biObjLongConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjSrtConsumer.biObjSrtConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3, LTieBoolConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieByteConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3, LTieByteConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieCharConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3, LTieCharConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieDblConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LTieDblConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieFltConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LTieFltConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieIntConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3, LTieIntConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieLongConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3, LTieLongConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieSrtConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3, LTieSrtConsumer<T> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjBoolConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LPredicate<? super V3> before3, LBiObjBoolConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjByteConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteFunction<? super V3> before3, LBiObjByteConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjCharConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToCharFunction<? super V3> before3, LBiObjCharConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjDblConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjIntConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToIntFunction<? super V3> before3, LBiObjIntConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjLongConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToLongFunction<? super V3> before3, LBiObjLongConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjSrtConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtConsumer<T1,T2> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieBoolConsumer.tieBoolConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieByteConsumer.tieByteConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToByteFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieCharConsumer.tieCharConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToCharFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieConsumer.tieConsCompose(LFunction<? super V1,? extends T1> before1, LToIntFunction<? super V2> before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieDblConsumer.tieDblConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieFltConsumer.tieFltConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieIntConsumer.tieIntConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToIntFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieLongConsumer.tieLongConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToLongFunction<? super V3> before3) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieSrtConsumer.tieSrtConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToSrtFunction<? super V3> before3) Allows to manipulate the domain of the function.

Uses of LTriConsumer in eu.lunisolar.magma.func.consumer.primitives.tri

Methods in eu.lunisolar.magma.func.consumer.primitives.tri that return LTriConsumer

Modifier and Type	Method and Description
static <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTriBoolConsumer.composed(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3, LTriBoolConsumer after)
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTriBoolConsumer.triBoolConsCompose(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3) Allows to manipulate the domain of the function.

Uses of LTriConsumer in eu.lunisolar.magma.func.function

Methods in eu.lunisolar.magma.func.function that return LTriConsumer

Modifier and Type	Method and Description
default LTriConsumer<T1,T2,T3>	LTriFunction.thenConsume(LConsumer<? super R> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LTriFunction<T1,T2,T3,R>	LTriFunction.before(LTriConsumer<? super T1,? super T2,? super T3> before)

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

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

Modifier and Type	Method and Description
default boolean	LTriPredicate.doIf(T1 a1, T2 a2, T3 a3, LTriConsumer<? super T1,? super T2,? super T3> consumer)
static <T1,T2,T3> boolean	LTriPredicate.doIf(T1 a1, T2 a2, T3 a3, LTriPredicate<T1,T2,T3> predicate, LTriConsumer<? super T1,? super T2,? super T3> consumer)
default <V> boolean	LBiPredicate.doIf(V a1, T1 a2, T2 a3, LTriConsumer<V,? super T1,? super T2> consumer)
default <C1,C2,C3> void	LTriPredicate.filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,C3,I3> void	LTriPredicate.filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2,C3> void	LTriPredicate.filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2,C3,I3> void	LTriPredicate.filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,C3> void	LTriPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,C3,I3> void	LTriPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2,C3> void	LTriPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.a<T3>> ia3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2,C3,I3> void	LTriPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T3>> sa3, C3 source3, LTriConsumer<? super T1,? super T2,? super T3> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.