Requirements (Requirement 1.2 API)

java.lang.Object
- org.granitesoft.requirement.Requirements

```
public final class Requirements
extends Object
```
Utility for making generalized requirements. A thorough understanding of "lambda"'s is very helpful, but not strictly required. See https://github.com/ericgoffster/requirement.
This code licensed under Mozilla Public License Version 2.0.
The primary place to start is here: require(Object, Predicate)

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Predicate<T>`	`and(Predicate<T> p1, Predicate<T> p2)` Returns a predicate that is the "and" of `p1` and `p2`.
`static <T,U> Predicate<T>`	`chain(Function<T,U> f, Predicate<U> p)` Returns a predicate for the test of `f(o)`.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`contains(E val)` Returns a predicate that checks for its collection to contain `val`.
`static <K,V,T extends Map<? extends K,? extends V>> Predicate<T>`	`containsKey(K key)` Returns a predicate that checks for its map to contain `key`.
`static <T extends Comparable<T>> Predicate<T>`	`eq(T val)` Returns a predicate that checks for its object to be `== val` (via numerical sense).
`static Predicate<boolean[]>`	`equalTo(boolean[] arr)` Returns a predicate that checks for its boolean[] object to be `== arr` (using Arrays.equals).
`static Predicate<byte[]>`	`equalTo(byte[] arr)` Returns a predicate that checks for its byte[] object to be `== arr` (using Arrays.equals).
`static Predicate<char[]>`	`equalTo(char[] arr)` Returns a predicate that checks for its char[] object to be `== arr` (using Arrays.equals).
`static Predicate<double[]>`	`equalTo(double[] arr)` Returns a predicate that checks for its double[] object to be `== arr` (using Arrays.equals).
`static <E> Predicate<E[]>`	`equalTo(E[] arr)` Returns a predicate that checks for its Object[] object to be `== arr` (using Arrays.deepEquals).
`static Predicate<float[]>`	`equalTo(float[] arr)` Returns a predicate that checks for its float[] object to be `== arr` (using Arrays.equals).
`static Predicate<int[]>`	`equalTo(int[] arr)` Returns a predicate that checks for its int[] object to be `== arr` (using Arrays.equals).
`static Predicate<long[]>`	`equalTo(long[] arr)` Returns a predicate that checks for its long[] object to be `== arr` (using Arrays.equals).
`static Predicate<short[]>`	`equalTo(short[] arr)` Returns a predicate that checks for its short[] object to be `== arr` (using Arrays.equals).
`static <T> Predicate<T>`	`equalTo(T val)` Returns a predicate that checks for its Object object to be `== arr` (using equals).
`static <T extends Comparable<T>> Predicate<T>`	`ge(T val)` Returns a predicate that checks for its object to be `>= val`.
`static <T extends Comparable<T>> Predicate<T>`	`gt(T val)` Returns a predicate that checks for its object to be `> val`.
`static <T> Function<T,Integer>`	`hash()` Returns the Object::hashCode function named "hash".
`static <K,V,T extends Map<? extends K,? extends V>> Function<T,Set<? extends K>>`	`keySet()` Returns the Map::keySet function named "keys".
`static <T extends Comparable<T>> Predicate<T>`	`le(T val)` Returns a predicate that checks for its object to be `<= val`.
`static Function<String,Integer>`	`length()` Returns the String::length function named "length".
`static <T extends Comparable<T>> Predicate<T>`	`lt(T val)` Returns a predicate that checks for its object to be `< val`.
`static <K,V,T extends Map<? extends K,? extends V>> Predicate<T>`	`mapNotEmpty()` Returns a predicate that checks for its map to be not empty.
`static <K,V,T extends Map<? extends K,? extends V>> Function<T,Integer>`	`mapSize()` Returns the Map::size function named "size".
`static Predicate<String>`	`matches(Pattern p)` Returns a predicate that checks for its string argument to match `p`.
`static Predicate<String>`	`matches(String p)` Returns a predicate that checks for its string argument to match `p`.
`static Predicate<String>`	`maxLength(int n)` Returns a predicate that checks for its string argument to have a length `<= n`.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`maxSize(int n)` Returns a predicate that checks for its collection to have a size `<= n`.
`static <T> Predicate<T>`	`memberOf(Collection<? extends T> coll)` Returns a predicate that checks for its object to be a member of `coll`.
`static <T> Predicate<T>`	`memberOf(T... arr)` Returns a predicate that checks for its object to be a member of `arr`.
`static Predicate<String>`	`minLength(int n)` Returns a predicate that checks for its string argument to have a length `>= n`.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`minSize(int n)` Returns a predicate that checks for its collection to have a size `>= n`.
`static <T> Predicate<T>`	`name(Predicate<T> pred, Supplier<String> msg)` Add a toString to `pred`.
`static <T,U> Function<T,U>`	`nameF(Function<T,U> f, Supplier<String> msg)` Adds a toString to a predicate.
`static <T extends Comparable<T>> Predicate<T>`	`ne(T val)` Returns a predicate that checks for its object to be `!= val` (via numerical sense).
`static <T> Predicate<T>`	`negate(Predicate<T> p)` Returns a predicate that is the "not" of `p`.
`static Predicate<String>`	`notBlank()` Returns a predicate that checks for its string argument to be not blank.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`notEmpty()` Returns a predicate that checks for its collection based argument to be not empty.
`static <T> Predicate<T>`	`notNull()` Returns a predicate that checks for its argument to be not null.
`static <T> Predicate<T>`	`or(Predicate<T> p1, Predicate<T> p2)` Returns a predicate that is the "or" of `p1` and `p2`.
`static <T> T`	`require(T obj, Predicate<T> validator)` Performs a test on the argument, returning that argument if it succeeds, throwing an `IllegalArgumentException` if it fails.
`static <T,EX extends Exception> T`	`require(T obj, Predicate<T> validator, BiFunction<T,Predicate<T>,EX> ex)` Performs a test on the argument, returning that argument if it succeeds, but throwing a user supplied exception if it fails.
`static <T> T`	`require(T obj, Predicate<T> validator, Supplier<String> msg)` Performs a test on the argument, returning that argument if it succeeds, but throwing an `IllegalArgumentException` if it fails.
`static <T> Predicate<T>`	`same(T val)` Returns a predicate that checks for its object to be `== val` (using pointer equality).
`static <E,T extends Collection<? extends E>> Function<T,Integer>`	`size()` Returns the Collection::size function named "size".
`static <T> Function<T,String>`	`stringify()` Returns the Object::toString function named "toString".
`static <E,T extends Collection<? extends E>> Predicate<T>`	`subSetOf(Collection<? extends E> coll)` Returns a predicate that checks for its collection to be a subset of `coll`.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`subSetOf(E... arr)` Returns a predicate that checks for its collection to be a subset of `arr`.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`superSetOf(Collection<? extends E> coll)` Returns a predicate that checks for its collection to be a superset of `coll`.
`static <E,T extends Collection<? extends E>> Predicate<T>`	`superSetOf(E... arr)` Returns a predicate that checks for its collection to be a superset of `arr`.
`static <K,V,T extends Map<? extends K,? extends V>> Function<T,Collection<? extends V>>`	`values()` Returns the Map::values function named "values".

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

Method Detail

require

public static <T,EX extends Exception> T require(T obj,
                                                 Predicate<T> validator,
                                                 BiFunction<T,Predicate<T>,EX> ex)
                                          throws EX extends Exception

Performs a test on the argument, returning that argument if it succeeds, but throwing a user supplied exception if it fails. This is the most general form of "require".

 Example:
     Require.require(null,  Require.notNull(), (o, v) -> new MyException()) # throws MyException
     Require.require("abc", Require.notNull(), (o, v) -> new MyException()) == "abc"

Type Parameters:: T - The type of the object being tested; EX - The type of the exception that could be thrown.
Parameters:: obj - The object to verify - Can be null; validator - The predicate that must succeed - Can't be null; ex - The Exception supplier - Can't be null
Returns:: The verified object
Throws:: EX - if the test fails; EX extends Exception

require
```
public static <T> T require(T obj,
                            Predicate<T> validator,
                            Supplier<String> msg)
