de.caff.generics.function

Interface Predicate4<P1,P2,P3,P4>

Type Parameters:

P1 - parameter type 1

P2 - parameter type 2

P3 - parameter type 3

P4 - parameter type 4

All Superinterfaces:

java.util.function.Predicate<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>, Predicate1<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface Predicate4<P1,P2,P3,P4>
extends Predicate1<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

A function with four arguments which returns a boolean value.

Predicates can be chained to simulate boolean logic by and(Predicate4), or(Predicate4), xor(Predicate4), and negate().

There is a general problem with combining types which don't allow to use the above combination methods in all cases similar to standard Java's logical expressions. The following static methods of this interface may be used in all cases: and(Predicate4, Predicate4), or(Predicate4, Predicate4), and xor(Predicate4, Predicate4).

Useful for start values in algorithms or as default values are the two values returned by alwaysTrue() (a predicate which always returns true regardless the argument applied to the test(Object, Object, Object, Object) method) and alwaysFalse() (same for false).

Partial evaluation is also possible.

Author:

Rammi

See Also:

Predicate1, Predicate2, Predicate3, Predicate5, Predicate6, Predicate7, Predicate8, Predicate9

Field Summary

Fields inherited from interface de.caff.generics.function.Predicate1

ALWAYS_FALSE, ALWAYS_TRUE

Method Summary

Modifier and Type	Method and Description
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP> Predicate1<FP>	after1(java.util.function.Function<FP,FR> before) Get a chained predicate which first applies the given function, then this predicate.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2> Predicate2<FP1,FP2>	after2(java.util.function.BiFunction<FP1,FP2,FR> before) Get a chained predicate which first applies the given 2-parameter function, then this predicate.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3> Predicate3<FP1,FP2,FP3>	after3(Function3<FR,FP1,FP2,FP3> before) Get a chained predicate which first applies the given 3-parameter function, then this predicate.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5> Predicate5<FP1,FP2,FP3,FP4,FP5>	after5(Function5<FR,FP1,FP2,FP3,FP4,FP5> before) Get a chained predicate which first applies the given 5-parameter function, then this predicate.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6> Predicate6<FP1,FP2,FP3,FP4,FP5,FP6>	after6(Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before) Get a chained predicate which first applies the given 6-parameter function, then this predicate.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Predicate7<FP1,FP2,FP3,FP4,FP5,FP6,FP7>	after7(Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before) Get a chained predicate which first applies the given 7-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Predicate8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8>	after8(Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before) Get a chained predicate which first applies the given 8-parameter function, then this one.
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Predicate9<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9>	after9(Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before) Get a chained predicate which first applies the given 9-parameter function, then this one.
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4>	alwaysFalse() Get a predicate which always evaluates to false.
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4>	alwaysTrue() Get a predicate which always evaluates to true.
default Predicate4<P1,P2,P3,P4>	and(Predicate4<? super P1,? super P2,? super P3,? super P4> other) Combine this and another predicate with logical and.
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4>	and(Predicate4<? super T1,? super T2,? super T3,? super T4> pred1, Predicate4<? super T1,? super T2,? super T3,? super T4> pred2) Get a predicate which is the combination of two predicates with a logical and.
default Predicate4<P1,P2,P3,P4>	negate() Get the negation of this predicate.
default Predicate4<P1,P2,P3,P4>	or(Predicate4<? super P1,? super P2,? super P3,? super P4> other) Combine this and another predicate with logical or.
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4>	or(Predicate4<? super T1,? super T2,? super T3,? super T4> pred1, Predicate4<? super T1,? super T2,? super T3,? super T4> pred2) Get a predicate which is the combination of two predicates with a logical or.
default Predicate3<P2,P3,P4>	partial1(P1 argument) Get a partially applied predicate with a fix first argument.
default Predicate3<P1,P3,P4>	partial2(P2 argument) Get a partially applied predicate with a fix second argument.
default Predicate3<P1,P2,P4>	partial3(P3 argument) Get a partially applied predicate with a fix third argument.
default Predicate3<P1,P2,P3>	partial4(P4 argument) Get a partially applied predicate with a fix fourth argument.
default boolean	test(ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4) Expand a tuple into the arguments of this predicate.
boolean	test(P1 arg1, P2 arg2, P3 arg3, P4 arg4) Test the given values.
default Predicate4<P1,P2,P3,P4>	xor(Predicate4<? super P1,? super P2,? super P3,? super P4> other) Combine this and another predicate with logical exclusive or.
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4>	xor(Predicate4<? super T1,? super T2,? super T3,? super T4> pred1, Predicate4<? super T1,? super T2,? super T3,? super T4> pred2) Get a predicate which is the combination of two predicates with a logical exclusive or.

