Package software.amazon.awssdk.utils

Class Validate

java.lang.Object

software.amazon.awssdk.utils.Validate

public class Validate
extends Object

This class assists in validating arguments. The validation methods are based along the following principles:

• An invalid null argument causes a NullPointerException.
• A non-null argument causes an IllegalArgumentException.
• An invalid index into an array/collection/map/string causes an IndexOutOfBoundsException.

All exceptions messages are format strings as defined by the Java platform. For example:

 Validate.isTrue(i > 0, "The value must be greater than zero: %d", i);
 Validate.notNull(surname, "The surname must not be %s", null);
 

This class's source was modified from the Apache commons-lang library: https://github.com/apache/commons-lang/

#ThreadSafe#

See Also:

String.format(String, Object...)

Constructor Summary

Constructors

Constructor	Description
Validate()	Constructor.

Method Summary

Modifier and Type	Method	Description
static double	exclusiveBetween(double start, double end, double value, String message)	Validate that the specified primitive value falls between the two exclusive values specified; otherwise, throws an exception with the specified message.
static long	exclusiveBetween(long start, long end, long value, String message)	Validate that the specified primitive value falls between the two exclusive values specified; otherwise, throws an exception with the specified message.
static <T extends Comparable<U>,U> T	exclusiveBetween(U start, U end, T value, String message, Object... values)	Validate that the specified argument object fall between the two exclusive values specified; otherwise, throws an exception with the specified message.
static double	inclusiveBetween(double start, double end, double value, String message)	Validate that the specified primitive value falls between the two inclusive values specified; otherwise, throws an exception with the specified message.
static long	inclusiveBetween(long start, long end, long value, String message)	Validate that the specified primitive value falls between the two inclusive values specified; otherwise, throws an exception with the specified message.
static <T extends Comparable<U>,U> T	inclusiveBetween(U start, U end, T value, String message, Object... values)	Validate that the specified argument object fall between the two inclusive values specified; otherwise, throws an exception with the specified message.
static void	isAssignableFrom(Class<?> superType, Class<?> type, String message, Object... values)	Validates that the argument can be converted to the specified class, if not throws an exception.
static String	isInstanceOf(Class<?> type, Object obj, String message, Object... values)	Validate that the argument is an instance of the specified class; otherwise throwing an exception with the specified message.
static void	isTrue(boolean expression, String message, Object... values)	Validate that the argument condition is true; otherwise throwing an exception with the specified message.
static <T> T[]	noNullElements(T[] array, String message, Object... values)	Validate that the specified argument array is neither null nor contains any elements that are null; otherwise throwing an exception with the specified message.
static <T extends Iterable<?>> T	noNullElements(T iterable, String message, Object... values)	Validate that the specified argument iterable is neither null nor contains any elements that are null; otherwise throwing an exception with the specified message.
static <T extends CharSequence> T	notBlank(T chars, String message, Object... values)	Validate that the specified argument character sequence is neither null, a length of zero (no characters), empty nor whitespace; otherwise throwing an exception with the specified message.
static <T> T[]	notEmpty(T[] array, String message, Object... values)	Validate that the specified argument array is neither null nor a length of zero (no elements); otherwise throwing an exception with the specified message.
static <T extends Collection<?>> T	notEmpty(T collection, String message, Object... values)	Validate that the specified argument collection is neither null nor a size of zero (no elements); otherwise throwing an exception with the specified message.
static <T> T	notNull(T object, String message, Object... values)	Validate that the specified argument is not null; otherwise throwing an exception with the specified message.
static <T> T	paramNotNull(T object, String paramName)	Validate that the specified field/param is not null; otherwise throwing an exception with a precanned message that includes the parameter name.
static void	validState(boolean expression, String message, Object... values)	Validate that the stateful condition is true; otherwise throwing an exception with the specified message.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Validate

public Validate()

Constructor. This class should not normally be instantiated.

Method Detail

isTrue

public static void isTrue(boolean expression,
                          String message,
                          Object... values)

Validate that the argument condition is true; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary boolean expression, such as validating a primitive number or using your own custom validation expression.

 Validate.isTrue(i >= min && i <= max, "The value must be between %d and %d", min, max);
 Validate.isTrue(myObject.isOk(), "The object is not okay");

Parameters:

expression - the boolean expression to check

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Throws:

IllegalArgumentException - if expression is false

notNull

public static <T> T notNull(T object,
                            String message,
                            Object... values)

