de.caff.generics.function

Interface Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9>

Type Parameters:

P1 - parameter type 1

P2 - parameter type 2

P3 - parameter type 3

P4 - parameter type 4

P5 - parameter type 5

P6 - parameter type 6

P7 - parameter type 7

P8 - parameter type 8

P9 - parameter type 9

All Superinterfaces:

java.util.function.Predicate<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>, Predicate1<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

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 Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9>
extends Predicate1<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

A function with nine arguments which returns a boolean value.

Predicates can be chained to simulate boolean logic by and(Predicate9), or(Predicate9), xor(Predicate9), 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(Predicate9, Predicate9), or(Predicate9, Predicate9), and xor(Predicate9, Predicate9).

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, Object, Object, Object, Object, Object) method) and alwaysFalse() (same for false).

Partial evaluation is also possible.

Author:

Rammi

See Also:

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

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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	alwaysFalse() Get a predicate which always evaluates to false.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	alwaysTrue() Get a predicate which always evaluates to true.
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9>	and(Predicate9<? super P1,? super P2,? super P3,? super P4,? super P5,? super P6,? super P7,? super P8,? super P9> other) Combine this and another predicate with logical and.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	and(Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred1, Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred2) Get a predicate which is the combination of two predicates with a logical and.
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9>	negate() Get the negation of this predicate.
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9>	or(Predicate9<? super P1,? super P2,? super P3,? super P4,? super P5,? super P6,? super P7,? super P8,? super P9> other) Combine this and another predicate with logical or.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	or(Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred1, Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred2) Get a predicate which is the combination of two predicates with a logical or.
default Predicate8<P2,P3,P4,P5,P6,P7,P8,P9>	partial1(P1 argument) Get a partially applied predicate with a fix first argument.
default Predicate8<P1,P3,P4,P5,P6,P7,P8,P9>	partial2(P2 argument) Get a partially applied predicate with a fix second argument.
default Predicate8<P1,P2,P4,P5,P6,P7,P8,P9>	partial3(P3 argument) Get a partially applied predicate with a fix third argument.
default Predicate8<P1,P2,P3,P5,P6,P7,P8,P9>	partial4(P4 argument) Get a partially applied predicate with a fix fourth argument.
default Predicate8<P1,P2,P3,P4,P6,P7,P8,P9>	partial5(P5 argument) Get a partially applied predicate with a fix fifth argument.
default Predicate8<P1,P2,P3,P4,P5,P7,P8,P9>	partial6(P6 argument) Get a partially applied predicate with a fix sixth argument.
default Predicate8<P1,P2,P3,P4,P5,P6,P8,P9>	partial7(P7 argument) Get a partially applied predicate with a fix seventh argument.
default Predicate8<P1,P2,P3,P4,P5,P6,P7,P9>	partial8(P8 argument) Get a partially applied predicate with a fix eighth argument.
default Predicate8<P1,P2,P3,P4,P5,P6,P7,P8>	partial9(P9 argument) Get a partially applied predicate with a fix ninth argument.
default boolean	test(ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9> tuple9) Expand a tuple into the arguments of this predicate.
boolean	test(P1 arg1, P2 arg2, P3 arg3, P4 arg4, P5 arg5, P6 arg6, P7 arg7, P8 arg8, P9 arg9) Test the given values.
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9>	xor(Predicate9<? super P1,? super P2,? super P3,? super P4,? super P5,? super P6,? super P7,? super P8,? super P9> other) Combine this and another predicate with logical exclusive or.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	xor(Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred1, Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> 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,
             P5 arg5,
             P6 arg6,
             P7 arg7,
             P8 arg8,
             P9 arg9)

Test the given values.

Parameters:

arg1 - function argument 1

arg2 - function argument 2

arg3 - function argument 3

arg4 - function argument 4

arg5 - function argument 5

arg6 - function argument 6

arg7 - function argument 7

arg8 - function argument 8

arg9 - function argument 9

Returns:

true or false

test

default boolean test(@NotNull
                     ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9> tuple9)

Expand a tuple into the arguments of this predicate.

Specified by:

test in interface java.util.function.Predicate<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

Parameters:

tuple9 - tuple to expand

Returns:

the result of testing the expended eleeents of the tuple

and

