eu.lunisolar.magma.func.predicate

Interface LBiLongPredicate

All Superinterfaces:

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

All Known Subinterfaces:

LBiLongPredicate.LLong1Long0Pred

All Known Implementing Classes:

LBiLongPredicate.LBiLongPredicateSingle

@FunctionalInterface
public interface LBiLongPredicate
extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain2<aType.aLong,aType.aLong>

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

Type: predicate

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

Co-domain: boolean

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LBiLongPredicate.LBiLongPredicateSingle
static interface	LBiLongPredicate.LLong1Long0Pred Permutation of LBiLongPredicate for method references.

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 boolean	alwaysFalse(long a1, long a2) Returns FALSE.
static boolean	alwaysTrue(long a1, long a2) Returns TRUE.
default LBiLongPredicate	and(LBiLongPredicate other) Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
static LBiLongPredicate	biLongPred(LBiLongPredicate 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>	biLongPredCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LBiLongPredicate	biLongPredThrowing(ExF<Throwable> exF)
static LBiLongPredicate	biLongPredThrowing(String message, ExMF<Throwable> exF)
default <V> LBiLongFunction<V>	boolToBiLongFunc(LBoolFunction<? extends V> after) Combines two functions together in a order.
default LBiLongPredicate	boolToBiLongPred(LLogicalOperator after) Combines two functions together in a order.
default LLongBinaryOperator	boolToLongBinaryOp(LBoolToLongFunction after) Combines two functions together in a order.
static boolean	call(long a1, long a2, LBiLongPredicate lambda)
default LBoolSupplier	capture(long a1, long a2) Captures arguments but delays the evaluation.
default LBiLongPredicate	compose(LLongUnaryOperator before1, LLongUnaryOperator before2) Allows to manipulate the domain of the function.
static LBiLongPredicate	composed(LLongUnaryOperator before1, LLongUnaryOperator before2, LBiLongPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LBiLongPredicate after)
static LBiLongPredicate	constant(boolean r) Creates function that always returns the same value.
default boolean	doApplyAsBoolean(long a1, long a2) For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
default boolean	doIf(long a1, long a2, LAction action)
default boolean	doIf(long a1, long a2, LBiLongConsumer consumer)
static boolean	doIf(long a1, long a2, LBiLongPredicate predicate, LAction action)
static boolean	doIf(long a1, long a2, LBiLongPredicate predicate, LBiLongConsumer consumer)
static LBiLongPredicate	failSafe(LBiLongPredicate func, LBiLongPredicate failSafe)
default boolean	failSafeTest(long a1, long a2, LBiLongPredicate failSafe)
static boolean	failSafeTest(long a1, long a2, LBiLongPredicate func, LBiLongPredicate failSafe)
default <C1,C2> void	filterForEach(IndexedRead<C1,aType.aLong> ia1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LBiLongConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2> void	filterIterate(IndexedRead<C1,aType.aLong> ia1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LBiLongConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2> void	filterIterate(SequentialRead<C1,I1,aType.aLong> sa1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LBiLongConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2> void	filterIterate(SequentialRead<C1,I1,aType.aLong> sa1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LBiLongConsumer consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
static void	fromTill(int min_i, int max_i, long a1, long a2, LBiLongPredicate func) From-To.
static void	fromTo(int min_i, int max_i, long a1, long a2, LBiLongPredicate func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LBiLongPredicate	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default boolean	handlingTest(long a1, long a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static boolean	handlingTest(long a1, long a2, LBiLongPredicate func, HandlingInstructions<Throwable,RuntimeException> handling)
static LBiLongPredicate	isEqual(long v1, long v2) Creates predicate that evaluates if an object is equal with the argument one.
static LBiLongPredicate.LLong1Long0Pred	long1Long0Pred(LBiLongPredicate.LLong1Long0Pred lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default LLongPredicate	lShrink(LLongUnaryOperator left)
default LLongPredicate	lShrinkc(long a1)
static LLongPredicate	lShrinked(LLongUnaryOperator left, LBiLongPredicate func)
static LLongPredicate	lShrinkedc(long a1, LBiLongPredicate func)
default LBiLongPredicate	negate() Returns a predicate that represents the logical negation of this predicate.
default boolean	nestingTest(long a1, long a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default boolean	nonNullTest(long a1, long a2) Just to mirror the method: Ensures the result is not null
default LBiLongPredicate	or(LBiLongPredicate other) Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
static LBiLongPredicate	recursive(LFunction<LBiLongPredicate,LBiLongPredicate> selfLambda)
default LLongPredicate	rShrink(LLongUnaryOperator right)
default LLongPredicate	rShrinkc(long a2)
static LLongPredicate	rShrinked(LLongUnaryOperator right, LBiLongPredicate func)
static LLongPredicate	rShrinkedc(long a2, LBiLongPredicate func)
static LBiLongPredicate	safe() Safe instance.
static LBiLongPredicate	safe(LBiLongPredicate other) Safe wrapping.
static LSupplier<LBiLongPredicate>	safeSupplier() Safe instance supplier.
static LSupplier<LBiLongPredicate>	safeSupplier(LSupplier<LBiLongPredicate> supplier) Safe supplier.
default boolean	shovingTest(long a1, long a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default boolean	test(long a1, long a2)
default boolean	test(long a1, long a2, ExWF<RuntimeException> exF)
default boolean	test(long a1, long a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static LBiLongPredicate	test1st(LLongPredicate func) Captures single parameter function into this interface where only 1st parameter will be used.
static LBiLongPredicate	test2nd(LLongPredicate func) Captures single parameter function into this interface where only 2nd parameter will be used.
default boolean	testThen(long a1, long a2, LPredicate<Throwable> handler)
boolean	testX(long a1, long a2) Implement this, but call test(long a1,long a2)
static void	throwIf(long a1, long a2, LBiLongPredicate pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)
static void	throwIfNot(long a1, long a2, LBiLongPredicate pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)
static void	times(int max_i, long a1, long a2, LBiLongPredicate func) From-To.
default LBiLongPredicate	trying(ExWF<RuntimeException> exF)
default LBiLongPredicate	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LBiLongPredicate	tryingThen(LPredicate<Throwable> handler)
static boolean	tryTest(long a1, long a2, LBiLongPredicate func)
static boolean	tryTest(long a1, long a2, LBiLongPredicate func, ExWF<RuntimeException> exF)
static boolean	tryTest(long a1, long a2, LBiLongPredicate func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static boolean	tryTestThen(long a1, long a2, LBiLongPredicate func, LPredicate<Throwable> handler)
default boolean	tupleTest(LLongPair args)
static LBiLongPredicate	uncurry(LLongFunction<LLongPredicate> func)
default LBiLongPredicate	xor(LBiLongPredicate 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.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, isOperator, isSupplier

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

isThrowing

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

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

test

default boolean test(long a1,
                     long a2)

testX

boolean testX(long a1,
              long a2)
       throws Throwable

Implement this, but call test(long a1,long a2)

Throws:

Throwable

tupleTest

default boolean tupleTest(LLongPair args)

handlingTest

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

Function call that handles exceptions according to the instructions.

handling

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

test

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

trying

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

test

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

trying

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

testThen

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

tryingThen

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

nestingTest

default boolean nestingTest(long a1,
                            long a2)

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

shovingTest

default boolean shovingTest(long a1,
                            long a2)

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

handlingTest

static boolean handlingTest(long a1,
                            long a2,
                            LBiLongPredicate func,
                            HandlingInstructions<Throwable,RuntimeException> handling)

tryTest

static boolean tryTest(long a1,
                       long a2,
                       LBiLongPredicate func)

tryTest

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

tryTest

static boolean tryTest(long a1,
                       long a2,
                       LBiLongPredicate func,
                       @Nonnull
                       ExWF<RuntimeException> exF)

tryTestThen

static boolean tryTestThen(long a1,
                           long a2,
                           LBiLongPredicate func,
                           @Nonnull
                           LPredicate<Throwable> handler)

failSafeTest

default boolean failSafeTest(long a1,
                             long a2,
                             @Nonnull
                             LBiLongPredicate failSafe)

failSafeTest

static boolean failSafeTest(long a1,
                            long a2,
                            LBiLongPredicate func,
                            @Nonnull
                            LBiLongPredicate failSafe)

failSafe

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

doIf

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

doIf

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

doIf

static boolean doIf(long a1,
                    long a2,
                    @Nonnull
                    LBiLongPredicate predicate,
                    @Nonnull
                    LBiLongConsumer consumer)

doIf

default boolean doIf(long a1,
                     long a2,
                     @Nonnull
                     LBiLongConsumer consumer)

throwIf

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

throwIfNot

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

nonNullTest

default boolean nonNullTest(long a1,
                            long a2)

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

doApplyAsBoolean

default boolean doApplyAsBoolean(long a1,
                                 long a2)

For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.

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,
                   long a1,
                   long a2,
                   LBiLongPredicate func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     long a1,
                     long a2,
                     LBiLongPredicate func)

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

times

static void times(int max_i,
                  long a1,
                  long a2,
                  LBiLongPredicate func)

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

lShrink

default LLongPredicate lShrink(LLongUnaryOperator left)

lShrinkc

default LLongPredicate lShrinkc(long a1)

lShrinked

static LLongPredicate lShrinked(LLongUnaryOperator left,
                                LBiLongPredicate func)

lShrinkedc

static LLongPredicate lShrinkedc(long a1,
                                 LBiLongPredicate func)

rShrink

default LLongPredicate rShrink(LLongUnaryOperator right)

rShrinkc

default LLongPredicate rShrinkc(long a2)

rShrinked

static LLongPredicate rShrinked(LLongUnaryOperator right,
                                LBiLongPredicate func)

rShrinkedc

static LLongPredicate rShrinkedc(long a2,
                                 LBiLongPredicate func)

uncurry

static LBiLongPredicate uncurry(LLongFunction<LLongPredicate> func)

capture

default LBoolSupplier capture(long a1,
                              long a2)

Captures arguments but delays the evaluation.

constant

static LBiLongPredicate constant(boolean r)

Creates function that always returns the same value.

test1st

@Nonnull
static LBiLongPredicate test1st(@Nonnull
                                          LLongPredicate func)

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

test2nd

@Nonnull
static LBiLongPredicate test2nd(@Nonnull
                                          LLongPredicate func)

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

biLongPred

@Nonnull
static LBiLongPredicate biLongPred(@Nonnull
                                             LBiLongPredicate lambda)

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

recursive

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

biLongPredThrowing

@Nonnull
static LBiLongPredicate biLongPredThrowing(@Nonnull
                                                     ExF<Throwable> exF)

biLongPredThrowing

@Nonnull
static LBiLongPredicate biLongPredThrowing(String message,
                                                     @Nonnull
                                                     ExMF<Throwable> exF)

long1Long0Pred

@Nonnull
static LBiLongPredicate.LLong1Long0Pred long1Long0Pred(@Nonnull
                                                                 LBiLongPredicate.LLong1Long0Pred lambda)

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

call

static boolean call(long a1,
                    long a2,
                    @Nonnull
                    LBiLongPredicate lambda)

safe

@Nonnull
static LBiLongPredicate safe()

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

safeSupplier

@Nonnull
static LSupplier<LBiLongPredicate> safeSupplier()

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

safe

@Nonnull
static LBiLongPredicate safe(@Nullable
                                       LBiLongPredicate other)

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

safeSupplier

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

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

negate

@Nonnull
default LBiLongPredicate negate()

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

See Also:

java.util.function.Predicate#negate}

and

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

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

See Also:

java.util.function.Predicate#isEqual()

compose

@Nonnull
default LBiLongPredicate compose(@Nonnull
                                           LLongUnaryOperator before1,
                                           @Nonnull
                                           LLongUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LBiLongPredicate composed(@Nonnull
                                 LLongUnaryOperator before1,
                                 @Nonnull
                                 LLongUnaryOperator before2,
                                 LBiLongPredicate after)

biLongPredCompose

@Nonnull
default <V1,V2> LBiPredicate<V1,V2> biLongPredCompose(@Nonnull
                                                                LToLongFunction<? super V1> before1,
                                                                @Nonnull
                                                                LToLongFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

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

boolToBiLongFunc

@Nonnull
default <V> LBiLongFunction<V> boolToBiLongFunc(@Nonnull
                                                          LBoolFunction<? extends V> after)

Combines two functions together in a order.

boolToLongBinaryOp

@Nonnull
default LLongBinaryOperator boolToLongBinaryOp(@Nonnull
                                                         LBoolToLongFunction after)

Combines two functions together in a order.

boolToBiLongPred

@Nonnull
default LBiLongPredicate boolToBiLongPred(@Nonnull
                                                    LLogicalOperator after)

Combines two functions together in a order.

alwaysTrue

static boolean alwaysTrue(long a1,
                          long a2)

Returns TRUE.

alwaysFalse

static boolean alwaysFalse(long a1,
                           long a2)

Returns FALSE.

filterForEach

default <C1,C2> void filterForEach(IndexedRead<C1,aType.aLong> ia1,
                                   C1 source1,
                                   IndexedRead<C2,aType.aLong> ia2,
                                   C2 source2,
                                   LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.

filterIterate

default <C1,I1,C2> void filterIterate(SequentialRead<C1,I1,aType.aLong> sa1,
                                      C1 source1,
                                      IndexedRead<C2,aType.aLong> ia2,
                                      C2 source2,
                                      LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.

filterIterate

default <C1,C2,I2> void filterIterate(IndexedRead<C1,aType.aLong> ia1,
                                      C1 source1,
                                      SequentialRead<C2,I2,aType.aLong> sa2,
                                      C2 source2,
                                      LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.

filterIterate

default <C1,I1,C2,I2> void filterIterate(SequentialRead<C1,I1,aType.aLong> sa1,
                                         C1 source1,
                                         SequentialRead<C2,I2,aType.aLong> sa2,
                                         C2 source2,
                                         LBiLongConsumer consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.