| Package | Description |
|---|---|
| eu.lunisolar.magma.func.consumer.primitives.obj | |
| eu.lunisolar.magma.func.function.from | |
| eu.lunisolar.magma.func.function.to | |
| eu.lunisolar.magma.func.predicate |
| Modifier and Type | Method and Description |
|---|---|
default LObjIntConsumer<T2> |
LBiObjIntConsumer.lShrink(LOiFunction<T2,T1> left) |
static <T2,T1> LObjIntConsumer<T2> |
LBiObjIntConsumer.lShrinked(LOiFunction<T2,T1> left,
LBiObjIntConsumer<T1,T2> func) |
static <T1,SRC,T2> |
LTieConsumer.tieForEach(int sStart,
int sEnd,
int tStart,
T1 trg1,
SRC src3,
LOiFunction<SRC,T2> srcAcc3,
LTieConsumer<? super T1,? super T2> 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=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=TIE_SOURCE}, SourcePurpose{arg=T2 a3, type=TIE_SUPPLIER}, SourcePurpose{arg=LTieConsumer<? super T1,? super T2> consumer, type=CONST}]
|
| Modifier and Type | Interface and Description |
|---|---|
static interface |
LOiFunction.LIntObjFunc<T,R>
Permutation of LOiFunction for method references.
|
| Modifier and Type | Class and Description |
|---|---|
static class |
LOiFunction.LOiFunctionSingle<T,R> |
| Modifier and Type | Method and Description |
|---|---|
default LOiFunction<T,R> |
LOiFunction.after(LConsumer<? super R> after) |
static <T,R> LOiFunction<T,R> |
LOiFunction.apply1st(LFunction<T,R> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T,R> LOiFunction<T,R> |
LOiFunction.apply2nd(LIntFunction<R> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
default LOiFunction<T,R> |
LOiFunction.before(LObjIntConsumer<? super T> before) |
default <V2,V3> LOiFunction<V2,V3> |
LOiFunction.cast()
Cast that replace generics.
|
static <V2,V3,T,R> |
LOiFunction.cast(LOiFunction<T,R> function)
Cast that replace generics.
|
default <V1> LOiFunction<V1,R> |
LOiFunction.compose(LFunction<? super V1,? extends T> before1,
LIntUnaryOperator before2)
Allows to manipulate the domain of the function.
|
static <V1,T,R> LOiFunction<V1,R> |
LOiFunction.composed(LFunction<? super V1,? extends T> before1,
LIntUnaryOperator before2,
LOiFunction<T,R> after) |
static <T,R> LOiFunction<T,R> |
LOiFunction.constant(R r)
Creates function that always returns the same value.
|
static <T,R> LOiFunction<T,R> |
LOiFunction.failSafe(LOiFunction<T,R> func,
LOiFunction<T,R> failSafe) |
default LOiFunction<T,R> |
LOiFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default LOiFunction<T2,R> |
LBiObjIntFunction.lShrink(LOiFunction<T2,T1> left) |
default LOiFunction<T2,R> |
LBiObjIntFunction.lShrinkc(T1 a1) |
static <T2,R,T1> LOiFunction<T2,R> |
LBiObjIntFunction.lShrinked(LOiFunction<T2,T1> left,
LBiObjIntFunction<T1,T2,R> func) |
static <T2,R,T1> LOiFunction<T2,R> |
LBiObjIntFunction.lShrinkedc(T1 a1,
LBiObjIntFunction<T1,T2,R> func) |
default LOiFunction<T,R> |
LOiFunction.nonNullable()
Converts to function that makes sure that the result is not null.
|
static <T,R> LOiFunction<T,R> |
LOiFunction.oiFunc(LOiFunction<T,R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T,R> LOiFunction<T,R> |
LOiFunction.oiFuncThrowing(ExF<Throwable> exF) |
static <T,R> LOiFunction<T,R> |
LOiFunction.oiFuncThrowing(String message,
ExMF<Throwable> exF) |
static <T,R> LOiFunction<T,R> |
LOiFunction.recursive(LFunction<LOiFunction<T,R>,LOiFunction<T,R>> selfLambda) |
default LOiFunction<T,R> |
LObjBiIntFunction.rShrink(LOiToIntFunction<T> right) |
default LOiFunction<T,R> |
LObjBiIntFunction.rShrinkc(int a3) |
static <T,R> LOiFunction<T,R> |
LObjBiIntFunction.rShrinked(LOiToIntFunction<T> right,
LObjBiIntFunction<T,R> func) |
static <T,R> LOiFunction<T,R> |
LObjBiIntFunction.rShrinkedc(int a3,
LObjBiIntFunction<T,R> func) |
static <T,R> LOiFunction<T,R> |
LOiFunction.safe()
Safe instance.
|
static <T,R> LOiFunction<T,R> |
LOiFunction.safe(LOiFunction<T,R> other)
Safe wrapping.
|
default <V> LOiFunction<T,V> |
LOiFunction.then(LFunction<? super R,? extends V> after)
Combines two functions together in a order.
|
default LOiFunction<T,R> |
LOiFunction.trying(ExWF<RuntimeException> exF) |
default LOiFunction<T,R> |
LOiFunction.trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LOiFunction<T,R> |
LOiFunction.tryingThen(LFunction<Throwable,R> handler) |
static <T,R> LOiFunction<T,R> |
LOiFunction.uncurry(LFunction<T,LIntFunction<R>> func) |
default LOiFunction |
LOiFunction.untyped()
Cast that removes generics.
|
LOiFunction<T,R> |
LOiFunction.LOiFunctionSingle.value() |
| Modifier and Type | Method and Description |
|---|---|
static <T,R> LSupplier<LOiFunction<T,R>> |
LOiFunction.safeSupplier()
Safe instance supplier.
|
static <T,R> LSupplier<LOiFunction<T,R>> |
LOiFunction.safeSupplier(LSupplier<LOiFunction<T,R>> supplier)
Safe supplier.
|
| Modifier and Type | Method and Description |
|---|---|
static <T,R> R |
LOiFunction.call(T a1,
int a2,
LOiFunction<T,R> lambda) |
static <V2,V3,T,R> |
LOiFunction.cast(LOiFunction<T,R> function)
Cast that replace generics.
|
static <V1,T,R> LOiFunction<V1,R> |
LOiFunction.composed(LFunction<? super V1,? extends T> before1,
LIntUnaryOperator before2,
LOiFunction<T,R> after) |
static <V1,V2,T,R> |
LOiFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LOiFunction<T,R> after) |
static <T,R> LOiFunction<T,R> |
LOiFunction.failSafe(LOiFunction<T,R> func,
LOiFunction<T,R> failSafe) |
static <T,R> LOiFunction<T,R> |
LOiFunction.failSafe(LOiFunction<T,R> func,
LOiFunction<T,R> failSafe) |
default R |
LOiFunction.failSafeApply(T a1,
int a2,
LOiFunction<T,R> failSafe) |
static <T,R> R |
LOiFunction.failSafeApply(T a1,
int a2,
LOiFunction<T,R> func,
LOiFunction<T,R> failSafe) |
static <T,R> R |
LOiFunction.failSafeApply(T a1,
int a2,
LOiFunction<T,R> func,
LOiFunction<T,R> failSafe) |
static <T,R> void |
LOiFunction.fromTill(int min_a2,
int max_a2,
T a1,
LOiFunction<T,R> func)
From-To.
|
static <T,R> void |
LOiFunction.fromTo(int min_a2,
int max_a2,
T a1,
LOiFunction<T,R> func)
From-To.
|
static <T,R> R |
LOiFunction.handlingApply(T a1,
int a2,
LOiFunction<T,R> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
default LOiFunction<T2,R> |
LBiObjIntFunction.lShrink(LOiFunction<T2,T1> left) |
static <R,T> LIntFunction<R> |
LOiFunction.lShrinked(LIntFunction<T> left,
LOiFunction<T,R> func) |
static <T2,R,T1> LOiFunction<T2,R> |
LBiObjIntFunction.lShrinked(LOiFunction<T2,T1> left,
LBiObjIntFunction<T1,T2,R> func) |
static <R,T> LIntFunction<R> |
LOiFunction.lShrinkedc(T a1,
LOiFunction<T,R> func) |
static <T,R> LOiFunction<T,R> |
LOiFunction.oiFunc(LOiFunction<T,R> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T,R> LFunction<T,R> |
LOiFunction.rShrinked(LToIntFunction<T> right,
LOiFunction<T,R> func) |
static <T,R> LFunction<T,R> |
LOiFunction.rShrinkedc(int a2,
LOiFunction<T,R> func) |
static <T,R> LOiFunction<T,R> |
LOiFunction.safe(LOiFunction<T,R> other)
Safe wrapping.
|
static <T,R> void |
LOiFunction.times(int max_a2,
T a1,
LOiFunction<T,R> func)
From-To.
|
static <T,R> R |
LOiFunction.tryApply(T a1,
int a2,
LOiFunction<T,R> func) |
static <T,R> R |
LOiFunction.tryApply(T a1,
int a2,
LOiFunction<T,R> func,
ExWF<RuntimeException> exF) |
static <T,R> R |
LOiFunction.tryApply(T a1,
int a2,
LOiFunction<T,R> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <T,R> R |
LOiFunction.tryApplyThen(T a1,
int a2,
LOiFunction<T,R> func,
LFunction<Throwable,R> handler) |
| Modifier and Type | Method and Description |
|---|---|
static <T,R> LOiFunction<T,R> |
LOiFunction.recursive(LFunction<LOiFunction<T,R>,LOiFunction<T,R>> selfLambda) |
static <T,R> LOiFunction<T,R> |
LOiFunction.recursive(LFunction<LOiFunction<T,R>,LOiFunction<T,R>> selfLambda) |
static <T,R> LSupplier<LOiFunction<T,R>> |
LOiFunction.safeSupplier(LSupplier<LOiFunction<T,R>> supplier)
Safe supplier.
|
| Modifier and Type | Method and Description |
|---|---|
default <V> LOiFunction<T,V> |
LOiToByteFunction.then(LByteFunction<? extends V> after)
Combines two functions together in a order.
|
default <V> LOiFunction<T,V> |
LOiToCharFunction.then(LCharFunction<? extends V> after)
Combines two functions together in a order.
|
default <V> LOiFunction<T,V> |
LOiToDblFunction.then(LDblFunction<? extends V> after)
Combines two functions together in a order.
|
default <V> LOiFunction<T,V> |
LOiToFltFunction.then(LFltFunction<? extends V> after)
Combines two functions together in a order.
|
default <V> LOiFunction<T,V> |
LOiToIntFunction.then(LIntFunction<? extends V> after)
Combines two functions together in a order.
|
default <V> LOiFunction<T,V> |
LOiToLongFunction.then(LLongFunction<? extends V> after)
Combines two functions together in a order.
|
default <V> LOiFunction<T,V> |
LOiToSrtFunction.then(LSrtFunction<? extends V> after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
static <T1,SRC,T2> |
LTieFunction.tieForEach(int sStart,
int sEnd,
int tStart,
T1 trg1,
SRC src3,
LOiFunction<SRC,T2> srcAcc3,
LTieFunction<? super T1,? super T2> 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=T1 trg1, type=CONST}, SourcePurpose{arg=T2 a3, type=TIE_SOURCE}, SourcePurpose{arg=T2 a3, type=TIE_SUPPLIER}, SourcePurpose{arg=LTieFunction<? super T1,? super T2> consumer, type=CONST}]
|
| Modifier and Type | Method and Description |
|---|---|
default <V> LOiFunction<T,V> |
LObjIntPredicate.boolToOiFunc(LBoolFunction<? extends V> after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
default LObjIntPredicate<T2> |
LBiObjIntPredicate.lShrink(LOiFunction<T2,T1> left) |
static <T2,T1> LObjIntPredicate<T2> |
LBiObjIntPredicate.lShrinked(LOiFunction<T2,T1> left,
LBiObjIntPredicate<T1,T2> func) |
Copyright © 2019. All rights reserved.