Uses of Interface
eu.lunisolar.magma.func.consumer.primitives.obj.LTieLongConsumer

Packages that use LTieLongConsumer

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

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

Subinterfaces of LTieLongConsumer in eu.lunisolar.magma.func.consumer.primitives.obj

Modifier and Type	Interface and Description
static interface	LTieLongConsumer.LIntLongObjCons<T> Permutation of LTieLongConsumer for method references.
static interface	LTieLongConsumer.LIntObjLongCons<T> Permutation of LTieLongConsumer for method references.
static interface	LTieLongConsumer.LLongIntObjCons<T> Permutation of LTieLongConsumer for method references.
static interface	LTieLongConsumer.LLongObjIntCons<T> Permutation of LTieLongConsumer for method references.
static interface	LTieLongConsumer.LObjLongIntCons<T> Permutation of LTieLongConsumer for method references.

Classes in eu.lunisolar.magma.func.consumer.primitives.obj that implement LTieLongConsumer

Modifier and Type	Class and Description
static class	LTieLongConsumer.LTieLongConsumerSingle<T>

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

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

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

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

Methods in eu.lunisolar.magma.func.consumer.primitives.obj with parameters of type LTieLongConsumer

Modifier and Type	Method and Description
default LTieLongConsumer<T>	LTieLongConsumer.andThen(LTieLongConsumer<? super T> after) Combines two LTieLongConsumer together in a order.
static <T> void	LTieLongConsumer.call(T a1, int a2, long a3, LTieLongConsumer<T> lambda)
static <V2,T> LTieLongConsumer<V2>	LTieLongConsumer.cast(LTieLongConsumer<T> function) Cast that replace generics.
static <V1,T> LTieLongConsumer<V1>	LTieLongConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LTieLongConsumer<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 <T> LTieLongConsumer<T>	LTieLongConsumer.failSafe(LTieLongConsumer<T> func, LTieLongConsumer<T> failSafe)
static <T> LTieLongConsumer<T>	LTieLongConsumer.failSafe(LTieLongConsumer<T> func, LTieLongConsumer<T> failSafe)
default void	LTieLongConsumer.failSafeAccept(T a1, int a2, long a3, LTieLongConsumer<T> failSafe)
static <T> void	LTieLongConsumer.failSafeAccept(T a1, int a2, long a3, LTieLongConsumer<T> func, LTieLongConsumer<T> failSafe)
static <T> void	LTieLongConsumer.failSafeAccept(T a1, int a2, long a3, LTieLongConsumer<T> func, LTieLongConsumer<T> failSafe)
static <C1,C2,C3,T> int	LTieLongConsumer.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T> void	LTieLongConsumer.fromTill(int min_i, int max_i, T a1, int a2, long a3, LTieLongConsumer<T> func) From-To.
static <T> void	LTieLongConsumer.fromTo(int min_i, int max_i, T a1, int a2, long a3, LTieLongConsumer<T> func) From-To.
static <T> void	LTieLongConsumer.handlingAccept(T a1, int a2, long a3, LTieLongConsumer<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C1,C3,T> int	LTieLongConsumer.indexed2ndForEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C3,I3,T> int	LTieLongConsumer.indexed2ndIterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1,C3,T> int	LTieLongConsumer.indexed2ndIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1,C3,I3,T> int	LTieLongConsumer.indexed2ndIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C2,T> long	LTieLongConsumer.indexed3rdForEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C2,I2,T> long	LTieLongConsumer.indexed3rdIterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1,C2,T> long	LTieLongConsumer.indexed3rdIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,I1,C2,I2,T> long	LTieLongConsumer.indexed3rdIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with index).
static <C1,C2,C3,I3,T> int	LTieLongConsumer.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,C2,I2,C3,T> int	LTieLongConsumer.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,C2,I2,C3,I3,T> int	LTieLongConsumer.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,C3,T> int	LTieLongConsumer.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,C3,I3,T> int	LTieLongConsumer.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,C3,T> int	LTieLongConsumer.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,C3,I3,T> int	LTieLongConsumer.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T,C3> T	LTieLongConsumer.ntiForEach(LIntFunction<T> trgFactory1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH_NEW: FOR, [SourcePurpose{arg=T trg1, type=SIZE_FACTORY}, SourcePurpose{arg=long a3, type=IA}, SourcePurpose{arg=LTieLongConsumer<? super T> consumer, type=CONST}]
static <T,C3,I3> T	LTieLongConsumer.ntiIterate(LSupplier<T> source1, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_ITERATE_NEW: WHILE, [SourcePurpose{arg=T trg1, type=SUPPLIER}, SourcePurpose{arg=long a3, type=SA}, SourcePurpose{arg=LTieLongConsumer<? super T> consumer, type=CONST}]
static <T> LTieLongConsumer<T>	LTieLongConsumer.safe(LTieLongConsumer<T> other) Safe wrapping.
static <T,C2,C3> T	LTieLongConsumer.targetedForEach(T a1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T,C2,C3,I3> T	LTieLongConsumer.targetedIterate(T a1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T,C2,I2,C3> T	LTieLongConsumer.targetedIterate(T a1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T,C2,I2,C3,I3> T	LTieLongConsumer.targetedIterate(T a1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T,SRC> int	LTieLongConsumer.tieForEach(int sStart, int sEnd, int tStart, T trg1, SRC src3, LOiToLongFunction<SRC> srcAcc3, LTieLongConsumer<? super T> consumer) ITERATION: TIE_CONSUMER: FOR, [SourcePurpose{arg=int sStart, type=CONST}, SourcePurpose{arg=int sEnd, type=CONST}, SourcePurpose{arg=int tStart, type=CONST}, SourcePurpose{arg=T trg1, type=CONST}, SourcePurpose{arg=long a3, type=TIE_SOURCE}, SourcePurpose{arg=long a3, type=TIE_SUPPLIER}, SourcePurpose{arg=LTieLongConsumer<? super T> consumer, type=CONST}]
static <T,SRC> int	LTieLongConsumer.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToLongFunction<SRC> srcAcc3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T,C3> int	LTieLongConsumer.tieForEach(T trg1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) ITERATION: TIE_CONSUMER_SHORT: FOR, [SourcePurpose{arg=T trg1, type=CONST}, SourcePurpose{arg=long a3, type=IA}, SourcePurpose{arg=LTieLongConsumer<? super T> consumer, type=CONST}]
static <T,C3,I3> int	LTieLongConsumer.tieIterate(T trg1, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T> LTieLongConsumer<T>	LTieLongConsumer.tieLongCons(LTieLongConsumer<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T,C3> T	LTieLongConsumer.tiForEach(T trg1, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) ITERATION: TARGETED_INDEXED_FOR_EACH: FOR, [SourcePurpose{arg=T trg1, type=CONST}, SourcePurpose{arg=long a3, type=IA}, SourcePurpose{arg=LTieLongConsumer<? super T> consumer, type=CONST}]
static <T,C3,I3> T	LTieLongConsumer.tiIterate(T trg1, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T> void	LTieLongConsumer.times(int max_i, T a1, int a2, long a3, LTieLongConsumer<T> func) From-To.
static <T> void	LTieLongConsumer.tryAccept(T a1, int a2, long a3, LTieLongConsumer<T> func)
static <T> void	LTieLongConsumer.tryAccept(T a1, int a2, long a3, LTieLongConsumer<T> func, ExWF<RuntimeException> exF)
static <T> void	LTieLongConsumer.tryAccept(T a1, int a2, long a3, LTieLongConsumer<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T> void	LTieLongConsumer.tryAcceptThen(T a1, int a2, long a3, LTieLongConsumer<T> func, LConsumer<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.consumer.primitives.obj with type arguments of type LTieLongConsumer

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

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

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

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

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

Modifier and Type	Method and Description
default LObjIntLongFunction<T,R>	LObjIntLongFunction.before(LTieLongConsumer<? super T> before)

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

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

Modifier and Type	Method and Description
static <T> boolean	LObjIntLongPredicate.doIf(T a1, int a2, long a3, LObjIntLongPredicate<T> predicate, LTieLongConsumer<? super T> consumer)
default boolean	LObjIntLongPredicate.doIf(T a1, int a2, long a3, LTieLongConsumer<? super T> consumer)
default <V> boolean	LLongPredicate.doIf(V a1, int a2, long a3, LTieLongConsumer<? super V> consumer)
default <V> boolean	LLongIntPredicate.doIf(V a1, int a2, long a3, LTieLongConsumer<? super V> consumer)
default <C1,C2,C3> void	LObjIntLongPredicate.filterForEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,C3,I3> void	LObjIntLongPredicate.filterIterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2,C3> void	LObjIntLongPredicate.filterIterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2,C3,I3> void	LObjIntLongPredicate.filterIterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,C3> void	LObjIntLongPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,C3,I3> void	LObjIntLongPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aInt> ia2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2,C3> void	LObjIntLongPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, IndexedRead<C3,aType.aLong> ia3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2,C3,I3> void	LObjIntLongPredicate.filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aInt> sa2, C2 source2, SequentialRead<C3,I3,aType.aLong> sa3, C3 source3, LTieLongConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <V,C0> int	LLongPredicate.tieForEach(V v, IndexedRead<C0,aType.aLong> ia, C0 source, LTieLongConsumer<V> consumer) For each element (or tuple) from arguments, calls the consumer (with index) if predicate test passes.
default <V,C0,I0> int	LLongPredicate.tieIterate(V v, SequentialRead<C0,I0,aType.aLong> sa, C0 source, LTieLongConsumer<V> consumer) For each element (or tuple) from arguments, calls the consumer (with index) if predicate test passes.