PredicateUtil (commons-lang 1.2.13-SNAPSHOT API)

java.lang.Object
- de.unkrig.commons.lang.protocol.PredicateUtil

public final class PredicateUtil
extends Object

Various Predicate-related utility methods.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static Predicate<Object>`	`after(long expirationTime)` Deprecated. Use "`PredicateUtil.ignoreSubject(ProducerUtil.after(expirationTime))`" instead
`static <T> Predicate<T>`	`always()`
`static <T> Predicate<T>`	`always(boolean value)`
`static <T> Predicate<T>`	`and(boolean lhs, Predicate<? super T> rhs)` Returns a `Predicate` which evaluates to `true` iff both the `lhs` is `true` and the `rhs` evaluates to `true`.
`static <T> Predicate<T>`	`and(Predicate<? super T> lhs, boolean rhs)` Returns a `Predicate` which evaluates to `true` iff both the `rhs` is `true` and the `lhs` evaluates to `true`.
`static <T> Predicate<T>`	`and(Predicate<? super T> lhs, Predicate<? super T> rhs)` Returns a `Predicate` which evaluates to `true` iff both `lhs` and `rhs` evaluate to `true`.
`static <T,EX extends RuntimeException> Predicate<T>`	`asPredicate(PredicateWhichThrows<T,EX> source)` Converts a `PredicateWhichThrows` into a `Predicate`, which is possible iff the source's exception is a subclass of `RuntimeException` and the source's element type is a subclass of the target's element type.
`static <T,EX extends Throwable> PredicateWhichThrows<T,EX>`	`asPredicateWhichThrows(Predicate<? super T> source)` Converts a `Predicate` into a `PredicateWhichThrows`, which is possible iff the source's element type is a subclass of the target's element type.
`static <T> Predicate<T>`	`atMostEvery(long milliseconds)` Deprecated. Use "`PredicateUtil.ignoreSubject(ProducerUtil.atMostEvery(milliseconds))`" instead
`static <C extends Comparable<C>> Predicate<C>`	`between(C min, C max)`
`static <T> Predicate<T>`	`contains(Collection<? extends T> collection)`
`static <K> Predicate<K>`	`containsKey(Map<K,?> map)`
`static <K> Predicate<K>`	`containsKey(Mapping<K,?> mapping)`
`static <C extends Comparable<C>> Predicate<C>`	`equal(C other)`
`static <T> Predicate<T>`	`equal(T other)` Value equality, as opposed to arithmetical equality.
`static <T extends Predicate<String>> T`	`forString(String format, T delegate)` Returns a predicate that evaluates the `format` against the `delegate` after each "*" in the `format` has been replaced with the subject.
`static <C extends Comparable<C>> Predicate<C>`	`greater(C other)`
`static <C extends Comparable<C>> Predicate<C>`	`greaterEqual(C other)`
`static <T,EX extends Throwable> Predicate<T>`	`ignoreExceptions(Class<EX> exceptionClass, PredicateWhichThrows<T,EX> delegate, boolean defaultValue)` Wraps the `delegate` such that its declared exception is caught, ignored, and the `defaultValue` is returned.
`static <T,EX extends Throwable> Predicate<T>`	`ignoreSubject(Producer<Boolean> delegate)`
`static <T,EX extends Throwable> PredicateWhichThrows<T,EX>`	`ignoreSubject(ProducerWhichThrows<Boolean,EX> delegate)`
`static <C extends Comparable<C>> Predicate<C>`	`less(C other)`
`static <C extends Comparable<C>> Predicate<C>`	`lessEqual(C other)`
`static <T> Predicate<T>`	`never()`
`static <T> Predicate<T>`	`not(boolean value)` Shorthand for "`always(value)`".
`static <T> Predicate<T>`	`not(Predicate<? super T> delegate)`
`static <C extends Comparable<C>> Predicate<C>`	`notEqual(C other)`
`static <T> Predicate<T>`	`notEqual(T other)` Value inequality.
`static <T> Predicate<T>`	`or(boolean lhs, Predicate<? super T> rhs)` Returns a `Predicate` which evaluates to `true` if the `lhs` is `true`, or the `rhs` evaluates to `true`, or both.
`static <T> Predicate<T>`	`or(Predicate<? super T> lhs, boolean rhs)` Returns a `Predicate` which evaluates to `true` the `lhs` evaluates to `true`, or the `rhs` is `true`, or both.
`static <T> Predicate<T>`	`or(Predicate<? super T> lhs, Predicate<? super T> rhs)` Returns `Predicate` which evaluates to `true` if `lhs`, or `rhs`, or both evaluate to `true`.
`static <T,EX extends Throwable> PredicateWhichThrows<? super T,? extends EX>`	`or(PredicateWhichThrows<? super T,? extends EX> lhs, PredicateWhichThrows<? super T,? extends EX> rhs)` Returns `Predicate` which evaluates to `true` if `lhs`, or `rhs`, or both evaluate to `true`.
`static <T,EX extends Throwable> PredicateWhichThrows<T,EX>`	`synchronizedPredicate(PredicateWhichThrows<? super T,EX> delegate)` Creates and returns a proxy to the `delegate` with a synchronized `evaluate()` method.
`static <T> Predicate<T>`	`xor(boolean lhs, Predicate<? super T> rhs)`
`static <T> Predicate<T>`	`xor(Predicate<? super T> lhs, boolean rhs)`
`static <T> Predicate<T>`	`xor(Predicate<? super T> lhs, Predicate<? super T> rhs)`

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

- Method Detail
  - always
```
public static <T> Predicate<T> always(boolean value)
```
    Returns:
    
    A Predicate which evaluates to the value (regardless of the subject)
  - always
```
public static <T> Predicate<T> always()
```
    Returns:
    
    A Predicate which evaluates to true (regardless of the subject)
  - never
```
public static <T> Predicate<T> never()
```
    Returns:
    
    A Predicate which evaluates to false (regardless of the subject)
  - atMostEvery
```
@Deprecated
public static <T> Predicate<T> atMostEvery(long milliseconds)
```
    Deprecated. Use "PredicateUtil.ignoreSubject(ProducerUtil.atMostEvery(milliseconds))" instead
    
    Creates and returns a Predicate for which the first evaluation will yield true, and, after that, the time interval between adjacent true evaluations will (A) be minimal and (B) never shorter than milliseconds.
  - and
```
public static <T> Predicate<T> and(Predicate<? super T> lhs,
                                   Predicate<? super T> rhs)
