Package org.drasyl.util

Class Preconditions

java.lang.Object

org.drasyl.util.Preconditions

public final class Preconditions
extends Object

Static convenience methods that help a method or constructor check whether it was invoked correctly (that is, whether its preconditions were met).

If the precondition is not met, the Preconditions method throws an unchecked exception of a specified type, which helps the method in which the exception was thrown communicate that its caller has made a mistake.

Field Summary

Fields

Modifier and Type	Field	Description
static String	MUST_BE_IN_RANGE
static String	MUST_BE_NON_NEGATIVE
static String	MUST_BE_POSITIVE

Method Summary

Modifier and Type	Method	Description
static byte	requireInRange(byte obj, byte min, byte max)	Checks that the specified number is in the given range [min, max].
static byte	requireInRange(byte obj, byte min, byte max, String message)	Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not.
static double	requireInRange(double obj, double min, double max)	Checks that the specified number is in the given range [min, max].
static double	requireInRange(double obj, double min, double max, String message)	Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not.
static float	requireInRange(float obj, float min, float max)	Checks that the specified number is in the given range [min, max].
static float	requireInRange(float obj, float min, float max, String message)	Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not.
static int	requireInRange(int obj, int min, int max)	Checks that the specified number is in the given range [min, max].
static int	requireInRange(int obj, int min, int max, String message)	Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not.
static long	requireInRange(long obj, long min, long max)	Checks that the specified number is in the given range [min, max].
static long	requireInRange(long obj, long min, long max, String message)	Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not.
static short	requireInRange(short obj, short min, short max)	Checks that the specified number is in the given range [min, max].
static short	requireInRange(short obj, short min, short max, String message)	Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not.
static byte	requireNonNegative(byte obj)	Checks that the specified number is non-negative.
static byte	requireNonNegative(byte obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static double	requireNonNegative(double obj)	Checks that the specified number is non-negative.
static double	requireNonNegative(double obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static float	requireNonNegative(float obj)	Checks that the specified number is non-negative.
static float	requireNonNegative(float obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static int	requireNonNegative(int obj)	Checks that the specified number is non-negative.
static int	requireNonNegative(int obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static long	requireNonNegative(long obj)	Checks that the specified number is non-negative.
static long	requireNonNegative(long obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static short	requireNonNegative(short obj)	Checks that the specified number is non-negative.
static short	requireNonNegative(short obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static Duration	requireNonNegative(Duration obj)	Checks that the specified number is non-negative.
static Duration	requireNonNegative(Duration obj, String message)	Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not.
static byte	requirePositive(byte obj)	Checks that the specified number is positive.
static byte	requirePositive(byte obj, String message)	Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not.
static double	requirePositive(double obj)	Checks that the specified number is positive.
static double	requirePositive(double obj, String message)	Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not.
static float	requirePositive(float obj)	Checks that the specified number is positive.
static float	requirePositive(float obj, String message)	Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not.
static int	requirePositive(int obj)	Checks that the specified number is positive.
static int	requirePositive(int obj, String message)	Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not.
static long	requirePositive(long obj)	Checks that the specified number is positive.
static long	requirePositive(long obj, String message)	Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not.
static short	requirePositive(short obj)	Checks that the specified number is positive.
static short	requirePositive(short obj, String message)	Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not.

Methods inherited from class java.lang.Object

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

Field Detail

MUST_BE_NON_NEGATIVE

public static final String MUST_BE_NON_NEGATIVE

See Also:

Constant Field Values

MUST_BE_POSITIVE

public static final String MUST_BE_POSITIVE

See Also:

Constant Field Values

MUST_BE_IN_RANGE

public static final String MUST_BE_IN_RANGE

See Also:

Constant Field Values

Method Detail

requireNonNegative

public static byte requireNonNegative(byte obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static byte requireNonNegative(byte obj,
                                      String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static int requireNonNegative(int obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static int requireNonNegative(int obj,
                                     String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static long requireNonNegative(long obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static long requireNonNegative(long obj,
                                      String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static short requireNonNegative(short obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static short requireNonNegative(short obj,
                                       String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static float requireNonNegative(float obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static float requireNonNegative(float obj,
                                       String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static double requireNonNegative(double obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static double requireNonNegative(double obj,
                                        String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requireNonNegative

public static Duration requireNonNegative(Duration obj)

Checks that the specified number is non-negative. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

NullPointerException - if obj is null

requireNonNegative

public static Duration requireNonNegative(Duration obj,
                                          String message)

Checks that the specified number is non-negative and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireNonNegative(bar, "bar must be non-negative");
 }
 

Parameters:

obj - the number to check for negativity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

NullPointerException - if obj is null

requirePositive

public static byte requirePositive(byte obj)

Checks that the specified number is positive. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requirePositive

public static byte requirePositive(byte obj,
                                   String message)

Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar, "bar must be positive");
 }
 

Parameters:

obj - the number to check for positivity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requirePositive

public static int requirePositive(int obj)

Checks that the specified number is positive. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requirePositive

public static int requirePositive(int obj,
                                  String message)

Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar, "bar must be positive");
 }
 

Parameters:

obj - the number to check for positivity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requirePositive

public static long requirePositive(long obj)

Checks that the specified number is positive. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requirePositive

public static long requirePositive(long obj,
                                   String message)

Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar, "bar must be positive");
 }
 

Parameters:

obj - the number to check for positivity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requirePositive

public static short requirePositive(short obj)

Checks that the specified number is positive. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar);
 }
 

Parameters:

obj - the number to check for positivity

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requirePositive

public static short requirePositive(short obj,
                                    String message)

Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar, "bar must be positive");
 }
 

Parameters:

obj - the number to check for positivity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requirePositive

public static float requirePositive(float obj)

Checks that the specified number is positive. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requirePositive

public static float requirePositive(float obj,
                                    String message)

Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar, "bar must be positive");
 }
 

Parameters:

obj - the number to check for positivity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requirePositive

public static double requirePositive(double obj)

Checks that the specified number is positive. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar);
 }
 

Parameters:

obj - the number to check for negativity

Returns:

obj if non-negative

Throws:

IllegalArgumentException - if obj is negative

requirePositive

public static double requirePositive(double obj,
                                     String message)

Checks that the specified number is positive and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requirePositive(bar, "bar must be positive");
 }
 

Parameters:

obj - the number to check for positivity

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if positive

Throws:

IllegalArgumentException - if obj is not positive

requireInRange

public static byte requireInRange(byte obj,
                                  byte min,
                                  byte max)

Checks that the specified number is in the given range [min, max]. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max);
 }
 

