LBiObjSrtPredicate (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aBool>, Domain, Domain3<aType.a<T1>,aType.a<T2>,aType.aShort>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaPredicate

All Known Subinterfaces:

LBiObjSrtPredicate.LObj0Srt2Obj1Pred<T1,T2>, LBiObjSrtPredicate.LObj1Obj0Srt2Pred<T2,T1>, LBiObjSrtPredicate.LObj1Srt2Obj0Pred<T2,T1>, LBiObjSrtPredicate.LSrt2Obj0Obj1Pred<T1,T2>, LBiObjSrtPredicate.LSrt2Obj1Obj0Pred<T2,T1>

All Known Implementing Classes:

LBiObjSrtPredicate.LBiObjSrtPredicateSingle
```
@FunctionalInterface
public interface LBiObjSrtPredicate<T1,T2>
extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain3<aType.a<T1>,aType.a<T2>,aType.aShort>
```
Non-throwing functional interface (lambda) LBiObjSrtPredicate for Java 8.
Type: predicate
Domain (lvl: 3): T1 a1,T2 a2,short a3
Co-domain: boolean

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`LBiObjSrtPredicate.LBiObjSrtPredicateSingle<T1,T2>`
`static interface`	`LBiObjSrtPredicate.LObj0Srt2Obj1Pred<T1,T2>` Permutation of LBiObjSrtPredicate for method references.
`static interface`	`LBiObjSrtPredicate.LObj1Obj0Srt2Pred<T2,T1>` Permutation of LBiObjSrtPredicate for method references.
`static interface`	`LBiObjSrtPredicate.LObj1Srt2Obj0Pred<T2,T1>` Permutation of LBiObjSrtPredicate for method references.
`static interface`	`LBiObjSrtPredicate.LSrt2Obj0Obj1Pred<T1,T2>` Permutation of LBiObjSrtPredicate for method references.
`static interface`	`LBiObjSrtPredicate.LSrt2Obj1Obj0Pred<T2,T1>` Permutation of LBiObjSrtPredicate 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

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 <T1,T2> boolean`	`alwaysFalse(short a3, T1 a1, T2 a2)` Returns FALSE.
`static <T1,T2> boolean`	`alwaysFalse(T1 a1, short a3, T2 a2)` Returns FALSE.
`static <T1,T2> boolean`	`alwaysFalse(T1 a1, T2 a2, short a3)` Returns FALSE.
`static <T1,T2> boolean`	`alwaysTrue(short a3, T1 a1, T2 a2)` Returns TRUE.
`static <T1,T2> boolean`	`alwaysTrue(T1 a1, short a3, T2 a2)` Returns TRUE.
`static <T1,T2> boolean`	`alwaysTrue(T1 a1, T2 a2, short a3)` Returns TRUE.
`default LBiObjSrtPredicate<T1,T2>`	`and(LBiObjSrtPredicate<? super T1,? super T2> other)` Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`biObjSrtPred(LBiObjSrtPredicate<T1,T2> 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>`	`biObjSrtPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3)` Allows to manipulate the domain of the function.
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`biObjSrtPredThrowing(ExF<Throwable> exF)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`biObjSrtPredThrowing(String message, ExMF<Throwable> exF)`
`default <V> LBiObjSrtFunction<T1,T2,V>`	`boolToBiObjSrtFunc(LBoolFunction<? extends V> after)` Combines two functions together in a order.
`default LBiObjSrtPredicate<T1,T2>`	`boolToBiObjSrtPred(LLogicalOperator after)` Combines two functions together in a order.
`static <T1,T2> boolean`	`call(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> lambda)`
`default LBoolSupplier`	`capture(T1 a1, T2 a2, short a3)` Captures arguments but delays the evaluation.
`default <V2,V3> LBiObjSrtPredicate<V2,V3>`	`cast()` Cast that replace generics.
`static <V2,V3,T1,T2> LBiObjSrtPredicate<V2,V3>`	`cast(LBiObjSrtPredicate<T1,T2> function)` Cast that replace generics.
`default <V1,V2> LBiObjSrtPredicate<V1,V2>`	`compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3)` Allows to manipulate the domain of the function.
`static <V1,V2,T1,T2> LBiObjSrtPredicate<V1,V2>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LSrtUnaryOperator before3, LBiObjSrtPredicate<T1,T2> after)`
`static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>`	`composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToSrtFunction<? super V3> before3, LBiObjSrtPredicate<T1,T2> after)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`constant(boolean r)` Creates function that always returns the same value.
`default boolean`	`doApplyAsBoolean(T1 a1, T2 a2, short a3)` For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
`default boolean`	`doIf(T1 a1, T2 a2, short a3, LAction action)`
`default boolean`	`doIf(T1 a1, T2 a2, short a3, LBiObjSrtConsumer<? super T1,? super T2> consumer)`
`static <T1,T2> boolean`	`doIf(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> predicate, LAction action)`
`static <T1,T2> boolean`	`doIf(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> predicate, LBiObjSrtConsumer<? super T1,? super T2> consumer)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`failSafe(LBiObjSrtPredicate<T1,T2> func, LBiObjSrtPredicate<T1,T2> failSafe)`
`default boolean`	`failSafeTest(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> failSafe)`
`static <T1,T2> boolean`	`failSafeTest(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func, LBiObjSrtPredicate<T1,T2> failSafe)`
`default <C1,C2,C3> void`	`filterForEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,C3,I3> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,I2,C3> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,C2,I2,C3,I3> void`	`filterIterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,C3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,C3,I3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,I2,C3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, IndexedRead<C3,aType.aShort> ia3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`default <C1,I1,C2,I2,C3,I3> void`	`filterIterate(SequentialRead<C1,I1,aType.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, SequentialRead<C3,I3,aType.aShort> sa3, C3 source3, LBiObjSrtConsumer<? super T1,? super T2> consumer)` For each element (or tuple) from arguments, calls the consumer if predicate test passes.
`static <T1,T2> void`	`fromTill(int min_i, int max_i, T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func)` From-To.
`static <T1,T2> void`	`fromTo(int min_i, int max_i, T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func)` From-To.
`default String`	`functionalInterfaceDescription()` Returns description of the functional interface.
`default LBiObjSrtPredicate<T1,T2>`	`handling(HandlingInstructions<Throwable,RuntimeException> handling)`
`default boolean`	`handlingTest(T1 a1, T2 a2, short a3, HandlingInstructions<Throwable,RuntimeException> handling)` Function call that handles exceptions according to the instructions.
`static <T1,T2> boolean`	`handlingTest(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`isEqual(T1 v1, T2 v2, short v3)` Creates predicate that evaluates if an object is equal with the argument one.
`default LObjSrtPredicate<T2>`	`lShrink(LObjSrtFunction<T2,T1> left)`
`default LObjSrtPredicate<T2>`	`lShrinkc(T1 a1)`
`static <T2,T1> LObjSrtPredicate<T2>`	`lShrinked(LObjSrtFunction<T2,T1> left, LBiObjSrtPredicate<T1,T2> func)`
`static <T2,T1> LObjSrtPredicate<T2>`	`lShrinkedc(T1 a1, LBiObjSrtPredicate<T1,T2> func)`
`default LBiObjSrtPredicate<T1,T2>`	`negate()` Returns a predicate that represents the logical negation of this predicate.
`default boolean`	`nestingTest(T1 a1, T2 a2, short a3)` Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
`default boolean`	`nonNullTest(T1 a1, T2 a2, short a3)` Just to mirror the method: Ensures the result is not null
`static <T1,T2> LBiObjSrtPredicate.LObj0Srt2Obj1Pred<T1,T2>`	`obj0Srt2Obj1Pred(LBiObjSrtPredicate.LObj0Srt2Obj1Pred<T1,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1> LBiObjSrtPredicate.LObj1Obj0Srt2Pred<T2,T1>`	`obj1Obj0Srt2Pred(LBiObjSrtPredicate.LObj1Obj0Srt2Pred<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1> LBiObjSrtPredicate.LObj1Srt2Obj0Pred<T2,T1>`	`obj1Srt2Obj0Pred(LBiObjSrtPredicate.LObj1Srt2Obj0Pred<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default LBiObjSrtPredicate<T1,T2>`	`or(LBiObjSrtPredicate<? super T1,? super T2> other)` Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`recursive(LFunction<LBiObjSrtPredicate<T1,T2>,LBiObjSrtPredicate<T1,T2>> selfLambda)`
`default LBiPredicate<T1,T2>`	`rShrink(LToSrtBiFunction<T1,T2> right)`
`default LBiPredicate<T1,T2>`	`rShrinkc(short a3)`
`static <T1,T2> LBiPredicate<T1,T2>`	`rShrinked(LToSrtBiFunction<T1,T2> right, LBiObjSrtPredicate<T1,T2> func)`
`static <T1,T2> LBiPredicate<T1,T2>`	`rShrinkedc(short a3, LBiObjSrtPredicate<T1,T2> func)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`safe()` Safe instance.
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`safe(LBiObjSrtPredicate<T1,T2> other)` Safe wrapping.
`static <T1,T2> LSupplier<LBiObjSrtPredicate<T1,T2>>`	`safeSupplier()` Safe instance supplier.
`static <T1,T2> LSupplier<LBiObjSrtPredicate<T1,T2>>`	`safeSupplier(LSupplier<LBiObjSrtPredicate<T1,T2>> supplier)` Safe supplier.
`default boolean`	`shovingTest(T1 a1, T2 a2, short a3)` Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
`static <T1,T2> LBiObjSrtPredicate.LSrt2Obj0Obj1Pred<T1,T2>`	`srt2Obj0Obj1Pred(LBiObjSrtPredicate.LSrt2Obj0Obj1Pred<T1,T2> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`static <T2,T1> LBiObjSrtPredicate.LSrt2Obj1Obj0Pred<T2,T1>`	`srt2Obj1Obj0Pred(LBiObjSrtPredicate.LSrt2Obj1Obj0Pred<T2,T1> lambda)` Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
`default boolean`	`test(T1 a1, T2 a2, short a3)`
`default boolean`	`test(T1 a1, T2 a2, short a3, ExWF<RuntimeException> exF)`
`default boolean`	`test(T1 a1, T2 a2, short a3, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`test1st(LPredicate<T1> func)` Captures single parameter function into this interface where only 1st parameter will be used.
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`test2nd(LPredicate<T2> func)` Captures single parameter function into this interface where only 2nd parameter will be used.
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`test3rd(LSrtPredicate func)` Captures single parameter function into this interface where only 3rd parameter will be used.
`default boolean`	`testThen(T1 a1, T2 a2, short a3, LPredicate<Throwable> handler)`
`boolean`	`testX(T1 a1, T2 a2, short a3)` Implement this, but call test(T1 a1,T2 a2,short a3)
`static <T1,T2> void`	`throwIf(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T1,T2> void`	`throwIfNot(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)`
`static <T1,T2> void`	`times(int max_i, T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func)` From-To.
`default LBiObjSrtPredicate<T1,T2>`	`trying(ExWF<RuntimeException> exF)`
`default LBiObjSrtPredicate<T1,T2>`	`trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`default LBiObjSrtPredicate<T1,T2>`	`tryingThen(LPredicate<Throwable> handler)`
`static <T1,T2> boolean`	`tryTest(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func)`
`static <T1,T2> boolean`	`tryTest(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func, ExWF<RuntimeException> exF)`
`static <T1,T2> boolean`	`tryTest(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)`
`static <T1,T2> boolean`	`tryTestThen(T1 a1, T2 a2, short a3, LBiObjSrtPredicate<T1,T2> func, LPredicate<Throwable> handler)`
`default boolean`	`tupleTest(LBiObjSrtTriple<T1,T2> args)`
`static <T1,T2> LBiObjSrtPredicate<T1,T2>`	`uncurry(LFunction<T1,LFunction<T2,LSrtPredicate>> func)`
`default LBiObjSrtPredicate`	`untyped()` Cast that removes generics.
`default LBiObjSrtPredicate<T1,T2>`	`xor(LBiObjSrtPredicate<? super T1,? super T2> 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(T1 a1,
                     T2 a2,
                     short a3)

testX

boolean testX(T1 a1,
              T2 a2,
              short a3)
       throws Throwable

Implement this, but call test(T1 a1,T2 a2,short a3)

Throws:: Throwable

tupleTest

default boolean tupleTest(LBiObjSrtTriple<T1,T2> args)

handlingTest

default boolean handlingTest(T1 a1,
                             T2 a2,
                             short a3,
                             HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LBiObjSrtPredicate<T1,T2> handling(HandlingInstructions<Throwable,RuntimeException> handling)

test

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

trying

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

test

default boolean test(T1 a1,
                     T2 a2,
                     short a3,
                     @Nonnull
                     ExWF<RuntimeException> exF)

trying

default LBiObjSrtPredicate<T1,T2> trying(@Nonnull
                                         ExWF<RuntimeException> exF)

testThen

default boolean testThen(T1 a1,
                         T2 a2,
                         short a3,
                         @Nonnull
                         LPredicate<Throwable> handler)

tryingThen

default LBiObjSrtPredicate<T1,T2> tryingThen(@Nonnull
                                             LPredicate<Throwable> handler)

nestingTest

default boolean nestingTest(T1 a1,
                            T2 a2,
                            short a3)

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

shovingTest

default boolean shovingTest(T1 a1,
                            T2 a2,
                            short a3)

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

handlingTest

static <T1,T2> boolean handlingTest(T1 a1,
                                    T2 a2,
                                    short a3,
                                    LBiObjSrtPredicate<T1,T2> func,
                                    HandlingInstructions<Throwable,RuntimeException> handling)

tryTest

static <T1,T2> boolean tryTest(T1 a1,
                               T2 a2,
                               short a3,
                               LBiObjSrtPredicate<T1,T2> func)

tryTest

static <T1,T2> boolean tryTest(T1 a1,
                               T2 a2,
                               short a3,
                               LBiObjSrtPredicate<T1,T2> func,
                               @Nonnull
                               ExWMF<RuntimeException> exF,
                               @Nonnull
                               String newMessage,
                               @Nullable
                               Object... messageParams)

tryTest

static <T1,T2> boolean tryTest(T1 a1,
                               T2 a2,
                               short a3,
                               LBiObjSrtPredicate<T1,T2> func,
                               @Nonnull
                               ExWF<RuntimeException> exF)

tryTestThen

static <T1,T2> boolean tryTestThen(T1 a1,
                                   T2 a2,
                                   short a3,
                                   LBiObjSrtPredicate<T1,T2> func,
                                   @Nonnull
                                   LPredicate<Throwable> handler)

failSafeTest

default boolean failSafeTest(T1 a1,
                             T2 a2,
                             short a3,
                             @Nonnull
                             LBiObjSrtPredicate<T1,T2> failSafe)

failSafeTest

static <T1,T2> boolean failSafeTest(T1 a1,
                                    T2 a2,
                                    short a3,
                                    LBiObjSrtPredicate<T1,T2> func,
                                    @Nonnull
                                    LBiObjSrtPredicate<T1,T2> failSafe)

failSafe

static <T1,T2> LBiObjSrtPredicate<T1,T2> failSafe(LBiObjSrtPredicate<T1,T2> func,
                                                  @Nonnull
                                                  LBiObjSrtPredicate<T1,T2> failSafe)

doIf

default boolean doIf(T1 a1,
                     T2 a2,
                     short a3,
                     LAction action)

doIf

static <T1,T2> boolean doIf(T1 a1,
                            T2 a2,
                            short a3,
                            @Nonnull
                            LBiObjSrtPredicate<T1,T2> predicate,
                            @Nonnull
                            LAction action)

doIf

static <T1,T2> boolean doIf(T1 a1,
                            T2 a2,
                            short a3,
                            @Nonnull
                            LBiObjSrtPredicate<T1,T2> predicate,
                            @Nonnull
                            LBiObjSrtConsumer<? super T1,? super T2> consumer)

doIf

default boolean doIf(T1 a1,
                     T2 a2,
                     short a3,
                     @Nonnull
                     LBiObjSrtConsumer<? super T1,? super T2> consumer)

throwIf

static <T1,T2> void throwIf(T1 a1,
                            T2 a2,
                            short a3,
                            LBiObjSrtPredicate<T1,T2> pred,
                            ExMF<RuntimeException> factory,
                            @Nonnull
                            String newMessage,
                            @Nullable
                            Object... messageParams)

throwIfNot

static <T1,T2> void throwIfNot(T1 a1,
                               T2 a2,
                               short a3,
                               LBiObjSrtPredicate<T1,T2> pred,
                               ExMF<RuntimeException> factory,
                               @Nonnull
                               String newMessage,
                               @Nullable
                               Object... messageParams)

nonNullTest

default boolean nonNullTest(T1 a1,
                            T2 a2,
                            short a3)

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

doApplyAsBoolean

default boolean doApplyAsBoolean(T1 a1,
                                 T2 a2,
                                 short a3)

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 <T1,T2> void fromTo(int min_i,
                           int max_i,
                           T1 a1,
                           T2 a2,
                           short a3,
                           LBiObjSrtPredicate<T1,T2> func)

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

fromTill

static <T1,T2> void fromTill(int min_i,
                             int max_i,
                             T1 a1,
                             T2 a2,
                             short a3,
                             LBiObjSrtPredicate<T1,T2> func)

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

times

static <T1,T2> void times(int max_i,
                          T1 a1,
                          T2 a2,
                          short a3,
                          LBiObjSrtPredicate<T1,T2> func)

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

lShrink

default LObjSrtPredicate<T2> lShrink(LObjSrtFunction<T2,T1> left)

lShrinkc

default LObjSrtPredicate<T2> lShrinkc(T1 a1)

lShrinked

static <T2,T1> LObjSrtPredicate<T2> lShrinked(LObjSrtFunction<T2,T1> left,
                                              LBiObjSrtPredicate<T1,T2> func)

lShrinkedc

static <T2,T1> LObjSrtPredicate<T2> lShrinkedc(T1 a1,
                                               LBiObjSrtPredicate<T1,T2> func)

rShrink

default LBiPredicate<T1,T2> rShrink(LToSrtBiFunction<T1,T2> right)

rShrinkc

default LBiPredicate<T1,T2> rShrinkc(short a3)

rShrinked

static <T1,T2> LBiPredicate<T1,T2> rShrinked(LToSrtBiFunction<T1,T2> right,
                                             LBiObjSrtPredicate<T1,T2> func)

rShrinkedc

static <T1,T2> LBiPredicate<T1,T2> rShrinkedc(short a3,
                                              LBiObjSrtPredicate<T1,T2> func)

uncurry

static <T1,T2> LBiObjSrtPredicate<T1,T2> uncurry(LFunction<T1,LFunction<T2,LSrtPredicate>> func)

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

cast

default <V2,V3> LBiObjSrtPredicate<V2,V3> cast()

Cast that replace generics.

cast

static <V2,V3,T1,T2> LBiObjSrtPredicate<V2,V3> cast(LBiObjSrtPredicate<T1,T2> function)

Cast that replace generics.

capture

default LBoolSupplier capture(T1 a1,
                              T2 a2,
                              short a3)

Captures arguments but delays the evaluation.

constant

static <T1,T2> LBiObjSrtPredicate<T1,T2> constant(boolean r)

Creates function that always returns the same value.

test1st

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> test1st(@Nonnull
                                                           LPredicate<T1> func)

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

test2nd

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> test2nd(@Nonnull
                                                           LPredicate<T2> func)

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

test3rd

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> test3rd(@Nonnull
                                                           LSrtPredicate func)

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

biObjSrtPred

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> biObjSrtPred(@Nonnull
                                                                LBiObjSrtPredicate<T1,T2> lambda)

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

recursive

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> recursive(@Nonnull
                                                             LFunction<LBiObjSrtPredicate<T1,T2>,LBiObjSrtPredicate<T1,T2>> selfLambda)

biObjSrtPredThrowing

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> biObjSrtPredThrowing(@Nonnull
                                                                        ExF<Throwable> exF)

biObjSrtPredThrowing

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> biObjSrtPredThrowing(String message,
                                                                        @Nonnull
                                                                        ExMF<Throwable> exF)

obj0Srt2Obj1Pred

@Nonnull
static <T1,T2> LBiObjSrtPredicate.LObj0Srt2Obj1Pred<T1,T2> obj0Srt2Obj1Pred(@Nonnull
                                                                                      LBiObjSrtPredicate.LObj0Srt2Obj1Pred<T1,T2> lambda)

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

obj1Obj0Srt2Pred

@Nonnull
static <T2,T1> LBiObjSrtPredicate.LObj1Obj0Srt2Pred<T2,T1> obj1Obj0Srt2Pred(@Nonnull
                                                                                      LBiObjSrtPredicate.LObj1Obj0Srt2Pred<T2,T1> lambda)

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

obj1Srt2Obj0Pred

@Nonnull
static <T2,T1> LBiObjSrtPredicate.LObj1Srt2Obj0Pred<T2,T1> obj1Srt2Obj0Pred(@Nonnull
                                                                                      LBiObjSrtPredicate.LObj1Srt2Obj0Pred<T2,T1> lambda)

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

srt2Obj0Obj1Pred

@Nonnull
static <T1,T2> LBiObjSrtPredicate.LSrt2Obj0Obj1Pred<T1,T2> srt2Obj0Obj1Pred(@Nonnull
                                                                                      LBiObjSrtPredicate.LSrt2Obj0Obj1Pred<T1,T2> lambda)

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

srt2Obj1Obj0Pred

@Nonnull
static <T2,T1> LBiObjSrtPredicate.LSrt2Obj1Obj0Pred<T2,T1> srt2Obj1Obj0Pred(@Nonnull
                                                                                      LBiObjSrtPredicate.LSrt2Obj1Obj0Pred<T2,T1> lambda)

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

call

static <T1,T2> boolean call(T1 a1,
                            T2 a2,
                            short a3,
                            @Nonnull
                            LBiObjSrtPredicate<T1,T2> lambda)

safe
```
@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> safe()
```
Safe instance. That always returns the same value (as alwaysFalse).

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LBiObjSrtPredicate<T1,T2>> safeSupplier()

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

safe

@Nonnull
static <T1,T2> LBiObjSrtPredicate<T1,T2> safe(@Nullable
                                                        LBiObjSrtPredicate<T1,T2> other)

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

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LBiObjSrtPredicate<T1,T2>> safeSupplier(@Nullable
                                                                           LSupplier<LBiObjSrtPredicate<T1,T2>> supplier)

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

negate
```
@Nonnull
default LBiObjSrtPredicate<T1,T2> negate()
```
Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LBiObjSrtPredicate<T1,T2> and(@Nonnull
                                                LBiObjSrtPredicate<? super T1,? super T2> 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 LBiObjSrtPredicate<T1,T2> or(@Nonnull
                                               LBiObjSrtPredicate<? super T1,? super T2> 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 LBiObjSrtPredicate<T1,T2> xor(@Nonnull
                                                LBiObjSrtPredicate<? super T1,? super T2> 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 <T1,T2> LBiObjSrtPredicate<T1,T2> isEqual(T1 v1,
                                                           T2 v2,
                                                           short v3)

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

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

compose

@Nonnull
default <V1,V2> LBiObjSrtPredicate<V1,V2> compose(@Nonnull
                                                            LFunction<? super V1,? extends T1> before1,
                                                            @Nonnull
                                                            LFunction<? super V2,? extends T2> before2,
                                                            @Nonnull
                                                            LSrtUnaryOperator before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,T1,T2> LBiObjSrtPredicate<V1,V2> composed(@Nonnull
                                                        LFunction<? super V1,? extends T1> before1,
                                                        @Nonnull
                                                        LFunction<? super V2,? extends T2> before2,
                                                        @Nonnull
                                                        LSrtUnaryOperator before3,
                                                        LBiObjSrtPredicate<T1,T2> after)

biObjSrtPredCompose

@Nonnull
default <V1,V2,V3> LTriPredicate<V1,V2,V3> biObjSrtPredCompose(@Nonnull
                                                                         LFunction<? super V1,? extends T1> before1,
                                                                         @Nonnull
                                                                         LFunction<? super V2,? extends T2> before2,
                                                                         @Nonnull
                                                                         LToSrtFunction<? super V3> before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3> composed(@Nonnull
                                                         LFunction<? super V1,? extends T1> before1,
                                                         @Nonnull
                                                         LFunction<? super V2,? extends T2> before2,
                                                         @Nonnull
                                                         LToSrtFunction<? super V3> before3,
                                                         LBiObjSrtPredicate<T1,T2> after)

boolToBiObjSrtFunc

@Nonnull
default <V> LBiObjSrtFunction<T1,T2,V> boolToBiObjSrtFunc(@Nonnull
                                                                    LBoolFunction<? extends V> after)

Combines two functions together in a order.

boolToBiObjSrtPred

@Nonnull
default LBiObjSrtPredicate<T1,T2> boolToBiObjSrtPred(@Nonnull
                                                               LLogicalOperator after)

Combines two functions together in a order.

alwaysTrue

static <T1,T2> boolean alwaysTrue(T1 a1,
                                  T2 a2,
                                  short a3)

Returns TRUE.

alwaysFalse

static <T1,T2> boolean alwaysFalse(T1 a1,
                                   T2 a2,
                                   short a3)

Returns FALSE.

alwaysTrue

static <T1,T2> boolean alwaysTrue(T1 a1,
                                  short a3,
                                  T2 a2)

Returns TRUE.

alwaysFalse

static <T1,T2> boolean alwaysFalse(T1 a1,
                                   short a3,
                                   T2 a2)

Returns FALSE.

alwaysTrue

static <T1,T2> boolean alwaysTrue(short a3,
                                  T1 a1,
                                  T2 a2)

Returns TRUE.

alwaysFalse

static <T1,T2> boolean alwaysFalse(short a3,
                                   T1 a1,
                                   T2 a2)

Returns FALSE.