```
Performs a test on the argument, returning that argument if it succeeds, but throwing an IllegalArgumentException if it fails. A specified prefix is prepended to the beginning of the message in that exception.
```
 Example:
     Require.require(null,  Require.notNull(), () -> "someobj") # throws IllegalArgumentException("someobj: Must not be null")
     Require.require("abc", Require.notNull(), () -> "someobj") == "abc"
 
```
Type Parameters:

T - The type of the object being tested

Parameters:

obj - The object to verify - Can be null

validator - The predicate that must succeed - Can't be null - Note that "toString" on this predicate will be called. To make this predicate have a toString, use name(Predicate)

msg - The supplier of the additional message to prepend - Can't be null

Returns:

The verified object

Throws:

IllegalArgumentException - if the test fails

require
```
public static <T> T require(T obj,
                            Predicate<T> validator)
```
Performs a test on the argument, returning that argument if it succeeds, throwing an IllegalArgumentException if it fails.
```
 Example:
     Require.require(null,  Require.notNull()) # throws IllegalArgumentException("Must not be null")
     Require.require("abc", Require.notNull())  == "abc"
 
```
Type Parameters:

T - The type of the object being tested

Parameters:

obj - The object to verify - Can be null

validator - The predicate that must succeed - Can't be null - Note that "toString" on this predicate will be called. To make this predicate have a toString, use name(Predicate)

Returns:

The verified object

Throws:

IllegalArgumentException - if the test fails

notNull

public static <T> Predicate<T> notNull()

Returns a predicate that checks for its argument to be not null.

 Example:
     Require.require(null,  Require.notNull()) # throws IllegalArgumentException("Must not be null")
     Require.require("abc", Require.notNull())  == "abc"

Type Parameters:: T - The type of the object being tested
Returns:: A predicate that checks for its argument to be not null

notBlank

public static Predicate<String> notBlank()

Returns a predicate that checks for its string argument to be not blank. A string must be non-null and have a length > 0 to satisfy the condition.

 Example:
     Require.require(null,  Require.notBlank()) # throws IllegalArgumentException("Must not be blank")
     Require.require("",    Require.notBlank()) # throws IllegalArgumentException("Must not be blank")
     Require.require("abc", Require.notBlank())  == "abc"

Returns:: A predicate that checks for its string argument to be not blank

minLength

public static Predicate<String> minLength(int n)

Returns a predicate that checks for its string argument to have a length >= n. A string must be non-null and have a length of at least "n" to satisfy the condition.

 Example:
     Require.require(null,  Require.minLength(2)) # throws IllegalArgumentException("Must have a length of at least 2")
     Require.require("",    Require.minLength(2)) # throws IllegalArgumentException("Must have a length of at least 2")
     Require.require("ab",  Require.minLength(2))  == "ab"
     Require.require("abc", Require.minLength(2))  == "abc"

Parameters:: n - The minimum length - Must be >= 0
Returns:: A predicate that checks for its string argument to have a length >= n

maxLength

public static Predicate<String> maxLength(int n)

Returns a predicate that checks for its string argument to have a length <= n. A string must be non-null and have a length of at most "n" to satisfy the condition.

 Example:
     Require.require(null,  Require.maxLength(2)) # throws IllegalArgumentException("Must have a length of at most 2")
     Require.require("",    Require.maxLength(2)) == ""
     Require.require("ab",  Require.maxLength(2))  == "ab"
     Require.require("abc", Require.maxLength(2)) # throws IllegalArgumentException("Must have a length of at most 2")

Parameters:: n - The maximum length - Must be >= 0
Returns:: A predicate that checks for its string argument to have a length <= n

matches

public static Predicate<String> matches(Pattern p)

Returns a predicate that checks for its string argument to match p. A string must be non-null and match the pattern to satisfy the condition.

 Example:
     Require.require(null,     Require.matches(Pattern.compile("\\d+"))) # throws IllegalArgumentException("Must match \d+")
     Require.require("",       Require.matches(Pattern.compile("\\d+"))) # throws IllegalArgumentException("Must match \d+")
     Require.require("1",      Require.matches(Pattern.compile("\\d+")))  == "1"
     Require.require("123",    Require.matches(Pattern.compile("\\d+")))  == "123"
     Require.require("abc123", Require.matches(Pattern.compile("\\d+"))) # throws IllegalArgumentException("Must match \d+")

Parameters:: p - The pattern - Can't be null
Returns:: A predicate that checks for its string argument to match p

matches

public static Predicate<String> matches(String p)

Returns a predicate that checks for its string argument to match p. A string must be non-null and match the pattern to satisfy the condition.

 Example:
     Require.require(null,     Require.matches("\\d+")) # throws IllegalArgumentException("Must match \d+")
     Require.require("",       Require.matches("\\d+")) # throws IllegalArgumentException("Must match \d+")
     Require.require("1",      Require.matches("\\d+"))  == "1"
     Require.require("123",    Require.matches("\\d+"))  == "123"
     Require.require("abc123", Require.matches("\\d+")) # throws IllegalArgumentException("Must match \d+")

Parameters:: p - The pattern - Can't be null
Returns:: A predicate that checks for its string argument to match p

notEmpty

public static <E,T extends Collection<? extends E>> Predicate<T> notEmpty()

Returns a predicate that checks for its collection based argument to be not empty. A collection must be non-null and have a size > 0 to satisfy the condition.

 Example:
     Require.require(null,   Require.notEmpty()) # throws IllegalArgumentException("Must not be empty")
     Require.require([],     Require.notEmpty()) # throws IllegalArgumentException("Must not be empty")
     Require.require([1, 2], Require.notEmpty()) == [1, 2]

Type Parameters:: E - The type of the elements of the collection; T - The Collection type of the object being tested
Returns:: A predicate that checks for its collection based argument to be not empty

contains

public static <E,T extends Collection<? extends E>> Predicate<T> contains(E val)

Returns a predicate that checks for its collection to contain val. A collection must be non-null and contain the given object to satisfy the condition.

 Example:
     Require.require(null,   Require.contains(1)) # throws IllegalArgumentException("Must contain 1")
     Require.require([],     Require.contains(1)) # throws IllegalArgumentException("Must contain 1")
     Require.require([2, 3], Require.contains(1)) # throws IllegalArgumentException("Must contain 1")
     Require.require([1, 2], Require.contains(1)) == [1]

Type Parameters:: E - The type of the elements of the collection.; T - The Collection type of the object being tested
Parameters:: val - The object the collection must contain - Can be null
Returns:: A predicate that checks for its collection to contain val

containsKey

public static <K,V,T extends Map<? extends K,? extends V>> Predicate<T> containsKey(K key)

Returns a predicate that checks for its map to contain key. A map must be non-null and contain the given key to satisfy the condition.

 Example:
     Require.require(null,             Require.containsKey(1)) # throws IllegalArgumentException("Must contain key 1")
     Require.require({},               Require.containsKey(1)) # throws IllegalArgumentException("Must contain key 1")
     Require.require({a => 1, b => 2}, Require.containsKey(c)) # throws IllegalArgumentException("Must contain 1")
     Require.require({a => 1, b => 2}, Require.containsKey(a)) == {a => 1, b => 2}

Type Parameters:: K - The type of the keys of the map.; V - The type of the values of the map.; T - The Map type of the object being tested
Parameters:: key - The key the map must contain - Can be null
Returns:: A predicate that checks for its map to contain key

mapNotEmpty

public static <K,V,T extends Map<? extends K,? extends V>> Predicate<T> mapNotEmpty()

Returns a predicate that checks for its map to be not empty. A map must be non-null and be not empty to satisfy the condition.

 Example:
     Require.require(null,             Require.mapNotEmpty()) # throws IllegalArgumentException("Must not be empty")
     Require.require({},               Require.mapNotEmpty()) # throws IllegalArgumentException("Must not be empty")
     Require.require({a => 1, b => 2}, Require.mapNotEmpty()) == {a => 1, b => 2}

Type Parameters:: K - The type of the keys of the map; V - The type of the values of the map; T - The Map type of the object being tested
Returns:: A predicate that checks for its map to be not empty

minSize

public static <E,T extends Collection<? extends E>> Predicate<T> minSize(int n)

Returns a predicate that checks for its collection to have a size >= n. A collection must be non-null and have a size of at least "n" to satisfy the condition.

 Example:
     Require.require(null,      Require.minSize(2)) # throws IllegalArgumentException("Must have a size of at least 2")
     Require.require([],        Require.minSize(2)) # throws IllegalArgumentException("Must have a size of at least 2")
     Require.require([1, 2],    Require.minSize(2)) == [1, 2]
     Require.require([1, 2, 3], Require.minSize(2))  == [1, 2, 3]

Type Parameters:: E - The element type of the collection; T - The type of the collection
Parameters:: n - The minimum size - Must be >= 0
Returns:: A predicate that checks for its collection to have a size >= n

maxSize

public static <E,T extends Collection<? extends E>> Predicate<T> maxSize(int n)

Returns a predicate that checks for its collection to have a size <= n. A collection must be non-null and have a size of at most "n" to satisfy the condition.

 Example:
     Require.require(null,      Require.maxSize(2)) # throws IllegalArgumentException("Must have a size of at most 2")
     Require.require([],        Require.maxSize(2)) == []
     Require.require([1, 2],    Require.maxSize(2)) == [1, 2]
     Require.require([1, 2, 3], Require.maxSize(2)) # throws IllegalArgumentException("Must have a size of at most 2")

Type Parameters:: E - The element type of the collection; T - The type of the collection
Parameters:: n - The maximum size - Must be >= 0
Returns:: A predicate that checks for its collection to have a size <= n

superSetOf

public static <E,T extends Collection<? extends E>> Predicate<T> superSetOf(Collection<? extends E> coll)

Returns a predicate that checks for its collection to be a superset of coll. A collection must be non-null and be a superset of the given collection to satisfy the condition.

 Example:
     Require.require(null,      Require.superSetOf([1, 2])) # throws IllegalArgumentException("Must be superset of [1, 2]")
     Require.require([],        Require.superSetOf([1, 2])) # throws IllegalArgumentException("Must be superset of [1, 2]")
     Require.require([1],       Require.superSetOf([1, 2])) # throws IllegalArgumentException("Must be superset of [1, 2]")
     Require.require([1, 2],    Require.superSetOf([1, 2])) == [1, 2]
     Require.require([1, 2, 3], Require.superSetOf([1, 2])) == [1, 2, 3]

Type Parameters:: E - The type of the elements of either collection.; T - The Collection type of the object being tested
Parameters:: coll - The collection to test against - Can't be null
Returns:: A predicate that checks for its collection to be a superset of coll

superSetOf

@SafeVarargs
public static <E,T extends Collection<? extends E>> Predicate<T> superSetOf(E... arr)

Returns a predicate that checks for its collection to be a superset of arr. A collection must be non-null and be a superset of the given collection to satisfy the condition.

 Example:
     Require.require(null,      Require.superSetOf(1, 2)) # throws IllegalArgumentException("Must be superset of [1, 2]")
     Require.require([],        Require.superSetOf(1, 2)) # throws IllegalArgumentException("Must be superset of [1, 2]")
     Require.require([1],       Require.superSetOf(1, 2)) # throws IllegalArgumentException("Must be superset of [1, ]}")
     Require.require([1, 2],    Require.superSetOf(1, 2)) == [1, 2]
     Require.require([1, 2, 3], Require.superSetOf(1, 2)) == [1, 2, 3]

Type Parameters:: E - The type of the elements of either collection.; T - The Collection type of the object being tested
Parameters:: arr - The collection to test against - Can't be null
Returns:: A predicate that checks for its collection to be a superset of arr

subSetOf

public static <E,T extends Collection<? extends E>> Predicate<T> subSetOf(Collection<? extends E> coll)

Returns a predicate that checks for its collection to be a subset of coll. A collection must be non-null and be a subset of the given collection to satisfy the condition.

 Example:
     Require.require(null,      Require.subSetOf([1, 2])) # throws IllegalArgumentException("Must be subset of [1, 2]")
     Require.require([],        Require.subSetOf([1, 2])) == []
     Require.require([1],       Require.subSetOf([1, 2])) == [1]
     Require.require([1, 2],    Require.subSetOf([1, 2])) == [1, 2]
     Require.require([1, 2, 3], Require.subSetOf([1, 2])) # throws IllegalArgumentException("Must be subset of [1, 2]")

Type Parameters:: E - The type of the elements of either collection.; T - The Collection type of the object being tested
Parameters:: coll - The collection to test against - Can't be null
Returns:: A predicate that checks for its collection to be a subset of coll

subSetOf

@SafeVarargs
public static <E,T extends Collection<? extends E>> Predicate<T> subSetOf(E... arr)

Returns a predicate that checks for its collection to be a subset of arr. A collection must be non-null and be a subset of the given collection to satisfy the condition.

 Example:
     Require.require(null,      Require.subSetOf(1, 2)) # throws IllegalArgumentException("Must be subset of [1, 2]")
     Require.require([],        Require.subSetOf(1, 2)) == []
     Require.require([1],       Require.subSetOf(1, 2)) == [1]
     Require.require([1, 2],    Require.subSetOf(1, 2)) == [1, 2]
     Require.require([1, 2, 3], Require.subSetOf(1, 2)) # throws IllegalArgumentException("Must be subset of [1, 2]")

Type Parameters:: E - The type of the elements of either collection.; T - The Collection type of the object being tested
Parameters:: arr - The collection to test against - Can't be null
Returns:: A predicate that checks for its collection to be a subset of arr

memberOf

@SafeVarargs
public static <T> Predicate<T> memberOf(T... arr)

Returns a predicate that checks for its object to be a member of arr. An object must be a member of the given collection to satisfy the condition.

 Example:
     Require.require(null, Require.memberOf([])    ) # throws IllegalArgumentException("Must be a member of {}")
     Require.require(null, Require.memberOf([null])) == null
     Require.require(null, Require.memberOf([1, 2])) # throws IllegalArgumentException("Must be a member of [1, 2]")
     Require.require(1,    Require.memberOf([1, 2])) == 1
     Require.require(3,    Require.memberOf([1, 2])) # throws IllegalArgumentException("Must be a member of [1, 2]")

Type Parameters:: T - The type of the object being tested
Parameters:: arr - The collection that must contain the object - Can't be null
Returns:: A predicate that checks for its object to be a member of arr

memberOf

public static <T> Predicate<T> memberOf(Collection<? extends T> coll)

Returns a predicate that checks for its object to be a member of coll. An object must be a member of the given collection to satisfy the condition.

 Example:
     Require.require(null, Require.memberOf([])    ) # throws IllegalArgumentException("Must be a member of []")
     Require.require(null, Require.memberOf([null])) == null
     Require.require(null, Require.memberOf([1, 2])) # throws IllegalArgumentException("Must be a member of [1, 2]")
     Require.require(1,    Require.memberOf([1, 2])) == 1
     Require.require(3,    Require.memberOf([1, 2])) # throws IllegalArgumentException("Must be a member of [1, 2]")

Type Parameters:: T - The type of the object being tested
Parameters:: coll - The collection that must contain the object - Can't be null
Returns:: A predicate that checks for its object to be a member of coll

lt

public static <T extends Comparable<T>> Predicate<T> lt(T val)

Returns a predicate that checks for its object to be < val. An object must be less than another object using compareTo to satisfy the condition. NULL comparison follows the rule null always less than non-null.

 Example:
     Require.require(null, Require.lt(null)) # throws IllegalArgumentException("Must be less than null")
     Require.require(null, Require.lt(2)   ) == null
     Require.require(1,    Require.lt(2)   ) == 1
     Require.require(2,    Require.lt(2)   ) # throws IllegalArgumentException("Must be less than 2")
     Require.require(3,    Require.lt(2)   ) # throws IllegalArgumentException("Must be less than 2")

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be < val

gt

public static <T extends Comparable<T>> Predicate<T> gt(T val)

Returns a predicate that checks for its object to be > val. An object must be greater than another object using compareTo to satisfy the condition. NULL comparison follows the rule null always less than non-null.

 Example:
     Require.require(null, Require.gt(null)) # throws IllegalArgumentException("Must be greater than null")
     Require.require(null, Require.gt(2)   ) # throws IllegalArgumentException("Must be greater than 2")
     Require.require(1,    Require.gt(2)   ) # throws IllegalArgumentException("Must be greater than 2")
     Require.require(2,    Require.gt(2)   ) # throws IllegalArgumentException("Must be greater than 2")
     Require.require(3,    Require.gt(2)   ) == 3

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be > val.

le

public static <T extends Comparable<T>> Predicate<T> le(T val)

Returns a predicate that checks for its object to be <= val. An object must be less than or equal to another object using compareTo to satisfy the condition. NULL comparison follows the rule null always less than non-null.

 Example:
     Require.require(null, Require.le(null)) == null
     Require.require(null, Require.le(2)   ) == null
     Require.require(1,    Require.le(2)   ) == 1
     Require.require(2,    Require.le(2)   ) == 2
     Require.require(3,    Require.le(2)   ) # throws IllegalArgumentException("Must be less than or equal to 2")

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be <= val

ge

public static <T extends Comparable<T>> Predicate<T> ge(T val)

Returns a predicate that checks for its object to be >= val. An object must be greater than or equal to another object using compareTo to satisfy the condition. NULL comparison follows the rule null always less than non-null.

 Example:
     Require.require(null, Require.ge(null)) == null
     Require.require(null, Require.ge(2)   ) # throws IllegalArgumentException("Must be greater than or equal to 2")
     Require.require(1,    Require.ge(2)   ) # throws IllegalArgumentException("Must be greater than or equal to 2")
     Require.require(2,    Require.ge(2)   ) == 2
     Require.require(3,    Require.ge(2)   ) == 3

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be >= val

eq

public static <T extends Comparable<T>> Predicate<T> eq(T val)

Returns a predicate that checks for its object to be == val (via numerical sense). An object must be equal to another object using compareTo to satisfy the condition. NULL comparison follows the rule null always less than non-null.

 Example:
     Require.require(null, Require.eq(null)) == null
     Require.require(null, Require.eq(2)   ) # throws IllegalArgumentException("Must be equal to 2")
     Require.require(1,    Require.eq(2)   ) # throws IllegalArgumentException("Must be equal to 2")
     Require.require(2,    Require.eq(2)   ) == 2
     Require.require(3,    Require.eq(2)   ) # throws IllegalArgumentException("Must be equal to 2")

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == val

ne

public static <T extends Comparable<T>> Predicate<T> ne(T val)

Returns a predicate that checks for its object to be != val (via numerical sense). An object must not be equal to another object using compareTo to satisfy the condition. NULL comparison follows the rule null always less than non-null.

 Example:
     Require.require(null, Require.ne(null)) # throws IllegalArgumentException("Must be not equal to null")
     Require.require(null, Require.ne(2)   ) == null
     Require.require(1,    Require.ne(2)   ) == 1
     Require.require(2,    Require.ne(2)   ) # throws IllegalArgumentException("Must be not equal to 2")
     Require.require(3,    Require.ne(2)   ) == 3

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be != val

equalTo

public static Predicate<byte[]> equalTo(byte[] arr)

Returns a predicate that checks for its byte[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,      Require.equalTo(null)  ) == null
     Require.require([],        Require.equalTo(null)  ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],        Require.equalTo([])    ) == []
     Require.require([1],       Require.equalTo([1, 2])) # throws IllegalArgumentException("Must be equal to [1, 2]")
     Require.require([1, 2],    Require.equalTo([1, 2])) == [1, 2]
     Require.require([2, 1],    Require.equalTo([1, 2])) # throws IllegalArgumentException("Must be equal to [1, 2]")
     Require.require([1, 2, 3], Require.equalTo([1, 2])) # throws IllegalArgumentException("Must be equal to [1, 2]")

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<short[]> equalTo(short[] arr)

Returns a predicate that checks for its short[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,      Require.equalTo(null)  ) == null
     Require.require([],        Require.equalTo(null)  ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],        Require.equalTo([])    ) == []
     Require.require([1],       Require.equalTo([1, 2])) # throws IllegalArgumentException
     Require.require([1, 2],    Require.equalTo([1, 2])) == [1, 2]
     Require.require([2, 1],    Require.equalTo([1, 2])) # throws IllegalArgumentException
     Require.require([1, 2, 3], Require.equalTo([1, 2])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<int[]> equalTo(int[] arr)

Returns a predicate that checks for its int[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,      Require.equalTo(null)  ) == null
     Require.require([],        Require.equalTo(null)  ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],        Require.equalTo([])    ) == []
     Require.require([1],       Require.equalTo([1, 2])) # throws IllegalArgumentException
     Require.require([1, 2],    Require.equalTo([1, 2])) == [1, 2]
     Require.require([2, 1],    Require.equalTo([1, 2])) # throws IllegalArgumentException
     Require.require([1, 2, 3], Require.equalTo([1, 2])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<long[]> equalTo(long[] arr)

Returns a predicate that checks for its long[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,      Require.equalTo(null)  ) == null
     Require.require([],        Require.equalTo(null)  ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],        Require.equalTo([])    ) == []
     Require.require([1],       Require.equalTo([1, 2])) # throws IllegalArgumentException
     Require.require([1, 2],    Require.equalTo([1, 2])) == [1, 2]
     Require.require([2, 1],    Require.equalTo([1, 2])) # throws IllegalArgumentException
     Require.require([1, 2, 3], Require.equalTo([1, 2])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<char[]> equalTo(char[] arr)

Returns a predicate that checks for its char[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,            Require.equalTo(null)      ) == null
     Require.require([],              Require.equalTo(null)      ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],              Require.equalTo([])        ) == []
     Require.require(['1'],           Require.equalTo(['1', '2'])) # throws IllegalArgumentException
     Require.require(['1', '2'],      Require.equalTo(['1', '2'])) == ['1', '2']
     Require.require(['2', '1'],      Require.equalTo(['1', '2'])) # throws IllegalArgumentException
     Require.require(['1', '2', '3'], Require.equalTo(['1', '2'])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<boolean[]> equalTo(boolean[] arr)

Returns a predicate that checks for its boolean[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,                 Require.equalTo(null)         ) == null
     Require.require([],                   Require.equalTo(null)         ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],                   Require.equalTo([])           ) == []
     Require.require([true],               Require.equalTo([true, false])) # throws IllegalArgumentException
     Require.require([true, false],        Require.equalTo([true, false])) == [true, false]
     Require.require([false, true],        Require.equalTo([true, false])) # throws IllegalArgumentException
     Require.require([true, false, false], Require.equalTo([true, false])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<float[]> equalTo(float[] arr)

Returns a predicate that checks for its float[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,            Require.equalTo(null)      ) == null
     Require.require([],              Require.equalTo(null)      ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],              Require.equalTo([])        ) == []
     Require.require([1.0],           Require.equalTo([1.0, 2.0])) # throws IllegalArgumentException
     Require.require([1.0, 2.0],      Require.equalTo([1.0, 2.0])) == [1.0, 2.0]
     Require.require([2.0, 1.0],      Require.equalTo([1.0, 2.0])) # throws IllegalArgumentException
     Require.require([1.0, 2.0, 3.0], Require.equalTo([1.0, 2.0])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static Predicate<double[]> equalTo(double[] arr)

Returns a predicate that checks for its double[] object to be == arr (using Arrays.equals). An object must not be equal to another object using Arrays.equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,            Require.equalTo(null)      ) == null
     Require.require([],              Require.equalTo(null)      ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],              Require.equalTo([])        ) == []
     Require.require([1.0],           Require.equalTo([1.0, 2.0])) # throws IllegalArgumentException
     Require.require([1.0, 2.0],      Require.equalTo([1.0, 2.0])) == [1.0, 2.0]
     Require.require([2.0, 1.0],      Require.equalTo([1.0, 2.0])) # throws IllegalArgumentException
     Require.require([1.0, 2.0, 3.0], Require.equalTo([1.0, 2.0])) # throws IllegalArgumentException

Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static <E> Predicate<E[]> equalTo(E[] arr)

Returns a predicate that checks for its Object[] object to be == arr (using Arrays.deepEquals). An object must not be equal to another object using Arrays.deepEquals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null,            Require.equalTo(null)      ) == null
     Require.require([],              Require.equalTo(null)      ) # throws IllegalArgumentException("Must be equal to null")
     Require.require([],              Require.equalTo([])        ) == []
     Require.require(["1"],           Require.equalTo(["1", "2"])) # throws IllegalArgumentException
     Require.require(["1", "2"],      Require.equalTo(["1", "2"])) == ["1", "2"]
     Require.require(["2", "1"],      Require.equalTo(["1", "2"])) # throws IllegalArgumentException
     Require.require(["1", "2", "3"], Require.equalTo(["1", "2"])) # throws IllegalArgumentException

Type Parameters:: E - the element type of the array being tests
Parameters:: arr - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

equalTo

public static <T> Predicate<T> equalTo(T val)

Returns a predicate that checks for its Object object to be == arr (using equals). An object must be equal to another object using equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null, Require.equalTo("1") ) # throws IllegalArgumentException
     Require.require(null, Require.equalTo(null)) == null
     Require.require("",   Require.equalTo(null)) # throws IllegalArgumentException
     Require.require("1",  Require.equalTo("1") ) == ""
     Require.require("2",  Require.equalTo("1") ) # throws IllegalArgumentException

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == arr

same

public static <T> Predicate<T> same(T val)

Returns a predicate that checks for its object to be == val (using pointer equality). An object must be equal to another object using equals to satisfy the condition. NULL's are allowed.

 Example:
     Require.require(null, Require.same("1") ) # throws IllegalArgumentException("Must be same object as 1")
     Require.require(null, Require.same(null)) == null
     Require.require("",   Require.same(null)) # throws IllegalArgumentException("Must be same object as null")
     Require.require("1",  Require.same("1") ) == ""
     Require.require("2",  Require.same("1") ) # throws IllegalArgumentException("Must be same object as 1")
     Foo foo = new Foo();
     Foo bar = new Foo();
     Require.require(foo, Require.same(bar) # throws IllegalArgumentException("Must be same object as ...")

Type Parameters:: T - The type of the object being tested
Parameters:: val - The object to compare to - Can be null
Returns:: A predicate that checks for its object to be == val

and

public static <T> Predicate<T> and(Predicate<T> p1,
                                   Predicate<T> p2)

Returns a predicate that is the "and" of p1 and p2. An object must match 2 predicates. NULL's are allowed.

 Example:
     Require.require(1, Require.and(Equal.gt(0), Equal.lt(2))) == 1
     Require.require(1, Require.and(Equal.gt(1), Equal.lt(2))) # throws IllegalArgumentException("(Must be greater than 1) and (Must be less than 2)")
     Require.require(1, Require.and(Equal.gt(0), Equal.lt(0))) # throws IllegalArgumentException("(Must be greater than 0) and (Must be less than 0)")

Type Parameters:: T - the type of the object being tested
Parameters:: p1 - The first predicate - Can't be null - always evaluated; p2 - The second predicate - Can't be null - conditionally evaluated
Returns:: A predicate that is the "and" of p1 and p2

or

public static <T> Predicate<T> or(Predicate<T> p1,
                                  Predicate<T> p2)

Returns a predicate that is the "or" of p1 and p2. An object must match one of two predicates. NULL's are allowed.

 Example:
     Require.require(1, Require.or(Equal.gt(0), Equal.lt(2))) == 1
     Require.require(1, Require.or(Equal.gt(1), Equal.lt(2))) == 1
     Require.require(1, Require.or(Equal.gt(0), Equal.lt(0))) == 1
     Require.require(1, Require.or(Equal.gt(1), Equal.gt(3))) # throws IllegalArgumentException("(Must be greater than 1) or (Must be less than 3)")

Type Parameters:: T - the type of the object being tested
Parameters:: p1 - The first predicate - Can't be null - always evaluated; p2 - The second predicate - Can't be null - conditionally evaluated
Returns:: A predicate that is the "or" of p1 and p2

negate
```
public static <T> Predicate<T> negate(Predicate<T> p)
```
Returns a predicate that is the "not" of p. An object must match not match a sub predicate. NULL's are allowed.
```
 Example:
     Require.require(1, Require.not(Equal.gt(0))) # throws IllegalArgumentException("not (Must be greater than 0)")
     Require.require(1, Require.not(Equal.gt(1))) == 1
 
