com.hazelcast.internal.util.Preconditions Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2008-2024, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.internal.util;
import javax.annotation.Nonnull;
import java.util.Objects;
import static java.lang.String.format;
/**
* A utility class for validating arguments and state.
*/
public final class Preconditions {
private Preconditions() {
}
/**
* Tests if a string contains text.
*
* @param argument the string tested to see if it contains text.
* @param errorMessage the errorMessage
* @return the string argument that was tested.
* @throws IllegalArgumentException if the string is empty
*/
public static String checkHasText(String argument, String errorMessage) {
if (argument == null || argument.isEmpty()) {
throw new IllegalArgumentException(errorMessage);
}
return argument;
}
@Nonnull
public static T checkNotNull(T argument, String errorMessage) {
return Objects.requireNonNull(argument, errorMessage);
}
/**
* Tests if the elements inside the argument collection are not null.
* If collection is null or empty the test is ignored.
*
* @param argument the iterable tested to see if it does not contain null elements; may be null or empty
* @param errorMessage the errorMessage
* @return the argument that was tested.
* @throws java.lang.NullPointerException if argument contains a null element inside
*/
public static Iterable checkNoNullInside(Iterable argument, String errorMessage) {
if (argument == null) {
return argument;
}
for (T element : argument) {
Objects.requireNonNull(element, errorMessage);
}
return argument;
}
@Nonnull
public static T checkNotNull(T argument) {
return Objects.requireNonNull(argument);
}
/**
* Tests if an argument is not null.
*
* @param argument the argument tested to see if it is not null.
* @param argName the argument name (used in message if an error is thrown).
* @return the string argument that was tested.
* @throws IllegalArgumentException if the string is null.
*/
public static E isNotNull(E argument, String argName) {
if (argument == null) {
throw new IllegalArgumentException(format("argument '%s' can't be null", argName));
}
return argument;
}
/**
* Tests if the {@code value} is >= 0.
*
* @param value the value tested to see if it is not negative.
* @param errorMessage the errorMessage
* @return the value
* @throws IllegalArgumentException if the value is negative.
*/
public static long checkNotNegative(long value, String errorMessage) {
if (value < 0) {
throw new IllegalArgumentException(errorMessage);
}
return value;
}
/**
* Tests if the {@code value} is >= 0.
*
* @param value the value tested to see if it is not negative.
* @param errorMessage the errorMessage
* @return the value
* @throws IllegalArgumentException if the value is negative.
*/
public static int checkNotNegative(int value, String errorMessage) {
if (value < 0) {
throw new IllegalArgumentException(errorMessage);
}
return value;
}
/**
* Tests if a {@code value} is positive, that is strictly larger than 0 (value > 0).
*
* @param paramName the name of the checked parameter that will be in exception message
* @param value the value tested to see if it is positive.
* @return the value
* @throws IllegalArgumentException if the value is not positive.
*/
public static long checkPositive(String paramName, long value) {
if (value <= 0) {
throw new IllegalArgumentException(paramName + " is " + value + " but must be > 0");
}
return value;
}
/**
* Tests if a {@code value} is positive, that is strictly larger than 0 (value > 0).
*
* @param value the value tested to see if it is positive.
* @param errorMessage the message
* @return the value
* @throws IllegalArgumentException if the value is not positive.
*/
public static double checkPositive(double value, String errorMessage) {
if (value <= 0) {
throw new IllegalArgumentException(errorMessage);
}
return value;
}
/**
* Tests if a {@code value} is positive, that is strictly larger than 0 (value > 0).
*
* @param paramName the name of the checked parameter that will be in exception message
* @param value the value tested to see if it is positive.
* @return the value
* @throws IllegalArgumentException if the value is not positive.
*/
public static int checkPositive(String paramName, int value) {
if (value <= 0) {
throw new IllegalArgumentException(paramName + " is " + value + " but must be > 0");
}
return value;
}
/**
* Tests whether the supplied expression is {@code false}.
*
* @param expression the expression tested to see if it is {@code false}.
* @param errorMessage the errorMessage
* @throws java.lang.IllegalArgumentException if the supplied expression is {@code true}.
*/
public static void checkFalse(boolean expression, String errorMessage) {
if (expression) {
throw new IllegalArgumentException(errorMessage);
}
}
/**
* Tests whether the supplied expression is {@code true}.
*
* @param expression the expression tested to see if it is {@code true}.
* @param errorMessage the errorMessage
* @throws IllegalArgumentException if the supplied expression is {@code false}.
*/
public static void checkTrue(boolean expression, String errorMessage) {
if (!expression) {
throw new IllegalArgumentException(errorMessage);
}
}
/**
* Tests the supplied object to see if it is not a type of the supplied class.
*
* @param type the type that is not of the supplied class.
* @param object the object tested against the type.
* @param errorMessage the errorMessage
* @return the object argument.
* @throws java.lang.IllegalArgumentException if the object is an instance of the type that is not of the expected class.
*/
public static E checkNotInstanceOf(Class type, E object, String errorMessage) {
isNotNull(type, "type");
if (type.isInstance(object)) {
throw new IllegalArgumentException(errorMessage);
}
return object;
}
/**
* Tests whether the supplied object is an instance of the supplied class type.
*
* @param type the expected type.
* @param object the object tested against the expected type.
* @param errorMessage the errorMessage
* @return the object argument.
* @throws java.lang.IllegalArgumentException if the object is not an instance of the expected type.
*/
public static E checkInstanceOf(Class type, Object object, String errorMessage) {
isNotNull(type, "type");
if (!type.isInstance(object)) {
throw new IllegalArgumentException(errorMessage);
}
return (E) object;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy