com.helger.commons

Class ValueEnforcer

java.lang.Object

com.helger.commons.ValueEnforcer

@Immutable
public final class ValueEnforcer
extends Object

Method Summary

Methods

Modifier and Type	Method and Description
static void	isArrayOfsLen(boolean[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(byte[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(char[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(double[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(float[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(int[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(long[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(Object[] aArray, int nOfs, int nLen)
static void	isArrayOfsLen(short[] aArray, int nOfs, int nLen)
static BigDecimal	isBetweenExclusive(BigDecimal aValue, String sName, BigDecimal aLowerBoundExclusive, BigDecimal aUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static BigInteger	isBetweenExclusive(BigInteger aValue, String sName, BigInteger aLowerBoundExclusive, BigInteger aUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static double	isBetweenExclusive(double dValue, String sName, double dLowerBoundExclusive, double dUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static float	isBetweenExclusive(float fValue, String sName, float fLowerBoundExclusive, float fUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static int	isBetweenExclusive(int nValue, String sName, int nLowerBoundExclusive, int nUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static long	isBetweenExclusive(long nValue, String sName, long nLowerBoundExclusive, long nUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static short	isBetweenExclusive(short nValue, String sName, short nLowerBoundExclusive, short nUpperBoundExclusive) Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive
static BigDecimal	isBetweenInclusive(BigDecimal aValue, String sName, BigDecimal aLowerBoundInclusive, BigDecimal aUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static BigInteger	isBetweenInclusive(BigInteger aValue, String sName, BigInteger aLowerBoundInclusive, BigInteger aUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static double	isBetweenInclusive(double dValue, String sName, double dLowerBoundInclusive, double dUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static float	isBetweenInclusive(float fValue, String sName, float fLowerBoundInclusive, float fUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static int	isBetweenInclusive(int nValue, String sName, int nLowerBoundInclusive, int nUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static long	isBetweenInclusive(long nValue, String sName, long nLowerBoundInclusive, long nUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static short	isBetweenInclusive(short nValue, String sName, short nLowerBoundInclusive, short nUpperBoundInclusive) Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive
static void	isFalse(boolean bValue, String sMsg) Check that the passed value is false.
static BigDecimal	isGE0(BigDecimal aValue, String sName)
static BigInteger	isGE0(BigInteger aValue, String sName)
static double	isGE0(double dValue, String sName)
static float	isGE0(float fValue, String sName)
static int	isGE0(int nValue, String sName)
static long	isGE0(long nValue, String sName)
static short	isGE0(short nValue, String sName)
static BigDecimal	isGT0(BigDecimal aValue, String sName)
static BigInteger	isGT0(BigInteger aValue, String sName)
static double	isGT0(double dValue, String sName)
static float	isGT0(float fValue, String sName)
static int	isGT0(int nValue, String sName)
static long	isGT0(long nValue, String sName)
static short	isGT0(short nValue, String sName)
static BigDecimal	isLE0(BigDecimal aValue, String sName)
static BigInteger	isLE0(BigInteger aValue, String sName)
static double	isLE0(double dValue, String sName)
static float	isLE0(float fValue, String sName)
static int	isLE0(int nValue, String sName)
static long	isLE0(long nValue, String sName)
static short	isLE0(short nValue, String sName)
static BigDecimal	isLT0(BigDecimal aValue, String sName)
static BigInteger	isLT0(BigInteger aValue, String sName)
static double	isLT0(double dValue, String sName)
static float	isLT0(float fValue, String sName)
static int	isLT0(int nValue, String sName)
static long	isLT0(long nValue, String sName)
static short	isLT0(short nValue, String sName)
static void	isNull(Object aValue, String sName) Check that the passed value is null.
static <T> T	isSame(T aValue, String sName, T aExpectedValue) Check that the passed value is the same as the provided expected value using == to check comparison.
static void	isTrue(boolean bValue, String sMsg) Check that the passed value is true.
static <T> T[]	noNullValue(T[] aValue, String sName) Check that the passed Array contains no null value.
static <T extends Iterable<?>> T	noNullValue(T aValue, String sName) Check that the passed iterable contains no null value.
static <T extends Map<?,?>> T	noNullValue(T aValue, String sName) Check that the passed map is neither null nor empty and that no null key or value is contained.
static boolean[]	notEmpty(boolean[] aValue, String sName) Check that the passed Array is neither null nor empty.
static byte[]	notEmpty(byte[] aValue, String sName) Check that the passed Array is neither null nor empty.
static char[]	notEmpty(char[] aValue, String sName) Check that the passed Array is neither null nor empty.
static double[]	notEmpty(double[] aValue, String sName) Check that the passed Array is neither null nor empty.
static float[]	notEmpty(float[] aValue, String sName) Check that the passed Array is neither null nor empty.
static int[]	notEmpty(int[] aValue, String sName) Check that the passed Array is neither null nor empty.
static long[]	notEmpty(long[] aValue, String sName) Check that the passed Array is neither null nor empty.
static short[]	notEmpty(short[] aValue, String sName) Check that the passed Array is neither null nor empty.
static <T> T[]	notEmpty(T[] aValue, String sName) Check that the passed Array is neither null nor empty.
static <T extends CharSequence> T	notEmpty(T aValue, String sName) Check that the passed String is neither null nor empty.
static <T extends Iterable<?>> T	notEmpty(T aValue, String sName) Check that the passed Iterable is neither null nor empty.
static <T extends Collection<?>> T	notEmpty(T aValue, String sName) Check that the passed Collection is neither null nor empty.
static <T extends Map<?,?>> T	notEmpty(T aValue, String sName) Check that the passed Collection is neither null nor empty.
static <T> T[]	notEmptyNoNullValue(T[] aValue, String sName) Check that the passed Array is neither null nor empty and that no null value is contained.
static <T extends Iterable<?>> T	notEmptyNoNullValue(T aValue, String sName) Check that the passed collection is neither null nor empty and that no null value is contained.
static <T extends Map<?,?>> T	notEmptyNoNullValue(T aValue, String sName) Check that the passed map is neither null nor empty and that no null value is contained.
static <T> T	notNull(T aValue, String sName) Check that the passed value is not null.
static <T> T	notNullAndEquals(T aValue, String sName, T aExpectedValue) Check that the passed value is not null and equal to the provided expected value.
static <T> T	notNullNotEquals(T aValue, String sName, T aUnexpectedValue) Check that the passed value is not null and not equal to the provided value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

isTrue

public static void isTrue(boolean bValue,
          String sMsg)

Check that the passed value is true.

Parameters:

bValue - The value to check.

sMsg - The message to be emitted in case the value is false

Throws:

IllegalArgumentException - if the passed value is not null.

isFalse

public static void isFalse(boolean bValue,
           String sMsg)

Check that the passed value is false.

Parameters:

bValue - The value to check.

sMsg - The message to be emitted in case the value is true

Throws:

IllegalArgumentException - if the passed value is not null.

notNull

@Nonnull
public static <T> T notNull(T aValue,
                    String sName)

Check that the passed value is not null.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

NullPointerException - if the passed value is null.

isNull

@Nonnull
public static void isNull(Object aValue,
                  String sName)

Check that the passed value is null.

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

Throws:

IllegalArgumentException - if the passed value is not null.

notEmpty

@Nonnull
public static <T extends CharSequence> T notEmpty(T aValue,
                                          String sName)

Check that the passed String is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static <T> T[] notEmpty(T[] aValue,
                       String sName)

Check that the passed Array is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static boolean[] notEmpty(boolean[] aValue,
                         String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static byte[] notEmpty(byte[] aValue,
                      String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static char[] notEmpty(char[] aValue,
                      String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static double[] notEmpty(double[] aValue,
                        String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static float[] notEmpty(float[] aValue,
                       String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static int[] notEmpty(int[] aValue,
                     String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static long[] notEmpty(long[] aValue,
                      String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static short[] notEmpty(short[] aValue,
                       String sName)

Check that the passed Array is neither null nor empty.

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static <T extends Collection<?>> T notEmpty(T aValue,
                                           String sName)

Check that the passed Collection is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static <T extends Iterable<?>> T notEmpty(T aValue,
                                         String sName)

Check that the passed Iterable is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

notEmpty

@Nonnull
public static <T extends Map<?,?>> T notEmpty(T aValue,
                                      String sName)

Check that the passed Collection is neither null nor empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The String to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty

noNullValue

@Nullable
public static <T> T[] noNullValue(T[] aValue,
                           String sName)

Check that the passed Array contains no null value. But the whole array can be null or empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null value is contained

noNullValue

@Nullable
public static <T extends Iterable<?>> T noNullValue(T aValue,
                                             String sName)

Check that the passed iterable contains no null value. But the whole iterable can be null or empty.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null value is contained

noNullValue

@Nullable
public static <T extends Map<?,?>> T noNullValue(T aValue,
                                          String sName)

Check that the passed map is neither null nor empty and that no null key or value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The map to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is not empty and a null key or null value is contained

notEmptyNoNullValue

@Nonnull
public static <T> T[] notEmptyNoNullValue(T[] aValue,
                                  String sName)

Check that the passed Array is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The Array to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue

@Nonnull
public static <T extends Iterable<?>> T notEmptyNoNullValue(T aValue,
                                                    String sName)

Check that the passed collection is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The collection to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notEmptyNoNullValue

@Nonnull
public static <T extends Map<?,?>> T notEmptyNoNullValue(T aValue,
                                                 String sName)

Check that the passed map is neither null nor empty and that no null value is contained.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The map to check.

sName - The name of the value (e.g. the parameter name)

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is empty or a null value is contained

notNullNotEquals

@Nonnull
public static <T> T notNullNotEquals(@Nonnull
                             T aValue,
                             String sName,
                             @Nonnull
                             T aUnexpectedValue)

Check that the passed value is not null and not equal to the provided value.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check. May not be null.

sName - The name of the value (e.g. the parameter name)

aUnexpectedValue - The value that may not be equal to aValue. May not be null.

Returns:

The passed value and never null.

notNullAndEquals

@Nonnull
public static <T> T notNullAndEquals(T aValue,
                             @Nonnull@Nonempty
                             String sName,
                             @Nonnull
                             T aExpectedValue)

Check that the passed value is not null and equal to the provided expected value.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May not be null.

Returns:

The passed value and never null.

Throws:

IllegalArgumentException - if the passed value is not null.

isSame

@Nullable
public static <T> T isSame(T aValue,
                    @Nonnull@Nonempty
                    String sName,
                    @Nullable
                    T aExpectedValue)

Check that the passed value is the same as the provided expected value using == to check comparison.

Type Parameters:

T - Type to be checked and returned

Parameters:

aValue - The value to check.

sName - The name of the value (e.g. the parameter name)

aExpectedValue - The expected value. May be null.

Returns:

The passed value and maybe null if the expected value is null.

Throws:

IllegalArgumentException - if the passed value is not null.

isGE0

public static short isGE0(short nValue,
          String sName)

isGE0

public static int isGE0(int nValue,
        String sName)

isGE0

public static long isGE0(long nValue,
         String sName)

isGE0

public static double isGE0(double dValue,
           String sName)

isGE0

public static float isGE0(float fValue,
          String sName)

isGE0

@Nonnull
public static BigDecimal isGE0(@Nonnull
                       BigDecimal aValue,
                       String sName)

isGE0

@Nonnull
public static BigInteger isGE0(@Nonnull
                       BigInteger aValue,
                       String sName)

isGT0

public static short isGT0(short nValue,
          String sName)

isGT0

public static int isGT0(int nValue,
        String sName)

isGT0

public static long isGT0(long nValue,
         String sName)

isGT0

public static double isGT0(double dValue,
           String sName)

isGT0

public static float isGT0(float fValue,
          String sName)

isGT0

@Nonnull
public static BigDecimal isGT0(@Nonnull
                       BigDecimal aValue,
                       String sName)

isGT0

@Nonnull
public static BigInteger isGT0(@Nonnull
                       BigInteger aValue,
                       String sName)

isLE0

public static short isLE0(short nValue,
          String sName)

isLE0

public static int isLE0(int nValue,
        String sName)

isLE0

public static long isLE0(long nValue,
         String sName)

isLE0

public static double isLE0(double dValue,
           String sName)

isLE0

public static float isLE0(float fValue,
          String sName)

isLE0

@Nonnull
public static BigDecimal isLE0(@Nonnull
                       BigDecimal aValue,
                       String sName)

isLE0

@Nonnull
public static BigInteger isLE0(@Nonnull
                       BigInteger aValue,
                       String sName)

isLT0

public static short isLT0(short nValue,
          String sName)

isLT0

public static int isLT0(int nValue,
        String sName)

isLT0

public static long isLT0(long nValue,
         String sName)

isLT0

public static double isLT0(double dValue,
           String sName)

isLT0

public static float isLT0(float fValue,
          String sName)

isLT0

@Nonnull
public static BigDecimal isLT0(@Nonnull
                       BigDecimal aValue,
                       String sName)

isLT0

@Nonnull
public static BigInteger isLT0(@Nonnull
                       BigInteger aValue,
                       String sName)

isBetweenInclusive

public static short isBetweenInclusive(short nValue,
                       String sName,
                       short nLowerBoundInclusive,
                       short nUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

nValue - Value

sName - Name

nLowerBoundInclusive - Lower bound

nUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenInclusive

public static int isBetweenInclusive(int nValue,
                     String sName,
                     int nLowerBoundInclusive,
                     int nUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

nValue - Value

sName - Name

nLowerBoundInclusive - Lower bound

nUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenInclusive

public static long isBetweenInclusive(long nValue,
                      String sName,
                      long nLowerBoundInclusive,
                      long nUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

nValue - Value

sName - Name

nLowerBoundInclusive - Lower bound

nUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenInclusive

public static float isBetweenInclusive(float fValue,
                       String sName,
                       float fLowerBoundInclusive,
                       float fUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

fValue - Value

sName - Name

fLowerBoundInclusive - Lower bound

fUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenInclusive

public static double isBetweenInclusive(double dValue,
                        String sName,
                        double dLowerBoundInclusive,
                        double dUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

dValue - Value

sName - Name

dLowerBoundInclusive - Lower bound

dUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenInclusive

public static BigDecimal isBetweenInclusive(@Nonnull
                            BigDecimal aValue,
                            String sName,
                            @Nonnull
                            BigDecimal aLowerBoundInclusive,
                            @Nonnull
                            BigDecimal aUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

aValue - Value

sName - Name

aLowerBoundInclusive - Lower bound

aUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenInclusive

public static BigInteger isBetweenInclusive(@Nonnull
                            BigInteger aValue,
                            String sName,
                            @Nonnull
                            BigInteger aLowerBoundInclusive,
                            @Nonnull
                            BigInteger aUpperBoundInclusive)

Check if nValue ≥ nLowerBoundInclusive && nValue ≤ nUpperBoundInclusive

Parameters:

aValue - Value

sName - Name

aLowerBoundInclusive - Lower bound

aUpperBoundInclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static short isBetweenExclusive(short nValue,
                       String sName,
                       short nLowerBoundExclusive,
                       short nUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

nValue - Value

sName - Name

nLowerBoundExclusive - Lower bound

nUpperBoundExclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static int isBetweenExclusive(int nValue,
                     String sName,
                     int nLowerBoundExclusive,
                     int nUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

nValue - Value

sName - Name

nLowerBoundExclusive - Lower bound

nUpperBoundExclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static long isBetweenExclusive(long nValue,
                      String sName,
                      long nLowerBoundExclusive,
                      long nUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

nValue - Value

sName - Name

nLowerBoundExclusive - Lower bound

nUpperBoundExclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static float isBetweenExclusive(float fValue,
                       String sName,
                       float fLowerBoundExclusive,
                       float fUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

fValue - Value

sName - Name

fLowerBoundExclusive - Lower bound

fUpperBoundExclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static double isBetweenExclusive(double dValue,
                        String sName,
                        double dLowerBoundExclusive,
                        double dUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

dValue - Value

sName - Name

dLowerBoundExclusive - Lower bound

dUpperBoundExclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static BigDecimal isBetweenExclusive(@Nonnull
                            BigDecimal aValue,
                            String sName,
                            @Nonnull
                            BigDecimal aLowerBoundExclusive,
                            @Nonnull
                            BigDecimal aUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

aValue - Value

sName - Name

aLowerBoundExclusive - Lower bound

aUpperBoundExclusive - Upper bound

Returns:

The value

isBetweenExclusive

public static BigInteger isBetweenExclusive(@Nonnull
                            BigInteger aValue,
                            String sName,
                            @Nonnull
                            BigInteger aLowerBoundExclusive,
                            @Nonnull
                            BigInteger aUpperBoundExclusive)

Check if nValue > nLowerBoundInclusive && nValue < nUpperBoundInclusive

Parameters:

aValue - Value

sName - Name

aLowerBoundExclusive - Lower bound

aUpperBoundExclusive - Upper bound

Returns:

The value

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 Object[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 boolean[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 byte[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 char[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 double[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 float[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 int[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 long[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)

isArrayOfsLen

public static void isArrayOfsLen(@Nonnull
                 short[] aArray,
                 @Nonnegative
                 int nOfs,
                 @Nonnegative
                 int nLen)