ValueEnforcer (ph-commons 8.0.0-rc1 API)

java.lang.Object
- com.helger.commons.ValueEnforcer

@Immutable
public final class ValueEnforcer
extends Object

Method Summary

All Methods Static Methods Concrete 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[]`	`notNullNoNullValue(T[] aValue, String sName)` Check that the passed Array is not `null` and that no `null` value is contained.
`static <T extends Iterable<?>> T`	`notNullNoNullValue(T aValue, String sName)` Check that the passed collection is not `null` and that no `null` value is contained.
`static <T extends Map<?,?>> T`	`notNullNoNullValue(T aValue, String sName)` Check that the passed map is not `null` and that no `null` value is contained.
`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. May be null.

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

Returns:

The passed value. Maybe 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. May be null.

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

Returns:

The passed value. Maybe 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. May be null.

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

Returns:

The passed value. Maybe null.

Throws:

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

notNullNoNullValue
```
@Nonnull
public static <T> T[] notNullNoNullValue(T[] aValue,
                                                   String sName)
```
Check that the passed Array is not null 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 null or a null value is contained

notNullNoNullValue
```
@Nonnull
public static <T extends Iterable<?>> T notNullNoNullValue(T aValue,
                                                                     String sName)
```
Check that the passed collection is not null 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 null or a null value is contained

notNullNoNullValue
```
@Nonnull
public static <T extends Map<?,?>> T notNullNoNullValue(T aValue,
                                                                  String sName)
```
Check that the passed map is not null 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 null or a 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