Predicates (durian 3.4.0 API)

java.lang.Object
- com.diffplug.common.base.Predicates

```
public final class Predicates
extends Object
```
Helper functions for manipulating Predicate, copied from Guava.
The function signatures below are identical to Google's Guava 18.0, except that guava's functional interfaces have been swapped with Java 8's. It is tested against the same test suite as Google Guava to ensure functional compatibility.
Most of the implementation has been replaced with lambdas, which means that the following functionality has been removed: equals(), hashCode(), toString(), GWT, and serialization.
Lambdas don't support these methods, and there isn't much reason why they should, so we removed them in Durian.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Predicate<T>`	`alwaysFalse()` Returns a predicate that always evaluates to `false`.
`static <T> Predicate<T>`	`alwaysTrue()` Returns a predicate that always evaluates to `true`.
`static <T> Predicate<T>`	`and(Iterable<? extends Predicate<? super T>> components)` Returns a predicate that evaluates to `true` if each of its components evaluates to `true`.
`static <T> Predicate<T>`	`and(Predicate<? super T>... components)` Returns a predicate that evaluates to `true` if each of its components evaluates to `true`.
`static <T> Predicate<T>`	`and(Predicate<? super T> first, Predicate<? super T> second)` Returns a predicate that evaluates to `true` if both of its components evaluate to `true`.
`static Predicate<Class<?>>`	`assignableFrom(Class<?> clazz)` Returns a predicate that evaluates to `true` if the class being tested is assignable from the given class.
`static <A,B> Predicate<A>`	`compose(Predicate<B> predicate, Function<A,? extends B> function)` Returns the composition of a function and a predicate.
`static Predicate<CharSequence>`	`contains(Pattern pattern)` Returns a predicate that evaluates to `true` if the `CharSequence` being tested contains any match for the given regular expression pattern.
`static Predicate<CharSequence>`	`containsPattern(String pattern)` Returns a predicate that evaluates to `true` if the `CharSequence` being tested contains any match for the given regular expression pattern.
`static <T> Predicate<T>`	`equalTo(T target)` Returns a predicate that evaluates to `true` if the object being tested `equals()` the given target or both are null.
`static <T> Predicate<T>`	`in(Collection<? extends T> target)` Returns a predicate that evaluates to `true` if the object reference being tested is a member of the given collection.
`static Predicate<Object>`	`instanceOf(Class<?> clazz)` Returns a predicate that evaluates to `true` if the object being tested is an instance of the given class.
`static <T> Predicate<T>`	`isNull()` Returns a predicate that evaluates to `true` if the object reference being tested is null.
`static <T> Predicate<T>`	`not(Predicate<T> predicate)` Returns a predicate that evaluates to `true` if the given predicate evaluates to `false`.
`static <T> Predicate<T>`	`notNull()` Returns a predicate that evaluates to `true` if the object reference being tested is not null.
`static <T> Predicate<T>`	`or(Iterable<? extends Predicate<? super T>> components)` Returns a predicate that evaluates to `true` if any one of its components evaluates to `true`.
`static <T> Predicate<T>`	`or(Predicate<? super T>... components)` Returns a predicate that evaluates to `true` if any one of its components evaluates to `true`.
`static <T> Predicate<T>`	`or(Predicate<? super T> first, Predicate<? super T> second)` Returns a predicate that evaluates to `true` if either of its components evaluates to `true`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - alwaysTrue
```
public static <T> Predicate<T> alwaysTrue()
```
    Returns a predicate that always evaluates to true.
  - alwaysFalse
```
public static <T> Predicate<T> alwaysFalse()
```
    Returns a predicate that always evaluates to false.
  - isNull
```
public static <T> Predicate<T> isNull()
```
    Returns a predicate that evaluates to true if the object reference being tested is null.
  - notNull
```
public static <T> Predicate<T> notNull()
```
    Returns a predicate that evaluates to true if the object reference being tested is not null.
  - not
```
public static <T> Predicate<T> not(Predicate<T> predicate)
```
    Returns a predicate that evaluates to true if the given predicate evaluates to false.
  - and
```
public static <T> Predicate<T> and(Iterable<? extends Predicate<? super T>> components)
```
    Returns a predicate that evaluates to true if each of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found. It defensively copies the iterable passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to true.
  - and
```
@SafeVarargs
public static <T> Predicate<T> and(Predicate<? super T>... components)
```
    Returns a predicate that evaluates to true if each of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found. It defensively copies the array passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to true.
  - and
```
public static <T> Predicate<T> and(Predicate<? super T> first,
                                   Predicate<? super T> second)
