LObjBiIntPredicate (magma-func 2.0.0 API)

All Superinterfaces:

Codomain<aType.aBool>, Domain, Domain3<aType.a<T>,aType.aInt,aType.aInt>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaPredicate

All Known Subinterfaces:

LObjBiIntPredicate.LBiInt1Obj0Pred<T>, LObjBiIntPredicate.LInt1Int2Obj0Pred<T>, LObjBiIntPredicate.LInt1Obj0Int2Pred<T>, LObjBiIntPredicate.LInt2Obj0Int1Pred<T>, LObjBiIntPredicate.LObj0Int2Int1Pred<T>

All Known Implementing Classes:

LObjBiIntPredicate.LObjBiIntPredicateSingle
```
@FunctionalInterface
public interface LObjBiIntPredicate<T>
extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain3<aType.a<T>,aType.aInt,aType.aInt>
```
Non-throwing functional interface (lambda) LObjBiIntPredicate for Java 8.
Type: predicate
Domain (lvl: 3): T a1,int a2,int a3
Co-domain: boolean

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`LObjBiIntPredicate.LBiInt1Obj0Pred<T>` Permutation of LObjBiIntPredicate for method references.
`static interface`	`LObjBiIntPredicate.LInt1Int2Obj0Pred<T>` Permutation of LObjBiIntPredicate for method references.
`static interface`	`LObjBiIntPredicate.LInt1Obj0Int2Pred<T>` Permutation of LObjBiIntPredicate for method references.
`static interface`	`LObjBiIntPredicate.LInt2Obj0Int1Pred<T>` Permutation of LObjBiIntPredicate for method references.
`static interface`	`LObjBiIntPredicate.LObj0Int2Int1Pred<T>` Permutation of LObjBiIntPredicate for method references.
`static class`	`LObjBiIntPredicate.LObjBiIntPredicateSingle<T>`

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

testX

boolean testX(T a1,
              int a2,
              int a3)
       throws Throwable

Implement this, but call test(T a1,int a2,int a3)

Throws:: Throwable

tupleTest

default boolean tupleTest(LObjBiIntTriple<T> args)

handlingTest