```
Type Parameters:

T - the type of the object being tested

Parameters:

p - The predicate to negate - Can't be null

Returns:

A predicate that is the "not" of p.

name
```
public static <T> Predicate<T> name(Predicate<T> pred,
                                    Supplier<String> msg)
```
Add a toString to pred. This is the mechanism by which we can associate strings with predicates, giving nice messages when they fail.
```
 Example:
     Require.name(someobj -> true, () -> "True").toString() == "True"
 
```
Type Parameters:

T - The type of the object being tested

Parameters:

pred - The predicate to decorate with a message - Can't be null

msg - The supplier of the message - Can't be null

Returns:

A predicate whose toString will return the msg

values

public static <K,V,T extends Map<? extends K,? extends V>> Function<T,Collection<? extends V>> values()

Returns the Map::values function named "values".

 Example:
     Require.values().apply({a => 1, b => 2}) == [1, 2]
     Require.values().toString() == "values"

Type Parameters:: K - The Map key type; V - The Map value type; T - The Map type
Returns:: A named function representing Map::values

keySet

public static <K,V,T extends Map<? extends K,? extends V>> Function<T,Set<? extends K>> keySet()

Returns the Map::keySet function named "keys".

 Example:
     Require.values().apply({a => 1, b =>2}) == [1, 2]
     Require.values().toString() == "keys"

Type Parameters:: K - The Map key type; V - The Map value type; T - The Map type
Returns:: A named function representing Map::values

mapSize

public static <K,V,T extends Map<? extends K,? extends V>> Function<T,Integer> mapSize()

Returns the Map::size function named "size".

 Example:
     Require.mapSize().apply({a => 1, b => 2}) == 2
     Require.mapSize().toString() == "size"

Type Parameters:: K - The Map key type; V - The Map value type; T - The Map type
Returns:: A named function representing Map::size

stringify
```
public static <T> Function<T,String> stringify()
```
Returns the Object::toString function named "toString".
```
 Example:
     Require.stringify().apply(3) == "3"
     Require.stringify().toString() == "toString"
 