Validate that the specified argument is not null; otherwise throwing an exception with the specified message.

Validate.notNull(myObject, "The object must not be null");

Type Parameters:

T - the object type

Parameters:

object - the object to check

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message

Returns:

the validated object (never null for method chaining)

Throws:

NullPointerException - if the object is null

paramNotNull

public static <T> T paramNotNull(T object,
                                 String paramName)

Validate that the specified field/param is not null; otherwise throwing an exception with a precanned message that includes the parameter name.

Validate.paramNotNull(myObject, "myObject");

Type Parameters:

T - the object type

Parameters:

object - the object to check

paramName - The name of the param or field being checked.

Returns:

the validated object (never null for method chaining)

Throws:

NullPointerException - if the object is null

notEmpty

public static <T> T[] notEmpty(T[] array,
                               String message,
                               Object... values)

Validate that the specified argument array is neither null nor a length of zero (no elements); otherwise throwing an exception with the specified message.

Validate.notEmpty(myArray, "The array must not be empty");

Type Parameters:

T - the array type

Parameters:

array - the array to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Returns:

the validated array (never null method for chaining)

Throws:

NullPointerException - if the array is null

IllegalArgumentException - if the array is empty

notEmpty

public static <T extends Collection<?>> T notEmpty(T collection,
                                                   String message,
                                                   Object... values)

Validate that the specified argument collection is neither null nor a size of zero (no elements); otherwise throwing an exception with the specified message.

Validate.notEmpty(myCollection, "The collection must not be empty");

Type Parameters:

T - the collection type

Parameters:

collection - the collection to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Returns:

the validated collection (never null method for chaining)

Throws:

NullPointerException - if the collection is null

IllegalArgumentException - if the collection is empty

notEmpty

public static <T extends Map<?,?>> T notEmpty(T map,
                                              String message,
                                              Object... values)

Validate that the specified argument map is neither null nor a size of zero (no elements); otherwise throwing an exception with the specified message.

Validate.notEmpty(myMap, "The map must not be empty");

Type Parameters:

T - the map type

Parameters:

map - the map to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Returns:

the validated map (never null method for chaining)

Throws:

NullPointerException - if the map is null

IllegalArgumentException - if the map is empty

notEmpty

public static <T extends CharSequence> T notEmpty(T chars,
                                                  String message,
                                                  Object... values)

Validate that the specified argument character sequence is neither null nor a length of zero (no characters); otherwise throwing an exception with the specified message.

Validate.notEmpty(myString, "The string must not be empty");

Type Parameters:

T - the character sequence type

Parameters:

chars - the character sequence to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Returns:

the validated character sequence (never null method for chaining)

Throws:

NullPointerException - if the character sequence is null

IllegalArgumentException - if the character sequence is empty

notBlank

public static <T extends CharSequence> T notBlank(T chars,
                                                  String message,
                                                  Object... values)

Validate that the specified argument character sequence is neither null, a length of zero (no characters), empty nor whitespace; otherwise throwing an exception with the specified message.

Validate.notBlank(myString, "The string must not be blank");

Type Parameters:

T - the character sequence type

Parameters:

chars - the character sequence to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Returns:

the validated character sequence (never null method for chaining)

Throws:

NullPointerException - if the character sequence is null

IllegalArgumentException - if the character sequence is blank

noNullElements

public static <T> T[] noNullElements(T[] array,
                                     String message,
                                     Object... values)

Validate that the specified argument array is neither null nor contains any elements that are null; otherwise throwing an exception with the specified message.

Validate.noNullElements(myArray, "The array is null or contains null.");

Type Parameters:

T - the array type

Parameters:

array - the array to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message

Returns:

the validated array (never null method for chaining)

Throws:

NullPointerException - if the array is null

IllegalArgumentException - if an element is null

noNullElements

public static <T extends Iterable<?>> T noNullElements(T iterable,
                                                       String message,
                                                       Object... values)

Validate that the specified argument iterable is neither null nor contains any elements that are null; otherwise throwing an exception with the specified message.

Validate.noNullElements(myCollection, "The collection is null or contains null.");

Type Parameters:

T - the iterable type

Parameters:

iterable - the iterable to check, validated not null by this method

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message.

Returns:

the validated iterable (never null method for chaining)

Throws:

NullPointerException - if the array is null

IllegalArgumentException - if an element is null

validState

public static void validState(boolean expression,
                              String message,
                              Object... values)

Validate that the stateful condition is true; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary boolean expression, such as validating a primitive number or using your own custom validation expression.

