| Modifier and Type | Method and Description |
|---|---|
LPredicate<I> |
SA.The.genericTester() |
| Modifier and Type | Method and Description |
|---|---|
static <C,I,E extends aType> |
SA.sA(LToIntFunction<C> sizeFunc,
LFunction<C,I> adapter,
LPredicate<I> tester,
OFunction<I,E> getter,
TeConsumer<C,E> consumer) |
| Constructor and Description |
|---|
The(LToIntFunction<C> sizeFunc,
LFunction<C,I> adapter,
LPredicate<I> tester,
OFunction<I,E> getter,
TeConsumer<C,E> consumer) |
| Modifier and Type | Method and Description |
|---|---|
default <V> LConsumer<V> |
LBoolConsumer.boolConsCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
static <V> LConsumer<V> |
LBoolConsumer.composed(LPredicate<? super V> before,
LBoolConsumer after) |
| Modifier and Type | Method and Description |
|---|---|
default <V1,V2> LBiConsumer<V1,V2> |
LBiBoolConsumer.biBoolConsCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2> LBiConsumer<V1,V2> |
LBiBoolConsumer.biBoolConsCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2> LBiConsumer<V1,V2> |
LBoolIntConsumer.boolIntConsCompose(LPredicate<? super V1> before1,
LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
|
static <V1,V2> LBiConsumer<V1,V2> |
LBiBoolConsumer.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LBiBoolConsumer after) |
static <V1,V2> LBiConsumer<V1,V2> |
LBiBoolConsumer.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LBiBoolConsumer after) |
static <V1,V2> LBiConsumer<V1,V2> |
LBoolIntConsumer.composed(LPredicate<? super V1> before1,
LToIntFunction<? super V2> before2,
LBoolIntConsumer after) |
| Modifier and Type | Method and Description |
|---|---|
default <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LBiObjBoolConsumer.biObjBoolConsCompose(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
static <V1,V2,T> LBiConsumer<V1,V2> |
LObjBoolConsumer.composed(LFunction<? super V1,? extends T> before1,
LPredicate<? super V2> before2,
LObjBoolConsumer<T> after) |
static <V1,V2,V3,T> |
LTieBoolConsumer.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3,
LTieBoolConsumer<T> after) |
static <V1,V2,V3,T1,T2> |
LBiObjBoolConsumer.composed(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LPredicate<? super V3> before3,
LBiObjBoolConsumer<T1,T2> after) |
default <V1,V2> LBiConsumer<V1,V2> |
LObjBoolConsumer.objBoolConsCompose(LFunction<? super V1,? extends T> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default LConsumer<T> |
LObjBoolConsumer.rShrink(LPredicate<T> right) |
static <T> LConsumer<T> |
LObjBoolConsumer.rShrinked(LPredicate<T> right,
LObjBoolConsumer<T> func) |
default <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTieBoolConsumer.tieBoolConsCompose(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
static <T1,SRC,T2> |
LTieConsumer.tieForEach(int sStart,
int tStart,
T1 trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LFunction<SRC,T2> srcAcc3,
LTieConsumer<? super T1,? super T2> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieBoolConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LPredicate<SRC> srcAcc3,
LTieBoolConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieBoolConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LPredicate<SRC> srcAcc3,
LTieBoolConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieByteConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToByteFunction<SRC> srcAcc3,
LTieByteConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieCharConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToCharFunction<SRC> srcAcc3,
LTieCharConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieDblConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToDblFunction<SRC> srcAcc3,
LTieDblConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieFltConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToFltFunction<SRC> srcAcc3,
LTieFltConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieIntConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToIntFunction<SRC> srcAcc3,
LTieIntConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieLongConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToLongFunction<SRC> srcAcc3,
LTieLongConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieSrtConsumer.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToSrtFunction<SRC> srcAcc3,
LTieSrtConsumer<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
| Modifier and Type | Method and Description |
|---|---|
static <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTriBoolConsumer.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LTriBoolConsumer after) |
static <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTriBoolConsumer.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LTriBoolConsumer after) |
static <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTriBoolConsumer.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LTriBoolConsumer after) |
default <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTriBoolConsumer.triBoolConsCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTriBoolConsumer.triBoolConsCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriConsumer<V1,V2,V3> |
LTriBoolConsumer.triBoolConsCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
| Modifier and Type | Method and Description |
|---|---|
default LPredicate<T> |
LFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
default LTriPredicate<T1,T2,T3> |
LTriFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LPredicate<T> |
LFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiPredicate<T1,T2> |
LBiFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
default <V> LToByteFunction<V> |
LBoolToByteFunction.boolToByteFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LToCharFunction<V> |
LBoolToCharFunction.boolToCharFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LToDblFunction<V> |
LBoolToDblFunction.boolToDblFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LToFltFunction<V> |
LBoolToFltFunction.boolToFltFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LToIntFunction<V> |
LBoolToIntFunction.boolToIntFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LToLongFunction<V> |
LBoolToLongFunction.boolToLongFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LToSrtFunction<V> |
LBoolToSrtFunction.boolToSrtFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
static <V> LToByteFunction<V> |
LBoolToByteFunction.composed(LPredicate<? super V> before,
LBoolToByteFunction after) |
static <V> LToCharFunction<V> |
LBoolToCharFunction.composed(LPredicate<? super V> before,
LBoolToCharFunction after) |
static <V> LToDblFunction<V> |
LBoolToDblFunction.composed(LPredicate<? super V> before,
LBoolToDblFunction after) |
static <V> LToFltFunction<V> |
LBoolToFltFunction.composed(LPredicate<? super V> before,
LBoolToFltFunction after) |
static <V> LToIntFunction<V> |
LBoolToIntFunction.composed(LPredicate<? super V> before,
LBoolToIntFunction after) |
static <V> LToLongFunction<V> |
LBoolToLongFunction.composed(LPredicate<? super V> before,
LBoolToLongFunction after) |
static <V> LToSrtFunction<V> |
LBoolToSrtFunction.composed(LPredicate<? super V> before,
LBoolToSrtFunction after) |
| Modifier and Type | Method and Description |
|---|---|
default <V1,V2> LBiFunction<V1,V2,R> |
LBiBoolFunction.biBoolFuncCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2> LBiFunction<V1,V2,R> |
LBiBoolFunction.biBoolFuncCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> |
LBiObjBoolFunction.biObjBoolFuncCompose(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V> LFunction<V,R> |
LBoolFunction.boolFuncCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
static <V1,V2,T,R> |
LObjBoolFunction.composed(LFunction<? super V1,? extends T> before1,
LPredicate<? super V2> before2,
LObjBoolFunction<T,R> after) |
static <V1,V2,V3,T,R> |
LObjIntBoolFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3,
LObjIntBoolFunction<T,R> after) |
static <V1,V2,V3,T1,T2,R> |
LBiObjBoolFunction.composed(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LPredicate<? super V3> before3,
LBiObjBoolFunction<T1,T2,R> after) |
static <V,R> LFunction<V,R> |
LBoolFunction.composed(LPredicate<? super V> before,
LBoolFunction<R> after) |
static <V1,V2,R> LBiFunction<V1,V2,R> |
LBiBoolFunction.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LBiBoolFunction<R> after) |
static <V1,V2,R> LBiFunction<V1,V2,R> |
LBiBoolFunction.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LBiBoolFunction<R> after) |
static <V1,V2,V3,R> |
LTriBoolFunction.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LTriBoolFunction<R> after) |
static <V1,V2,V3,R> |
LTriBoolFunction.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LTriBoolFunction<R> after) |
static <V1,V2,V3,R> |
LTriBoolFunction.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LTriBoolFunction<R> after) |
default <V1,V2> LBiFunction<V1,V2,R> |
LObjBoolFunction.objBoolFuncCompose(LFunction<? super V1,? extends T> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> |
LObjIntBoolFunction.objIntBoolFuncCompose(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default LFunction<T,R> |
LObjBoolFunction.rShrink(LPredicate<T> right) |
static <T,R> LFunction<T,R> |
LObjBoolFunction.rShrinked(LPredicate<T> right,
LObjBoolFunction<T,R> func) |
default LLogicalTernaryOperator |
LTriBoolFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LSrtPredicate |
LSrtFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntPredicate<T> |
LOiFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjSrtPredicate<T> |
LObjSrtFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjLongPredicate<T> |
LObjLongFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntSrtPredicate<T> |
LObjIntSrtFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntObjPredicate<T1,T2> |
LObjIntObjFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntLongPredicate<T> |
LObjIntLongFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntFltPredicate<T> |
LObjIntFltFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntDblPredicate<T> |
LObjIntDblFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntCharPredicate<T> |
LObjIntCharFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntBytePredicate<T> |
LObjIntByteFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjIntBoolPredicate<T> |
LObjIntBoolFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjFltPredicate<T> |
LObjFltFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjDblPredicate<T> |
LObjDblFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjCharPredicate<T> |
LObjCharFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjBytePredicate<T> |
LObjByteFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjBoolPredicate<T> |
LObjBoolFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LObjBiIntPredicate<T> |
LObjBiIntFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LLongPredicate |
LLongFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LIntPredicate |
LIntFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LFltPredicate |
LFltFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LDblPredicate |
LDblFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LCharPredicate |
LCharFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBytePredicate |
LByteFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LLogicalOperator |
LBoolFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiSrtPredicate |
LBiSrtFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjSrtPredicate<T1,T2> |
LBiObjSrtFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjLongPredicate<T1,T2> |
LBiObjLongFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjIntPredicate<T1,T2> |
LBiObjIntFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjFltPredicate<T1,T2> |
LBiObjFltFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjDblPredicate<T1,T2> |
LBiObjDblFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjCharPredicate<T1,T2> |
LBiObjCharFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjBytePredicate<T1,T2> |
LBiObjByteFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiObjBoolPredicate<T1,T2> |
LBiObjBoolFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiLongPredicate |
LBiLongFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiIntPredicate |
LBiIntFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiFltPredicate |
LBiFltFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiDblPredicate |
LBiDblFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiCharPredicate |
LBiCharFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LBiBytePredicate |
LBiByteFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default LLogicalBinaryOperator |
LBiBoolFunction.thenToBool(LPredicate<? super R> after)
Combines two functions together in a order.
|
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> |
LTriBoolFunction.triBoolFuncCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> |
LTriBoolFunction.triBoolFuncCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriFunction<V1,V2,V3,R> |
LTriBoolFunction.triBoolFuncCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
| Modifier and Type | Method and Description |
|---|---|
default LPredicate<T> |
LToByteFunction.thenToBool(LBytePredicate after)
Combines two functions together in a order.
|
default LPredicate<T> |
LToCharFunction.thenToBool(LCharPredicate after)
Combines two functions together in a order.
|
default LPredicate<T> |
LToDblFunction.thenToBool(LDblPredicate after)
Combines two functions together in a order.
|
default LPredicate<T> |
LToFltFunction.thenToBool(LFltPredicate after)
Combines two functions together in a order.
|
default LPredicate<T> |
LToIntFunction.thenToBool(LIntPredicate after)
Combines two functions together in a order.
|
default LPredicate<T> |
LToLongFunction.thenToBool(LLongPredicate after)
Combines two functions together in a order.
|
default LPredicate<T> |
LToSrtFunction.thenToBool(LSrtPredicate after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
static <V1,V2,V3,T> |
LTieBoolFunction.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3,
LTieBoolFunction<T> after) |
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3> |
LTieBoolFunction.tieBoolFuncCompose(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
static <T1,SRC,T2> |
LTieFunction.tieForEach(int sStart,
int tStart,
T1 trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LFunction<SRC,T2> srcAcc3,
LTieFunction<? super T1,? super T2> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieBoolFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LPredicate<SRC> srcAcc3,
LTieBoolFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieBoolFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LPredicate<SRC> srcAcc3,
LTieBoolFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieByteFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToByteFunction<SRC> srcAcc3,
LTieByteFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieCharFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToCharFunction<SRC> srcAcc3,
LTieCharFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieDblFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToDblFunction<SRC> srcAcc3,
LTieDblFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieFltFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToFltFunction<SRC> srcAcc3,
LTieFltFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieIntFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToIntFunction<SRC> srcAcc3,
LTieIntFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieLongFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToLongFunction<SRC> srcAcc3,
LTieLongFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
static <T,SRC> int |
LTieSrtFunction.tieForEach(int sStart,
int tStart,
T trg1,
SRC src3,
LPredicate<SRC> srcTest3,
LToSrtFunction<SRC> srcAcc3,
LTieSrtFunction<? super T> consumer)
For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
|
| Modifier and Type | Method and Description |
|---|---|
default boolean |
LLogicalBinaryOperator.applyThen(boolean a1,
boolean a2,
LPredicate<Throwable> handler) |
static <V1,V2> LBiPredicate<V1,V2> |
LLogicalBinaryOperator.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LLogicalBinaryOperator after) |
static <V1,V2> LBiPredicate<V1,V2> |
LLogicalBinaryOperator.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LLogicalBinaryOperator after) |
default <V1,V2> LBiPredicate<V1,V2> |
LLogicalBinaryOperator.logicalBinaryOpCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2> LBiPredicate<V1,V2> |
LLogicalBinaryOperator.logicalBinaryOpCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default LBiPredicate<T,T> |
LBinaryOperator.thenToBool(LPredicate<? super T> after)
Combines two functions together in a order.
|
static boolean |
LLogicalBinaryOperator.tryApplyThen(boolean a1,
boolean a2,
LLogicalBinaryOperator func,
LPredicate<Throwable> handler) |
default LLogicalBinaryOperator |
LLogicalBinaryOperator.tryingThen(LPredicate<Throwable> handler) |
| Modifier and Type | Method and Description |
|---|---|
default boolean |
LLogicalTernaryOperator.applyThen(boolean a1,
boolean a2,
boolean a3,
LPredicate<Throwable> handler) |
static <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LLogicalTernaryOperator.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LLogicalTernaryOperator after) |
static <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LLogicalTernaryOperator.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LLogicalTernaryOperator after) |
static <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LLogicalTernaryOperator.composed(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3,
LLogicalTernaryOperator after) |
default <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LLogicalTernaryOperator.logicalTernaryOpCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LLogicalTernaryOperator.logicalTernaryOpCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LLogicalTernaryOperator.logicalTernaryOpCompose(LPredicate<? super V1> before1,
LPredicate<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default LTriPredicate<T,T,T> |
LTernaryOperator.thenToBool(LPredicate<? super T> after)
Combines two functions together in a order.
|
static boolean |
LLogicalTernaryOperator.tryApplyThen(boolean a1,
boolean a2,
boolean a3,
LLogicalTernaryOperator func,
LPredicate<Throwable> handler) |
default LLogicalTernaryOperator |
LLogicalTernaryOperator.tryingThen(LPredicate<Throwable> handler) |
| Modifier and Type | Method and Description |
|---|---|
static <V> LPredicate<V> |
LLogicalOperator.composed(LPredicate<? super V> before,
LLogicalOperator after) |
default <V> LPredicate<V> |
LLogicalOperator.logicalOpCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default LPredicate<T> |
LUnaryOperator.thenToBool(LPredicate<? super T> after)
Combines two functions together in a order.
|
| Modifier and Type | Method and Description |
|---|---|
default boolean |
LLogicalOperator.applyThen(boolean a,
LPredicate<Throwable> handler) |
static <V> LPredicate<V> |
LLogicalOperator.composed(LPredicate<? super V> before,
LLogicalOperator after) |
default <V> LPredicate<V> |
LLogicalOperator.logicalOpCompose(LPredicate<? super V> before)
Allows to manipulate the domain of the function.
|
default LPredicate<T> |
LUnaryOperator.thenToBool(LPredicate<? super T> after)
Combines two functions together in a order.
|
static boolean |
LLogicalOperator.tryApplyThen(boolean a,
LLogicalOperator func,
LPredicate<Throwable> handler) |
default LLogicalOperator |
LLogicalOperator.tryingThen(LPredicate<Throwable> handler) |
| Modifier and Type | Class and Description |
|---|---|
static class |
LPredicate.LPredicateSingle<T> |
| Modifier and Type | Method and Description |
|---|---|
default LPredicate<T> |
LPredicate.and(LPredicate<? super T> other)
Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
|
default LPredicate<T> |
LPredicate.boolToPred(LLogicalOperator after)
Combines two functions together in a order.
|
default <V> LPredicate<V> |
LBytePredicate.bytePredCompose(LToByteFunction<? super V> before)
Allows to manipulate the domain of the function.
|
default <V2> LPredicate<V2> |
LPredicate.cast()
Cast that replace generics.
|
static <V2,T> LPredicate<V2> |
LPredicate.cast(LPredicate<T> function)
Cast that replace generics.
|
default <V> LPredicate<V> |
LCharPredicate.charPredCompose(LToCharFunction<? super V> before)
Allows to manipulate the domain of the function.
|
default <V> LPredicate<V> |
LPredicate.compose(LFunction<? super V,? extends T> before)
Allows to manipulate the domain of the function.
|
static <V,T> LPredicate<V> |
LPredicate.composed(LFunction<? super V,? extends T> before,
LPredicate<T> after) |
static <V> LPredicate<V> |
LBytePredicate.composed(LToByteFunction<? super V> before,
LBytePredicate after) |
static <V> LPredicate<V> |
LCharPredicate.composed(LToCharFunction<? super V> before,
LCharPredicate after) |
static <V> LPredicate<V> |
LDblPredicate.composed(LToDblFunction<? super V> before,
LDblPredicate after) |
static <V> LPredicate<V> |
LFltPredicate.composed(LToFltFunction<? super V> before,
LFltPredicate after) |
static <V> LPredicate<V> |
LIntPredicate.composed(LToIntFunction<? super V> before,
LIntPredicate after) |
static <V> LPredicate<V> |
LLongPredicate.composed(LToLongFunction<? super V> before,
LLongPredicate after) |
static <V> LPredicate<V> |
LSrtPredicate.composed(LToSrtFunction<? super V> before,
LSrtPredicate after) |
static <T> LPredicate<T> |
LPredicate.constant(boolean r)
Creates function that always returns the same value.
|
default <V> LPredicate<V> |
LDblPredicate.dblPredCompose(LToDblFunction<? super V> before)
Allows to manipulate the domain of the function.
|
static <T> LPredicate<T> |
LPredicate.failSafe(LPredicate<T> func,
LPredicate<T> failSafe) |
default <V> LPredicate<V> |
LFltPredicate.fltPredCompose(LToFltFunction<? super V> before)
Allows to manipulate the domain of the function.
|
default LPredicate<T> |
LPredicate.handling(HandlingInstructions<Throwable,RuntimeException> handling) |
default <V> LPredicate<V> |
LIntPredicate.intPredCompose(LToIntFunction<? super V> before)
Allows to manipulate the domain of the function.
|
static <T> LPredicate<T> |
LPredicate.isEqual(T target)
Creates predicate that evaluates if an object is equal with the argument one.
|
default <V> LPredicate<V> |
LLongPredicate.longPredCompose(LToLongFunction<? super V> before)
Allows to manipulate the domain of the function.
|
default LPredicate<T2> |
LBiPredicate.lShrink(LFunction<T2,T1> left) |
default LPredicate<T2> |
LBiPredicate.lShrinkc(T1 a1) |
static <T2,T1> LPredicate<T2> |
LBiPredicate.lShrinked(LFunction<T2,T1> left,
LBiPredicate<T1,T2> func) |
static <T2,T1> LPredicate<T2> |
LBiPredicate.lShrinkedc(T1 a1,
LBiPredicate<T1,T2> func) |
default LPredicate<T> |
LPredicate.negate()
Returns a predicate that represents the logical negation of this predicate.
|
default LPredicate<T> |
LPredicate.or(LPredicate<? super T> other)
Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
|
static <T> LPredicate<T> |
LPredicate.pred(LPredicate<T> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
static <T> LPredicate<T> |
LPredicate.predThrowing(ExF<Throwable> exF) |
static <T> LPredicate<T> |
LPredicate.predThrowing(String message,
ExMF<Throwable> exF) |
static <T> LPredicate<T> |
LPredicate.recursive(LFunction<LPredicate<T>,LPredicate<T>> selfLambda) |
default LPredicate<T1> |
LBiPredicate.rShrink(LFunction<T1,T2> right) |
default LPredicate<T> |
LObjBoolPredicate.rShrink(LPredicate<T> right) |
default LPredicate<T> |
LObjBytePredicate.rShrink(LToByteFunction<T> right) |
default LPredicate<T> |
LObjCharPredicate.rShrink(LToCharFunction<T> right) |
default LPredicate<T> |
LObjDblPredicate.rShrink(LToDblFunction<T> right) |
default LPredicate<T> |
LObjFltPredicate.rShrink(LToFltFunction<T> right) |
default LPredicate<T> |
LObjIntPredicate.rShrink(LToIntFunction<T> right) |
default LPredicate<T> |
LObjLongPredicate.rShrink(LToLongFunction<T> right) |
default LPredicate<T> |
LObjSrtPredicate.rShrink(LToSrtFunction<T> right) |
default LPredicate<T> |
LObjBoolPredicate.rShrinkc(boolean a2) |
default LPredicate<T> |
LObjBytePredicate.rShrinkc(byte a2) |
default LPredicate<T> |
LObjCharPredicate.rShrinkc(char a2) |
default LPredicate<T> |
LObjDblPredicate.rShrinkc(double a2) |
default LPredicate<T> |
LObjFltPredicate.rShrinkc(float a2) |
default LPredicate<T> |
LObjIntPredicate.rShrinkc(int a2) |
default LPredicate<T> |
LObjLongPredicate.rShrinkc(long a2) |
default LPredicate<T> |
LObjSrtPredicate.rShrinkc(short a2) |
default LPredicate<T1> |
LBiPredicate.rShrinkc(T2 a2) |
static <T1,T2> LPredicate<T1> |
LBiPredicate.rShrinked(LFunction<T1,T2> right,
LBiPredicate<T1,T2> func) |
static <T> LPredicate<T> |
LObjBoolPredicate.rShrinked(LPredicate<T> right,
LObjBoolPredicate<T> func) |
static <T> LPredicate<T> |
LObjBytePredicate.rShrinked(LToByteFunction<T> right,
LObjBytePredicate<T> func) |
static <T> LPredicate<T> |
LObjCharPredicate.rShrinked(LToCharFunction<T> right,
LObjCharPredicate<T> func) |
static <T> LPredicate<T> |
LObjDblPredicate.rShrinked(LToDblFunction<T> right,
LObjDblPredicate<T> func) |
static <T> LPredicate<T> |
LObjFltPredicate.rShrinked(LToFltFunction<T> right,
LObjFltPredicate<T> func) |
static <T> LPredicate<T> |
LObjIntPredicate.rShrinked(LToIntFunction<T> right,
LObjIntPredicate<T> func) |
static <T> LPredicate<T> |
LObjLongPredicate.rShrinked(LToLongFunction<T> right,
LObjLongPredicate<T> func) |
static <T> LPredicate<T> |
LObjSrtPredicate.rShrinked(LToSrtFunction<T> right,
LObjSrtPredicate<T> func) |
static <T> LPredicate<T> |
LObjBoolPredicate.rShrinkedc(boolean a2,
LObjBoolPredicate<T> func) |
static <T> LPredicate<T> |
LObjBytePredicate.rShrinkedc(byte a2,
LObjBytePredicate<T> func) |
static <T> LPredicate<T> |
LObjCharPredicate.rShrinkedc(char a2,
LObjCharPredicate<T> func) |
static <T> LPredicate<T> |
LObjDblPredicate.rShrinkedc(double a2,
LObjDblPredicate<T> func) |
static <T> LPredicate<T> |
LObjFltPredicate.rShrinkedc(float a2,
LObjFltPredicate<T> func) |
static <T> LPredicate<T> |
LObjIntPredicate.rShrinkedc(int a2,
LObjIntPredicate<T> func) |
static <T> LPredicate<T> |
LObjLongPredicate.rShrinkedc(long a2,
LObjLongPredicate<T> func) |
static <T> LPredicate<T> |
LObjSrtPredicate.rShrinkedc(short a2,
LObjSrtPredicate<T> func) |
static <T1,T2> LPredicate<T1> |
LBiPredicate.rShrinkedc(T2 a2,
LBiPredicate<T1,T2> func) |
static <T> LPredicate<T> |
LPredicate.safe()
Safe instance.
|
static <T> LPredicate<T> |
LPredicate.safe(LPredicate<T> other)
Safe wrapping.
|
default <V> LPredicate<V> |
LSrtPredicate.srtPredCompose(LToSrtFunction<? super V> before)
Allows to manipulate the domain of the function.
|
default LPredicate<T> |
LPredicate.trying(ExWF<RuntimeException> exF) |
default LPredicate<T> |
LPredicate.trying(ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
default LPredicate<T> |
LPredicate.tryingThen(LPredicate<Throwable> handler) |
default LPredicate |
LPredicate.untyped()
Cast that removes generics.
|
LPredicate<T> |
LPredicate.LPredicateSingle.value() |
static <T> LPredicate<T> |
LPredicate.wrap(java.util.function.Predicate<T> other)
Wraps JRE instance.
|
default LPredicate<T> |
LPredicate.xor(LPredicate<? super T> other)
Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.
|
| Modifier and Type | Method and Description |
|---|---|
static <T> LSupplier<LPredicate<T>> |
LPredicate.safeSupplier()
Safe instance supplier.
|
static <T> LSupplier<LPredicate<T>> |
LPredicate.safeSupplier(LSupplier<LPredicate<T>> supplier)
Safe supplier.
|
| Modifier and Type | Method and Description |
|---|---|
default LPredicate<T> |
LPredicate.and(LPredicate<? super T> other)
Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
|
default <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LBiObjBoolPredicate.biObjBoolPredCompose(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default <V1,V2> LBiPredicate<V1,V2> |
LBoolIntPredicate.boolIntPredCompose(LPredicate<? super V1> before1,
LToIntFunction<? super V2> before2)
Allows to manipulate the domain of the function.
|
static <T> boolean |
LPredicate.call(T a,
LPredicate<T> lambda) |
static <V2,T> LPredicate<V2> |
LPredicate.cast(LPredicate<T> function)
Cast that replace generics.
|
static <V,T> LPredicate<V> |
LPredicate.composed(LFunction<? super V,? extends T> before,
LPredicate<T> after) |
static <V1,V2,T> LBiPredicate<V1,V2> |
LObjBoolPredicate.composed(LFunction<? super V1,? extends T> before1,
LPredicate<? super V2> before2,
LObjBoolPredicate<T> after) |
static <V1,V2,V3,T> |
LObjIntBoolPredicate.composed(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3,
LObjIntBoolPredicate<T> after) |
static <V1,V2,V3,T1,T2> |
LBiObjBoolPredicate.composed(LFunction<? super V1,? extends T1> before1,
LFunction<? super V2,? extends T2> before2,
LPredicate<? super V3> before3,
LBiObjBoolPredicate<T1,T2> after) |
static <V1,V2> LBiPredicate<V1,V2> |
LBoolIntPredicate.composed(LPredicate<? super V1> before1,
LToIntFunction<? super V2> before2,
LBoolIntPredicate after) |
static <T> boolean |
LPredicate.doIf(T a,
LPredicate<T> predicate,
LAction action) |
static <T> boolean |
LPredicate.doIf(T a,
LPredicate<T> predicate,
LConsumer<? super T> consumer) |
static <T> LPredicate<T> |
LPredicate.failSafe(LPredicate<T> func,
LPredicate<T> failSafe) |
static <T> LPredicate<T> |
LPredicate.failSafe(LPredicate<T> func,
LPredicate<T> failSafe) |
default boolean |
LPredicate.failSafeTest(T a,
LPredicate<T> failSafe) |
static <T> boolean |
LPredicate.failSafeTest(T a,
LPredicate<T> func,
LPredicate<T> failSafe) |
static <T> boolean |
LPredicate.failSafeTest(T a,
LPredicate<T> func,
LPredicate<T> failSafe) |
static <T> void |
LPredicate.fromTill(int min_i,
int max_i,
T a,
LPredicate<T> func)
From-To.
|
static <T> void |
LPredicate.fromTo(int min_i,
int max_i,
T a,
LPredicate<T> func)
From-To.
|
static <T> boolean |
LPredicate.handlingTest(T a,
LPredicate<T> func,
HandlingInstructions<Throwable,RuntimeException> handling) |
default <V1,V2> LBiPredicate<V1,V2> |
LObjBoolPredicate.objBoolPredCompose(LFunction<? super V1,? extends T> before1,
LPredicate<? super V2> before2)
Allows to manipulate the domain of the function.
|
default <V1,V2,V3> LTriPredicate<V1,V2,V3> |
LObjIntBoolPredicate.objIntBoolPredCompose(LFunction<? super V1,? extends T> before1,
LToIntFunction<? super V2> before2,
LPredicate<? super V3> before3)
Allows to manipulate the domain of the function.
|
default LPredicate<T> |
LPredicate.or(LPredicate<? super T> other)
Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
|
static <T> LPredicate<T> |
LPredicate.pred(LPredicate<T> lambda)
Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
|
default LPredicate<T> |
LObjBoolPredicate.rShrink(LPredicate<T> right) |
static <T> LPredicate<T> |
LObjBoolPredicate.rShrinked(LPredicate<T> right,
LObjBoolPredicate<T> func) |
static <T> LPredicate<T> |
LPredicate.safe(LPredicate<T> other)
Safe wrapping.
|
static <T> LObjSrtPredicate<T> |
LObjSrtPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjLongPredicate<T> |
LObjLongPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntSrtPredicate<T> |
LObjIntSrtPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntPredicate<T> |
LObjIntPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntLongPredicate<T> |
LObjIntLongPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntFltPredicate<T> |
LObjIntFltPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntDblPredicate<T> |
LObjIntDblPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntCharPredicate<T> |
LObjIntCharPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntBytePredicate<T> |
LObjIntBytePredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjIntBoolPredicate<T> |
LObjIntBoolPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjFltPredicate<T> |
LObjFltPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjDblPredicate<T> |
LObjDblPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjCharPredicate<T> |
LObjCharPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjBytePredicate<T> |
LObjBytePredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjBoolPredicate<T> |
LObjBoolPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T> LObjBiIntPredicate<T> |
LObjBiIntPredicate.test1st(LPredicate<T> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LObjIntObjPredicate<T1,T2> |
LObjIntObjPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiPredicate<T1,T2> |
LBiPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjSrtPredicate<T1,T2> |
LBiObjSrtPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjLongPredicate<T1,T2> |
LBiObjLongPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjIntPredicate<T1,T2> |
LBiObjIntPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjFltPredicate<T1,T2> |
LBiObjFltPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjDblPredicate<T1,T2> |
LBiObjDblPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjCharPredicate<T1,T2> |
LBiObjCharPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjBytePredicate<T1,T2> |
LBiObjBytePredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiObjBoolPredicate<T1,T2> |
LBiObjBoolPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
LTriPredicate.test1st(LPredicate<T1> func)
Captures single parameter function into this interface where only 1st parameter will be used.
|
static <T1,T2> LBiPredicate<T1,T2> |
LBiPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjSrtPredicate<T1,T2> |
LBiObjSrtPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjLongPredicate<T1,T2> |
LBiObjLongPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjIntPredicate<T1,T2> |
LBiObjIntPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjFltPredicate<T1,T2> |
LBiObjFltPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjDblPredicate<T1,T2> |
LBiObjDblPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjCharPredicate<T1,T2> |
LBiObjCharPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjBytePredicate<T1,T2> |
LBiObjBytePredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LBiObjBoolPredicate<T1,T2> |
LBiObjBoolPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
LTriPredicate.test2nd(LPredicate<T2> func)
Captures single parameter function into this interface where only 2nd parameter will be used.
|
static <T1,T2> LObjIntObjPredicate<T1,T2> |
LObjIntObjPredicate.test3rd(LPredicate<T2> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
|
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
LTriPredicate.test3rd(LPredicate<T3> func)
Captures single parameter function into this interface where only 3rd parameter will be used.
|
default boolean |
LBoolIntPredicate.testThen(boolean a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LBiBytePredicate.testThen(byte a1,
byte a2,
LPredicate<Throwable> handler) |
default boolean |
LByteIntPredicate.testThen(byte a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LBytePredicate.testThen(byte a,
LPredicate<Throwable> handler) |
default boolean |
LBiCharPredicate.testThen(char a1,
char a2,
LPredicate<Throwable> handler) |
default boolean |
LCharIntPredicate.testThen(char a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LCharPredicate.testThen(char a,
LPredicate<Throwable> handler) |
default boolean |
LBiDblPredicate.testThen(double a1,
double a2,
LPredicate<Throwable> handler) |
default boolean |
LDblIntPredicate.testThen(double a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LDblPredicate.testThen(double a,
LPredicate<Throwable> handler) |
default boolean |
LBiFltPredicate.testThen(float a1,
float a2,
LPredicate<Throwable> handler) |
default boolean |
LFltIntPredicate.testThen(float a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LFltPredicate.testThen(float a,
LPredicate<Throwable> handler) |
default boolean |
LBiIntPredicate.testThen(int a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LIntPredicate.testThen(int a,
LPredicate<Throwable> handler) |
default boolean |
LLongIntPredicate.testThen(long a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LBiLongPredicate.testThen(long a1,
long a2,
LPredicate<Throwable> handler) |
default boolean |
LLongPredicate.testThen(long a,
LPredicate<Throwable> handler) |
default boolean |
LSrtIntPredicate.testThen(short a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LSrtPredicate.testThen(short a,
LPredicate<Throwable> handler) |
default boolean |
LBiSrtPredicate.testThen(short a1,
short a2,
LPredicate<Throwable> handler) |
default boolean |
LObjIntObjPredicate.testThen(T1 a1,
int a2,
T2 a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjBoolPredicate.testThen(T1 a1,
T2 a2,
boolean a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjBytePredicate.testThen(T1 a1,
T2 a2,
byte a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjCharPredicate.testThen(T1 a1,
T2 a2,
char a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjDblPredicate.testThen(T1 a1,
T2 a2,
double a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjFltPredicate.testThen(T1 a1,
T2 a2,
float a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjIntPredicate.testThen(T1 a1,
T2 a2,
int a3,
LPredicate<Throwable> handler) |
default boolean |
LBiObjLongPredicate.testThen(T1 a1,
T2 a2,
long a3,
LPredicate<Throwable> handler) |
default boolean |
LBiPredicate.testThen(T1 a1,
T2 a2,
LPredicate<Throwable> handler) |
default boolean |
LBiObjSrtPredicate.testThen(T1 a1,
T2 a2,
short a3,
LPredicate<Throwable> handler) |
default boolean |
LTriPredicate.testThen(T1 a1,
T2 a2,
T3 a3,
LPredicate<Throwable> handler) |
default boolean |
LObjBoolPredicate.testThen(T a1,
boolean a2,
LPredicate<Throwable> handler) |
default boolean |
LObjBytePredicate.testThen(T a1,
byte a2,
LPredicate<Throwable> handler) |
default boolean |
LObjCharPredicate.testThen(T a1,
char a2,
LPredicate<Throwable> handler) |
default boolean |
LObjDblPredicate.testThen(T a1,
double a2,
LPredicate<Throwable> handler) |
default boolean |
LObjFltPredicate.testThen(T a1,
float a2,
LPredicate<Throwable> handler) |
default boolean |
LObjIntBoolPredicate.testThen(T a1,
int a2,
boolean a3,
LPredicate<Throwable> handler) |
default boolean |
LObjIntBytePredicate.testThen(T a1,
int a2,
byte a3,
LPredicate<Throwable> handler) |
default boolean |
LObjIntCharPredicate.testThen(T a1,
int a2,
char a3,
LPredicate<Throwable> handler) |
default boolean |
LObjIntDblPredicate.testThen(T a1,
int a2,
double a3,
LPredicate<Throwable> handler) |
default boolean |
LObjIntFltPredicate.testThen(T a1,
int a2,
float a3,
LPredicate<Throwable> handler) |
default boolean |
LObjBiIntPredicate.testThen(T a1,
int a2,
int a3,
LPredicate<Throwable> handler) |
default boolean |
LObjIntLongPredicate.testThen(T a1,
int a2,
long a3,
LPredicate<Throwable> handler) |
default boolean |
LObjIntPredicate.testThen(T a1,
int a2,
LPredicate<Throwable> handler) |
default boolean |
LObjIntSrtPredicate.testThen(T a1,
int a2,
short a3,
LPredicate<Throwable> handler) |
default boolean |
LObjLongPredicate.testThen(T a1,
long a2,
LPredicate<Throwable> handler) |
default boolean |
LPredicate.testThen(T a,
LPredicate<Throwable> handler) |
default boolean |
LObjSrtPredicate.testThen(T a1,
short a2,
LPredicate<Throwable> handler) |
static <T> void |
LPredicate.throwIf(T a,
LPredicate<T> pred,
ExMF<RuntimeException> factory,
String newMessage,
Object... messageParams) |
static <T> void |
LPredicate.throwIfNot(T a,
LPredicate<T> pred,
ExMF<RuntimeException> factory,
String newMessage,
Object... messageParams) |
static <T> void |
LPredicate.times(int max_i,
T a,
LPredicate<T> func)
From-To.
|
default LTriPredicate<T1,T2,T3> |
LTriPredicate.tryingThen(LPredicate<Throwable> handler) |
default LSrtPredicate |
LSrtPredicate.tryingThen(LPredicate<Throwable> handler) |
default LSrtIntPredicate |
LSrtIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LPredicate<T> |
LPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjSrtPredicate<T> |
LObjSrtPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjLongPredicate<T> |
LObjLongPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntSrtPredicate<T> |
LObjIntSrtPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntPredicate<T> |
LObjIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntObjPredicate<T1,T2> |
LObjIntObjPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntLongPredicate<T> |
LObjIntLongPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntFltPredicate<T> |
LObjIntFltPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntDblPredicate<T> |
LObjIntDblPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntCharPredicate<T> |
LObjIntCharPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntBytePredicate<T> |
LObjIntBytePredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjIntBoolPredicate<T> |
LObjIntBoolPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjFltPredicate<T> |
LObjFltPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjDblPredicate<T> |
LObjDblPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjCharPredicate<T> |
LObjCharPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjBytePredicate<T> |
LObjBytePredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjBoolPredicate<T> |
LObjBoolPredicate.tryingThen(LPredicate<Throwable> handler) |
default LObjBiIntPredicate<T> |
LObjBiIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LLongPredicate |
LLongPredicate.tryingThen(LPredicate<Throwable> handler) |
default LLongIntPredicate |
LLongIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LIntPredicate |
LIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LFltPredicate |
LFltPredicate.tryingThen(LPredicate<Throwable> handler) |
default LFltIntPredicate |
LFltIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LDblPredicate |
LDblPredicate.tryingThen(LPredicate<Throwable> handler) |
default LDblIntPredicate |
LDblIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LCharPredicate |
LCharPredicate.tryingThen(LPredicate<Throwable> handler) |
default LCharIntPredicate |
LCharIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBytePredicate |
LBytePredicate.tryingThen(LPredicate<Throwable> handler) |
default LByteIntPredicate |
LByteIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBoolIntPredicate |
LBoolIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiSrtPredicate |
LBiSrtPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiPredicate<T1,T2> |
LBiPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjSrtPredicate<T1,T2> |
LBiObjSrtPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjLongPredicate<T1,T2> |
LBiObjLongPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjIntPredicate<T1,T2> |
LBiObjIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjFltPredicate<T1,T2> |
LBiObjFltPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjDblPredicate<T1,T2> |
LBiObjDblPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjCharPredicate<T1,T2> |
LBiObjCharPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjBytePredicate<T1,T2> |
LBiObjBytePredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiObjBoolPredicate<T1,T2> |
LBiObjBoolPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiLongPredicate |
LBiLongPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiIntPredicate |
LBiIntPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiFltPredicate |
LBiFltPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiDblPredicate |
LBiDblPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiCharPredicate |
LBiCharPredicate.tryingThen(LPredicate<Throwable> handler) |
default LBiBytePredicate |
LBiBytePredicate.tryingThen(LPredicate<Throwable> handler) |
static <T> boolean |
LPredicate.tryTest(T a,
LPredicate<T> func) |
static <T> boolean |
LPredicate.tryTest(T a,
LPredicate<T> func,
ExWF<RuntimeException> exF) |
static <T> boolean |
LPredicate.tryTest(T a,
LPredicate<T> func,
ExWMF<RuntimeException> exF,
String newMessage,
Object... messageParams) |
static boolean |
LBoolIntPredicate.tryTestThen(boolean a1,
int a2,
LBoolIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiBytePredicate.tryTestThen(byte a1,
byte a2,
LBiBytePredicate func,
LPredicate<Throwable> handler) |
static boolean |
LByteIntPredicate.tryTestThen(byte a1,
int a2,
LByteIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBytePredicate.tryTestThen(byte a,
LBytePredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiCharPredicate.tryTestThen(char a1,
char a2,
LBiCharPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LCharIntPredicate.tryTestThen(char a1,
int a2,
LCharIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LCharPredicate.tryTestThen(char a,
LCharPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiDblPredicate.tryTestThen(double a1,
double a2,
LBiDblPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LDblIntPredicate.tryTestThen(double a1,
int a2,
LDblIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LDblPredicate.tryTestThen(double a,
LDblPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiFltPredicate.tryTestThen(float a1,
float a2,
LBiFltPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LFltIntPredicate.tryTestThen(float a1,
int a2,
LFltIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LFltPredicate.tryTestThen(float a,
LFltPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiIntPredicate.tryTestThen(int a1,
int a2,
LBiIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LIntPredicate.tryTestThen(int a,
LIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LLongIntPredicate.tryTestThen(long a1,
int a2,
LLongIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LLongPredicate.tryTestThen(long a,
LLongPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiLongPredicate.tryTestThen(long a1,
long a2,
LBiLongPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LSrtIntPredicate.tryTestThen(short a1,
int a2,
LSrtIntPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LSrtPredicate.tryTestThen(short a,
LSrtPredicate func,
LPredicate<Throwable> handler) |
static boolean |
LBiSrtPredicate.tryTestThen(short a1,
short a2,
LBiSrtPredicate func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LObjIntObjPredicate.tryTestThen(T1 a1,
int a2,
T2 a3,
LObjIntObjPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjBoolPredicate.tryTestThen(T1 a1,
T2 a2,
boolean a3,
LBiObjBoolPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjBytePredicate.tryTestThen(T1 a1,
T2 a2,
byte a3,
LBiObjBytePredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjCharPredicate.tryTestThen(T1 a1,
T2 a2,
char a3,
LBiObjCharPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjDblPredicate.tryTestThen(T1 a1,
T2 a2,
double a3,
LBiObjDblPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjFltPredicate.tryTestThen(T1 a1,
T2 a2,
float a3,
LBiObjFltPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjIntPredicate.tryTestThen(T1 a1,
T2 a2,
int a3,
LBiObjIntPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiPredicate.tryTestThen(T1 a1,
T2 a2,
LBiPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjLongPredicate.tryTestThen(T1 a1,
T2 a2,
long a3,
LBiObjLongPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2> boolean |
LBiObjSrtPredicate.tryTestThen(T1 a1,
T2 a2,
short a3,
LBiObjSrtPredicate<T1,T2> func,
LPredicate<Throwable> handler) |
static <T1,T2,T3> boolean |
LTriPredicate.tryTestThen(T1 a1,
T2 a2,
T3 a3,
LTriPredicate<T1,T2,T3> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjBoolPredicate.tryTestThen(T a1,
boolean a2,
LObjBoolPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjBytePredicate.tryTestThen(T a1,
byte a2,
LObjBytePredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjCharPredicate.tryTestThen(T a1,
char a2,
LObjCharPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjDblPredicate.tryTestThen(T a1,
double a2,
LObjDblPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjFltPredicate.tryTestThen(T a1,
float a2,
LObjFltPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntBoolPredicate.tryTestThen(T a1,
int a2,
boolean a3,
LObjIntBoolPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntBytePredicate.tryTestThen(T a1,
int a2,
byte a3,
LObjIntBytePredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntCharPredicate.tryTestThen(T a1,
int a2,
char a3,
LObjIntCharPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntDblPredicate.tryTestThen(T a1,
int a2,
double a3,
LObjIntDblPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntFltPredicate.tryTestThen(T a1,
int a2,
float a3,
LObjIntFltPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjBiIntPredicate.tryTestThen(T a1,
int a2,
int a3,
LObjBiIntPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntPredicate.tryTestThen(T a1,
int a2,
LObjIntPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntLongPredicate.tryTestThen(T a1,
int a2,
long a3,
LObjIntLongPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjIntSrtPredicate.tryTestThen(T a1,
int a2,
short a3,
LObjIntSrtPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjLongPredicate.tryTestThen(T a1,
long a2,
LObjLongPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LPredicate.tryTestThen(T a,
LPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LPredicate.tryTestThen(T a,
LPredicate<T> func,
LPredicate<Throwable> handler) |
static <T> boolean |
LObjSrtPredicate.tryTestThen(T a1,
short a2,
LObjSrtPredicate<T> func,
LPredicate<Throwable> handler) |
default LPredicate<T> |
LPredicate.xor(LPredicate<? super T> other)
Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.
|
| Modifier and Type | Method and Description |
|---|---|
static <T> LPredicate<T> |
LPredicate.recursive(LFunction<LPredicate<T>,LPredicate<T>> selfLambda) |
static <T> LPredicate<T> |
LPredicate.recursive(LFunction<LPredicate<T>,LPredicate<T>> selfLambda) |
static <T> LSupplier<LPredicate<T>> |
LPredicate.safeSupplier(LSupplier<LPredicate<T>> supplier)
Safe supplier.
|
static <T1,T2,T3> LTriPredicate<T1,T2,T3> |
LTriPredicate.uncurry(LFunction<T1,LFunction<T2,LPredicate<T3>>> func) |
static <T1,T2> LObjIntObjPredicate<T1,T2> |
LObjIntObjPredicate.uncurry(LFunction<T1,LIntFunction<LPredicate<T2>>> func) |
static <T1,T2> LBiPredicate<T1,T2> |
LBiPredicate.uncurry(LFunction<T1,LPredicate<T2>> func) |
| Modifier and Type | Method and Description |
|---|---|
default boolean |
LBoolSupplier.getAsBoolThen(LPredicate<Throwable> handler) |
default LBoolSupplier |
LSupplier.toBoolSup(LPredicate<? super T> after)
Combines two functions together in a order.
|
static boolean |
LBoolSupplier.tryGetAsBoolThen(LBoolSupplier func,
LPredicate<Throwable> handler) |
default LBoolSupplier |
LBoolSupplier.tryingThen(LPredicate<Throwable> handler) |
| Modifier and Type | Method and Description |
|---|---|
LObjSrtPair.MutObjSrtPair<T> |
LObjSrtPair.MutObjSrtPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjSrtPair.MutCompObjSrtPair<T> |
LObjSrtPair.MutCompObjSrtPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjLongPair.MutObjLongPair<T> |
LObjLongPair.MutObjLongPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjLongPair.MutCompObjLongPair<T> |
LObjLongPair.MutCompObjLongPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntSrtTriple.MutObjIntSrtTriple<T> |
LObjIntSrtTriple.MutObjIntSrtTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntSrtTriple.MutCompObjIntSrtTriple<T> |
LObjIntSrtTriple.MutCompObjIntSrtTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntPair.MutObjIntPair<T> |
LObjIntPair.MutObjIntPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntPair.MutCompObjIntPair<T> |
LObjIntPair.MutCompObjIntPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntLongTriple.MutObjIntLongTriple<T> |
LObjIntLongTriple.MutObjIntLongTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntLongTriple.MutCompObjIntLongTriple<T> |
LObjIntLongTriple.MutCompObjIntLongTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntFltTriple.MutObjIntFltTriple<T> |
LObjIntFltTriple.MutObjIntFltTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntFltTriple.MutCompObjIntFltTriple<T> |
LObjIntFltTriple.MutCompObjIntFltTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntDblTriple.MutObjIntDblTriple<T> |
LObjIntDblTriple.MutObjIntDblTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntDblTriple.MutCompObjIntDblTriple<T> |
LObjIntDblTriple.MutCompObjIntDblTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntCharTriple.MutObjIntCharTriple<T> |
LObjIntCharTriple.MutObjIntCharTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntCharTriple.MutCompObjIntCharTriple<T> |
LObjIntCharTriple.MutCompObjIntCharTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntByteTriple.MutObjIntByteTriple<T> |
LObjIntByteTriple.MutObjIntByteTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntByteTriple.MutCompObjIntByteTriple<T> |
LObjIntByteTriple.MutCompObjIntByteTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntBoolTriple.MutObjIntBoolTriple<T> |
LObjIntBoolTriple.MutObjIntBoolTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntBoolTriple.MutCompObjIntBoolTriple<T> |
LObjIntBoolTriple.MutCompObjIntBoolTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjFltPair.MutObjFltPair<T> |
LObjFltPair.MutObjFltPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjFltPair.MutCompObjFltPair<T> |
LObjFltPair.MutCompObjFltPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjDblPair.MutObjDblPair<T> |
LObjDblPair.MutObjDblPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjDblPair.MutCompObjDblPair<T> |
LObjDblPair.MutCompObjDblPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjCharPair.MutObjCharPair<T> |
LObjCharPair.MutObjCharPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjCharPair.MutCompObjCharPair<T> |
LObjCharPair.MutCompObjCharPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjBytePair.MutObjBytePair<T> |
LObjBytePair.MutObjBytePair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjBytePair.MutCompObjBytePair<T> |
LObjBytePair.MutCompObjBytePair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjBoolPair.MutObjBoolPair<T> |
LObjBoolPair.MutObjBoolPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjBoolPair.MutCompObjBoolPair<T> |
LObjBoolPair.MutCompObjBoolPair.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjBiIntTriple.MutObjBiIntTriple<T> |
LObjBiIntTriple.MutObjBiIntTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LObjBiIntTriple.MutCompObjBiIntTriple<T> |
LObjBiIntTriple.MutCompObjBiIntTriple.setFirstIf(LPredicate<T> predicate,
T first)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutTriple<T1,T2,T3> |
LTriple.MutTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutCompTriple<T1,T2,T3> |
LTriple.MutCompTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LPair.MutPair<T1,T2> |
LPair.MutPair.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LPair.MutCompPair<T1,T2> |
LPair.MutCompPair.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntObjTriple.MutObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutObjIntObjTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutCompObjIntObjTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutBiObjSrtTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutCompBiObjSrtTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjLongTriple.MutBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutBiObjLongTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutCompBiObjLongTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjIntTriple.MutBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutBiObjIntTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutCompBiObjIntTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjFltTriple.MutBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutBiObjFltTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutCompBiObjFltTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjDblTriple.MutBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutBiObjDblTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutCompBiObjDblTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjCharTriple.MutBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutBiObjCharTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutCompBiObjCharTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjByteTriple.MutBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutBiObjByteTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutCompBiObjByteTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutBiObjBoolTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutCompBiObjBoolTriple.setFirstIf(LPredicate<T1> predicate,
T1 first)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutTriple<T1,T2,T3> |
LTriple.MutTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LTriple.MutCompTriple<T1,T2,T3> |
LTriple.MutCompTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LPair.MutPair<T1,T2> |
LPair.MutPair.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LPair.MutCompPair<T1,T2> |
LPair.MutCompPair.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntObjTriple.MutObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutObjIntObjTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutCompObjIntObjTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutBiObjSrtTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutCompBiObjSrtTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjLongTriple.MutBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutBiObjLongTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutCompBiObjLongTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjIntTriple.MutBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutBiObjIntTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutCompBiObjIntTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjFltTriple.MutBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutBiObjFltTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutCompBiObjFltTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjDblTriple.MutBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutBiObjDblTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutCompBiObjDblTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjCharTriple.MutBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutBiObjCharTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutCompBiObjCharTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjByteTriple.MutBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutBiObjByteTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutCompBiObjByteTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutBiObjBoolTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutCompBiObjBoolTriple.setFirstIfArg(T1 first,
LPredicate<T1> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjSrtPair.MutObjSrtPair<T> |
LObjSrtPair.MutObjSrtPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjSrtPair.MutCompObjSrtPair<T> |
LObjSrtPair.MutCompObjSrtPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjLongPair.MutObjLongPair<T> |
LObjLongPair.MutObjLongPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjLongPair.MutCompObjLongPair<T> |
LObjLongPair.MutCompObjLongPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntSrtTriple.MutObjIntSrtTriple<T> |
LObjIntSrtTriple.MutObjIntSrtTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntSrtTriple.MutCompObjIntSrtTriple<T> |
LObjIntSrtTriple.MutCompObjIntSrtTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntPair.MutObjIntPair<T> |
LObjIntPair.MutObjIntPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntPair.MutCompObjIntPair<T> |
LObjIntPair.MutCompObjIntPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntLongTriple.MutObjIntLongTriple<T> |
LObjIntLongTriple.MutObjIntLongTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntLongTriple.MutCompObjIntLongTriple<T> |
LObjIntLongTriple.MutCompObjIntLongTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntFltTriple.MutObjIntFltTriple<T> |
LObjIntFltTriple.MutObjIntFltTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntFltTriple.MutCompObjIntFltTriple<T> |
LObjIntFltTriple.MutCompObjIntFltTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntDblTriple.MutObjIntDblTriple<T> |
LObjIntDblTriple.MutObjIntDblTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntDblTriple.MutCompObjIntDblTriple<T> |
LObjIntDblTriple.MutCompObjIntDblTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntCharTriple.MutObjIntCharTriple<T> |
LObjIntCharTriple.MutObjIntCharTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntCharTriple.MutCompObjIntCharTriple<T> |
LObjIntCharTriple.MutCompObjIntCharTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntByteTriple.MutObjIntByteTriple<T> |
LObjIntByteTriple.MutObjIntByteTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntByteTriple.MutCompObjIntByteTriple<T> |
LObjIntByteTriple.MutCompObjIntByteTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntBoolTriple.MutObjIntBoolTriple<T> |
LObjIntBoolTriple.MutObjIntBoolTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntBoolTriple.MutCompObjIntBoolTriple<T> |
LObjIntBoolTriple.MutCompObjIntBoolTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjFltPair.MutObjFltPair<T> |
LObjFltPair.MutObjFltPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjFltPair.MutCompObjFltPair<T> |
LObjFltPair.MutCompObjFltPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjDblPair.MutObjDblPair<T> |
LObjDblPair.MutObjDblPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjDblPair.MutCompObjDblPair<T> |
LObjDblPair.MutCompObjDblPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjCharPair.MutObjCharPair<T> |
LObjCharPair.MutObjCharPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjCharPair.MutCompObjCharPair<T> |
LObjCharPair.MutCompObjCharPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjBytePair.MutObjBytePair<T> |
LObjBytePair.MutObjBytePair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjBytePair.MutCompObjBytePair<T> |
LObjBytePair.MutCompObjBytePair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjBoolPair.MutObjBoolPair<T> |
LObjBoolPair.MutObjBoolPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjBoolPair.MutCompObjBoolPair<T> |
LObjBoolPair.MutCompObjBoolPair.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjBiIntTriple.MutObjBiIntTriple<T> |
LObjBiIntTriple.MutObjBiIntTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjBiIntTriple.MutCompObjBiIntTriple<T> |
LObjBiIntTriple.MutCompObjBiIntTriple.setFirstIfArg(T first,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
<R> LBoolTriple.MutBoolTriple |
LBoolTriple.MutBoolTriple.setFirstIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolTriple.MutCompBoolTriple |
LBoolTriple.MutCompBoolTriple.setFirstIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolPair.MutBoolPair |
LBoolPair.MutBoolPair.setFirstIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolPair.MutCompBoolPair |
LBoolPair.MutCompBoolPair.setFirstIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolIntPair.MutBoolIntPair |
LBoolIntPair.MutBoolIntPair.setFirstIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolIntPair.MutCompBoolIntPair |
LBoolIntPair.MutCompBoolIntPair.setFirstIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
LTriple.MutTriple<T1,T2,T3> |
LTriple.MutTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutCompTriple<T1,T2,T3> |
LTriple.MutCompTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LPair.MutPair<T1,T2> |
LPair.MutPair.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LPair.MutCompPair<T1,T2> |
LPair.MutCompPair.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutBiObjSrtTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutCompBiObjSrtTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjLongTriple.MutBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutBiObjLongTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutCompBiObjLongTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjIntTriple.MutBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutBiObjIntTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutCompBiObjIntTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjFltTriple.MutBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutBiObjFltTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutCompBiObjFltTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjDblTriple.MutBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutBiObjDblTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutCompBiObjDblTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjCharTriple.MutBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutBiObjCharTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutCompBiObjCharTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjByteTriple.MutBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutBiObjByteTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutCompBiObjByteTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutBiObjBoolTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutCompBiObjBoolTriple.setSecondIf(LPredicate<T2> predicate,
T2 second)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutTriple<T1,T2,T3> |
LTriple.MutTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LTriple.MutCompTriple<T1,T2,T3> |
LTriple.MutCompTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LPair.MutPair<T1,T2> |
LPair.MutPair.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LPair.MutCompPair<T1,T2> |
LPair.MutCompPair.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjSrtTriple.MutBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutBiObjSrtTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjSrtTriple.MutCompBiObjSrtTriple<T1,T2> |
LBiObjSrtTriple.MutCompBiObjSrtTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjLongTriple.MutBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutBiObjLongTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjLongTriple.MutCompBiObjLongTriple<T1,T2> |
LBiObjLongTriple.MutCompBiObjLongTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjIntTriple.MutBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutBiObjIntTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjIntTriple.MutCompBiObjIntTriple<T1,T2> |
LBiObjIntTriple.MutCompBiObjIntTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjFltTriple.MutBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutBiObjFltTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2> |
LBiObjFltTriple.MutCompBiObjFltTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjDblTriple.MutBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutBiObjDblTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2> |
LBiObjDblTriple.MutCompBiObjDblTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjCharTriple.MutBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutBiObjCharTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjCharTriple.MutCompBiObjCharTriple<T1,T2> |
LBiObjCharTriple.MutCompBiObjCharTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjByteTriple.MutBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutBiObjByteTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjByteTriple.MutCompBiObjByteTriple<T1,T2> |
LBiObjByteTriple.MutCompBiObjByteTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutBiObjBoolTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutCompBiObjBoolTriple.setSecondIfArg(T2 second,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
<R> LObjBoolPair.MutObjBoolPair<T> |
LObjBoolPair.MutObjBoolPair.setSecondIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LObjBoolPair.MutCompObjBoolPair<T> |
LObjBoolPair.MutCompObjBoolPair.setSecondIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolTriple.MutBoolTriple |
LBoolTriple.MutBoolTriple.setSecondIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolTriple.MutCompBoolTriple |
LBoolTriple.MutCompBoolTriple.setSecondIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolPair.MutBoolPair |
LBoolPair.MutBoolPair.setSecondIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolPair.MutCompBoolPair |
LBoolPair.MutCompBoolPair.setSecondIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
LObjIntObjTriple.MutObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutObjIntObjTriple.setThirdIf(LPredicate<T2> predicate,
T2 third)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutCompObjIntObjTriple.setThirdIf(LPredicate<T2> predicate,
T2 third)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutTriple<T1,T2,T3> |
LTriple.MutTriple.setThirdIf(LPredicate<T3> predicate,
T3 third)
Sets value if predicate(current) OR current::predicate is true
|
LTriple.MutCompTriple<T1,T2,T3> |
LTriple.MutCompTriple.setThirdIf(LPredicate<T3> predicate,
T3 third)
Sets value if predicate(current) OR current::predicate is true
|
LObjIntObjTriple.MutObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutObjIntObjTriple.setThirdIfArg(T2 third,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LObjIntObjTriple.MutCompObjIntObjTriple<T1,T2> |
LObjIntObjTriple.MutCompObjIntObjTriple.setThirdIfArg(T2 third,
LPredicate<T2> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LTriple.MutTriple<T1,T2,T3> |
LTriple.MutTriple.setThirdIfArg(T3 third,
LPredicate<T3> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LTriple.MutCompTriple<T1,T2,T3> |
LTriple.MutCompTriple.setThirdIfArg(T3 third,
LPredicate<T3> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
<R> LObjIntBoolTriple.MutObjIntBoolTriple<T> |
LObjIntBoolTriple.MutObjIntBoolTriple.setThirdIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LObjIntBoolTriple.MutCompObjIntBoolTriple<T> |
LObjIntBoolTriple.MutCompObjIntBoolTriple.setThirdIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolTriple.MutBoolTriple |
LBoolTriple.MutBoolTriple.setThirdIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolTriple.MutCompBoolTriple |
LBoolTriple.MutCompBoolTriple.setThirdIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBiObjBoolTriple.MutBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutBiObjBoolTriple.setThirdIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBiObjBoolTriple.MutCompBiObjBoolTriple<T1,T2> |
LBiObjBoolTriple.MutCompBiObjBoolTriple.setThirdIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
LSingle.MutSingle<T> |
LSingle.MutSingle.setValueIf(LPredicate<T> predicate,
T value)
Sets value if predicate(current) OR current::predicate is true
|
LSingle.MutCompSingle<T> |
LSingle.MutCompSingle.setValueIf(LPredicate<T> predicate,
T value)
Sets value if predicate(current) OR current::predicate is true
|
LSingle.MutSingle<T> |
LSingle.MutSingle.setValueIfArg(T value,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
LSingle.MutCompSingle<T> |
LSingle.MutCompSingle.setValueIfArg(T value,
LPredicate<T> predicate)
Sets value if predicate(newValue) OR newValue::predicate is true
|
<R> LBoolSingle.MutBoolSingle |
LBoolSingle.MutBoolSingle.setValueIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
<R> LBoolSingle.MutCompBoolSingle |
LBoolSingle.MutCompBoolSingle.setValueIfArgNotNull(R arg,
LPredicate<R> func)
Sets value derived from non-null argument, only if argument is not null.
|
Copyright © 2019. All rights reserved.