```
    Returns a predicate that evaluates to true if both of its components evaluate to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a false predicate is found.
  - or
```
public static <T> Predicate<T> or(Iterable<? extends Predicate<? super T>> components)
```
    Returns a predicate that evaluates to true if any one of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found. It defensively copies the iterable passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to false.
  - or
```
@SafeVarargs
public static <T> Predicate<T> or(Predicate<? super T>... components)
```
    Returns a predicate that evaluates to true if any one of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found. It defensively copies the array passed in, so future changes to it won't alter the behavior of this predicate. If components is empty, the returned predicate will always evaluate to false.
  - or
```
public static <T> Predicate<T> or(Predicate<? super T> first,
                                  Predicate<? super T> second)
```
    Returns a predicate that evaluates to true if either of its components evaluates to true. The components are evaluated in order, and evaluation will be "short-circuited" as soon as a true predicate is found.
  - equalTo
```
public static <T> Predicate<T> equalTo(@Nullable
                                       T target)
```
    Returns a predicate that evaluates to true if the object being tested equals() the given target or both are null.
  - instanceOf
```
public static Predicate<Object> instanceOf(Class<?> clazz)
```
    Returns a predicate that evaluates to true if the object being tested is an instance of the given class. If the object being tested is null this predicate evaluates to false.
  - assignableFrom
```
public static Predicate<Class<?>> assignableFrom(Class<?> clazz)
```
    Returns a predicate that evaluates to true if the class being tested is assignable from the given class. The returned predicate does not allow null inputs.
    
    Since:
    
    10.0
  - in
```
public static <T> Predicate<T> in(Collection<? extends T> target)
```
    Returns a predicate that evaluates to true if the object reference being tested is a member of the given collection. It does not defensively copy the collection passed in, so future changes to it will alter the behavior of the predicate.
    This method can technically accept any Collection<?>, but using a typed collection helps prevent bugs. This approach doesn't block any potential users since it is always possible to use Predicates.<Object>in().
    
    Parameters:
    
    target - the collection that may contain the function input
  - compose
```
public static <A,B> Predicate<A> compose(Predicate<B> predicate,
                                         Function<A,? extends B> function)
```
    Returns the composition of a function and a predicate. For every x, the generated predicate returns predicate(function(x)).
    
    Returns:
    
    the composition of the provided function and predicate
  - containsPattern
```
public static Predicate<CharSequence> containsPattern(String pattern)
```
    Returns a predicate that evaluates to true if the CharSequence being tested contains any match for the given regular expression pattern. The test used is equivalent to Pattern.compile(pattern).matcher(arg).find()
    
    Throws:
    
    PatternSyntaxException - if the pattern is invalid
    
    Since:
    
    3.0
  - contains
```
public static Predicate<CharSequence> contains(Pattern pattern)
```
    Returns a predicate that evaluates to true if the CharSequence being tested contains any match for the given regular expression pattern. The test used is equivalent to pattern.matcher(arg).find()
    
    Since:
    
    3.0

com.diffplug.durian:durian:3.4.0 by DiffPlug

Class Predicates

Method Summary

Methods inherited from class java.lang.Object

Method Detail

alwaysTrue

alwaysFalse

isNull

notNull

not

and

and

and

or

or

or

equalTo

instanceOf

assignableFrom

in

compose

containsPattern

contains

com.diffplug.durian:durian:3.4.0 by DiffPlug