```
    Returns a Predicate which evaluates to true iff both lhs and rhs evaluate to true.
    Notice that iff either of the lhs and the rhs is never(), then none of the two will ever be evaluated.
  - and
```
public static <T> Predicate<T> and(Predicate<? super T> lhs,
                                   boolean rhs)
```
    Returns a Predicate which evaluates to true iff both the rhs is true and the lhs evaluates to true.
    Notice that iff the rhs is false, then the lhs will ever be evaluated.
  - and
```
public static <T> Predicate<T> and(boolean lhs,
                                   Predicate<? super T> rhs)
```
    Returns a Predicate which evaluates to true iff both the lhs is true and the rhs evaluates to true.
    Notice that iff the lhs is false, then the rhs will ever be evaluated.
  - or
```
public static <T> Predicate<T> or(Predicate<? super T> lhs,
                                  Predicate<? super T> rhs)
```
    Returns Predicate which evaluates to true if lhs, or rhs, or both evaluate to true.
    Notice that iff either of the lhs and the rhs is always(), then none of the two will ever be evaluated.
  - or
```
public static <T,EX extends Throwable> PredicateWhichThrows<? super T,? extends EX> or(PredicateWhichThrows<? super T,? extends EX> lhs,
                                                                                       PredicateWhichThrows<? super T,? extends EX> rhs)
```
    Returns Predicate which evaluates to true if lhs, or rhs, or both evaluate to true.
    Notice that iff either of the lhs and the rhs is always(), then none of the two will ever be evaluated.
  - or
```
public static <T> Predicate<T> or(Predicate<? super T> lhs,
                                  boolean rhs)
```
    Returns a Predicate which evaluates to true the lhs evaluates to true, or the rhs is true, or both.
    Notice that iff the rhs is true, then the lhs will ever be evaluated.
  - or
```
public static <T> Predicate<T> or(boolean lhs,
                                  Predicate<? super T> rhs)
```
    Returns a Predicate which evaluates to true if the lhs is true, or the rhs evaluates to true, or both.
    Notice that iff the lhs is true, then the rhs will ever be evaluated.
  - xor
```
public static <T> Predicate<T> xor(Predicate<? super T> lhs,
                                   Predicate<? super T> rhs)
```
    Returns:
    
    A Predicate which evaluates to true iff exactly one of lhs or rhs evaluate to true
  - xor
```
public static <T> Predicate<T> xor(Predicate<? super T> lhs,
                                   boolean rhs)
```
    Returns:
    
    A Predicate which evaluates to true iff either the lhs evaluates to true and rhs is false, or the lhs evaluates to false and rhs is true
  - xor
```
public static <T> Predicate<T> xor(boolean lhs,
                                   Predicate<? super T> rhs)
