io.cloudslang.content.utils.NumberUtilities.java Source code

Java tutorial

Introduction

Here is the source code for io.cloudslang.content.utils.NumberUtilities.java

Source

/*
 * (c) Copyright 2017 EntIT Software LLC, a Micro Focus company, L.P.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Apache License v2.0 which accompany this distribution.
 *
 * The Apache License is available 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 io.cloudslang.content.utils;

import io.cloudslang.content.constants.ExceptionValues;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.jetbrains.annotations.Nullable;

/**
 * A Number utility class that offers integer and double validation and conversion.
 * Created by victor on 31.08.2016.
 */
public final class NumberUtilities {

    private NumberUtilities() {
    }

    /**
     * Given an integer string, it checks if it's a valid integer (based on apaches NumberUtils.createInteger)
     *
     * @param integerStr the integer string to check
     * @return true if it's valid, otherwise false
     */
    public static boolean isValidInt(@Nullable final String integerStr) {
        if (StringUtils.isBlank(integerStr)) {
            return false;
        }
        final String stripedInteger = StringUtils.strip(integerStr);
        try {
            NumberUtils.createInteger(stripedInteger);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    /**
     * Given a long integer string, it checks if it's a valid long integer (based on apaches NumberUtils.createLong)
     *
     * @param longStr the long integer string to check
     * @return true if it's valid, otherwise false
     */
    public static boolean isValidLong(@Nullable final String longStr) {
        if (StringUtils.isBlank(longStr)) {
            return false;
        }
        final String stripedLong = StringUtils.strip(longStr);
        try {
            NumberUtils.createLong(stripedLong);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    /**
     * Given an integer string, it checks if it's a valid integer (base on apaches NumberUtils.createInteger) and if
     * it's between the lowerBound and upperBound.
     *
     * @param integerStr        the integer string to check
     * @param lowerBound        the lower bound of the interval
     * @param upperBound        the upper bound of the interval
     * @param includeLowerBound boolean if to include the lower bound of the interval
     * @param includeUpperBound boolean if to include the upper bound of the interval
     * @return true if the integer string is valid and in between the lowerBound and upperBound, false otherwise
     * @throws IllegalArgumentException if the lowerBound is not less than the upperBound
     */
    public static boolean isValidInt(@Nullable final String integerStr, final int lowerBound, final int upperBound,
            final boolean includeLowerBound, final boolean includeUpperBound) {
        if (lowerBound > upperBound) {
            throw new IllegalArgumentException(ExceptionValues.INVALID_BOUNDS);
        } else if (!isValidInt(integerStr)) {
            return false;
        }
        final int aInteger = toInteger(integerStr);
        final boolean respectsLowerBound = includeLowerBound ? lowerBound <= aInteger : lowerBound < aInteger;
        final boolean respectsUpperBound = includeUpperBound ? aInteger <= upperBound : aInteger < upperBound;
        return respectsLowerBound && respectsUpperBound;
    }

    /**
     * Given a long integer string, it checks if it's a valid long (base on apaches NumberUtils.createLong) and if
     * it's between the lowerBound and upperBound.
     *
     * @param longStr        the long integer string to check
     * @param lowerBound        the lower bound of the interval
     * @param upperBound        the upper bound of the interval
     * @param includeLowerBound boolean if to include the lower bound of the interval
     * @param includeUpperBound boolean if to include the upper bound of the interval
     * @return true if the long integer string is valid and in between the lowerBound and upperBound, false otherwise
     * @throws IllegalArgumentException if the lowerBound is not less than the upperBound
     */
    public static boolean isValidLong(@Nullable final String longStr, final long lowerBound, final long upperBound,
            final boolean includeLowerBound, final boolean includeUpperBound) {
        if (lowerBound > upperBound) {
            throw new IllegalArgumentException(ExceptionValues.INVALID_BOUNDS);
        } else if (!isValidLong(longStr)) {
            return false;
        }
        final long aLong = toLong(longStr);
        final boolean respectsLowerBound = includeLowerBound ? lowerBound <= aLong : lowerBound < aLong;
        final boolean respectsUpperBound = includeUpperBound ? aLong <= upperBound : aLong < upperBound;
        return respectsLowerBound && respectsUpperBound;
    }

    /**
     * Given an integer string, it checks if it's a valid integer (base on apaches NumberUtils.createInteger) and if
     * it's between the lowerBound and upperBound (including the lowerBound and excluding the upperBound).
     *
     * @param integerStr the integer string to check
     * @param lowerBound the lower bound of the interval
     * @param upperBound the upper bound of the interval
     * @return true if the integer string is valid and in between the lowerBound and upperBound, false otherwise
     * @throws IllegalArgumentException if the lowerBound is not less than the upperBound
     */
    public static boolean isValidInt(@Nullable final String integerStr, final int lowerBound,
            final int upperBound) {
        return isValidInt(integerStr, lowerBound, upperBound, true, false);
    }

    /**
     * Given a long integer string, it checks if it's a valid long (base on apaches NumberUtils.createLong) and if
     * it's between the lowerBound and upperBound (including the lowerBound and excluding the upperBound).
     *
     * @param longStr the long integer string to check
     * @param lowerBound the lower bound of the interval
     * @param upperBound the upper bound of the interval
     * @return true if the long integer string is valid and in between the lowerBound and upperBound, false otherwise
     * @throws IllegalArgumentException if the lowerBound is not less than the upperBound
     */
    public static boolean isValidLong(@Nullable final String longStr, final long lowerBound,
            final long upperBound) {
        return isValidLong(longStr, lowerBound, upperBound, true, false);
    }

    /**
     * Given an integer string if it's a valid int (see isValidInt) it converts it into an integer otherwise it throws an exception
     *
     * @param integerStr the integer to convert
     * @return the integer value of the integerStr
     * @throws IllegalArgumentException if the passed integer string is not a valid integer
     */
    public static int toInteger(@Nullable final String integerStr) {
        if (!isValidInt(integerStr)) {
            throw new IllegalArgumentException(
                    integerStr + ExceptionValues.EXCEPTION_DELIMITER + ExceptionValues.INVALID_INTEGER_VALUE);
        }
        final String stripedInteger = StringUtils.strip(integerStr);
        return NumberUtils.createInteger(stripedInteger);
    }

    /**
     * Given a long integer string if it's a valid long (see isValidLong) it converts it into a long integer otherwise it throws an exception
     *
     * @param longStr the long integer to convert
     * @return the long integer value of the longStr
     * @throws IllegalArgumentException if the passed long integer string is not a valid long value
     */
    public static long toLong(@Nullable final String longStr) {
        if (!isValidLong(longStr)) {
            throw new IllegalArgumentException(
                    longStr + ExceptionValues.EXCEPTION_DELIMITER + ExceptionValues.INVALID_LONG_VALUE);
        }
        final String stripedLong = StringUtils.strip(longStr);
        return NumberUtils.createLong(stripedLong);
    }

    /**
     * If the integer string is null or empty, it returns the defaultInteger otherwise it returns the integer value (see toInteger)
     *
     * @param integerStr     the integer to convert
     * @param defaultInteger the default value if the integerStr is null or the empty string
     * @return the integer value of the string or the defaultInteger is the integer string is empty
     * @throws IllegalArgumentException if the passed integer string is not a valid integer
     */
    public static int toInteger(@Nullable final String integerStr, final int defaultInteger) {
        return StringUtils.isNoneEmpty(integerStr) ? toInteger(integerStr) : defaultInteger;
    }

    /**
     * If the long integer string is null or empty, it returns the defaultLong otherwise it returns the long integer value (see toLong)
     *
     * @param longStr     the long integer to convert
     * @param defaultLong the default value if the longStr is null or the empty string
     * @return the long integer value of the string or the defaultLong if the long integer string is empty
     * @throws IllegalArgumentException if the passed long integer string is not a valid long integer
     */
    public static long toLong(@Nullable final String longStr, final long defaultLong) {
        return StringUtils.isNoneEmpty(longStr) ? toLong(longStr) : defaultLong;
    }

    /**
     * Given an double string, it checks if it's a valid double (base on apaches NumberUtils.createDouble) and if
     * it's between the lowerBound and upperBound.
     *
     * @param doubleStr         the integer string to check
     * @param lowerBound        the lower bound of the interval
     * @param upperBound        the upper bound of the interval
     * @param includeLowerBound boolean if to include the lower bound of the interval
     * @param includeUpperBound boolean if to include the upper bound of the interval
     * @return true if the integer string is valid and in between the lowerBound and upperBound, false otherwise
     * @throws IllegalArgumentException if the lowerBound is not less than the upperBound
     */
    public static boolean isValidDouble(@Nullable final String doubleStr, double lowerBound, double upperBound,
            final boolean includeLowerBound, final boolean includeUpperBound) {
        if (lowerBound > upperBound) {
            throw new IllegalArgumentException(ExceptionValues.INVALID_BOUNDS);
        } else if (!isValidDouble(doubleStr)) {
            return false;
        }
        final double aDouble = toDouble(doubleStr);
        final boolean respectsLowerBound = includeLowerBound ? Double.compare(lowerBound, aDouble) <= 0
                : lowerBound < aDouble;
        final boolean respectsUpperBound = includeUpperBound ? Double.compare(aDouble, upperBound) <= 0
                : aDouble < upperBound;
        return respectsLowerBound && respectsUpperBound;
    }

    /**
     * Given an double string, it checks if it's a valid double (base on apaches NumberUtils.createDouble) and if
     * it's between the lowerBound and upperBound (including the lower bound and excluding the upper one)
     *
     * @param doubleStr  the integer string to check
     * @param lowerBound the lower bound of the interval
     * @param upperBound the upper bound of the interval
     * @return true if the integer string is valid and in between the lowerBound and upperBound, false otherwise
     * @throws IllegalArgumentException if the lowerBound is not less than the upperBound
     */
    public static boolean isValidDouble(@Nullable final String doubleStr, double lowerBound, double upperBound) {
        return isValidDouble(doubleStr, lowerBound, upperBound, true, false);
    }

    /**
     * Given an double string, it checks if it's a valid double (based on apaches NumberUtils.createDouble)
     *
     * @param doubleStr the double string to check
     * @return true if it's valid, otherwise false
     */
    public static boolean isValidDouble(@Nullable final String doubleStr) {
        if (StringUtils.isBlank(doubleStr)) {
            return false;
        }
        final String stripedDouble = StringUtils.strip(doubleStr);
        try {
            NumberUtils.createDouble(stripedDouble);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    /**
     * Given an double string if it's a valid double (see isValidDouble) it converts it into an double otherwise it throws an exception
     *
     * @param doubleStr the double to convert
     * @return the double value of the doubleStr
     * @throws IllegalArgumentException if the passed double string is not a valid double
     */
    public static double toDouble(@Nullable final String doubleStr) {
        if (!isValidDouble(doubleStr)) {
            throw new IllegalArgumentException(
                    doubleStr + ExceptionValues.EXCEPTION_DELIMITER + ExceptionValues.INVALID_DOUBLE_VALUE);
        }
        final String stripedDouble = StringUtils.strip(doubleStr);
        return NumberUtils.createDouble(stripedDouble);
    }

    /**
     * If the double string is null or empty, it returns the defaultDouble otherwise it returns the duoble value (see toDouble)
     *
     * @param doubleStr     the double to convert
     * @param defaultDouble the default value if the doubleStr is null or the empty string
     * @return the double value of the string or the defaultDouble is the double string is empty
     * @throws IllegalArgumentException if the passed double string is not a valid double
     */
    public static double toDouble(@Nullable final String doubleStr, final double defaultDouble) {
        return StringUtils.isNoneEmpty(doubleStr) ? toDouble(doubleStr) : defaultDouble;
    }
}