```
Type Parameters:

T - the type of the object being operated on

Returns:

A named function representing Object::toString

hash
```
public static <T> Function<T,Integer> hash()
```
Returns the Object::hashCode function named "hash".
```
 Example:
     Require.hash().apply(o) == o.hashCode()
     Require.hash().toString() == "hash"
 
```
Type Parameters:

T - the type of the object being operated on

Returns:

A named function representing Object::hash

length

public static Function<String,Integer> length()

Returns the String::length function named "length".

 Example:
     Require.length().apply("abc") ==length3
     Require.length().toString() == "hash"

Returns:: A named function representing Object::hash

size
```
public static <E,T extends Collection<? extends E>> Function<T,Integer> size()
```
Returns the Collection::size function named "size".
```
 Example:
     Require.size().apply([4,5]) == 2
     Require.size().toString() == "size"
 
```
Type Parameters:

E - the type for the element of the collection

T - the type of the object being operated on

Returns:

A named function representing Collection::size

nameF
```
public static <T,U> Function<T,U> nameF(Function<T,U> f,
                                        Supplier<String> msg)
```
Adds a toString to a predicate. This is the mechanism by which we can associate strings with predicates, giving nice messages when they fail.
```
 Example:
     Require.nameF(String::length, () -> "Length").toString() == "Length"
 
