eu.lunisolar.magma.func.operator.binary

Interface LLogicalBinaryOperator

All Superinterfaces:

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

All Known Implementing Classes:

LLogicalBinaryOperator.LLogicalBinaryOperatorSingle

@FunctionalInterface
public interface LLogicalBinaryOperator
extends MetaInterface.NonThrowing, MetaLogicalOperator, Codomain<aType.aBool>, Domain2<aType.aBool,aType.aBool>

Non-throwing functional interface (lambda) LLogicalBinaryOperator for Java 8.

Type: operator

Domain (lvl: 2): boolean a1,boolean a2

Co-domain: boolean

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLogicalBinaryOperator.LLogicalBinaryOperatorSingle

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

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

applyX

boolean applyX(boolean a1,
               boolean a2)
        throws Throwable

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

Throws:

Throwable

tupleApply

default boolean tupleApply(LBoolPair args)

handlingApply

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

Function call that handles exceptions according to the instructions.

handling

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

apply

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

trying

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

apply

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

trying

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

applyThen

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

tryingThen

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

nestingApply

default boolean nestingApply(boolean a1,
                             boolean a2)

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

shovingApply

default boolean shovingApply(boolean a1,
                             boolean a2)

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,
                             LLogicalBinaryOperator func,
                             HandlingInstructions<Throwable,RuntimeException> handling)

tryApply

static boolean tryApply(boolean a1,
                        boolean a2,
                        LLogicalBinaryOperator func)

tryApply

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

tryApply

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

tryApplyThen

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

failSafeApply

default boolean failSafeApply(boolean a1,
                              boolean a2,
                              @Nonnull
                              LLogicalBinaryOperator failSafe)

failSafeApply

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

failSafe

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

doIf

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

doIf

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

doIf

static boolean doIf(boolean a1,
                    boolean a2,
                    @Nonnull
                    LLogicalBinaryOperator predicate,
                    @Nonnull
                    LBiBoolConsumer consumer)

doIf

default boolean doIf(boolean a1,
                     boolean a2,
                     @Nonnull
                     LBiBoolConsumer consumer)

throwIf

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

throwIfNot

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

nonNullApply

default boolean nonNullApply(boolean a1,
                             boolean a2)

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

doTest

default boolean doTest(boolean a1,
                       boolean a2)

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,
                   LLogicalBinaryOperator 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,
                     LLogicalBinaryOperator func)

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

times

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

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

lShrink

default LLogicalOperator lShrink(LLogicalOperator left)

lShrinkc

default LLogicalOperator lShrinkc(boolean a1)

lShrinked

static LLogicalOperator lShrinked(LLogicalOperator left,
                                  LLogicalBinaryOperator func)

lShrinkedc

static LLogicalOperator lShrinkedc(boolean a1,
                                   LLogicalBinaryOperator func)

rShrink

default LLogicalOperator rShrink(LLogicalOperator right)

rShrinkc

default LLogicalOperator rShrinkc(boolean a2)

rShrinked

static LLogicalOperator rShrinked(LLogicalOperator right,
                                  LLogicalBinaryOperator func)

rShrinkedc

static LLogicalOperator rShrinkedc(boolean a2,
                                   LLogicalBinaryOperator func)

uncurry

static LLogicalBinaryOperator uncurry(LBoolFunction<LLogicalOperator> func)

capture

default LBoolSupplier capture(boolean a1,
                              boolean a2)

Captures arguments but delays the evaluation.

constant

static LLogicalBinaryOperator constant(boolean r)

Creates function that always returns the same value.

apply1st

@Nonnull
static LLogicalBinaryOperator apply1st(@Nonnull
                                                 LLogicalOperator func)

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

apply2nd

@Nonnull
static LLogicalBinaryOperator apply2nd(@Nonnull
                                                 LLogicalOperator func)

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

logicalBinaryOp

@Nonnull
static LLogicalBinaryOperator logicalBinaryOp(@Nonnull
                                                        LLogicalBinaryOperator lambda)

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

recursive

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

logicalBinaryOpThrowing

@Nonnull
static LLogicalBinaryOperator logicalBinaryOpThrowing(@Nonnull
                                                                ExF<Throwable> exF)

logicalBinaryOpThrowing

@Nonnull
static LLogicalBinaryOperator logicalBinaryOpThrowing(String message,
                                                                @Nonnull
                                                                ExMF<Throwable> exF)

call

static boolean call(boolean a1,
                    boolean a2,
                    @Nonnull
                    LLogicalBinaryOperator lambda)

safe

@Nonnull
static LLogicalBinaryOperator safe()

Safe instance. That always returns the same value (as produceBoolean).

safeSupplier

@Nonnull
static LSupplier<LLogicalBinaryOperator> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LLogicalBinaryOperator safe(@Nullable
                                             LLogicalBinaryOperator other)

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

safeSupplier

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

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

negate

@Nonnull
default LLogicalBinaryOperator negate()

Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LLogicalBinaryOperator and(@Nonnull
                                             LLogicalBinaryOperator 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 LLogicalBinaryOperator or(@Nonnull
                                            LLogicalBinaryOperator 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 LLogicalBinaryOperator xor(@Nonnull
                                             LLogicalBinaryOperator 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 LLogicalBinaryOperator isEqual(boolean v1,
                                                boolean v2)

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

See Also:

java.util.function.Predicate#isEqual()

and

@Nonnull
static LLogicalBinaryOperator and()

Returns function that applies logical AND operator.

or

@Nonnull
static LLogicalBinaryOperator or()

Returns function that applies logical OR operator.

xor

@Nonnull
static LLogicalBinaryOperator xor()

Returns function that applies logical XOR operator.

compose

@Nonnull
default LLogicalBinaryOperator compose(@Nonnull
                                                 LLogicalOperator before1,
                                                 @Nonnull
                                                 LLogicalOperator before2)

Allows to manipulate the domain of the function.

composed

static LLogicalBinaryOperator composed(@Nonnull
                                       LLogicalOperator before1,
                                       @Nonnull
                                       LLogicalOperator before2,
                                       LLogicalBinaryOperator after)

logicalBinaryOpCompose

@Nonnull
default <V1,V2> LBiPredicate<V1,V2> logicalBinaryOpCompose(@Nonnull
                                                                     LPredicate<? super V1> before1,
                                                                     @Nonnull
                                                                     LPredicate<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2> LBiPredicate<V1,V2> composed(@Nonnull
                                            LPredicate<? super V1> before1,
                                            @Nonnull
                                            LPredicate<? super V2> before2,
                                            LLogicalBinaryOperator after)

then

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

Combines two functions together in a order.

thenToBool

@Nonnull
default LLogicalBinaryOperator thenToBool(@Nonnull
                                                    LLogicalOperator after)

Combines two functions together in a order.

produceBoolean

static boolean produceBoolean(boolean a1,
                              boolean a2)

Does nothing (LLogicalBinaryOperator) Operator

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.aBool> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.aBool> ia2,
                             C2 source2,
                             LBoolConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.aBool> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.aBool> ia2,
                                C2 source2,
                                LBoolConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,C2,I2> void iterate(IndexedRead<C1,aType.aBool> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.aBool> sa2,
                                C2 source2,
                                LBoolConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.aBool> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.aBool> sa2,
                                   C2 source2,
                                   LBoolConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.