LTernaryOperator (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.a<T>>, Domain, Domain3<aType.a<T>,aType.a<T>,aType.a<T>>, Formattable, LTriFunction<T,T,T,T>, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LTernaryOperator.LTernaryOperatorSingle
```
@FunctionalInterface
public interface LTernaryOperator<T>
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.a<T>>, Domain3<aType.a<T>,aType.a<T>,aType.a<T>>, LTriFunction<T,T,T,T>
```
Non-throwing functional interface (lambda) LTernaryOperator for Java 8.
Type: operator
Domain (lvl: 3): T a1,T a2,T a3
Co-domain: T

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LTernaryOperator.LTernaryOperatorSingle<T>
- Nested classes/interfaces inherited from interface eu.lunisolar.magma.func.function.LTriFunction
  LTriFunction.LBiObj1Obj0Func<T3,T2,T1,R>, LTriFunction.LObj0Obj2Obj1Func<T1,T3,T2,R>, LTriFunction.LObj1BiObj2Func<T2,T1,T3,R>, LTriFunction.LObj1Obj2Obj0Func<T2,T3,T1,R>, LTriFunction.LObj2Obj0Obj1Func<T3,T1,T2,R>, LTriFunction.LTriFunctionSingle<T1,T2,T3,R>
- Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface
  MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LTernaryOperator.LTernaryOperatorSingle<T>`

Field Summary

Fields
Modifier and Type Field and Description

static String DESCRIPTION

static LSupplier<String> NULL_VALUE_MESSAGE_SUPPLIER

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`
`static LSupplier<String>`	`NULL_VALUE_MESSAGE_SUPPLIER`

Method Summary

All Methods Static Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default T`	`apply(T a1, T a2, T a3, ExWF<RuntimeException> exF)`
`default T`	`apply(T a1, T a2, T a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T> LTernaryOperator<T>`	`apply1st(LUnaryOperator<T> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T> LTernaryOperator<T>`	`apply2nd(LUnaryOperator<T> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static <T> LTernaryOperator<T>`	`apply3rd(LUnaryOperator<T> func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default T`	`applyThen(T a1, T a2, T a3, LFunction<Throwable,T> handler)`
`static <T> T`	`call(T a1, T a2, T a3, LTernaryOperator<T> lambda)`
`default LSupplier<T>`	`capture(T a1, T a2, T a3)` Captures arguments but delays the evaluation.
`default LTernaryOperator`	`cast()` Cast that replace generics.
`static <T> LTernaryOperator`	`cast(LTernaryOperator<T> function)` Cast that replace generics.
`static <T> LTernaryOperator<T>`	`constant(T r)` Creates function that always returns the same value.
`static <T> LTernaryOperator<T>`	`failSafe(LTernaryOperator<T> func, LTernaryOperator<T> failSafe)`
`default T`	`failSafeApply(T a1, T a2, T a3, LTernaryOperator<T> failSafe)`
`static <T> T`	`failSafeApply(T a1, T a2, T a3, LTernaryOperator<T> func, LTernaryOperator<T> failSafe)`
`default <C1,C2,C3> void`	`forEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static <T> void`	`fromTill(int min_i, int max_i, T a1, T a2, T a3, LTernaryOperator<T> func)` From-To.
`static <T> void`	`fromTo(int min_i, int max_i, T a1, T a2, T a3, LTernaryOperator<T> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LTernaryOperator<T>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default T`	`handlingApply(T a1, T a2, T a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T> T`	`handlingApply(T a1, T a2, T a3, LTernaryOperator<T> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`default <C1,C2,C3,I3> void`	`iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,C2,I2,C3> void`	`iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,C2,I2,C3,I3> void`	`iterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,C3> void`	`iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,C3,I3> void`	`iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.a<T>> ia2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,I2,C3> void`	`iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, IndexedRead<C3,aType.a<T>> ia3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default <C1,I1,C2,I2,C3,I3> void`	`iterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T>> sa2, C2 source2, SequentialRead<C3,I3,aType.a<T>> sa3, C3 source3, LConsumer<? super T> consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`default LBinaryOperator<T>`	`lShrink(LBinaryOperator<T> left)`
`default LBinaryOperator<T>`	`lShrinkc(T a1)`
`static <T> LBinaryOperator<T>`	`lShrinked(LBinaryOperator<T> left, LTernaryOperator<T> func)`
`static <T> LBinaryOperator<T>`	`lShrinkedc(T a1, LTernaryOperator<T> func)`
`default T`	`nestingApply(T a1, T a2, T a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default LTernaryOperator<T>`	`nonNullable()` Converts to function that makes sure that the result is not null.
`default T`	`nonNullApply(T a1, T a2, T a3)` Function call that ensures the result is not null
`static <T> T`	`produce(T a1, T a2, T a3)` Does nothing (LTernaryOperator) Operator
`static <T> LTernaryOperator<T>`	`recursive(LFunction<LTernaryOperator<T>,LTernaryOperator<T>> selfLambda)`
`default LBinaryOperator<T>`	`rShrink(LBinaryOperator<T> right)`
`default LBinaryOperator<T>`	`rShrinkc(T a3)`
`static <T> LBinaryOperator<T>`	`rShrinked(LBinaryOperator<T> right, LTernaryOperator<T> func)`
`static <T> LBinaryOperator<T>`	`rShrinkedc(T a3, LTernaryOperator<T> func)`
`static <T> LTernaryOperator<T>`	`safe()` Safe instance.
`static <T> LTernaryOperator<T>`	`safe(LTernaryOperator<T> other)` Safe wrapping.
`static <T> LSupplier<LTernaryOperator<T>>`	`safeSupplier()` Safe instance supplier.
`static <T> LSupplier<LTernaryOperator<T>>`	`safeSupplier(LSupplier<LTernaryOperator<T>> supplier)` Safe supplier.
`default T`	`shovingApply(T a1, T a2, T a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static <T> LTernaryOperator<T>`	`ternaryOp(LTernaryOperator<T> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T> LTernaryOperator<T>`	`ternaryOpThrowing(ExF<Throwable> exF)`
`static <T> LTernaryOperator<T>`	`ternaryOpThrowing(String message, ExMF<Throwable> exF)`
`default <V> LTriFunction<T,T,T,V>`	`then(LFunction<? super T,? extends V> after)` Combines two functions together in a order.
`default LTriPredicate<T,T,T>`	`thenToBool(LPredicate<? super T> after)` Combines two functions together in a order.
`default LToIntTriFunction<T,T,T>`	`thenToInt(LToIntFunction<? super T> after)` Combines two functions together in a order.
`static <T> void`	`times(int max_i, T a1, T a2, T a3, LTernaryOperator<T> func)` From-To.
`static <T> T`	`tryApply(T a1, T a2, T a3, LTernaryOperator<T> func)`
`static <T> T`	`tryApply(T a1, T a2, T a3, LTernaryOperator<T> func, ExWF<RuntimeException> exF)`
`static <T> T`	`tryApply(T a1, T a2, T a3, LTernaryOperator<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T> T`	`tryApplyThen(T a1, T a2, T a3, LTernaryOperator<T> func, LFunction<Throwable,T> handler)`
`default LTernaryOperator<T>`	`trying(ExWF<RuntimeException> exF)`
`default LTernaryOperator<T>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LTernaryOperator<T>`	`tryingThen(LFunction<Throwable,T> handler)`
`default T`	`tupleApply(LTriple<T,T,T> args)`
`static <T> LTernaryOperator<T>`	`uncurry(LFunction<T,LFunction<T,LUnaryOperator<T>>> func)`
`default LTernaryOperator`	`untyped()` Cast that removes generics.

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaOperator
isOperator

Methods inherited from interface eu.lunisolar.magma.func.function.LTriFunction
after, apply, apply1st, apply2nd, apply3rd, applyX, before, biObj1Obj0Func, call, cast, compose, composed, failSafe, failSafeApply, failSafeApply, fromTill, fromTo, handlingApply, lShrink, lShrinked, lShrinkedc, obj0Obj2Obj1Func, obj1BiObj2Func, obj1Obj2Obj0Func, obj2Obj0Obj1Func, recursive, rShrink, rShrinked, rShrinkedc, safe, safeSupplier, thenConsume, times, triFunc, triFuncThrowing, triFuncThrowing, tryApply, tryApply, tryApply, tryApplyThen, uncurry

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction
isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface
formatTo, isAction, isConsumer, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing
isThrowing

Field Detail

DESCRIPTION
```
static final String DESCRIPTION
```
See Also:

Constant Field Values

NULL_VALUE_MESSAGE_SUPPLIER

static final LSupplier<String> NULL_VALUE_MESSAGE_SUPPLIER

Method Detail

tupleApply
```
default T tupleApply(LTriple<T,T,T> args)
```
Specified by:

tupleApply in interface LTriFunction<T,T,T,T>

handlingApply

default T handlingApply(T a1,
                        T a2,
                        T a3,
                        HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

Specified by:: handlingApply in interface LTriFunction<T,T,T,T>

handling

default LTernaryOperator<T> handling(HandlingInstructions<Throwable,RuntimeException> handling)

Specified by:: handling in interface LTriFunction<T,T,T,T>

apply

default T apply(T a1,
                T a2,
                T a3,
                @Nonnull
                ExWMF<RuntimeException> exF,
                @Nonnull
                String newMessage,
                @Nullable
                Object... messageParams)

Specified by:: apply in interface LTriFunction<T,T,T,T>

trying

default LTernaryOperator<T> trying(@Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

Specified by:: trying in interface LTriFunction<T,T,T,T>

apply

default T apply(T a1,
                T a2,
                T a3,
                @Nonnull
                ExWF<RuntimeException> exF)

Specified by:: apply in interface LTriFunction<T,T,T,T>

trying

default LTernaryOperator<T> trying(@Nonnull
                                   ExWF<RuntimeException> exF)

Specified by:: trying in interface LTriFunction<T,T,T,T>

applyThen

default T applyThen(T a1,
                    T a2,
                    T a3,
                    @Nonnull
                    LFunction<Throwable,T> handler)

Specified by:: applyThen in interface LTriFunction<T,T,T,T>

tryingThen

default LTernaryOperator<T> tryingThen(@Nonnull
                                       LFunction<Throwable,T> handler)

Specified by:: tryingThen in interface LTriFunction<T,T,T,T>

nestingApply
```
default T nestingApply(T a1,
                       T a2,
                       T a3)
```
Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

Specified by:

nestingApply in interface LTriFunction<T,T,T,T>

shovingApply
```
default T shovingApply(T a1,
                       T a2,
                       T a3)
```
Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

Specified by:

shovingApply in interface LTriFunction<T,T,T,T>

handlingApply

static <T> T handlingApply(T a1,
                           T a2,
                           T a3,
                           LTernaryOperator<T> func,
                           HandlingInstructions<Throwable,RuntimeException> handling)

tryApply

static <T> T tryApply(T a1,
                      T a2,
                      T a3,
                      LTernaryOperator<T> func)

tryApply

static <T> T tryApply(T a1,
                      T a2,
                      T a3,
                      LTernaryOperator<T> func,
                      @Nonnull
                      ExWMF<RuntimeException> exF,
                      @Nonnull
                      String newMessage,
                      @Nullable
                      Object... messageParams)

tryApply

static <T> T tryApply(T a1,
                      T a2,
                      T a3,
                      LTernaryOperator<T> func,
                      @Nonnull
                      ExWF<RuntimeException> exF)

tryApplyThen

static <T> T tryApplyThen(T a1,
                          T a2,
                          T a3,
                          LTernaryOperator<T> func,
                          @Nonnull
                          LFunction<Throwable,T> handler)

failSafeApply

default T failSafeApply(T a1,
                        T a2,
                        T a3,
                        @Nonnull
                        LTernaryOperator<T> failSafe)

failSafeApply

static <T> T failSafeApply(T a1,
                           T a2,
                           T a3,
                           LTernaryOperator<T> func,
                           @Nonnull
                           LTernaryOperator<T> failSafe)

failSafe

static <T> LTernaryOperator<T> failSafe(LTernaryOperator<T> func,
                                        @Nonnull
                                        LTernaryOperator<T> failSafe)

nonNullApply

@Nonnull
default T nonNullApply(T a1,
                                 T a2,
                                 T a3)

Function call that ensures the result is not null

Specified by:: nonNullApply in interface LTriFunction<T,T,T,T>

functionalInterfaceDescription
```
@Nonnull
default String functionalInterfaceDescription()
```
Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface LTriFunction<T,T,T,T>

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static <T> void fromTo(int min_i,
                       int max_i,
                       T a1,
                       T a2,
                       T a3,
                       LTernaryOperator<T> func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static <T> void fromTill(int min_i,
                         int max_i,
                         T a1,
                         T a2,
                         T a3,
                         LTernaryOperator<T> func)

From-To. Intended to be used with non-capturing lambda.

times

static <T> void times(int max_i,
                      T a1,
                      T a2,
                      T a3,
                      LTernaryOperator<T> func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LBinaryOperator<T> lShrink(LBinaryOperator<T> left)

lShrinkc
```
default LBinaryOperator<T> lShrinkc(T a1)
```
Specified by:

lShrinkc in interface LTriFunction<T,T,T,T>

lShrinked

static <T> LBinaryOperator<T> lShrinked(LBinaryOperator<T> left,
                                        LTernaryOperator<T> func)

lShrinkedc

static <T> LBinaryOperator<T> lShrinkedc(T a1,
                                         LTernaryOperator<T> func)

rShrink

default LBinaryOperator<T> rShrink(LBinaryOperator<T> right)

rShrinkc
```
default LBinaryOperator<T> rShrinkc(T a3)
```
Specified by:

rShrinkc in interface LTriFunction<T,T,T,T>

rShrinked

static <T> LBinaryOperator<T> rShrinked(LBinaryOperator<T> right,
                                        LTernaryOperator<T> func)

rShrinkedc

static <T> LBinaryOperator<T> rShrinkedc(T a3,
                                         LTernaryOperator<T> func)

uncurry

static <T> LTernaryOperator<T> uncurry(LFunction<T,LFunction<T,LUnaryOperator<T>>> func)

untyped
```
default LTernaryOperator untyped()
```
Cast that removes generics.

Specified by:

untyped in interface LTriFunction<T,T,T,T>

cast
```
default LTernaryOperator cast()
```
Cast that replace generics.

Specified by:

cast in interface LTriFunction<T,T,T,T>

cast

static <T> LTernaryOperator cast(LTernaryOperator<T> function)

Cast that replace generics.

capture

default LSupplier<T> capture(T a1,
                             T a2,
                             T a3)

Captures arguments but delays the evaluation.

Specified by:: capture in interface LTriFunction<T,T,T,T>

constant
```
static <T> LTernaryOperator<T> constant(T r)
```
Creates function that always returns the same value.

Specified by:

constant in interface LTriFunction<T,T,T,T>

apply1st

@Nonnull
static <T> LTernaryOperator<T> apply1st(@Nonnull
                                                  LUnaryOperator<T> func)

Captures single parameter function into this interface where only 1st parameter will be used.

apply2nd

@Nonnull
static <T> LTernaryOperator<T> apply2nd(@Nonnull
                                                  LUnaryOperator<T> func)

Captures single parameter function into this interface where only 2nd parameter will be used.

apply3rd

@Nonnull
static <T> LTernaryOperator<T> apply3rd(@Nonnull
                                                  LUnaryOperator<T> func)

Captures single parameter function into this interface where only 3rd parameter will be used.

ternaryOp

@Nonnull
static <T> LTernaryOperator<T> ternaryOp(@Nonnull
                                                   LTernaryOperator<T> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static <T> LTernaryOperator<T> recursive(@Nonnull
                                                   LFunction<LTernaryOperator<T>,LTernaryOperator<T>> selfLambda)

ternaryOpThrowing

@Nonnull
static <T> LTernaryOperator<T> ternaryOpThrowing(@Nonnull
                                                           ExF<Throwable> exF)

ternaryOpThrowing

@Nonnull
static <T> LTernaryOperator<T> ternaryOpThrowing(String message,
                                                           @Nonnull
                                                           ExMF<Throwable> exF)

call

static <T> T call(T a1,
                  T a2,
                  T a3,
                  @Nonnull
                  LTernaryOperator<T> lambda)

safe
```
@Nonnull
static <T> LTernaryOperator<T> safe()
```
Safe instance. That always returns the same value (as produce).

Specified by:

safe in interface LTriFunction<T,T,T,T>

safeSupplier
```
@Nonnull
static <T> LSupplier<LTernaryOperator<T>> safeSupplier()
```
Safe instance supplier. Returns supplier of safe() instance.

Specified by:

safeSupplier in interface LTriFunction<T,T,T,T>

safe

@Nonnull
static <T> LTernaryOperator<T> safe(@Nullable
                                              LTernaryOperator<T> other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static <T> LSupplier<LTernaryOperator<T>> safeSupplier(@Nullable
                                                                 LSupplier<LTernaryOperator<T>> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

then

@Nonnull
default <V> LTriFunction<T,T,T,V> then(@Nonnull
                                                 LFunction<? super T,? extends V> after)

Combines two functions together in a order.

Specified by:: then in interface LTriFunction<T,T,T,T>

thenToInt

@Nonnull
default LToIntTriFunction<T,T,T> thenToInt(@Nonnull
                                                     LToIntFunction<? super T> after)

Combines two functions together in a order.

Specified by:: thenToInt in interface LTriFunction<T,T,T,T>

thenToBool

@Nonnull
default LTriPredicate<T,T,T> thenToBool(@Nonnull
                                                  LPredicate<? super T> after)

Combines two functions together in a order.

Specified by:: thenToBool in interface LTriFunction<T,T,T,T>

nonNullable
```
@Nonnull
default LTernaryOperator<T> nonNullable()
```
Converts to function that makes sure that the result is not null.

Specified by:

nonNullable in interface LTriFunction<T,T,T,T>

produce
```
static <T> T produce(T a1,
                     T a2,
                     T a3)
```
Does nothing (LTernaryOperator) Operator

Specified by:

produce in interface LTriFunction<T,T,T,T>