Package software.amazon.awssdk.utils

Class Validate

  • public final class Validate
extends Object

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

    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...)

    • Method Summary

      All Methods Static Methods Concrete Methods 
      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 <T> T getOrDefault​(T param, Supplier<T> defaultValue)
      Returns the param if non null, otherwise gets a default value from the provided Supplier.
      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 <T> Class<? extends T> isAssignableFrom​(Class<T> superType, Class<?> type, String message, Object... values)
      Validates that the argument can be converted to the specified class, if not throws an exception.
      static void isFalse​(boolean expression, String message, Object... values)
      Validate that the argument condition is false; otherwise throwing an exception with the specified message.
      static <T,​U>
      U      		 isInstanceOf​(Class<U> type, T 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 int isNotNegative​(int num, String fieldName)  
      static long isNotNegative​(long num, String fieldName)  
      static Duration isNotNegative​(Duration duration, String fieldName)
      Asserts that the given duration is positive (non-negative and non-zero).
      static Long isNotNegativeOrNull​(Long num, String fieldName)  
      static <T> void isNull​(T object, String message, Object... values)
      Validate that the specified argument is null; otherwise throwing an exception with the specified message.
      static double isPositive​(double num, String fieldName)  
      static int isPositive​(int num, String fieldName)
      Asserts that the given number is positive (non-negative and non-zero).
      static long isPositive​(long num, String fieldName)
      Asserts that the given number is positive (non-negative and non-zero).
      static Duration isPositive​(Duration duration, String fieldName)
      Asserts that the given duration is positive (non-negative and non-zero).
      static Double isPositiveOrNull​(Double num, String fieldName)
      Asserts that the given boxed double is positive (non-negative and non-zero) or null.
      static Integer isPositiveOrNull​(Integer num, String fieldName)
      Asserts that the given boxed integer is positive (non-negative and non-zero) or null.
      static Long isPositiveOrNull​(Long num, String fieldName)
      Asserts that the given boxed long is positive (non-negative and non-zero) or null.
      static Duration isPositiveOrNull​(Duration duration, String fieldName)
      Asserts that the given duration is positive (non-negative and non-zero) or null.
      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 void mutuallyExclusive​(String message, Object... objs)
      Verify that only one of the objects is non null.
      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 extends CharSequence>
      T      		 paramNotBlank​(T chars, String paramName)
      Validate that the specified char sequence is neither null, a length of zero (no characters), empty nor whitespace; 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.
      static <T> T validState​(T object, Predicate<T> test, String message, Object... values)
      Validate the stateful predicate is true for the given object and return the object; otherwise throw an exception with the specified message.

    • 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

      • isFalse

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

        Validate that the argument condition is false; 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.isFalse(myObject.permitsSomething(), "The object is not allowed to permit something");
        Parameters:
        expression - the boolean expression to check
        message - the String.format(String, Object...) exception message if not false, not null
        values - the optional values for the formatted exception message, null array not recommended
        Throws:
        IllegalArgumentException - if expression is true

      • 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

      • isNull

        public static <T> void isNull​(T object,
                              String message,
                              Object... values)

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

        Validate.isNull(myObject, "The object must 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
        Throws:
        IllegalArgumentException - if the object is not 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

      • paramNotBlank

        public static <T extends CharSequence> T paramNotBlank​(T chars,
                                                       String paramName)

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

        Validate.paramNotBlank(myCharSequence, "myCharSequence");
        Type Parameters:
        T - the char sequence type
        Parameters:
        chars - the character sequence to check
        paramName - The name of the param or field being checked.
        Returns:
        the validated char sequence (never null for method chaining)
        Throws:
        NullPointerException - if the char sequence is null

      • validState

        public static <T> T validState​(T object,
                               Predicate<T> test,
                               String message,
                               Object... values)

        Validate the stateful predicate is true for the given object and return the object; otherwise throw an exception with the specified message.

        String value = Validate.validState(someString, s -> s.length() == 0, "must be blank got: %s", someString);
        Type Parameters:
        T - the object type
        Parameters:
        object - the object to check
        test - the predicate to apply, will return true if the object is valid
        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
        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 <T,​U> U isInstanceOf​(Class<U> type,
                                         T 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 <T> Class<? extends T> isAssignableFrom​(Class<T> 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

      • isPositive

        public static int isPositive​(int num,
                             String fieldName)
        Asserts that the given number is positive (non-negative and non-zero).
        Parameters:
        num - Number to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Number if positive.

      • isPositive

        public static long isPositive​(long num,
                              String fieldName)
        Asserts that the given number is positive (non-negative and non-zero).
        Parameters:
        num - Number to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Number if positive.

      • isPositive

        public static double isPositive​(double num,
                                String fieldName)

      • isNotNegative

        public static int isNotNegative​(int num,
                                String fieldName)

      • isNotNegativeOrNull

        public static Long isNotNegativeOrNull​(Long num,
                                       String fieldName)

      • isNotNegative

        public static long isNotNegative​(long num,
                                 String fieldName)

      • isPositive

        public static Duration isPositive​(Duration duration,
                                  String fieldName)
        Asserts that the given duration is positive (non-negative and non-zero).
        Parameters:
        duration - Number to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Duration if positive.

      • isPositiveOrNull

        public static Duration isPositiveOrNull​(Duration duration,
                                        String fieldName)
        Asserts that the given duration is positive (non-negative and non-zero) or null.
        Parameters:
        duration - Number to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Duration if positive or null.

      • isPositiveOrNull

        public static Integer isPositiveOrNull​(Integer num,
                                       String fieldName)
        Asserts that the given boxed integer is positive (non-negative and non-zero) or null.
        Parameters:
        num - Boxed integer to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Duration if positive or null.

      • isPositiveOrNull

        public static Double isPositiveOrNull​(Double num,
                                      String fieldName)
        Asserts that the given boxed double is positive (non-negative and non-zero) or null.
        Parameters:
        num - Boxed double to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Duration if double or null.

      • isPositiveOrNull

        public static Long isPositiveOrNull​(Long num,
                                    String fieldName)
        Asserts that the given boxed long is positive (non-negative and non-zero) or null.
        Parameters:
        num - Boxed long to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Duration if positive or null.

      • isNotNegative

        public static Duration isNotNegative​(Duration duration,
                                     String fieldName)
        Asserts that the given duration is positive (non-negative and non-zero).
        Parameters:
        duration - Number to validate
        fieldName - Field name to display in exception message if not positive.
        Returns:
        Duration if positive.

      • getOrDefault

        public static <T> T getOrDefault​(T param,
                                 Supplier<T> defaultValue)
        Returns the param if non null, otherwise gets a default value from the provided Supplier.
        Type Parameters:
        T - Type of value.
        Parameters:
        param - Param to return if non null.
        defaultValue - Supplier of default value.
        Returns:
        Value of param or default value if param was null.

      • mutuallyExclusive

        public static void mutuallyExclusive​(String message,
                                     Object... objs)
        Verify that only one of the objects is non null. If all objects are null this method does not throw.
        Parameters:
        message - Error message if more than one object is non-null.
        objs - Objects to validate.
        Throws:
        IllegalArgumentException - if more than one of the objects was non-null.