Methods inherited from interface de.caff.generics.function.Predicate1

adapted, and_, and, and, from, isEqual, or_, or, or, testNonNull, xor_, xor, xor

Method Detail

test

boolean test(P1 arg1,
             P2 arg2,
             P3 arg3,
             P4 arg4)

Test the given values.

Parameters:

arg1 - function argument 1

arg2 - function argument 2

arg3 - function argument 3

arg4 - function argument 4

Returns:

true or false

test

default boolean test(@NotNull
                     ITuple4<? extends P1,? extends P2,? extends P3,? extends P4> tuple4)

Expand a tuple into the arguments of this predicate.

Specified by:

test in interface java.util.function.Predicate<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Parameters:

tuple4 - tuple to expand

Returns:

the result of testing the expended eleeents of the tuple

and

@NotNull
default Predicate4<P1,P2,P3,P4> and(@NotNull
                                             Predicate4<? super P1,? super P2,? super P3,? super P4> other)

Combine this and another predicate with logical and. The result will use shortcut evaluation, so if this predicate already returns false the other one is not evaluated.

This method has a problem if either one of the argument types pf the parameter is not a super class of this predicate's parameter types. See and(Predicate4, Predicate4) for such cases.

Parameters:

other - other predicate to be chained with logical and

Returns:

predicates combined with logical and

or

@NotNull
default Predicate4<P1,P2,P3,P4> or(@NotNull
                                            Predicate4<? super P1,? super P2,? super P3,? super P4> other)

Combine this and another predicate with logical or. The result will use shortcut evaluation, so if this predicate already returns true the other one is not evaluated.

This method has a problem if either one of the argument types pf the parameter is not a super class of this predicate's parameter types. See or(Predicate4, Predicate4) for such cases.

Parameters:

other - other predicate to be chained with logical or

Returns:

predicates combined with logical or

xor

@NotNull
default Predicate4<P1,P2,P3,P4> xor(@NotNull
                                             Predicate4<? super P1,? super P2,? super P3,? super P4> other)

Combine this and another predicate with logical exclusive or.

This method has a problem if either one of the argument types pf the parameter is not a super class of this predicate's parameter types. See xor(Predicate4, Predicate4) for such cases.

Parameters:

other - other predicate to be chained with logical exclusive or

Returns:

predicates combined with logical exclusive or

negate

@NotNull
default Predicate4<P1,P2,P3,P4> negate()

Get the negation of this predicate.

Specified by:

negate in interface java.util.function.Predicate<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Specified by:

negate in interface Predicate1<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Returns:

negation of this predicate

partial1

@NotNull
default Predicate3<P2,P3,P4> partial1(P1 argument)

Get a partially applied predicate with a fix first argument.

Parameters:

argument - value applied for first argument

Returns:

partially evaluated two argument predicate

partial2

@NotNull
default Predicate3<P1,P3,P4> partial2(P2 argument)

Get a partially applied predicate with a fix second argument.

Parameters:

argument - value applied for second argument

Returns:

partially evaluated two argument predicate

partial3

@NotNull
default Predicate3<P1,P2,P4> partial3(P3 argument)

Get a partially applied predicate with a fix third argument.

Parameters:

argument - value applied for third argument

Returns:

partially evaluated two argument predicate

partial4

