| Methods Summary |
|---|
| public static float | checkArgumentFinite(float value, java.lang.String valueName)Ensures that the argument floating point value is a finite number.
A finite number is defined to be both representable (that is, not NaN) and
not infinite (that is neither positive or negative infinity).
if (Float.isNaN(value)) {
throw new IllegalArgumentException(valueName + " must not be NaN");
} else if (Float.isInfinite(value)) {
throw new IllegalArgumentException(valueName + " must not be infinite");
}
return value;
|
| public static int | checkArgumentInRange(int value, int lower, int upper, java.lang.String valueName)Ensures that the argument int value is within the inclusive range.
if (value < lower) {
throw new IllegalArgumentException(
String.format(
"%s is out of range of [%d, %d] (too low)", valueName, lower, upper));
} else if (value > upper) {
throw new IllegalArgumentException(
String.format(
"%s is out of range of [%d, %d] (too high)", valueName, lower, upper));
}
return value;
|
| public static float | checkArgumentInRange(float value, float lower, float upper, java.lang.String valueName)Ensures that the argument floating point value is within the inclusive range.
While this can be used to range check against +/- infinity, note that all NaN numbers
will always be out of range.
if (Float.isNaN(value)) {
throw new IllegalArgumentException(valueName + " must not be NaN");
} else if (value < lower) {
throw new IllegalArgumentException(
String.format(
"%s is out of range of [%f, %f] (too low)", valueName, lower, upper));
} else if (value > upper) {
throw new IllegalArgumentException(
String.format(
"%s is out of range of [%f, %f] (too high)", valueName, lower, upper));
}
return value;
|
| public static int | checkArgumentNonnegative(int value, java.lang.String errorMessage)Ensures that that the argument numeric value is non-negative.
if (value < 0) {
throw new IllegalArgumentException(errorMessage);
}
return value;
|
| public static long | checkArgumentNonnegative(long value, java.lang.String errorMessage)Ensures that that the argument numeric value is non-negative.
if (value < 0) {
throw new IllegalArgumentException(errorMessage);
}
return value;
|
| public static int | checkArgumentPositive(int value, java.lang.String errorMessage)Ensures that that the argument numeric value is positive.
if (value <= 0) {
throw new IllegalArgumentException(errorMessage);
}
return value;
|
| public static float[] | checkArrayElementsInRange(float[] value, float lower, float upper, java.lang.String valueName)Ensures that all elements in the argument floating point array are within the inclusive range
While this can be used to range check against +/- infinity, note that all NaN numbers
will always be out of range.
checkNotNull(value, valueName + " must not be null");
for (int i = 0; i < value.length; ++i) {
float v = value[i];
if (Float.isNaN(v)) {
throw new IllegalArgumentException(valueName + "[" + i + "] must not be NaN");
} else if (v < lower) {
throw new IllegalArgumentException(
String.format("%s[%d] is out of range of [%f, %f] (too low)",
valueName, i, lower, upper));
} else if (v > upper) {
throw new IllegalArgumentException(
String.format("%s[%d] is out of range of [%f, %f] (too high)",
valueName, i, lower, upper));
}
}
return value;
|
| public static T[] | checkArrayElementsNotNull(T[] value, java.lang.String valueName)Ensures that the array is not {@code null}, and none of its elements are {@code null}.
if (value == null) {
throw new NullPointerException(valueName + " must not be null");
}
for (int i = 0; i < value.length; ++i) {
if (value[i] == null) {
throw new NullPointerException(
String.format("%s[%d] must not be null", valueName, i));
}
}
return value;
|
| public static java.util.Collection | checkCollectionElementsNotNull(java.util.Collection value, java.lang.String valueName)Ensures that the {@link Collection} is not {@code null}, and none of its elements are
{@code null}.
if (value == null) {
throw new NullPointerException(valueName + " must not be null");
}
long ctr = 0;
for (T elem : value) {
if (elem == null) {
throw new NullPointerException(
String.format("%s[%d] must not be null", valueName, ctr));
}
++ctr;
}
return value;
|
| public static java.util.Collection | checkCollectionNotEmpty(java.util.Collection value, java.lang.String valueName)Ensures that the {@link Collection} is not {@code null}, and contains at least one element.
if (value == null) {
throw new NullPointerException(valueName + " must not be null");
}
if (value.isEmpty()) {
throw new IllegalArgumentException(valueName + " is empty");
}
return value;
|
| public static void | checkFlagsArgument(int requestedFlags, int allowedFlags)Check the requested flags, throwing if any requested flags are outside
the allowed set.
if ((requestedFlags & allowedFlags) != requestedFlags) {
throw new IllegalArgumentException("Requested flags 0x"
+ Integer.toHexString(requestedFlags) + ", but only 0x"
+ Integer.toHexString(allowedFlags) + " are allowed");
}
|
| public static T | checkNotNull(T reference)Ensures that an object reference passed as a parameter to the calling
method is not null.
if (reference == null) {
throw new NullPointerException();
}
return reference;
|
| public static T | checkNotNull(T reference, java.lang.Object errorMessage)Ensures that an object reference passed as a parameter to the calling
method is not null.
if (reference == null) {
throw new NullPointerException(String.valueOf(errorMessage));
}
return reference;
|
| public static void | checkState(boolean expression)Ensures the truth of an expression involving the state of the calling
instance, but not involving any parameters to the calling method.
if (!expression) {
throw new IllegalStateException();
}
|
