LLogicalTernaryOperator (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aBool>, Domain, Domain3<aType.aBool,aType.aBool,aType.aBool>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaLogicalOperator, MetaOperator, MetaPredicate

All Known Implementing Classes:

LLogicalTernaryOperator.LLogicalTernaryOperatorSingle
```
@FunctionalInterface
public interface LLogicalTernaryOperator
extends MetaInterface.NonThrowing, MetaLogicalOperator, Codomain<aType.aBool>, Domain3<aType.aBool,aType.aBool,aType.aBool>
```
Non-throwing functional interface (lambda) LLogicalTernaryOperator for Java 8.
Type: operator
Domain (lvl: 3): boolean a1,boolean a2,boolean a3
Co-domain: boolean

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class LLogicalTernaryOperator.LLogicalTernaryOperatorSingle
- 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`	`LLogicalTernaryOperator.LLogicalTernaryOperatorSingle`

Field Summary

Fields
Modifier and Type Field and Description

static String DESCRIPTION

Fields
Modifier and Type	Field and Description
`static String`	`DESCRIPTION`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static LLogicalTernaryOperator`	`and()` Returns function that applies logical AND operator.
`default LLogicalTernaryOperator`	`and(LLogicalTernaryOperator other)` Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
`default boolean`	`apply(boolean a1, boolean a2, boolean a3)`
`default boolean`	`apply(boolean a1, boolean a2, boolean a3, ExWF<RuntimeException> exF)`
`default boolean`	`apply(boolean a1, boolean a2, boolean a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static LLogicalTernaryOperator`	`apply1st(LLogicalOperator func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static LLogicalTernaryOperator`	`apply2nd(LLogicalOperator func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static LLogicalTernaryOperator`	`apply3rd(LLogicalOperator func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default boolean`	`applyThen(boolean a1, boolean a2, boolean a3, LPredicate<Throwable> handler)`
`boolean`	`applyX(boolean a1, boolean a2, boolean a3)` Implement this, but call apply(boolean a1,boolean a2,boolean a3)
`static boolean`	`call(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator lambda)`
`default LBoolSupplier`	`capture(boolean a1, boolean a2, boolean a3)` Captures arguments but delays the evaluation.
`default LLogicalTernaryOperator`	`compose(LLogicalOperator before1, LLogicalOperator before2, LLogicalOperator before3)` Allows to manipulate the domain of the function.
`static LLogicalTernaryOperator`	`composed(LLogicalOperator before1, LLogicalOperator before2, LLogicalOperator before3, LLogicalTernaryOperator after)`
`static <V1,V2,V3> LTriPredicate<V1,V2,V3>`	`composed(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3, LLogicalTernaryOperator after)`
`static LLogicalTernaryOperator`	`constant(boolean r)` Creates function that always returns the same value.
`default boolean`	`doIf(boolean a1, boolean a2, boolean a3, LAction action)`
`static boolean`	`doIf(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator predicate, LAction action)`
`static boolean`	`doIf(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator predicate, LTriBoolConsumer consumer)`
`default boolean`	`doIf(boolean a1, boolean a2, boolean a3, LTriBoolConsumer consumer)`
`default boolean`	`doTest(boolean a1, boolean a2, boolean a3)` For convenience, boolean operator is also special case of predicate.
`static LLogicalTernaryOperator`	`failSafe(LLogicalTernaryOperator func, LLogicalTernaryOperator failSafe)`
`default boolean`	`failSafeApply(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator failSafe)`
`static boolean`	`failSafeApply(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func, LLogicalTernaryOperator failSafe)`
`default <C1,C2,C3> void`	`forEach(IndexedRead<C1,aType.aBool> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LBoolConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static void`	`fromTill(int min_i, int max_i, boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func)` From-To.
`static void`	`fromTo(int min_i, int max_i, boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LLogicalTernaryOperator`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`handlingApply(boolean a1, boolean a2, boolean a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static boolean`	`handlingApply(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static LLogicalTernaryOperator`	`isEqual(boolean v1, boolean v2, boolean v3)` Creates predicate that evaluates if an object is equal with the argument one.
`default <C1,C2,C3,I3> void`	`iterate(IndexedRead<C1,aType.aBool> ia1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LBoolConsumer 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.aBool> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LBoolConsumer 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.aBool> ia1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LBoolConsumer 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.aBool> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LBoolConsumer 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.aBool> sa1, C1 source1, IndexedRead<C2,aType.aBool> ia2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LBoolConsumer 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.aBool> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, IndexedRead<C3,aType.aBool> ia3, C3 source3, LBoolConsumer 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.aBool> sa1, C1 source1, SequentialRead<C2,I2,aType.aBool> sa2, C2 source2, SequentialRead<C3,I3,aType.aBool> sa3, C3 source3, LBoolConsumer consumer)` For each element (or tuple) from arguments, calls the function and passes the result to consumer.
`static LLogicalTernaryOperator`	`logicalTernaryOp(LLogicalTernaryOperator lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default <V1,V2,V3> LTriPredicate<V1,V2,V3>`	`logicalTernaryOpCompose(LPredicate<? super V1> before1, LPredicate<? super V2> before2, LPredicate<? super V3> before3)` Allows to manipulate the domain of the function.
`static LLogicalTernaryOperator`	`logicalTernaryOpThrowing(ExF<Throwable> exF)`
`static LLogicalTernaryOperator`	`logicalTernaryOpThrowing(String message, ExMF<Throwable> exF)`
`default LLogicalBinaryOperator`	`lShrink(LLogicalBinaryOperator left)`
`default LLogicalBinaryOperator`	`lShrinkc(boolean a1)`
`static LLogicalBinaryOperator`	`lShrinked(LLogicalBinaryOperator left, LLogicalTernaryOperator func)`
`static LLogicalBinaryOperator`	`lShrinkedc(boolean a1, LLogicalTernaryOperator func)`
`default LLogicalTernaryOperator`	`negate()` Returns a predicate that represents the logical negation of this predicate.
`default boolean`	`nestingApply(boolean a1, boolean a2, boolean a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default boolean`	`nonNullApply(boolean a1, boolean a2, boolean a3)` Just to mirror the method: Ensures the result is not null
`static LLogicalTernaryOperator`	`or()` Returns function that applies logical OR operator.
`default LLogicalTernaryOperator`	`or(LLogicalTernaryOperator other)` Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
`static boolean`	`produceBoolean(boolean a1, boolean a2, boolean a3)` Does nothing (LLogicalTernaryOperator) Operator
`static LLogicalTernaryOperator`	`recursive(LFunction<LLogicalTernaryOperator,LLogicalTernaryOperator> selfLambda)`
`default LLogicalBinaryOperator`	`rShrink(LLogicalBinaryOperator right)`
`default LLogicalBinaryOperator`	`rShrinkc(boolean a3)`
`static LLogicalBinaryOperator`	`rShrinked(LLogicalBinaryOperator right, LLogicalTernaryOperator func)`
`static LLogicalBinaryOperator`	`rShrinkedc(boolean a3, LLogicalTernaryOperator func)`
`static LLogicalTernaryOperator`	`safe()` Safe instance.
`static LLogicalTernaryOperator`	`safe(LLogicalTernaryOperator other)` Safe wrapping.
`static LSupplier<LLogicalTernaryOperator>`	`safeSupplier()` Safe instance supplier.
`static LSupplier<LLogicalTernaryOperator>`	`safeSupplier(LSupplier<LLogicalTernaryOperator> supplier)` Safe supplier.
`default boolean`	`shovingApply(boolean a1, boolean a2, boolean a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`default <V> LTriBoolFunction<V>`	`then(LBoolFunction<? extends V> after)` Combines two functions together in a order.
`default LLogicalTernaryOperator`	`thenToBool(LLogicalOperator after)` Combines two functions together in a order.
`static void`	`throwIf(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static void`	`throwIfNot(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static void`	`times(int max_i, boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func)` From-To.
`static boolean`	`tryApply(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func)`
`static boolean`	`tryApply(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func, ExWF<RuntimeException> exF)`
`static boolean`	`tryApply(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static boolean`	`tryApplyThen(boolean a1, boolean a2, boolean a3, LLogicalTernaryOperator func, LPredicate<Throwable> handler)`
`default LLogicalTernaryOperator`	`trying(ExWF<RuntimeException> exF)`
`default LLogicalTernaryOperator`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LLogicalTernaryOperator`	`tryingThen(LPredicate<Throwable> handler)`
`default boolean`	`tupleApply(LBoolTriple args)`
`static LLogicalTernaryOperator`	`uncurry(LBoolFunction<LBoolFunction<LLogicalOperator>> func)`
`static LLogicalTernaryOperator`	`xor()` Returns function that applies logical XOR operator.
`default LLogicalTernaryOperator`	`xor(LLogicalTernaryOperator other)` Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

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

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

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaPredicate
isPredicate

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, isSupplier

Field Detail
- DESCRIPTION
```
static final String DESCRIPTION
```
  See Also:
  
  Constant Field Values

Method Detail

apply

default boolean apply(boolean a1,
                      boolean a2,
                      boolean a3)

applyX

boolean applyX(boolean a1,
               boolean a2,
               boolean a3)
        throws Throwable

Implement this, but call apply(boolean a1,boolean a2,boolean a3)

Throws:: Throwable

tupleApply

default boolean tupleApply(LBoolTriple args)

handlingApply

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

Function call that handles exceptions according to the instructions.

handling

default LLogicalTernaryOperator handling(HandlingInstructions<Throwable,RuntimeException> handling)

apply

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

trying

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

apply

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

trying

default LLogicalTernaryOperator trying(@Nonnull
                                       ExWF<RuntimeException> exF)

applyThen

default boolean applyThen(boolean a1,
                          boolean a2,
                          boolean a3,
                          @Nonnull
                          LPredicate<Throwable> handler)

tryingThen

default LLogicalTernaryOperator tryingThen(@Nonnull
                                           LPredicate<Throwable> handler)

nestingApply

default boolean nestingApply(boolean a1,
                             boolean a2,
                             boolean a3)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApply

default boolean shovingApply(boolean a1,
                             boolean a2,
                             boolean a3)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApply

static boolean handlingApply(boolean a1,
                             boolean a2,
                             boolean a3,
                             LLogicalTernaryOperator func,
                             HandlingInstructions<Throwable,RuntimeException> handling)

tryApply

static boolean tryApply(boolean a1,
                        boolean a2,
                        boolean a3,
                        LLogicalTernaryOperator func)

tryApply

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

tryApply

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

tryApplyThen

static boolean tryApplyThen(boolean a1,
                            boolean a2,
                            boolean a3,
                            LLogicalTernaryOperator func,
                            @Nonnull
                            LPredicate<Throwable> handler)

failSafeApply

default boolean failSafeApply(boolean a1,
                              boolean a2,
                              boolean a3,
                              @Nonnull
                              LLogicalTernaryOperator failSafe)

failSafeApply

static boolean failSafeApply(boolean a1,
                             boolean a2,
                             boolean a3,
                             LLogicalTernaryOperator func,
                             @Nonnull
                             LLogicalTernaryOperator failSafe)

failSafe

static LLogicalTernaryOperator failSafe(LLogicalTernaryOperator func,
                                        @Nonnull
                                        LLogicalTernaryOperator failSafe)

doIf

default boolean doIf(boolean a1,
                     boolean a2,
                     boolean a3,
                     LAction action)

doIf

static boolean doIf(boolean a1,
                    boolean a2,
                    boolean a3,
                    @Nonnull
                    LLogicalTernaryOperator predicate,
                    @Nonnull
                    LAction action)

doIf

static boolean doIf(boolean a1,
                    boolean a2,
                    boolean a3,
                    @Nonnull
                    LLogicalTernaryOperator predicate,
                    @Nonnull
                    LTriBoolConsumer consumer)

doIf

default boolean doIf(boolean a1,
                     boolean a2,
                     boolean a3,
                     @Nonnull
                     LTriBoolConsumer consumer)

throwIf

static void throwIf(boolean a1,
                    boolean a2,
                    boolean a3,
                    LLogicalTernaryOperator pred,
                    ExMF<RuntimeException> factory,
                    @Nonnull
                    String newMessage,
                    @Nullable
                    Object... messageParams)

throwIfNot

static void throwIfNot(boolean a1,
                       boolean a2,
                       boolean a3,
                       LLogicalTernaryOperator pred,
                       ExMF<RuntimeException> factory,
                       @Nonnull
                       String newMessage,
                       @Nullable
                       Object... messageParams)

nonNullApply

default boolean nonNullApply(boolean a1,
                             boolean a2,
                             boolean a3)

Just to mirror the method: Ensures the result is not null

doTest

default boolean doTest(boolean a1,
                       boolean a2,
                       boolean a3)

For convenience, boolean operator is also special case of predicate.

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

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static void fromTo(int min_i,
                   int max_i,
                   boolean a1,
                   boolean a2,
                   boolean a3,
                   LLogicalTernaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     boolean a1,
                     boolean a2,
                     boolean a3,
                     LLogicalTernaryOperator func)

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

times

static void times(int max_i,
                  boolean a1,
                  boolean a2,
                  boolean a3,
                  LLogicalTernaryOperator func)

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

lShrink

default LLogicalBinaryOperator lShrink(LLogicalBinaryOperator left)

lShrinkc

default LLogicalBinaryOperator lShrinkc(boolean a1)

lShrinked

static LLogicalBinaryOperator lShrinked(LLogicalBinaryOperator left,
                                        LLogicalTernaryOperator func)

lShrinkedc

static LLogicalBinaryOperator lShrinkedc(boolean a1,
                                         LLogicalTernaryOperator func)

rShrink

default LLogicalBinaryOperator rShrink(LLogicalBinaryOperator right)

rShrinkc

default LLogicalBinaryOperator rShrinkc(boolean a3)

rShrinked

static LLogicalBinaryOperator rShrinked(LLogicalBinaryOperator right,
                                        LLogicalTernaryOperator func)

rShrinkedc

static LLogicalBinaryOperator rShrinkedc(boolean a3,
                                         LLogicalTernaryOperator func)

uncurry

static LLogicalTernaryOperator uncurry(LBoolFunction<LBoolFunction<LLogicalOperator>> func)

capture

default LBoolSupplier capture(boolean a1,
                              boolean a2,
                              boolean a3)

Captures arguments but delays the evaluation.

constant
```
static LLogicalTernaryOperator constant(boolean r)
```
Creates function that always returns the same value.

apply1st

@Nonnull
static LLogicalTernaryOperator apply1st(@Nonnull
                                                  LLogicalOperator func)

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

apply2nd

@Nonnull
static LLogicalTernaryOperator apply2nd(@Nonnull
                                                  LLogicalOperator func)

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

apply3rd

@Nonnull
static LLogicalTernaryOperator apply3rd(@Nonnull
                                                  LLogicalOperator func)

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

logicalTernaryOp

@Nonnull
static LLogicalTernaryOperator logicalTernaryOp(@Nonnull
                                                          LLogicalTernaryOperator lambda)

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

recursive

@Nonnull
static LLogicalTernaryOperator recursive(@Nonnull
                                                   LFunction<LLogicalTernaryOperator,LLogicalTernaryOperator> selfLambda)

logicalTernaryOpThrowing

@Nonnull
static LLogicalTernaryOperator logicalTernaryOpThrowing(@Nonnull
                                                                  ExF<Throwable> exF)

logicalTernaryOpThrowing

@Nonnull
static LLogicalTernaryOperator logicalTernaryOpThrowing(String message,
                                                                  @Nonnull
                                                                  ExMF<Throwable> exF)

call

static boolean call(boolean a1,
                    boolean a2,
                    boolean a3,
                    @Nonnull
                    LLogicalTernaryOperator lambda)

safe
```
@Nonnull
static LLogicalTernaryOperator safe()
```
Safe instance. That always returns the same value (as produceBoolean).

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

safe

@Nonnull
static LLogicalTernaryOperator safe(@Nullable
                                              LLogicalTernaryOperator other)

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

safeSupplier

@Nonnull
static LSupplier<LLogicalTernaryOperator> safeSupplier(@Nullable
                                                                 LSupplier<LLogicalTernaryOperator> supplier)

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

negate
```
@Nonnull
default LLogicalTernaryOperator negate()
```
Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LLogicalTernaryOperator and(@Nonnull
                                              LLogicalTernaryOperator other)

Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.

See Also:: java.util.function.Predicate#and()}

or

@Nonnull
default LLogicalTernaryOperator or(@Nonnull
                                             LLogicalTernaryOperator other)

Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.

See Also:: java.util.function.Predicate#or}

xor

@Nonnull
default LLogicalTernaryOperator xor(@Nonnull
                                              LLogicalTernaryOperator other)

Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

See Also:: java.util.function.Predicate#or}

isEqual

@Nonnull
static LLogicalTernaryOperator isEqual(boolean v1,
                                                 boolean v2,
                                                 boolean v3)

Creates predicate that evaluates if an object is equal with the argument one.

See Also:: java.util.function.Predicate#isEqual()

and
```
@Nonnull
static LLogicalTernaryOperator and()
```
Returns function that applies logical AND operator.

or
```
@Nonnull
static LLogicalTernaryOperator or()
```
Returns function that applies logical OR operator.

xor
```
@Nonnull
static LLogicalTernaryOperator xor()
```
Returns function that applies logical XOR operator.

compose

@Nonnull
default LLogicalTernaryOperator compose(@Nonnull
                                                  LLogicalOperator before1,
                                                  @Nonnull
                                                  LLogicalOperator before2,
                                                  @Nonnull
                                                  LLogicalOperator before3)

Allows to manipulate the domain of the function.

composed

static LLogicalTernaryOperator composed(@Nonnull
                                        LLogicalOperator before1,
                                        @Nonnull
                                        LLogicalOperator before2,
                                        @Nonnull
                                        LLogicalOperator before3,
                                        LLogicalTernaryOperator after)

logicalTernaryOpCompose

@Nonnull
default <V1,V2,V3> LTriPredicate<V1,V2,V3> logicalTernaryOpCompose(@Nonnull
                                                                             LPredicate<? super V1> before1,
                                                                             @Nonnull
                                                                             LPredicate<? super V2> before2,
                                                                             @Nonnull
                                                                             LPredicate<? super V3> before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,V3> LTriPredicate<V1,V2,V3> composed(@Nonnull
                                                   LPredicate<? super V1> before1,
                                                   @Nonnull
                                                   LPredicate<? super V2> before2,
                                                   @Nonnull
                                                   LPredicate<? super V3> before3,
                                                   LLogicalTernaryOperator after)

then

@Nonnull
default <V> LTriBoolFunction<V> then(@Nonnull
                                               LBoolFunction<? extends V> after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LLogicalTernaryOperator thenToBool(@Nonnull
                                                     LLogicalOperator after)

Combines two functions together in a order.

produceBoolean

static boolean produceBoolean(boolean a1,
                              boolean a2,
                              boolean a3)

Does nothing (LLogicalTernaryOperator) Operator