default boolean handlingTest(T a1,
                             int a2,
                             int a3,
                             HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

test

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

trying

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

test

default boolean test(T a1,
                     int a2,
                     int a3,
                     @Nonnull
                     ExWF<RuntimeException> exF)

trying

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

testThen

default boolean testThen(T a1,
                         int a2,
                         int a3,
                         @Nonnull
                         LPredicate<Throwable> handler)

tryingThen

default LObjBiIntPredicate<T> tryingThen(@Nonnull
                                         LPredicate<Throwable> handler)

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

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

handlingTest

static <T> boolean handlingTest(T a1,
                                int a2,
                                int a3,
                                LObjBiIntPredicate<T> func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryTest

static <T> boolean tryTest(T a1,
                           int a2,
                           int a3,
                           LObjBiIntPredicate<T> func)

tryTest

static <T> boolean tryTest(T a1,
                           int a2,
                           int a3,
                           LObjBiIntPredicate<T> func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryTest

static <T> boolean tryTest(T a1,
                           int a2,
                           int a3,
                           LObjBiIntPredicate<T> func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryTestThen

static <T> boolean tryTestThen(T a1,
                               int a2,
                               int a3,
                               LObjBiIntPredicate<T> func,
                               @Nonnull
                               LPredicate<Throwable> handler)

failSafeTest

default boolean failSafeTest(T a1,
                             int a2,
                             int a3,
                             @Nonnull
                             LObjBiIntPredicate<T> failSafe)

failSafeTest

static <T> boolean failSafeTest(T a1,
                                int a2,
                                int a3,
                                LObjBiIntPredicate<T> func,
                                @Nonnull
                                LObjBiIntPredicate<T> failSafe)

failSafe

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

doIf

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

doIf

static <T> boolean doIf(T a1,
                        int a2,
                        int a3,
                        @Nonnull
                        LObjBiIntPredicate<T> predicate,
                        @Nonnull
                        LAction action)

doIf

static <T> boolean doIf(T a1,
                        int a2,
                        int a3,
                        @Nonnull
                        LObjBiIntPredicate<T> predicate,
                        @Nonnull
                        LTieIntConsumer<? super T> consumer)

doIf

default boolean doIf(T a1,
                     int a2,
                     int a3,
                     @Nonnull
                     LTieIntConsumer<? super T> consumer)

throwIf

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

throwIfNot

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

nonNullTest

default boolean nonNullTest(T a1,
                            int a2,
                            int a3)

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

doApplyAsBoolean

default boolean doApplyAsBoolean(T a1,
                                 int a2,
                                 int 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 <T> void fromTo(int min_i,
                       int max_i,
                       T a1,
                       int a2,
                       int a3,
                       LObjBiIntPredicate<T> func)

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

fromTill

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

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

times

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

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

lShrink

default LBiIntPredicate lShrink(LBiIntFunction<T> left)

lShrinkc

default LBiIntPredicate lShrinkc(T a1)

lShrinked

static <T> LBiIntPredicate lShrinked(LBiIntFunction<T> left,
                                     LObjBiIntPredicate<T> func)

lShrinkedc

static <T> LBiIntPredicate lShrinkedc(T a1,
                                      LObjBiIntPredicate<T> func)

rShrink

default LObjIntPredicate<T> rShrink(LOiToIntFunction<T> right)

rShrinkc

default LObjIntPredicate<T> rShrinkc(int a3)

rShrinked

static <T> LObjIntPredicate<T> rShrinked(LOiToIntFunction<T> right,
                                         LObjBiIntPredicate<T> func)

rShrinkedc

static <T> LObjIntPredicate<T> rShrinkedc(int a3,
                                          LObjBiIntPredicate<T> func)

uncurry

static <T> LObjBiIntPredicate<T> uncurry(LFunction<T,LIntFunction<LIntPredicate>> func)

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

cast

default <V2> LObjBiIntPredicate<V2> cast()

Cast that replace generics.

cast

static <V2,T> LObjBiIntPredicate<V2> cast(LObjBiIntPredicate<T> function)

Cast that replace generics.

capture

default LBoolSupplier capture(T a1,
                              int a2,
                              int a3)

Captures arguments but delays the evaluation.

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

test1st

@Nonnull
static <T> LObjBiIntPredicate<T> test1st(@Nonnull
                                                   LPredicate<T> func)

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

test2nd

@Nonnull
static <T> LObjBiIntPredicate<T> test2nd(@Nonnull
                                                   LIntPredicate func)

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

test3rd

@Nonnull
static <T> LObjBiIntPredicate<T> test3rd(@Nonnull
                                                   LIntPredicate func)

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

objBiIntPred

@Nonnull
static <T> LObjBiIntPredicate<T> objBiIntPred(@Nonnull
                                                        LObjBiIntPredicate<T> lambda)

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

recursive

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

objBiIntPredThrowing

@Nonnull
static <T> LObjBiIntPredicate<T> objBiIntPredThrowing(@Nonnull
                                                                ExF<Throwable> exF)

objBiIntPredThrowing

@Nonnull
static <T> LObjBiIntPredicate<T> objBiIntPredThrowing(String message,
                                                                @Nonnull
                                                                ExMF<Throwable> exF)

obj0Int2Int1Pred

@Nonnull
static <T> LObjBiIntPredicate.LObj0Int2Int1Pred<T> obj0Int2Int1Pred(@Nonnull
                                                                              LObjBiIntPredicate.LObj0Int2Int1Pred<T> lambda)

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

int1Obj0Int2Pred

@Nonnull
static <T> LObjBiIntPredicate.LInt1Obj0Int2Pred<T> int1Obj0Int2Pred(@Nonnull
                                                                              LObjBiIntPredicate.LInt1Obj0Int2Pred<T> lambda)

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

int1Int2Obj0Pred

@Nonnull
static <T> LObjBiIntPredicate.LInt1Int2Obj0Pred<T> int1Int2Obj0Pred(@Nonnull
                                                                              LObjBiIntPredicate.LInt1Int2Obj0Pred<T> lambda)

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

int2Obj0Int1Pred

@Nonnull
static <T> LObjBiIntPredicate.LInt2Obj0Int1Pred<T> int2Obj0Int1Pred(@Nonnull
                                                                              LObjBiIntPredicate.LInt2Obj0Int1Pred<T> lambda)

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

biInt1Obj0Pred

@Nonnull
static <T> LObjBiIntPredicate.LBiInt1Obj0Pred<T> biInt1Obj0Pred(@Nonnull
                                                                          LObjBiIntPredicate.LBiInt1Obj0Pred<T> lambda)

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

call

static <T> boolean call(T a1,
                        int a2,
                        int a3,
                        @Nonnull
                        LObjBiIntPredicate<T> lambda)

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

safeSupplier

@Nonnull
static <T> LSupplier<LObjBiIntPredicate<T>> safeSupplier()

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

safe

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

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

safeSupplier

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

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

negate
```
@Nonnull
default LObjBiIntPredicate<T> negate()
```
Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LObjBiIntPredicate<T> and(@Nonnull
                                            LObjBiIntPredicate<? super T> 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 LObjBiIntPredicate<T> or(@Nonnull
                                           LObjBiIntPredicate<? super T> 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 LObjBiIntPredicate<T> xor(@Nonnull
                                            LObjBiIntPredicate<? super T> 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 <T> LObjBiIntPredicate<T> isEqual(T v1,
                                                   int v2,
                                                   int 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> LObjBiIntPredicate<V1> compose(@Nonnull
                                                      LFunction<? super V1,? extends T> before1,
                                                      @Nonnull
                                                      LIntUnaryOperator before2,
                                                      @Nonnull
                                                      LIntUnaryOperator before3)

Allows to manipulate the domain of the function.

composed

static <V1,T> LObjBiIntPredicate<V1> composed(@Nonnull
                                              LFunction<? super V1,? extends T> before1,
                                              @Nonnull
                                              LIntUnaryOperator before2,
                                              @Nonnull
                                              LIntUnaryOperator before3,
                                              LObjBiIntPredicate<T> after)

objBiIntPredCompose

@Nonnull
default <V1,V2,V3> LTriPredicate<V1,V2,V3> objBiIntPredCompose(@Nonnull
                                                                         LFunction<? super V1,? extends T> before1,
                                                                         @Nonnull
                                                                         LToIntFunction<? super V2> before2,
                                                                         @Nonnull
                                                                         LToIntFunction<? super V3> before3)

Allows to manipulate the domain of the function.

composed

static <V1,V2,V3,T> LTriPredicate<V1,V2,V3> composed(@Nonnull
                                                     LFunction<? super V1,? extends T> before1,
                                                     @Nonnull
                                                     LToIntFunction<? super V2> before2,
                                                     @Nonnull
                                                     LToIntFunction<? super V3> before3,
                                                     LObjBiIntPredicate<T> after)

boolToObjBiIntFunc

@Nonnull
default <V> LObjBiIntFunction<T,V> boolToObjBiIntFunc(@Nonnull
                                                                LBoolFunction<? extends V> after)

Combines two functions together in a order.

boolToTieIntFunc

@Nonnull
default LTieIntFunction<T> boolToTieIntFunc(@Nonnull
                                                      LBoolToIntFunction after)

Combines two functions together in a order.

boolToObjBiIntPred

@Nonnull
default LObjBiIntPredicate<T> boolToObjBiIntPred(@Nonnull
                                                           LLogicalOperator after)

Combines two functions together in a order.

alwaysTrue

static <T> boolean alwaysTrue(T a1,
                              int a2,
                              int a3)

Returns TRUE.

alwaysFalse

static <T> boolean alwaysFalse(T a1,
                               int a2,
                               int a3)

Returns FALSE.

alwaysTrue

static <T> boolean alwaysTrue(int a2,
                              T a1,
                              int a3)

Returns TRUE.

alwaysFalse

static <T> boolean alwaysFalse(int a2,
                               T a1,
                               int a3)

Returns FALSE.

alwaysTrue

static <T> boolean alwaysTrue(int a2,
                              int a3,
                              T a1)

Returns TRUE.

alwaysFalse

static <T> boolean alwaysFalse(int a2,
                               int a3,
                               T a1)

Returns FALSE.