```
Type Parameters:

T - The type being operated on by the function

U - The return type of the function

Parameters:

f - The function to decorate with a message - Can't be null

msg - The supplier of the message - Can't be null

Returns:

A function whose toString will return the msg.

chain
```
public static <T,U> Predicate<T> chain(Function<T,U> f,
                                       Predicate<U> p)
```
Returns a predicate for the test of f(o). A function of an object must match match a sub predicate. NULL's are allowed, but only if the function allows null, so care needs to be taken here.
```
 Example:
     Require.require("abc", Require.chain(Require.length(), Equal.gt(2)) == "abc"
     Require.require("ab",  Require.chain(Require.length(), Equal.gt(2)) # throws IllegalArgumentException("length: Must be greater than 0")
 
```
If f throws an exception, it will be passed on to the caller.
Type Parameters:

T - The type of the object being tested

U - The type of the object returned by f

Parameters:

f - The function - Can't be null

p - The predicate of the return value - Can't be null

Returns:

A predicate for the test of f(o)

Class Requirements

Method Summary

Methods inherited from class java.lang.Object

Method Detail

require

require

require

notNull

notBlank

minLength

maxLength

matches

matches

notEmpty

contains

containsKey

mapNotEmpty

minSize

maxSize

superSetOf

superSetOf

subSetOf

subSetOf

memberOf

memberOf

lt

gt

le

ge

eq

ne

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

same

and

or

negate

name

values

keySet

mapSize

stringify

hash

length

size

nameF

chain