Parameters:

obj - the number to check for range

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static byte requireInRange(byte obj,
                                  byte min,
                                  byte max,
                                  String message)

Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max, "bar must be positive");
 }
 

Parameters:

obj - the number to check for range

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static int requireInRange(int obj,
                                 int min,
                                 int max)

Checks that the specified number is in the given range [min, max]. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max);
 }
 

Parameters:

obj - the number to check for range

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static int requireInRange(int obj,
                                 int min,
                                 int max,
                                 String message)

Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max, "bar must be positive");
 }
 

Parameters:

obj - the number to check for range

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static long requireInRange(long obj,
                                  long min,
                                  long max)

Checks that the specified number is in the given range [min, max]. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max);
 }
 

Parameters:

obj - the number to check for range

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static long requireInRange(long obj,
                                  long min,
                                  long max,
                                  String message)

Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max, "bar must be positive");
 }
 

Parameters:

obj - the number to check for range

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static short requireInRange(short obj,
                                   short min,
                                   short max)

Checks that the specified number is in the given range [min, max]. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max);
 }
 

Parameters:

obj - the number to check for range

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static short requireInRange(short obj,
                                   short min,
                                   short max,
                                   String message)

Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max, "bar must be positive");
 }
 

Parameters:

obj - the number to check for range

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static float requireInRange(float obj,
                                   float min,
                                   float max)

Checks that the specified number is in the given range [min, max]. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max);
 }
 

Parameters:

obj - the number to check for range

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static float requireInRange(float obj,
                                   float min,
                                   float max,
                                   String message)

Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max, "bar must be positive");
 }
 

Parameters:

obj - the number to check for range

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static double requireInRange(double obj,
                                    double min,
                                    double max)

Checks that the specified number is in the given range [min, max]. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max);
 }
 

Parameters:

obj - the number to check for range

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range

requireInRange

public static double requireInRange(double obj,
                                    double min,
                                    double max,
                                    String message)

Checks that the specified number is in the given range [min, max] and throws a customized IllegalArgumentException if it is not. This method is designed primarily for doing parameter validation in methods and constructors, as demonstrated below:

 public Foo(int bar) {
     this.bar = Preconditions.requireInRange(bar, min, max, "bar must be positive");
 }
 

Parameters:

obj - the number to check for range

message - detail message to be used in the event that a IllegalArgumentException is thrown

Returns:

obj if in range

Throws:

IllegalArgumentException - if obj is not in range