Java tutorial
/** * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.strata.collect; import java.util.Collection; import java.util.Map; import java.util.Map.Entry; import java.util.regex.Pattern; import com.google.common.base.CharMatcher; import com.google.common.math.DoubleMath; /** * Contains utility methods for checking inputs to methods. * <p> * This utility is used throughout the system to validate inputs to methods. * Most of the methods return their validated input, allowing patterns like this: * <pre> * // constructor * public Person(String name, int age) { * this.name = ArgChecker.notBlank(name, "name"); * this.age = ArgChecker.notNegative(age, "age"); * } * </pre> */ public final class ArgChecker { /** * Restricted constructor. */ private ArgChecker() { } //------------------------------------------------------------------------- /** * Checks that the specified boolean is true. * <p> * Given the input argument, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(collection.contains("value")); * </pre> * <p> * It is strongly recommended to pass an additional message argument using * {@link #isTrue(boolean, String)}. * * @param validIfTrue a boolean resulting from testing an argument * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue) { // return void, not the argument, as no need to check a boolean method argument if (!validIfTrue) { throw new IllegalArgumentException("Invalid argument, expression must be true"); } } /** * Checks that the specified boolean is true. * <p> * Given the input argument, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(collection.contains("value"), "Collection must contain 'value'"); * </pre> * * @param validIfTrue a boolean resulting from testing an argument * @param message the error message, not null * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue, String message) { // return void, not the argument, as no need to check a boolean method argument if (!validIfTrue) { throw new IllegalArgumentException(message); } } /** * Checks that the specified boolean is true. * <p> * Given the input argument, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(collection.contains("value"), "Collection must contain 'value': {}", collection); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean argument value. * <p> * The message is produced using a template that contains zero to many "{}" placeholders. * Each placeholder is replaced by the next available argument. * If there are too few arguments, then the message will be left with placeholders. * If there are too many arguments, then the excess arguments are appended to the * end of the message. No attempt is made to format the arguments. * See {@link Messages#format(String, Object...)} for more details. * * @param validIfTrue a boolean resulting from testing an argument * @param message the error message with {} placeholders, not null * @param arg the message arguments * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue, String message, Object... arg) { // return void, not the argument, as no need to check a boolean method argument if (!validIfTrue) { throw new IllegalArgumentException(Messages.format(message, arg)); } } /** * Checks that the specified boolean is true. * <p> * Given the input argument, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(value > check, "Value must be greater than check: {}", value); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean argument value. * <p> * The message is produced using a template that contains zero or one "{}" placeholders. * The placeholder, if present, is replaced by the argument. * If there is no placeholder, the argument is appended to the end of the message. * * @param validIfTrue a boolean resulting from testing an argument * @param message the error message with {} placeholders, not null * @param arg the message argument * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue, String message, long arg) { // return void, not the argument, as no need to check a boolean method argument if (!validIfTrue) { throw new IllegalArgumentException(Messages.format(message, arg)); } } /** * Checks that the specified boolean is true. * <p> * Given the input argument, this returns normally only if it is true. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isTrue(value > check, "Value must be greater than check: {}", value); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean argument value. * <p> * The message is produced using a template that contains zero or one "{}" placeholders. * The placeholder, if present, is replaced by the argument. * If there is no placeholder, the argument is appended to the end of the message. * * @param validIfTrue a boolean resulting from testing an argument * @param message the error message with {} placeholders, not null * @param arg the message argument * @throws IllegalArgumentException if the test value is false */ public static void isTrue(boolean validIfTrue, String message, double arg) { // return void, not the argument, as no need to check a boolean method argument if (!validIfTrue) { throw new IllegalArgumentException(Messages.format(message, arg)); } } /** * Checks that the specified boolean is false. * <p> * Given the input argument, this returns normally only if it is false. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isFalse(collection.contains("value"), "Collection must not contain 'value'"); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean argument value. * * @param validIfFalse a boolean resulting from testing an argument * @param message the error message, not null * @throws IllegalArgumentException if the test value is true */ public static void isFalse(boolean validIfFalse, String message) { // return void, not the argument, as no need to check a boolean method argument if (validIfFalse) { throw new IllegalArgumentException(message); } } /** * Checks that the specified boolean is false. * <p> * Given the input argument, this returns normally only if it is false. * This will typically be the result of a caller-specific check. * For example: * <pre> * ArgChecker.isFalse(collection.contains("value"), "Collection must not contain 'value': {}", collection); * </pre> * <p> * This returns {@code void}, and not the value being checked, as there is * never a good reason to validate a boolean argument value. * <p> * The message is produced using a template that contains zero to many "{}" placeholders. * Each placeholder is replaced by the next available argument. * If there are too few arguments, then the message will be left with placeholders. * If there are too many arguments, then the excess arguments are appended to the * end of the message. No attempt is made to format the arguments. * See {@link Messages#format(String, Object...)} for more details. * * @param validIfFalse a boolean resulting from testing an argument * @param message the error message with {} placeholders, not null * @param arg the message arguments, not null * @throws IllegalArgumentException if the test value is true */ public static void isFalse(boolean validIfFalse, String message, Object... arg) { // return void, not the argument, as no need to check a boolean method argument if (validIfFalse) { throw new IllegalArgumentException(Messages.format(message, arg)); } } //------------------------------------------------------------------------- /** * Checks that the specified argument is non-null. * <p> * Given the input argument, this returns only if it is non-null. * For example, in a constructor: * <pre> * this.name = ArgChecker.notNull(name, "name"); * </pre> * * @param <T> the type of the input argument reflected in the result * @param argument the argument to check, null throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null */ public static <T> T notNull(T argument, String name) { if (argument == null) { throw new IllegalArgumentException(notNullMsg(name)); } return argument; } // extracted to aid inlining performance private static String notNullMsg(String name) { return "Argument '" + name + "' must not be null"; } /** * Checks that the specified item is non-null. * <p> * Given the input argument, this returns only if it is non-null. * One use for this method is in a stream: * <pre> * ArgChecker.notNull(coll, "coll") * coll.stream() * .map(ArgChecker::notNullItem) * ... * </pre> * * @param <T> the type of the input argument reflected in the result * @param argument the argument to check, null throws an exception * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null */ public static <T> T notNullItem(T argument) { if (argument == null) { throw new IllegalArgumentException("Argument array/collection/map must not contain null"); } return argument; } //------------------------------------------------------------------------- /** * Checks that the specified argument is non-null and matches the specified pattern. * <p> * Given the input argument, this returns only if it is non-null and matches * the regular expression pattern specified. * For example, in a constructor: * <pre> * this.name = ArgChecker.matches(REGEX_NAME, name, "name"); * </pre> * * @param pattern the pattern to check against, not null * @param argument the argument to check, null throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static String matches(Pattern pattern, String argument, String name) { notNull(pattern, "pattern"); notNull(argument, name); if (!pattern.matcher(argument).matches()) { throw new IllegalArgumentException(matchesMsg(pattern, name, argument)); } return argument; } // extracted to aid inlining performance private static String matchesMsg(Pattern pattern, String name, String value) { return "Argument '" + name + "' with value '" + value + "' must match pattern: " + pattern; } //------------------------------------------------------------------------- /** * Checks that the specified argument is non-null and only contains the specified characters. * <p> * Given the input argument, this returns only if it is non-null and matches * the {@link CharMatcher} specified. * For example, in a constructor: * <pre> * this.name = ArgChecker.matches(REGEX_NAME, 1, Integer.MAX_VALUE, name, "name", "[A-Z]+"); * </pre> * * @param matcher the matcher to check against, not null * @param minLength the minimum length to allow * @param maxLength the minimum length to allow * @param argument the argument to check, null throws an exception * @param name the name of the argument to use in the error message, not null * @param equivalentRegex the equivalent regular expression pattern * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static String matches(CharMatcher matcher, int minLength, int maxLength, String argument, String name, String equivalentRegex) { notNull(matcher, "pattern"); notNull(argument, name); if (argument.length() < minLength || argument.length() > maxLength || !matcher.matchesAllOf(argument)) { throw new IllegalArgumentException(matchesMsg(matcher, name, argument, equivalentRegex)); } return argument; } // extracted to aid inlining performance private static String matchesMsg(CharMatcher matcher, String name, String value, String equivalentRegex) { return "Argument '" + name + "' with value '" + value + "' must match pattern: " + equivalentRegex; } //------------------------------------------------------------------------- /** * Checks that the specified argument is non-null and not blank. * <p> * Given the input argument, this returns the input only if it is non-null * and contains at least one non whitespace character. * This is often linked with a call to {@code trim()}. * For example, in a constructor: * <pre> * this.name = ArgChecker.notBlank(name, "name").trim(); * </pre> * <p> * The argument is trimmed using {@link String#trim()} to determine if it is empty. * The result is the original argument, not the trimmed one. * * @param argument the argument to check, null or blank throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or blank */ public static String notBlank(String argument, String name) { notNull(argument, name); if (argument.trim().isEmpty()) { throw new IllegalArgumentException(notBlankMsg(name)); } return argument; } // extracted to aid inlining performance private static String notBlankMsg(String name) { return "Argument '" + name + "' must not be blank"; } //------------------------------------------------------------------------- /** * Checks that the specified argument is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains * at least one character, which may be a whitespace character. * See also {@link #notBlank(String, String)}. * For example, in a constructor: * <pre> * this.name = ArgChecker.notEmpty(name, "name"); * </pre> * * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static String notEmpty(String argument, String name) { notNull(argument, name); if (argument.isEmpty()) { throw new IllegalArgumentException(notEmptyMsg(name)); } return argument; } // extracted to aid inlining performance private static String notEmptyMsg(String name) { return "Argument '" + name + "' must not be empty"; } /** * Checks that the specified argument array is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains * at least one element. The element is not validated and may be null. * For example, in a constructor: * <pre> * this.names = ArgChecker.notEmpty(names, "names"); * </pre> * * @param <T> the type of the input array reflected in the result * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <T> T[] notEmpty(T[] argument, String name) { notNull(argument, name); if (argument.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return argument; } // extracted to aid inlining performance private static String notEmptyArrayMsg(String name) { return "Argument array '" + name + "' must not be empty"; } /** * Checks that the specified argument array is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains * at least one element. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static int[] notEmpty(int[] argument, String name) { notNull(argument, name); if (argument.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return argument; } /** * Checks that the specified argument array is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains * at least one element. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static long[] notEmpty(long[] argument, String name) { notNull(argument, name); if (argument.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return argument; } /** * Checks that the specified argument array is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains * at least one element. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static double[] notEmpty(double[] argument, String name) { notNull(argument, name); if (argument.length == 0) { throw new IllegalArgumentException(notEmptyArrayMsg(name)); } return argument; } /** * Checks that the specified argument iterable is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains * at least one element. The element is not validated and may be null. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param <T> the element type of the input iterable reflected in the result * @param <I> the type of the input iterable, reflected in the result * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <T, I extends Iterable<T>> I notEmpty(I argument, String name) { notNull(argument, name); if (!argument.iterator().hasNext()) { throw new IllegalArgumentException(notEmptyIterableMsg(name)); } return argument; } // extracted to aid inlining performance private static String notEmptyIterableMsg(String name) { return "Argument iterable '" + name + "' must not be empty"; } /** * Checks that the specified argument collection is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains at least one element. * The element is not validated and may contain nulls if the collection allows nulls. * For example, in a constructor: * <pre> * this.values = ArgChecker.notEmpty(values, "values"); * </pre> * * @param <T> the element type of the input collection reflected in the result * @param <C> the type of the input collection, reflected in the result * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <T, C extends Collection<T>> C notEmpty(C argument, String name) { notNull(argument, name); if (argument.isEmpty()) { throw new IllegalArgumentException(notEmptyCollectionMsg(name)); } return argument; } // extracted to aid inlining performance private static String notEmptyCollectionMsg(String name) { return "Argument collection '" + name + "' must not be empty"; } /** * Checks that the specified argument map is non-null and not empty. * <p> * Given the input argument, this returns only if it is non-null and contains at least one mapping. * The element is not validated and may contain nulls if the collection allows nulls. * For example, in a constructor: * <pre> * this.keyValues = ArgChecker.notEmpty(keyValues, "keyValues"); * </pre> * * @param <K> the key type of the input map key, reflected in the result * @param <V> the value type of the input map value, reflected in the result * @param <M> the type of the input map, reflected in the result * @param argument the argument to check, null or empty throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or empty */ public static <K, V, M extends Map<K, V>> M notEmpty(M argument, String name) { notNull(argument, name); if (argument.isEmpty()) { throw new IllegalArgumentException(notEmptyMapMsg(name)); } return argument; } // extracted to aid inlining performance private static String notEmptyMapMsg(String name) { return "Argument map '" + name + "' must not be empty"; } //------------------------------------------------------------------------- /** * Checks that the specified argument array is non-null and contains no nulls. * <p> * Given the input argument, this returns only if it is non-null and contains no nulls. * For example, in a constructor: * <pre> * this.values = ArgChecker.noNulls(values, "values"); * </pre> * * @param <T> the type of the input array reflected in the result * @param argument the argument to check, null or contains null throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or contains nulls */ public static <T> T[] noNulls(T[] argument, String name) { notNull(argument, name); for (int i = 0; i < argument.length; i++) { if (argument[i] == null) { throw new IllegalArgumentException( "Argument array '" + name + "' must not contain null at index " + i); } } return argument; } /** * Checks that the specified argument collection is non-null and contains no nulls. * <p> * Given the input argument, this returns only if it is non-null and contains no nulls. * For example, in a constructor: * <pre> * this.values = ArgChecker.noNulls(values, "values"); * </pre> * * @param <T> the element type of the input iterable reflected in the result * @param <I> the type of the input iterable, reflected in the result * @param argument the argument to check, null or contains null throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or contains nulls */ public static <T, I extends Iterable<T>> I noNulls(I argument, String name) { notNull(argument, name); for (Object obj : argument) { if (obj == null) { throw new IllegalArgumentException("Argument iterable '" + name + "' must not contain null"); } } return argument; } /** * Checks that the specified argument map is non-null and contains no nulls. * <p> * Given the input argument, this returns only if it is non-null and contains no nulls. * For example, in a constructor: * <pre> * this.keyValues = ArgChecker.noNulls(keyValues, "keyValues"); * </pre> * * @param <K> the key type of the input map key, reflected in the result * @param <V> the value type of the input map value, reflected in the result * @param <M> the type of the input map, reflected in the result * @param argument the argument to check, null or contains null throws an exception * @param name the name of the argument to use in the error message, not null * @return the input {@code argument}, not null * @throws IllegalArgumentException if the input is null or contains nulls */ public static <K, V, M extends Map<K, V>> M noNulls(M argument, String name) { notNull(argument, name); for (Entry<K, V> entry : argument.entrySet()) { if (entry.getKey() == null) { throw new IllegalArgumentException("Argument map '" + name + "' must not contain a null key"); } if (entry.getValue() == null) { throw new IllegalArgumentException("Argument map '" + name + "' must not contain a null value"); } } return argument; } //------------------------------------------------------------------------- /** * Checks that the argument is not negative. * <p> * Given the input argument, this returns only if it is zero or greater. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegative(amount, "amount"); * </pre> * * @param argument the argument to check * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the input is negative */ public static int notNegative(int argument, String name) { if (argument < 0) { throw new IllegalArgumentException(notNegativeMsg(name)); } return argument; } // extracted to aid inlining performance private static String notNegativeMsg(String name) { return "Argument '" + name + "' must not be negative"; } /** * Checks that the argument is not negative. * <p> * Given the input argument, this returns only if it is zero or greater. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegative(amount, "amount"); * </pre> * * @param argument the argument to check * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the input is negative */ public static long notNegative(long argument, String name) { if (argument < 0) { throw new IllegalArgumentException(notNegativeMsg(name)); } return argument; } /** * Checks that the argument is not negative. * <p> * Given the input argument, this returns only if it is zero or greater. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegative(amount, "amount"); * </pre> * * @param argument the argument to check * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the input is negative */ public static double notNegative(double argument, String name) { if (argument < 0) { throw new IllegalArgumentException(notNegativeMsg(name)); } return argument; } //------------------------------------------------------------------------- /** * Checks that the argument is not negative or zero. * <p> * Given the input argument, this returns only if it is greater than zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, "amount"); * </pre> * * @param argument the argument to check * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the input is negative or zero */ public static int notNegativeOrZero(int argument, String name) { if (argument <= 0) { throw new IllegalArgumentException(notNegativeOrZeroMsg(name, argument)); } return argument; } // extracted to aid inlining performance private static String notNegativeOrZeroMsg(String name, double argument) { return "Argument '" + name + "' must not be negative or zero but has value " + argument; } /** * Checks that the argument is not negative or zero. * <p> * Given the input argument, this returns only if it is greater than zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, "amount"); * </pre> * * @param argument the argument to check * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the input is negative or zero */ public static long notNegativeOrZero(long argument, String name) { if (argument <= 0) { throw new IllegalArgumentException(notNegativeOrZeroMsg(name, argument)); } return argument; } /** * Checks that the argument is not negative or zero. * <p> * Given the input argument, this returns only if it is greater than zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, "amount"); * </pre> * * @param argument the argument to check * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the input is negative or zero */ public static double notNegativeOrZero(double argument, String name) { if (argument <= 0) { throw new IllegalArgumentException(notNegativeOrZeroMsg(name, argument)); } return argument; } /** * Checks that the argument is greater than zero to within a given accuracy. * <p> * Given the input argument, this returns only if it is greater than zero * using the {@code eps} accuracy for zero. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notNegativeOrZero(amount, 0.0001d, "amount"); * </pre> * * @param argument the value to check * @param tolerance the tolerance to use for zero * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the absolute value of the argument is less than eps */ public static double notNegativeOrZero(double argument, double tolerance, String name) { if (DoubleMath.fuzzyEquals(argument, 0, tolerance)) { throw new IllegalArgumentException("Argument '" + name + "' must not be zero"); } if (argument < 0) { throw new IllegalArgumentException( "Argument '" + name + "' must be greater than zero but has value " + argument); } return argument; } //------------------------------------------------------------------------- /** * Checks that the argument is not equal to zero to within a given accuracy. * <p> * Given the input argument, this returns only if it is not zero comparing * using the {@code eps} accuracy. * For example, in a constructor: * <pre> * this.amount = ArgChecker.notZero(amount, 0.0001d, "amount"); * </pre> * * @param argument the value to check * @param tolerance the tolerance to use for zero * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the absolute value of the argument is less than the tolerance */ public static double notZero(double argument, double tolerance, String name) { if (DoubleMath.fuzzyEquals(argument, 0d, tolerance)) { throw new IllegalArgumentException("Argument '" + name + "' must not be zero"); } return argument; } //------------------------------------------------------------------------- /** * Checks that the argument is within the range defined by {@code low <= x < high}. * <p> * Given a value, this returns true if it is within the specified range including the * lower boundary but excluding the upper boundary. * For example, in a constructor: * <pre> * this.amount = ArgChecker.inRange(amount, 0d, 1d, "amount"); * </pre> * * @param argument the value to check * @param lowInclusive the low value of the range * @param highExclusive the high value of the range * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the argument is outside the valid range */ public static double inRange(double argument, double lowInclusive, double highExclusive, String name) { if (argument < lowInclusive || argument >= highExclusive) { throw new IllegalArgumentException(Messages.format("Expected {} <= '{}' < {}, but found {}", lowInclusive, name, highExclusive, argument)); } return argument; } /** * Checks that the argument is within the range defined by {@code low <= x <= high}. * <p> * Given a value, this returns true if it is within the specified range including both boundaries. * For example, in a constructor: * <pre> * this.amount = ArgChecker.inRangeInclusive(amount, 0d, 1d, "amount"); * </pre> * * @param argument the value to check * @param lowInclusive the low value of the range * @param highInclusive the high value of the range * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the argument is outside the valid range */ public static double inRangeInclusive(double argument, double lowInclusive, double highInclusive, String name) { if (argument < lowInclusive || argument > highInclusive) { throw new IllegalArgumentException(Messages.format("Expected {} <= '{}' <= {}, but found {}", lowInclusive, name, highInclusive, argument)); } return argument; } /** * Checks that the argument is within the range defined by {@code low < x < high}. * <p> * Given a value, this returns true if it is within the specified range excluding both boundaries. * For example, in a constructor: * <pre> * this.amount = ArgChecker.inRangeExclusive(amount, 0d, 1d, "amount"); * </pre> * * @param argument the value to check * @param lowExclusive the low value of the range * @param highExclusive the high value of the range * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the argument is outside the valid range */ public static double inRangeExclusive(double argument, double lowExclusive, double highExclusive, String name) { if (argument <= lowExclusive || argument >= highExclusive) { throw new IllegalArgumentException(Messages.format("Expected {} < '{}' < {}, but found {}", lowExclusive, name, highExclusive, argument)); } return argument; } //------------------------------------------------------------------------- /** * Checks that the argument is within the range defined by {@code low <= x < high}. * <p> * Given a value, this returns true if it is within the specified range including the * lower boundary but excluding the upper boundary. * For example, in a constructor: * <pre> * this.amount = ArgChecker.inRange(amount, 0d, 1d, "amount"); * </pre> * * @param argument the value to check * @param lowInclusive the low value of the range * @param highExclusive the high value of the range * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the argument is outside the valid range */ public static int inRange(int argument, int lowInclusive, int highExclusive, String name) { if (argument < lowInclusive || argument >= highExclusive) { throw new IllegalArgumentException(Messages.format("Expected {} <= '{}' < {}, but found {}", lowInclusive, name, highExclusive, argument)); } return argument; } /** * Checks that the argument is within the range defined by {@code low <= x <= high}. * <p> * Given a value, this returns true if it is within the specified range including both boundaries. * For example, in a constructor: * <pre> * this.amount = ArgChecker.inRangeInclusive(amount, 0d, 1d, "amount"); * </pre> * * @param argument the value to check * @param lowInclusive the low value of the range * @param highInclusive the high value of the range * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the argument is outside the valid range */ public static int inRangeInclusive(int argument, int lowInclusive, int highInclusive, String name) { if (argument < lowInclusive || argument > highInclusive) { throw new IllegalArgumentException(Messages.format("Expected {} <= '{}' <= {}, but found {}", lowInclusive, name, highInclusive, argument)); } return argument; } /** * Checks that the argument is within the range defined by {@code low < x < high}. * <p> * Given a value, this returns true if it is within the specified range excluding both boundaries. * For example, in a constructor: * <pre> * this.amount = ArgChecker.inRangeExclusive(amount, 0d, 1d, "amount"); * </pre> * * @param argument the value to check * @param lowExclusive the low value of the range * @param highExclusive the high value of the range * @param name the name of the argument to use in the error message, not null * @return the input {@code argument} * @throws IllegalArgumentException if the argument is outside the valid range */ public static int inRangeExclusive(int argument, int lowExclusive, int highExclusive, String name) { if (argument <= lowExclusive || argument >= highExclusive) { throw new IllegalArgumentException(Messages.format("Expected {} < '{}' < {}, but found {}", lowExclusive, name, highExclusive, argument)); } return argument; } //------------------------------------------------------------------------- /** * Checks that the two values are in order and not equal. * <p> * Given two comparable instances, this checks that the first is "less than" the second. * Two equal values also throw the exception. * * @param <T> the type * @param obj1 the first object, null throws an exception * @param obj2 the second object, null throws an exception * @param name1 the first argument name, not null * @param name2 the second argument name, not null * @throws IllegalArgumentException if either input is null or they are not in order */ public static <T> void inOrderNotEqual(Comparable<? super T> obj1, T obj2, String name1, String name2) { notNull(obj1, name1); notNull(obj2, name2); if (obj1.compareTo(obj2) >= 0) { throw new IllegalArgumentException(Messages.format( "Invalid order: Expected '{}' < '{}', but found: '{}' >= '{}", name1, name2, obj1, obj2)); } } /** * Checks that the two values are in order or equal. * <p> * Given two comparable instances, this checks that the first is "less than" or "equal to" the second. * * @param <T> the type * @param obj1 the first object, null throws an exception * @param obj2 the second object, null throws an exception * @param name1 the first argument name, not null * @param name2 the second argument name, not null * @throws IllegalArgumentException if either input is null or they are not in order */ public static <T> void inOrderOrEqual(Comparable<? super T> obj1, T obj2, String name1, String name2) { notNull(obj1, name1); notNull(obj2, name2); if (obj1.compareTo(obj2) > 0) { throw new IllegalArgumentException(Messages.format( "Invalid order: Expected '{}' <= '{}', but found: '{}' > '{}", name1, name2, obj1, obj2)); } } }