```
    Returns:
    
    A Predicate which evaluates to true iff either lhs is true and the rhs evaluates to false, or the lhs is false and the rhs evaluates to true
  - not
```
public static <T> Predicate<T> not(Predicate<? super T> delegate)
```
    Returns:
    
    A Predicate which evaluates to true iff the delegate evaluates to false
  - not
```
public static <T> Predicate<T> not(boolean value)
```
    Shorthand for "always(value)".
    
    Returns:
    
    A Predicate which evaluates to the negation of the value (regardless of the subject)
  - less
```
public static <C extends Comparable<C>> Predicate<C> less(C other)
```
    Returns:
    
    A Predicate which evaluates to true for any subject that is less than the other
  - lessEqual
```
public static <C extends Comparable<C>> Predicate<C> lessEqual(C other)
```
    Returns:
    
    A Predicate which evaluates to true for any given subject that is less than or equal to the other
  - greater
```
public static <C extends Comparable<C>> Predicate<C> greater(C other)
```
    Returns:
    
    A Predicate which evaluates to true for any given subject that is greater than the other
  - greaterEqual
```
public static <C extends Comparable<C>> Predicate<C> greaterEqual(C other)
```
    Returns:
    
    A Predicate which evaluates to true for any given subject that is greater than or equal to the other
  - equal
```
public static <C extends Comparable<C>> Predicate<C> equal(C other)
```
    Returns:
    
    A Predicate which evaluates to true for any given subject that is (arithmetically) equal to the other
    
    See Also:
    
    Comparable.compareTo(Object)
  - notEqual
```
public static <C extends Comparable<C>> Predicate<C> notEqual(C other)
```
    Returns:
    
    A Predicate which evaluates to true for any given subject that is (arithmetically) not equal to the other
    
    See Also:
    
    Comparable.compareTo(Object)
  - between
```
public static <C extends Comparable<C>> Predicate<C> between(C min,
                                                             C max)
```
    Returns:
    
    A predicate that evaluates to "min <= subject <= max", or, if min > max, to "subject >= min || subject <= max"
  - equal
```
public static <T> Predicate<T> equal(T other)
```
    Value equality, as opposed to arithmetical equality.
    
    See Also:
    
    equal(Comparable)
  - notEqual
```
public static <T> Predicate<T> notEqual(T other)
```
    Value inequality.
  - after
```
@Deprecated
public static Predicate<Object> after(long expirationTime)
```
    Deprecated. Use "PredicateUtil.ignoreSubject(ProducerUtil.after(expirationTime))" instead
    
    Returns a "Predicate<Object>" that evaluates to true iff the current time is after the given expirationTime (in milliseconds).
    (The returned predicate ignores its subject argument.)
    
    Parameters:
    
    expirationTime - Milliseconds since Jan 1 1970, UTC
  - forString
```
public static <T extends Predicate<String>> T forString(String format,
                                                        T delegate)
```
    Returns a predicate that evaluates the format against the delegate after each "*" in the format has been replaced with the subject.
  - asPredicateWhichThrows
```
public static <T,EX extends Throwable> PredicateWhichThrows<T,EX> asPredicateWhichThrows(Predicate<? super T> source)
```
    Converts a Predicate into a PredicateWhichThrows, which is possible iff the source's element type is a subclass of the target's element type.
    
    Type Parameters:
    
    T - The subject type
    
    EX - The target predicate's exception
  - asPredicate
```
public static <T,EX extends RuntimeException> Predicate<T> asPredicate(PredicateWhichThrows<T,EX> source)
```
    Converts a PredicateWhichThrows into a Predicate, which is possible iff the source's exception is a subclass of RuntimeException and the source's element type is a subclass of the target's element type.
    
    Type Parameters:
    
    T - The predicate subject type
    
    EX - The source predicate's exception
  - contains
```
public static <T> Predicate<T> contains(Collection<? extends T> collection)
```
    Returns:
    
    A predicate which checks whether the given collection contains the subject
  - containsKey
```
public static <K> Predicate<K> containsKey(Map<K,?> map)
```
    Returns:
    
    A Predicate that evaluates to true iff the map contains a key equal to the predicate subject
  - containsKey
```
public static <K> Predicate<K> containsKey(Mapping<K,?> mapping)
```
    Returns:
    
    A Predicate that evaluates to true iff the mapping contains a key equal to the predicate subject
  - ignoreSubject
```
public static <T,EX extends Throwable> PredicateWhichThrows<T,EX> ignoreSubject(ProducerWhichThrows<Boolean,EX> delegate)
```
    Returns:
    
    A predicate which, when evaluated, ignores its subject, and returns the next product of the delegate
  - ignoreSubject
```
public static <T,EX extends Throwable> Predicate<T> ignoreSubject(Producer<Boolean> delegate)
```
    Returns:
    
    A predicate which, when evaluated, ignores its subject, and returns the next product of the delegate
  - ignoreExceptions
```
public static <T,EX extends Throwable> Predicate<T> ignoreExceptions(Class<EX> exceptionClass,
                                                                     PredicateWhichThrows<T,EX> delegate,
                                                                     boolean defaultValue)
```
    Wraps the delegate such that its declared exception is caught, ignored, and the defaultValue is returned.
  - synchronizedPredicate
```
public static <T,EX extends Throwable> PredicateWhichThrows<T,EX> synchronizedPredicate(PredicateWhichThrows<? super T,EX> delegate)
```
    Creates and returns a proxy to the delegate with a synchronized evaluate() method.
    
    See Also:
    
    PredicateWhichThrows

Class PredicateUtil

Method Summary

Methods inherited from class java.lang.Object

Method Detail

always

always

never

atMostEvery

and

and

and

or

or

or

or

xor

xor

xor

not

not

less

lessEqual

greater

greaterEqual

equal

notEqual

between

equal

notEqual

after

forString

asPredicateWhichThrows

asPredicate

contains

containsKey

containsKey

ignoreSubject

ignoreSubject

ignoreExceptions

synchronizedPredicate