de.caff.generics.function

## Interface Predicate3<P1,P2,P3>

• ### Method Summary

All Methods
Modifier and Type Method and Description
`static <T1,T2,T3> Predicate3<T1,T2,T3>` `alwaysFalse()`
Get a predicate which always evaluates to `false`.
`static <T1,T2,T3> Predicate3<T1,T2,T3>` `alwaysTrue()`
Get a predicate which always evaluates to `true`.
`default Predicate3<P1,P2,P3>` `and(Predicate3<? super P1,? super P2,? super P3> other)`
Combine this and another predicate with logical and.
`static <T1,T2,T3> Predicate3<T1,T2,T3>` ```and(Predicate3<? super T1,? super T2,? super T3> pred1, Predicate3<? super T1,? super T2,? super T3> pred2)```
Get a predicate which is the combination of two predicates with a logical and.
`default Predicate3<P1,P2,P3>` `negate()`
Get the negation of this predicate.
`default Predicate3<P1,P2,P3>` `or(Predicate3<? super P1,? super P2,? super P3> other)`
Combine this and another predicate with logical or.
`static <T1,T2,T3> Predicate3<T1,T2,T3>` ```or(Predicate3<? super T1,? super T2,? super T3> pred1, Predicate3<? super T1,? super T2,? super T3> pred2)```
Get a predicate which is the combination of two predicates with a logical or.
`default Predicate3<P1,P3,P2>` `order132()`
Get a three argument predicate which expects the arguments in different order.
`default Predicate3<P2,P1,P3>` `order213()`
Get a three argument predicate which expects the arguments in different order.
`default Predicate3<P2,P3,P1>` `order231()`
Get a three argument predicate which expects the arguments in different order.
`default Predicate3<P3,P1,P2>` `order312()`
Get a three argument predicate which expects the arguments in different order.
`default Predicate3<P3,P2,P1>` `order321()`
Get a three argument predicate which expects the arguments in different order.
`default Predicate2<P2,P3>` `partial1(P1 argument)`
Get a partially applied predicate with a fix first argument.
`default Predicate2<P1,P3>` `partial2(P2 argument)`
Get a partially applied predicate with a fix second argument.
`default Predicate2<P1,P2>` `partial3(P3 argument)`
Get a partially applied predicate with a fix third argument.
`default Predicate2<P2,P3>` `partialLeft(P1 argument)`
Get a partially applied predicate.
`default Predicate2<P1,P3>` `partialMid(P2 argument)`
Get a partially applied predicate.
`default Predicate2<P1,P2>` `partialRight(P3 argument)`
Get a partially applied predicate.
`boolean` ```test(P1 arg1, P2 arg2, P3 arg3)```
Test the given values.
`default Predicate3<P1,P2,P3>` `xor(Predicate3<? super P1,? super P2,? super P3> other)`
Combine this and another predicate with logical exclusive or.
`static <T1,T2,T3> Predicate3<T1,T2,T3>` ```xor(Predicate3<? super T1,? super T2,? super T3> pred1, Predicate3<? super T1,? super T2,? super T3> pred2)```
Get a predicate which is the combination of two predicates with a logical exclusive or.
• ### Method Detail

• #### test

```boolean test(P1 arg1,
P2 arg2,
P3 arg3)```
Test the given values.
Parameters:
`arg1` - function argument 1
`arg2` - function argument 2
`arg3` - function argument 3
Returns:
`true` or `false`
• #### and

```@NotNull
default Predicate3<P1,P2,P3> and(@NotNull
Predicate3<? super P1,? super P2,? super P3> 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(Predicate3, Predicate3)` for such cases.
Parameters:
`other` - other predicate to be chained with logical and
Returns:
predicates combined with logical and
• #### or

```@NotNull
default Predicate3<P1,P2,P3> or(@NotNull
Predicate3<? super P1,? super P2,? super P3> 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(Predicate3, Predicate3)` for such cases.
Parameters:
`other` - other predicate to be chained with logical or
Returns:
predicates combined with logical or
• #### xor

```@NotNull
default Predicate3<P1,P2,P3> xor(@NotNull
Predicate3<? super P1,? super P2,? super P3> 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(Predicate3, Predicate3)` for such cases.
Parameters:
`other` - other predicate to be chained with logical exclusive or
Returns:
predicates combined with logical exclusive or
• #### negate

```@NotNull
default Predicate3<P1,P2,P3> negate()```
Get the negation of this predicate.
Returns:
negation of this predicate
• #### partialLeft