@NotNull
default Predicate3<P1,P2,P3> partial4(P4 argument)

Get a partially applied predicate with a fix fourth argument.

Parameters:

argument - value applied for fourth argument

Returns:

partially evaluated two argument predicate

alwaysTrue

@NotNull
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4> alwaysTrue()

Get a predicate which always evaluates to true.

Specified by:

alwaysTrue in interface Predicate1<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Type Parameters:

T1 - type of first predicate parameter

T2 - type of second predicate parameter

T3 - type of third predicate parameter

T4 - type of fourth predicate parameter

Returns:

predicate always returning true

alwaysFalse

@NotNull
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4> alwaysFalse()

Get a predicate which always evaluates to false.

Specified by:

alwaysFalse in interface Predicate1<ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>>

Type Parameters:

T1 - type of first predicate parameter

T2 - type of second predicate parameter

T3 - type of third predicate parameter

T4 - type of fourth predicate parameter

Returns:

predicate always returning false

and

@NotNull
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4> and(@NotNull
                                                          Predicate4<? super T1,? super T2,? super T3,? super T4> pred1,
                                                          @NotNull
                                                          Predicate4<? super T1,? super T2,? super T3,? super T4> pred2)

Get a predicate which is the combination of two predicates with a logical and.

The result will use shortcut evaluation, so if this predicate already returns false the other one is not evaluated.

Type Parameters:

T1 - resulting type of first argument, which is the most extending type of both pred1's first argument type and pred2's first argument type, so if neither type is extending the other this method will not compile

T2 - resulting type of second argument, see <T1> for the fine print

T3 - resulting type of third argument, see <T1> for the fine print

T4 - resulting type of fourth argument, see <T1> for the fine print

Parameters:

pred1 - first predicate

pred2 - second predicate

Returns:

combination of both predicates with logical and

See Also:

and(Predicate4)

or

@NotNull
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4> or(@NotNull
                                                         Predicate4<? super T1,? super T2,? super T3,? super T4> pred1,
                                                         @NotNull
                                                         Predicate4<? super T1,? super T2,? super T3,? super T4> pred2)

Get a predicate which is the combination of two predicates with a logical or.

The result will use shortcut evaluation, so if this predicate already returns true the other one is not evaluated.

Type Parameters:

T1 - resulting type of first argument, which is the most extending type of both pred1's first argument type and pred2's first argument type, so if neither type is extending the other this method will not compile

T2 - resulting type of second argument, see <T1> for the fine print

T3 - resulting type of third argument, see <T1> for the fine print

T4 - resulting type of fourth argument, see <T1> for the fine print

Parameters:

pred1 - first predicate

pred2 - second predicate

Returns:

combination of both predicates with logical or

See Also:

or(Predicate4)

xor

@NotNull
static <T1,T2,T3,T4> Predicate4<T1,T2,T3,T4> xor(@NotNull
                                                          Predicate4<? super T1,? super T2,? super T3,? super T4> pred1,
                                                          @NotNull
                                                          Predicate4<? super T1,? super T2,? super T3,? super T4> pred2)

Get a predicate which is the combination of two predicates with a logical exclusive or.

The result will use shortcut evaluation, so if this predicate already returns true the other one is not evaluated.

Type Parameters:

T1 - resulting type of first argument, which is the most extending type of both pred1's first argument type and pred2's first argument type, so if neither type is extending the other this method will not compile

T2 - resulting type of second argument, see <T1> for the fine print

T3 - resulting type of third argument, see <T1> for the fine print

T4 - resulting type of fourth argument, see <T1> for the fine print

Parameters:

pred1 - first predicate

pred2 - second predicate

Returns:

combination of both predicates with logical exclusive or

See Also:

xor(Predicate4)

after1

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP> Predicate1<FP> after1(@NotNull
                                                                                                                    java.util.function.Function<FP,FR> before)

Get a chained predicate which first applies the given function, then this predicate. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this predicate.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP - function before's parameter type, same for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of function and this predicate