Validate.validState(this.isOk(), "The state is not OK: %s", myObject);

Parameters:

expression - the boolean expression to check

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Throws:

IllegalStateException - if expression is false

inclusiveBetween

public static <T extends Comparable<U>,U> T inclusiveBetween(U start,
                                                             U end,
                                                             T value,
                                                             String message,
                                                             Object... values)

Validate that the specified argument object fall between the two inclusive values specified; otherwise, throws an exception with the specified message.

Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");

Type Parameters:

T - the type of the argument object

Parameters:

start - the inclusive start value, not null

end - the inclusive end value, not null

value - the object to validate, not null

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Throws:

IllegalArgumentException - if the value falls outside the boundaries

inclusiveBetween

public static long inclusiveBetween(long start,
                                    long end,
                                    long value,
                                    String message)

Validate that the specified primitive value falls between the two inclusive values specified; otherwise, throws an exception with the specified message.

Validate.inclusiveBetween(0, 2, 1, "Not in range");

Parameters:

start - the inclusive start value

end - the inclusive end value

value - the value to validate

message - the exception message if invalid, not null

Throws:

IllegalArgumentException - if the value falls outside the boundaries

inclusiveBetween

public static double inclusiveBetween(double start,
                                      double end,
                                      double value,
                                      String message)

Validate that the specified primitive value falls between the two inclusive values specified; otherwise, throws an exception with the specified message.

Validate.inclusiveBetween(0.1, 2.1, 1.1, "Not in range");

Parameters:

start - the inclusive start value

end - the inclusive end value

value - the value to validate

message - the exception message if invalid, not null

Throws:

IllegalArgumentException - if the value falls outside the boundaries

exclusiveBetween

public static <T extends Comparable<U>,U> T exclusiveBetween(U start,
                                                             U end,
                                                             T value,
                                                             String message,
                                                             Object... values)

Validate that the specified argument object fall between the two exclusive values specified; otherwise, throws an exception with the specified message.

Validate.exclusiveBetween(0, 2, 1, "Not in boundaries");

Type Parameters:

T - the type of the argument object

Parameters:

start - the exclusive start value, not null

end - the exclusive end value, not null

value - the object to validate, not null

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Throws:

IllegalArgumentException - if the value falls outside the boundaries

exclusiveBetween

public static long exclusiveBetween(long start,
                                    long end,
                                    long value,
                                    String message)

Validate that the specified primitive value falls between the two exclusive values specified; otherwise, throws an exception with the specified message.

Validate.exclusiveBetween(0, 2, 1, "Not in range");

Parameters:

start - the exclusive start value

end - the exclusive end value

value - the value to validate

message - the exception message if invalid, not null

Throws:

IllegalArgumentException - if the value falls outside the boundaries

exclusiveBetween

public static double exclusiveBetween(double start,
                                      double end,
                                      double value,
                                      String message)

Validate that the specified primitive value falls between the two exclusive values specified; otherwise, throws an exception with the specified message.

Validate.exclusiveBetween(0.1, 2.1, 1.1, "Not in range");

Parameters:

start - the exclusive start value

end - the exclusive end value

value - the value to validate

message - the exception message if invalid, not null

Throws:

IllegalArgumentException - if the value falls outside the boundaries

isInstanceOf

public static String isInstanceOf(Class<?> type,
                                  Object obj,
                                  String message,
                                  Object... values)

Validate that the argument is an instance of the specified class; otherwise throwing an exception with the specified message. This method is useful when validating according to an arbitrary class

Validate.isInstanceOf(OkClass.class, object, "Wrong class, object is of class %s",
   object.getClass().getName());

Parameters:

type - the class the object must be validated against, not null

obj - the object to check, null throws an exception

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Throws:

IllegalArgumentException - if argument is not of specified class

isAssignableFrom

public static void isAssignableFrom(Class<?> superType,
                                    Class<?> type,
                                    String message,
                                    Object... values)

Validates that the argument can be converted to the specified class, if not throws an exception.

This method is useful when validating if there will be no casting errors.

Validate.isAssignableFrom(SuperClass.class, object.getClass());

The message of the exception is "The validated object can not be converted to the" followed by the name of the class and "class"

Parameters:

superType - the class the class must be validated against, not null

type - the class to check, not null

message - the String.format(String, Object...) exception message if invalid, not null

values - the optional values for the formatted exception message, null array not recommended

Throws:

IllegalArgumentException - if argument can not be converted to the specified class