| Package | Description |
|---|---|
| eu.lunisolar.magma.func.function | |
| eu.lunisolar.magma.func.function.to | |
| eu.lunisolar.magma.func.operator.ternary | |
| eu.lunisolar.magma.func.predicate |
| Modifier and Type | Method and Description |
|---|---|
default LToIntTriFunction<T1,T2,T3> |
LTriFunction.thenToInt(LToIntFunction<? super R> after)
Combines two functions together in a order.
|
| Modifier and Type | Interface and Description |
|---|---|
static interface |
LToIntTriFunction.LToIntBiObj1Obj0Func<T3,T2,T1>
Permutation of LToIntTriFunction for method references.
|
static interface |
LToIntTriFunction.LToIntObj0Obj2Obj1Func<T1,T3,T2>
Permutation of LToIntTriFunction for method references.
|
static interface |
LToIntTriFunction.LToIntObj1BiObj2Func<T2,T1,T3>
Permutation of LToIntTriFunction for method references.
|
static interface |
LToIntTriFunction.LToIntObj1Obj2Obj0Func<T2,T3,T1>
Permutation of LToIntTriFunction for method references.
|
static interface |
LToIntTriFunction.LToIntObj2Obj0Obj1Func<T3,T1,T2>
Permutation of LToIntTriFunction for method references.
|
| Modifier and Type | Class and Description |
|---|---|
static class |
LToIntTriFunction.LToIntTriFunctionSingle<T1,T2,T3> |
| Modifier and Type | Method and Description |
|---|---|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.apply1stAsInt(LToIntFunction<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.apply2ndAsInt(LToIntFunction<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.apply3rdAsInt(LToIntFunction<T3> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
|
default <V2,V3,V4> LToIntTriFunction<V2,V3,V4> |
LToIntTriFunction.cast()
Cast that replace generics.
|
static <V2,V3,V4,T1,T2,T3> |
LToIntTriFunction.cast(LToIntTriFunction<T1,T2,T3> function)
Cast that replace generics.
|
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3> |
LToIntTriFunction.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,T> |
LTieBoolFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3,
LTieBoolFunction<T> after) |
static <V1,V2,V3,T> |
LTieByteFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToByteFunction<? super V3> before3,
LTieByteFunction<T> after) |
static <V1,V2,V3,T> |
LTieCharFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToCharFunction<? super V3> before3,
LTieCharFunction<T> after) |
static <V1,V2,V3,T> |
LTieDblFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToDblFunction<? super V3> before3,
LTieDblFunction<T> after) |
static <V1,V2,V3,T> |
LTieFltFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToFltFunction<? super V3> before3,
LTieFltFunction<T> after) |
static <V1,V2,V3,T> |
LTieIntFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToIntFunction<? super V3> before3,
LTieIntFunction<T> after) |
static <V1,V2,V3,T> |
LTieLongFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToLongFunction<? super V3> before3,
LTieLongFunction<T> after) |
static <V1,V2,V3,T> |
LTieSrtFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToSrtFunction<? super V3> before3,
LTieSrtFunction<T> after) |
static <V1,V2,V3,T1,T2,T3> |
LToIntTriFunction.composed(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LFunction<? super V3,? extends T3> before3,
LToIntTriFunction<T1,T2,T3> after) |
static <V1,V2,V3,T1,T2> |
LTieFunction.composed(LFunction<? super V1,? extends T1> before1,
LToIntFunction<? super V2> before2,
LFunction<? super V3,? extends T2> before3,
LTieFunction<T1,T2> after) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.constant(int r)
Creates function that always returns the same value.
|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.failSafe(LToIntTriFunction<T1,T2,T3> func,
LToIntTriFunction<T1,T2,T3> failSafe) |
default LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.recursive(LFunction<LToIntTriFunction<T1,T2,T3>,LToIntTriFunction<T1,T2,T3>> selfLambda) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.safe()
Safe instance.
|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.safe(LToIntTriFunction<T1,T2,T3> other)
Safe wrapping.
|
default LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.thenToInt(LIntUnaryOperator after)
Combines two functions together in a order.
|
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3> |
LTieBoolFunction.tieBoolFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieByteFunction.tieByteFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieCharFunction.tieCharFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieDblFunction.tieDblFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieFltFunction.tieFltFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieFunction.tieFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieIntFunction.tieIntFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieLongFunction.tieLongFuncCompose(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> LToIntTriFunction<V1,V2,V3> |
LTieSrtFunction.tieSrtFuncCompose(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LToSrtFunction<? super V3> before3)
Allows to manipulate the domain of the function.
|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.toIntTriFunc(LToIntTriFunction<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> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.toIntTriFuncThrowing(ExF<Throwable> exF) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.toIntTriFuncThrowing(String message,
ExMF<Throwable> exF) |
default LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.trying(ExWF<RuntimeException> exF) |
default LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.tryingThen(LToIntFunction<Throwable> handler) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.uncurry(LFunction<T1,LFunction<T2,LToIntFunction<T3>>> func) |
default LToIntTriFunction |
LToIntTriFunction.untyped()
Cast that removes generics.
|
LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.LToIntTriFunctionSingle.value() |
| Modifier and Type | Method and Description |
|---|---|
static <T1,T2,T3> LSupplier<LToIntTriFunction<T1,T2,T3>> |
LToIntTriFunction.safeSupplier()
Safe instance supplier.
|
static <T1,T2,T3> LSupplier<LToIntTriFunction<T1,T2,T3>> |
LToIntTriFunction.safeSupplier(LSupplier<LToIntTriFunction<T1,T2,T3>> supplier)
Safe supplier.
|
| Modifier and Type | Method and Description |
|---|---|
static <T1,T2,T3> int |
LToIntTriFunction.call(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> lambda) |
static <V2,V3,V4,T1,T2,T3> |
LToIntTriFunction.cast(LToIntTriFunction<T1,T2,T3> function)
Cast that replace generics.
|
static <V1,V2,V3,T1,T2,T3> |
LToIntTriFunction.composed(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LFunction<? super V3,? extends T3> before3,
LToIntTriFunction<T1,T2,T3> after) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.failSafe(LToIntTriFunction<T1,T2,T3> func,
LToIntTriFunction<T1,T2,T3> failSafe) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.failSafe(LToIntTriFunction<T1,T2,T3> func,
LToIntTriFunction<T1,T2,T3> failSafe) |
default int |
LToIntTriFunction.failSafeApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> failSafe) |
static <T1,T2,T3> int |
LToIntTriFunction.failSafeApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func,
LToIntTriFunction<T1,T2,T3> failSafe) |
static <T1,T2,T3> int |
LToIntTriFunction.failSafeApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func,
LToIntTriFunction<T1,T2,T3> failSafe) |
static <T1,T2,T3> void |
LToIntTriFunction.fromTill(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func)
From-To.
|
static <T1,T2,T3> void |
LToIntTriFunction.fromTo(int min_i,
int max_i,
T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func)
From-To.
|
static <T1,T2,T3> int |
LToIntTriFunction.handlingApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
static <T2,T3,T1> LToIntBiFunction<T2,T3> |
LToIntTriFunction.lShrinked(LBiFunction<T2,T3,T1> left,
LToIntTriFunction<T1,T2,T3> func) |
static <T2,T3,T1> LToIntBiFunction<T2,T3> |
LToIntTriFunction.lShrinkedc(T1 a1,
LToIntTriFunction<T1,T2,T3> func) |
static <T1,T2,T3> LToIntBiFunction<T1,T2> |
LToIntTriFunction.rShrinked(LBiFunction<T1,T2,T3> right,
LToIntTriFunction<T1,T2,T3> func) |
static <T1,T2,T3> LToIntBiFunction<T1,T2> |
LToIntTriFunction.rShrinkedc(T3 a3,
LToIntTriFunction<T1,T2,T3> func) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.safe(LToIntTriFunction<T1,T2,T3> other)
Safe wrapping.
|
static <T1,T2,T3> void |
LToIntTriFunction.times(int max_i,
T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func)
From-To.
|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.toIntTriFunc(LToIntTriFunction<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> int |
LToIntTriFunction.tryApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func) |
static <T1,T2,T3> int |
LToIntTriFunction.tryApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func,
ExWF<RuntimeException> exF) |
static <T1,T2,T3> int |
LToIntTriFunction.tryApplyAsInt(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static <T1,T2,T3> int |
LToIntTriFunction.tryApplyAsIntThen(T1 a1,
T2 a2,
T3 a3,
LToIntTriFunction<T1,T2,T3> func,
LToIntFunction<Throwable> handler) |
| Modifier and Type | Method and Description |
|---|---|
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.recursive(LFunction<LToIntTriFunction<T1,T2,T3>,LToIntTriFunction<T1,T2,T3>> selfLambda) |
static <T1,T2,T3> LToIntTriFunction<T1,T2,T3> |
LToIntTriFunction.recursive(LFunction<LToIntTriFunction<T1,T2,T3>,LToIntTriFunction<T1,T2,T3>> selfLambda) |
static <T1,T2,T3> LSupplier<LToIntTriFunction<T1,T2,T3>> |
LToIntTriFunction.safeSupplier(LSupplier<LToIntTriFunction<T1,T2,T3>> supplier)
Safe supplier.
|
| Modifier and Type | Method and Description |
|---|---|
default LToIntTriFunction<T,T,T> |
LTernaryOperator.thenToInt(LToIntFunction<? super T> after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
default LToIntTriFunction<T1,T2,T3> |
LTriPredicate.boolToToIntTriFunc(LBoolToIntFunction after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
default <V> int |
LBiPredicate.doIf(V a1,
T1 a2,
T2 a3,
LToIntTriFunction<V,? super T1,? super T2> consumer)
2
|
Copyright © 2019. All rights reserved.