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

Packages that use LObjByteConsumer

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

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

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

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

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

Modifier and Type	Class and Description
static class	LObjByteConsumer.LObjByteConsumerSingle<T>

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

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

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

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

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

Modifier and Type	Method and Description
default LObjByteConsumer<T>	LObjByteConsumer.andThen(LObjByteConsumer<? super T> after) Combines two LObjByteConsumer together in a order.
static <T> void	LObjByteConsumer.call(T a1, byte a2, LObjByteConsumer<T> lambda)
static <V2,T> LObjByteConsumer<V2>	LObjByteConsumer.cast(LObjByteConsumer<T> function) Cast that replace generics.
static <V1,T> LObjByteConsumer<V1>	LObjByteConsumer.composed(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2, LObjByteConsumer<T> after)
static <V1,V2,T> LBiConsumer<V1,V2>	LObjByteConsumer.composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjByteConsumer<T> after)
static <T> LObjByteConsumer<T>	LObjByteConsumer.failSafe(LObjByteConsumer<T> func, LObjByteConsumer<T> failSafe)
static <T> LObjByteConsumer<T>	LObjByteConsumer.failSafe(LObjByteConsumer<T> func, LObjByteConsumer<T> failSafe)
default void	LObjByteConsumer.failSafeAccept(T a1, byte a2, LObjByteConsumer<T> failSafe)
static <T> void	LObjByteConsumer.failSafeAccept(T a1, byte a2, LObjByteConsumer<T> func, LObjByteConsumer<T> failSafe)
static <T> void	LObjByteConsumer.failSafeAccept(T a1, byte a2, LObjByteConsumer<T> func, LObjByteConsumer<T> failSafe)
static <C1,C2,T> int	LObjByteConsumer.forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T> void	LObjByteConsumer.fromTill(int min_i, int max_i, T a1, byte a2, LObjByteConsumer<T> func) From-To.
static <T> void	LObjByteConsumer.fromTo(int min_i, int max_i, T a1, byte a2, LObjByteConsumer<T> func) From-To.
static <T> void	LObjByteConsumer.handlingAccept(T a1, byte a2, LObjByteConsumer<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <C1,C2,I2,T> int	LObjByteConsumer.iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,T> int	LObjByteConsumer.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <C1,I1,C2,I2,T> int	LObjByteConsumer.iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T> LByteConsumer	LObjByteConsumer.lShrinked(LByteFunction<T> left, LObjByteConsumer<T> func)
static <T> LByteConsumer	LObjByteConsumer.lShrinkedc(T a1, LObjByteConsumer<T> func)
static <T> LObjByteConsumer<T>	LObjByteConsumer.objByteCons(LObjByteConsumer<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>	LObjByteConsumer.rShrinked(LToByteFunction<T> right, LObjByteConsumer<T> func)
static <T> LConsumer<T>	LObjByteConsumer.rShrinkedc(byte a2, LObjByteConsumer<T> func)
static <T> LObjByteConsumer<T>	LObjByteConsumer.safe(LObjByteConsumer<T> other) Safe wrapping.
static <T,C2> T	LObjByteConsumer.targetedForEach(T a1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T,C2,I2> T	LObjByteConsumer.targetedIterate(T a1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer.
static <T> void	LObjByteConsumer.times(int max_i, T a1, byte a2, LObjByteConsumer<T> func) From-To.
static <T> void	LObjByteConsumer.tryAccept(T a1, byte a2, LObjByteConsumer<T> func)
static <T> void	LObjByteConsumer.tryAccept(T a1, byte a2, LObjByteConsumer<T> func, ExWF<RuntimeException> exF)
static <T> void	LObjByteConsumer.tryAccept(T a1, byte a2, LObjByteConsumer<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T> void	LObjByteConsumer.tryAcceptThen(T a1, byte a2, LObjByteConsumer<T> func, LConsumer<Throwable> handler)

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

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

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

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

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

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

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

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

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

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