Requirements (Requirements 2.0.0 API)

java.lang.Object
- org.bitbucket.cowwoc.requirements.Requirements

```
public final class Requirements
extends Object
```
Verifies requirements of a parameter.
All verifier implementations must be immutable and final.

Author:

Gili Tzabari

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static BigDecimalRequirements`	`assertThat(BigDecimal parameter, String name)` Same as `requireThat(BigDecimal, String)` but does nothing if assertions are disabled for this class.
`static <T> ClassRequirements<T>`	`assertThat(Class<T> parameter, String name)` Same as `requireThat(Class, String)` but does nothing if assertions are disabled for this class.
`static <E> CollectionRequirements<E>`	`assertThat(Collection<E> parameter, String name)` Same as `requireThat(Collection, String)` but does nothing if assertions are disabled for this class.
`static <K,V> MapRequirements<K,V>`	`assertThat(Map<K,V> parameter, String name)` Same as `requireThat(Map, String)` but does nothing if assertions are disabled for this class.
`static ObjectRequirements<Object>`	`assertThat(Object parameter, String name)` Same as `requireThat(Object, String)` but does nothing if assertions are disabled for this class.
`static OptionalRequirements`	`assertThat(Optional<?> parameter, String name)` Same as `requireThat(Optional, String)` but does nothing if assertions are disabled for this class.
`static PathRequirements`	`assertThat(Path parameter, String name)` Same as `requireThat(Path, String)` but does nothing if assertions are disabled for this class.
`static StringRequirements`	`assertThat(String parameter, String name)` Same as `requireThat(String, String)` but does nothing if assertions are disabled for this class.
`static <T extends Comparable<? super T>> ComparableRequirements<T>`	`assertThat(T parameter, String name)` Same as `requireThat(Comparable, String)` but does nothing if assertions are disabled for this class.
`static <T extends Number & Comparable<? super T>> NumberRequirements<T>`	`assertThat(T parameter, String name)` Same as `requireThat(Number, String)` but does nothing if assertions are disabled for this class.
`static UriRequirements`	`assertThat(URI parameter, String name)` Same as `requireThat(URI, String)` but does nothing if assertions are disabled for this class.
`static BigDecimalRequirements`	`requireThat(BigDecimal parameter, String name)` Creates requirements for a `BigDecimal`.
`static <T> ClassRequirements<T>`	`requireThat(Class<T> parameter, String name)` Creates requirements for a `Class`.
`static <E> CollectionRequirements<E>`	`requireThat(Collection<E> parameter, String name)` Creates requirements for a `Collection`.
`static <K,V> MapRequirements<K,V>`	`requireThat(Map<K,V> parameter, String name)` Creates requirements for a `Map`.
`static ObjectRequirements<Object>`	`requireThat(Object parameter, String name)` Creates requirements for an `Object`.
`static OptionalRequirements`	`requireThat(Optional<?> parameter, String name)` Creates requirements for an `Optional`.
`static PathRequirements`	`requireThat(Path parameter, String name)` Creates requirements for a `Path`.
`static StringRequirements`	`requireThat(String parameter, String name)` Creates requirements for a `String`.
`static <T extends Comparable<? super T>> ComparableRequirements<T>`	`requireThat(T parameter, String name)` Creates requirements for a `Comparable`.
`static <T extends Number & Comparable<? super T>> NumberRequirements<T>`	`requireThat(T parameter, String name)` Creates requirements for a `Number`.
`static UriRequirements`	`requireThat(URI parameter, String name)` Creates requirements for a `Uri`.

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

Method Detail

requireThat

public static ObjectRequirements<Object> requireThat(Object parameter,
                                                     String name)
                                              throws NullPointerException,
                                                     IllegalArgumentException

Creates requirements for an Object.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static ObjectRequirements<Object> assertThat(Object parameter,
                                                    String name)
                                             throws NullPointerException,
                                                    IllegalArgumentException

Same as requireThat(Object, String) but does nothing if assertions are disabled for this class.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static <E> CollectionRequirements<E> requireThat(Collection<E> parameter,
                                                        String name)
                                                 throws NullPointerException,
                                                        IllegalArgumentException

Creates requirements for a Collection.

Type Parameters:: E - the type of element in the collection
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static <E> CollectionRequirements<E> assertThat(Collection<E> parameter,
                                                       String name)
                                                throws NullPointerException,
                                                       IllegalArgumentException

Same as requireThat(Collection, String) but does nothing if assertions are disabled for this class.

Type Parameters:: E - the type of element in the collection
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static <T extends Comparable<? super T>> ComparableRequirements<T> requireThat(T parameter,
                                                                                      String name)
                                                                               throws NullPointerException,
                                                                                      IllegalArgumentException

Creates requirements for a Comparable.

Type Parameters:: T - the type of objects that the parameter may be compared to
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static <T extends Comparable<? super T>> ComparableRequirements<T> assertThat(T parameter,
                                                                                     String name)
                                                                              throws NullPointerException,
                                                                                     IllegalArgumentException

Same as requireThat(Comparable, String) but does nothing if assertions are disabled for this class.

Type Parameters:: T - the type of objects that the parameter may be compared to
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static <T extends Number & Comparable<? super T>> NumberRequirements<T> requireThat(T parameter,
                                                                                           String name)
                                                                                    throws NullPointerException,
                                                                                           IllegalArgumentException

Creates requirements for a Number.

Type Parameters:: T - the type of the number
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static <T extends Number & Comparable<? super T>> NumberRequirements<T> assertThat(T parameter,
                                                                                          String name)
                                                                                   throws NullPointerException,
                                                                                          IllegalArgumentException

Same as requireThat(Number, String) but does nothing if assertions are disabled for this class.

Type Parameters:: T - the type of the number
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static BigDecimalRequirements requireThat(BigDecimal parameter,
                                                 String name)
                                          throws NullPointerException,
                                                 IllegalArgumentException

Creates requirements for a BigDecimal.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static BigDecimalRequirements assertThat(BigDecimal parameter,
                                                String name)
                                         throws NullPointerException,
                                                IllegalArgumentException

Same as requireThat(BigDecimal, String) but does nothing if assertions are disabled for this class.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static <K,V> MapRequirements<K,V> requireThat(Map<K,V> parameter,
                                                     String name)
                                              throws NullPointerException,
                                                     IllegalArgumentException

Creates requirements for a Map.

Type Parameters:: K - the type of key in the map; V - the type of value in the map
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static <K,V> MapRequirements<K,V> assertThat(Map<K,V> parameter,
                                                    String name)
                                             throws NullPointerException,
                                                    IllegalArgumentException

Same as requireThat(Map, String) but does nothing if assertions are disabled for this class.

Type Parameters:: K - the type of key in the map; V - the type of value in the map
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static PathRequirements requireThat(Path parameter,
                                           String name)
                                    throws NullPointerException,
                                           IllegalArgumentException

Creates requirements for a Path.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static PathRequirements assertThat(Path parameter,
                                          String name)
                                   throws NullPointerException,
                                          IllegalArgumentException

Same as requireThat(Path, String) but does nothing if assertions are disabled for this class.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static StringRequirements requireThat(String parameter,
                                             String name)
                                      throws NullPointerException,
                                             IllegalArgumentException

Creates requirements for a String.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static StringRequirements assertThat(String parameter,
                                            String name)
                                     throws NullPointerException,
                                            IllegalArgumentException

Same as requireThat(String, String) but does nothing if assertions are disabled for this class.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static UriRequirements requireThat(URI parameter,
                                          String name)
                                   throws NullPointerException,
                                          IllegalArgumentException

Creates requirements for a Uri.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static UriRequirements assertThat(URI parameter,
                                         String name)
                                  throws NullPointerException,
                                         IllegalArgumentException

Same as requireThat(URI, String) but does nothing if assertions are disabled for this class.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static <T> ClassRequirements<T> requireThat(Class<T> parameter,
                                                   String name)
                                            throws NullPointerException,
                                                   IllegalArgumentException

Creates requirements for a Class.

Type Parameters:: T - the type of class
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static <T> ClassRequirements<T> assertThat(Class<T> parameter,
                                                  String name)
                                           throws NullPointerException,
                                                  IllegalArgumentException

Same as requireThat(Class, String) but does nothing if assertions are disabled for this class.

Type Parameters:: T - the type of class
Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

requireThat

public static OptionalRequirements requireThat(Optional<?> parameter,
                                               String name)
                                        throws NullPointerException,
                                               IllegalArgumentException

Creates requirements for an Optional.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

assertThat

public static OptionalRequirements assertThat(Optional<?> parameter,
                                              String name)
                                       throws NullPointerException,
                                              IllegalArgumentException

Same as requireThat(Optional, String) but does nothing if assertions are disabled for this class.

Parameters:: parameter - the value of the parameter; name - the name of the parameter
Returns:: Requirements for the parameter
Throws:: NullPointerException - if name is null; IllegalArgumentException - if name is empty

Class Requirements

Method Summary

Methods inherited from class java.lang.Object

Method Detail

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat

requireThat

assertThat