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

Packages that use LObjIntConsumer

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

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

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

Modifier and Type	Interface and Description
static interface	LObjIntConsumer.LIntObjCons<T> Permutation of LObjIntConsumer for method references.

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

Modifier and Type	Class and Description
static class	LObjIntConsumer.LObjIntConsumerSingle<T>

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

Modifier and Type	Method and Description
static <T> LObjIntConsumer<T>	LObjIntConsumer.accept1st(LConsumer<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjIntConsumer<T>	LObjIntConsumer.accept2nd(LIntConsumer func) Captures single parameter function into this interface where only 2nd parameter will be used.
default LObjIntConsumer<T>	LObjIntConsumer.andThen(LObjIntConsumer<? super T> after) Combines two LObjIntConsumer together in a order.
default <V2> LObjIntConsumer<V2>	LObjIntConsumer.cast() Cast that replace generics.
static <V2,T> LObjIntConsumer<V2>	LObjIntConsumer.cast(LObjIntConsumer<T> function) Cast that replace generics.
default <V1> LObjIntConsumer<V1>	LObjIntConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
static <V1,T> LObjIntConsumer<V1>	LObjIntConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LObjIntConsumer<T> after)
static <T> LObjIntConsumer<T>	LObjIntConsumer.failSafe(LObjIntConsumer<T> func, LObjIntConsumer<T> failSafe)
default LObjIntConsumer<T>	LObjIntConsumer.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LObjIntConsumer<T2>	LBiObjIntConsumer.lShrink(LOiFunction<T2,T1> left)
default LObjIntConsumer<T2>	LBiObjIntConsumer.lShrinkc(T1 a1)
static <T2,T1> LObjIntConsumer<T2>	LBiObjIntConsumer.lShrinked(LOiFunction<T2,T1> left, LBiObjIntConsumer<T1,T2> func)
static <T2,T1> LObjIntConsumer<T2>	LBiObjIntConsumer.lShrinkedc(T1 a1, LBiObjIntConsumer<T1,T2> func)
static <T> LObjIntConsumer<T>	LObjIntConsumer.objIntCons(LObjIntConsumer<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LObjIntConsumer<T>	LObjIntConsumer.objIntConsThrowing(ExF<Throwable> exF)
static <T> LObjIntConsumer<T>	LObjIntConsumer.objIntConsThrowing(String message, ExMF<Throwable> exF)
static <T> LObjIntConsumer<T>	LObjIntConsumer.recursive(LFunction<LObjIntConsumer<T>,LObjIntConsumer<T>> selfLambda)
default LObjIntConsumer<T>	LTieIntConsumer.rShrink(LOiToIntFunction<T> right)
default LObjIntConsumer<T>	LTieIntConsumer.rShrinkc(int a3)
static <T> LObjIntConsumer<T>	LTieIntConsumer.rShrinked(LOiToIntFunction<T> right, LTieIntConsumer<T> func)
static <T> LObjIntConsumer<T>	LTieIntConsumer.rShrinkedc(int a3, LTieIntConsumer<T> func)
static <T> LObjIntConsumer<T>	LObjIntConsumer.safe() Safe instance.
static <T> LObjIntConsumer<T>	LObjIntConsumer.safe(LObjIntConsumer<T> other) Safe wrapping.
default LObjIntConsumer<T>	LObjIntConsumer.trying(ExWF<RuntimeException> exF)
default LObjIntConsumer<T>	LObjIntConsumer.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LObjIntConsumer<T>	LObjIntConsumer.tryingThen(LConsumer<Throwable> handler)
static <T> LObjIntConsumer<T>	LObjIntConsumer.uncurry(LFunction<T,LIntConsumer> func)
default LObjIntConsumer	LObjIntConsumer.untyped() Cast that removes generics.
LObjIntConsumer<T>	LObjIntConsumer.LObjIntConsumerSingle.value()
static <T> LObjIntConsumer<T>	LObjIntConsumer.wrap(java.util.function.ObjIntConsumer<T> other) Wraps JRE instance.

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

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

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

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

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

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

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

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

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

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

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

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

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

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