```@NotNull
default Predicate2<P2,P3> partialLeft(P1 argument)```
Get a partially applied predicate.
Parameters:
`argument` - value applied for first argument
Returns:
partially evaluated two argument predicate
• #### partial1

```@NotNull
default Predicate2<P2,P3> partial1(P1 argument)```
Get a partially applied predicate with a fix first argument. This is the same as `partialLeft(Object)` but more consitently named.
Parameters:
`argument` - value applied for first argument
Returns:
partially evaluated two argument predicate
• #### partialMid

```@NotNull
default Predicate2<P1,P3> partialMid(P2 argument)```
Get a partially applied predicate.
Parameters:
`argument` - value applied for second argument
Returns:
partially evaluated two argument predicate
• #### partial2

```@NotNull
default Predicate2<P1,P3> partial2(P2 argument)```
Get a partially applied predicate with a fix second argument. This is the same as `partialMid(Object)` but more consistently named.
Parameters:
`argument` - value applied for second argument
Returns:
partially evaluated two argument predicate
• #### partialRight

```@NotNull
default Predicate2<P1,P2> partialRight(P3 argument)```
Get a partially applied predicate.
Parameters:
`argument` - value applied for third argument
Returns:
partially evaluated two argument predicate
• #### partial3

```@NotNull
default Predicate2<P1,P2> partial3(P3 argument)```
Get a partially applied predicate with a fix third argument. This is the same as `partialRight(Object)` but more consistently named.
Parameters:
`argument` - value applied for third argument
Returns:
partially evaluated two argument predicate
• #### order231

```@NotNull
default Predicate3<P2,P3,P1> order231()```
Get a three argument predicate which expects the arguments in different order.
Returns:
predicate expecting the arguments in order arg2, arg3, arg1
• #### order312

```@NotNull
default Predicate3<P3,P1,P2> order312()```
Get a three argument predicate which expects the arguments in different order.
Returns:
predicate expecting the arguments in order arg3, arg1, arg2
• #### order321

```@NotNull
default Predicate3<P3,P2,P1> order321()```
Get a three argument predicate which expects the arguments in different order.
Returns:
predicate expecting the arguments in order arg3, arg2, arg1
• #### order132

```@NotNull
default Predicate3<P1,P3,P2> order132()```
Get a three argument predicate which expects the arguments in different order.
Returns:
predicate expecting the arguments in order arg1, arg3, arg2
• #### order213

```@NotNull
default Predicate3<P2,P1,P3> order213()```
Get a three argument predicate which expects the arguments in different order.
Returns:
predicate expecting the arguments in order arg2, arg1, arg3
• #### alwaysTrue

```@NotNull
static <T1,T2,T3> Predicate3<T1,T2,T3> alwaysTrue()```
Get a predicate which always evaluates to `true`.
Type Parameters:
`T1` - type of first predicate parameter
`T2` - type of second predicate parameter
`T3` - type of third predicate parameter
Returns:
predicate always returning `true`
• #### alwaysFalse

```@NotNull
static <T1,T2,T3> Predicate3<T1,T2,T3> alwaysFalse()```
Get a predicate which always evaluates to `false`.
Type Parameters:
`T1` - type of first predicate parameter
`T2` - type of second predicate parameter
`T3` - type of third predicate parameter
Returns:
predicate always returning `false`
• #### and

```@NotNull
static <T1,T2,T3> Predicate3<T1,T2,T3> and(@NotNull
Predicate3<? super T1,? super T2,? super T3> pred1,
@NotNull
Predicate3<? super T1,? super T2,? super T3> 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
Parameters:
`pred1` - first predicate
`pred2` - second predicate
Returns:
combination of both predicates with logical and
`and(Predicate3)`
• #### or

```@NotNull
static <T1,T2,T3> Predicate3<T1,T2,T3> or(@NotNull
Predicate3<? super T1,? super T2,? super T3> pred1,
@NotNull
Predicate3<? super T1,? super T2,? super T3> 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
Parameters:
`pred1` - first predicate
`pred2` - second predicate
Returns:
combination of both predicates with logical or
`or(Predicate3)`
• #### xor

```@NotNull
static <T1,T2,T3> Predicate3<T1,T2,T3> xor(@NotNull
Predicate3<? super T1,? super T2,? super T3> pred1,
@NotNull
Predicate3<? super T1,? super T2,? super T3> 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
Parameters:
`pred1` - first predicate
`pred2` - second predicate
Returns:
combination of both predicates with logical exclusive or
`xor(Predicate3)`