after2

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2> Predicate2<FP1,FP2> after2(@NotNull
                                                                                                                              java.util.function.BiFunction<FP1,FP2,FR> before)

Get a chained predicate which first applies the given 2-parameter function, then this predicate. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this predicate.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, same for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate

after3

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3> Predicate3<FP1,FP2,FP3> after3(@NotNull
                                                                                                                                      Function3<FR,FP1,FP2,FP3> before)

Get a chained predicate which first applies the given 3-parameter function, then this predicate. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this predicate.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, sane for returned predicate

FP3 - function before's third parameter type, sane for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate

after5

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5> Predicate5<FP1,FP2,FP3,FP4,FP5> after5(@NotNull
                                                                                                                                                      Function5<FR,FP1,FP2,FP3,FP4,FP5> before)

Get a chained predicate which first applies the given 5-parameter function, then this predicate. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, sane for returned predicate

FP3 - function before's third parameter type, sane for returned predicate

FP4 - function before's fourth parameter type, sane for returned predicate

FP5 - function before's fifth parameter type, sane for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate

after6

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6> Predicate6<FP1,FP2,FP3,FP4,FP5,FP6> after6(@NotNull
                                                                                                                                                              Function6<FR,FP1,FP2,FP3,FP4,FP5,FP6> before)

Get a chained predicate which first applies the given 6-parameter function, then this predicate. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this function.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, sane for returned predicate

FP3 - function before's third parameter type, sane for returned predicate

FP4 - function before's fourth parameter type, sane for returned predicate

FP5 - function before's fifth parameter type, sane for returned predicate

FP6 - function before's sixth parameter type, sane for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate

after7

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7> Predicate7<FP1,FP2,FP3,FP4,FP5,FP6,FP7> after7(@NotNull
                                                                                                                                                                      Function7<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7> before)

Get a chained predicate which first applies the given 7-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this predicate.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, sane for returned predicate

FP3 - function before's third parameter type, sane for returned predicate

FP4 - function before's fourth parameter type, sane for returned predicate

FP5 - function before's fifth parameter type, sane for returned predicate

FP6 - function before's sixth parameter type, sane for returned predicate

FP7 - function before's seventh parameter type, sane for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate

after8

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> Predicate8<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> after8(@NotNull
                                                                                                                                                                              Function8<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8> before)

Get a chained predicate which first applies the given 8-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this predicate.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, sane for returned predicate

FP3 - function before's third parameter type, sane for returned predicate

FP4 - function before's fourth parameter type, sane for returned predicate

FP5 - function before's fifth parameter type, sane for returned predicate

FP6 - function before's sixth parameter type, sane for returned predicate

FP7 - function before's seventh parameter type, sane for returned predicate

FP8 - function before's seventh parameter type, sane for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate

after9

@NotNull
default <FR extends ITuple4<? extends P1,? extends P2,? extends P3,? extends P4>,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> Predicate9<FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> after9(@NotNull
                                                                                                                                                                                      Function9<FR,FP1,FP2,FP3,FP4,FP5,FP6,FP7,FP8,FP9> before)

Get a chained predicate which first applies the given 9-parameter function, then this one. The given function has to return a ITuple4 with matching parametric types which are applied in their order to this predicate.

Type Parameters:

FR - function before's return type, has to be a 4-tuple with matching types

FP1 - function before's first parameter type, sane for returned predicate

FP2 - function before's second parameter type, sane for returned predicate

FP3 - function before's third parameter type, sane for returned predicate

FP4 - function before's fourth parameter type, sane for returned predicate

FP5 - function before's fifth parameter type, sane for returned predicate

FP6 - function before's sixth parameter type, sane for returned predicate

FP7 - function before's seventh parameter type, sane for returned predicate

FP8 - function before's seventh parameter type, sane for returned predicate

FP9 - function before's ninth parameter type, sane for returned predicate

Parameters:

before - function to apply first, has to return a non-null result so unpacking the parameters from the tuple is possible

Returns:

chain of the given function and this predicate