@NotNull
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9> and(@NotNull
                                                            Predicate9<? super P1,? super P2,? super P3,? super P4,? super P5,? super P6,? super P7,? super P8,? super P9> 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(Predicate9, Predicate9) for such cases.

Parameters:

other - other predicate to be chained with logical and

Returns:

predicates combined with logical and

or

@NotNull
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9> or(@NotNull
                                                           Predicate9<? super P1,? super P2,? super P3,? super P4,? super P5,? super P6,? super P7,? super P8,? super P9> 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(Predicate9, Predicate9) for such cases.

Parameters:

other - other predicate to be chained with logical or

Returns:

predicates combined with logical or

xor

@NotNull
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9> xor(@NotNull
                                                            Predicate9<? super P1,? super P2,? super P3,? super P4,? super P5,? super P6,? super P7,? super P8,? super P9> 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(Predicate9, Predicate9) for such cases.

Parameters:

other - other predicate to be chained with logical exclusive or

Returns:

predicates combined with logical exclusive or

negate

@NotNull
default Predicate9<P1,P2,P3,P4,P5,P6,P7,P8,P9> negate()

Get the negation of this predicate.

Specified by:

negate in interface java.util.function.Predicate<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

Specified by:

negate in interface Predicate1<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

Returns:

negation of this predicate

partial1

@NotNull
default Predicate8<P2,P3,P4,P5,P6,P7,P8,P9> 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 Predicate8<P1,P3,P4,P5,P6,P7,P8,P9> 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 Predicate8<P1,P2,P4,P5,P6,P7,P8,P9> 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 Predicate8<P1,P2,P3,P5,P6,P7,P8,P9> 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

partial5

@NotNull
default Predicate8<P1,P2,P3,P4,P6,P7,P8,P9> partial5(P5 argument)

Get a partially applied predicate with a fix fifth argument.

Parameters:

argument - value applied for fifth argument

Returns:

partially evaluated two argument predicate

partial6

@NotNull
default Predicate8<P1,P2,P3,P4,P5,P7,P8,P9> partial6(P6 argument)

Get a partially applied predicate with a fix sixth argument.

Parameters:

argument - value applied for sixth argument

Returns:

partially evaluated two argument predicate

partial7

@NotNull
default Predicate8<P1,P2,P3,P4,P5,P6,P8,P9> partial7(P7 argument)

Get a partially applied predicate with a fix seventh argument.

Parameters:

argument - value applied for seventh argument

Returns:

partially evaluated two argument predicate

partial8

@NotNull
default Predicate8<P1,P2,P3,P4,P5,P6,P7,P9> partial8(P8 argument)

Get a partially applied predicate with a fix eighth argument.

Parameters:

argument - value applied for eighth argument

Returns:

partially evaluated two argument predicate

partial9

@NotNull
default Predicate8<P1,P2,P3,P4,P5,P6,P7,P8> partial9(P9 argument)

Get a partially applied predicate with a fix ninth argument.

Parameters:

argument - value applied for ninth argument

Returns:

partially evaluated two argument predicate

alwaysTrue

@NotNull
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9> alwaysTrue()

Get a predicate which always evaluates to true.

Specified by:

alwaysTrue in interface Predicate1<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

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

T5 - type of fifth predicate parameter

T6 - type of sixth predicate parameter

T7 - type of seventh predicate parameter

T8 - type of eighth predicate parameter

T9 - type of ninth predicate parameter

Returns:

predicate always returning true

alwaysFalse

@NotNull
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9> alwaysFalse()

Get a predicate which always evaluates to false.

Specified by:

alwaysFalse in interface Predicate1<ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>>

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

T5 - type of fifth predicate parameter

T6 - type of sixth predicate parameter

T7 - type of seventh predicate parameter

T8 - type of eighth predicate parameter

T9 - type of ninth predicate parameter

Returns:

predicate always returning false

and

@NotNull
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9> and(@NotNull
                                                                                        Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred1,
                                                                                        @NotNull
                                                                                        Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> 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

T5 - resulting type of fifth argument, see <T1> for the fine print

T6 - resulting type of sixth argument, see <T1> for the fine print

T7 - resulting type of seventh argument, see <T1> for the fine print

T8 - resulting type of eighth argument, see <T1> for the fine print

T9 - resulting type of ninth 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(Predicate9)

or

@NotNull
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9> or(@NotNull
                                                                                       Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred1,
                                                                                       @NotNull
                                                                                       Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> 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

T5 - resulting type of fifth argument, see <T1> for the fine print

T6 - resulting type of sixth argument, see <T1> for the fine print

T7 - resulting type of seventh argument, see <T1> for the fine print

T8 - resulting type of eighth argument, see <T1> for the fine print

T9 - resulting type of ninth 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(Predicate9)

xor

@NotNull
static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Predicate9<T1,T2,T3,T4,T5,T6,T7,T8,T9> xor(@NotNull
                                                                                        Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> pred1,
                                                                                        @NotNull
                                                                                        Predicate9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9> 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

T5 - resulting type of fifth argument, see <T1> for the fine print

T6 - resulting type of sixth argument, see <T1> for the fine print

T7 - resulting type of seventh argument, see <T1> for the fine print

T8 - resulting type of eighth argument, see <T1> for the fine print

T9 - resulting type of ninth 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(Predicate9)

after1

@NotNull
default <FR extends ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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 ITuple9<? extends P1,? extends P2,? extends P3,? extends P4,? extends P5,? extends P6,? extends P7,? extends P8,? extends P9>,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 ITuple9 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 9-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