com.vladmihalcea.hibernate.type.range
Class Range<T extends Comparable>

java.lang.Object
  com.vladmihalcea.hibernate.type.range.Range<T>

All Implemented Interfaces:

Serializable

public final class Range<T extends Comparable>
extends Object
implements Serializable

Represents the range/interval with two bounds. Abstraction follows the semantics of the mathematical interval. The range can be unbounded or open from the left or/and unbounded from the right. The range supports half-open or closed bounds on both sides.

The class has some very simple methods for usability. For example contains(Comparable) method can tell user whether this range contains argument or not. The contains(Range) helps to find out whether this range fully enclosing argument or not.

For more details about how to use it, check out this article on vladmihalcea.com.

Author:

Edgar Asatryan, Vlad Mihalcea

See Also:

Serialized Form

Nested Class Summary

static interface

Range.Function<T,R>

Field Summary

static String	EMPTY
static String	INFINITY
static int	LOWER_EXCLUSIVE
static int	LOWER_INCLUSIVE
static int	LOWER_INFINITE
static int	UPPER_EXCLUSIVE
static int	UPPER_INCLUSIVE
static int	UPPER_INFINITE

Method Summary

String	asString()
static Range<BigDecimal>	bigDecimalRange(String range) Creates the BigDecimal range from provided string:
static <T extends Comparable<?>> Range<T>	closed(T lower, T upper) Creates the closed range with provided bounds.
static <T extends Comparable<?>> Range<T>	closedInfinite(T lower) Creates the left-bounded, left-closed and right-unbounded range with provided lower bound.
static <T extends Comparable<?>> Range<T>	closedOpen(T lower, T upper) Creates the left-closed, right-open range with provided bounds.
boolean	contains(Range<T> range) Determines whether this range contains this point or not.
boolean	contains(T point) Determines whether this range contains this point or not.
static <R extends Comparable<R>> Range<R>	emptyRange(Class<R> clazz)
boolean	equals(Object o)
int	hashCode()
boolean	hasLowerBound()
boolean	hasMask(int flag)
boolean	hasUpperBound()
static <T extends Comparable<?>> Range<T>	infinite(Class<T> cls) Creates the unbounded at both ends range with provided upper bound.
static <T extends Comparable<?>> Range<T>	infiniteClosed(T upper) Creates the left-unbounded, right-bounded and right-closed range with provided upper bound.
static <T extends Comparable<?>> Range<T>	infiniteOpen(T upper) Creates the left-unbounded, right-bounded and right-open range with provided upper bound.
static Range<Integer>	integerRange(String range) Creates the Integer range from provided string:
boolean	isLowerBoundClosed()
boolean	isUpperBoundClosed()
static Range<Long>	longRange(String range) Creates the Long range from provided string:
T	lower() Returns the lower bound of this range.
static <T extends Comparable> Range<T>	ofString(String str, Range.Function<String,T> converter, Class<T> clazz)
static <T extends Comparable<?>> Range<T>	open(T lower, T upper) Creates the open range with provided bounds.
static <T extends Comparable<?>> Range<T>	openClosed(T lower, T upper) Creates the left-open, right-closed range with provided bounds.
static <T extends Comparable<?>> Range<T>	openInfinite(T lower) Creates the left-bounded, left-open and right-unbounded range with provided lower bound.
String	toString()
T	upper() Returns the upper bound of this range.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

LOWER_INCLUSIVE

public static final int LOWER_INCLUSIVE

See Also:

Constant Field Values

LOWER_EXCLUSIVE

public static final int LOWER_EXCLUSIVE

See Also:

Constant Field Values

UPPER_INCLUSIVE

public static final int UPPER_INCLUSIVE

See Also:

Constant Field Values

UPPER_EXCLUSIVE

public static final int UPPER_EXCLUSIVE

See Also:

Constant Field Values

LOWER_INFINITE

public static final int LOWER_INFINITE

See Also:

Constant Field Values

UPPER_INFINITE

public static final int UPPER_INFINITE

See Also:

Constant Field Values

EMPTY

public static final String EMPTY

See Also:

Constant Field Values

INFINITY

public static final String INFINITY

See Also:

Constant Field Values

Method Detail

closed

public static <T extends Comparable<?>> Range<T> closed(T lower,
                                                        T upper)

Creates the closed range with provided bounds.

The mathematical equivalent will be:

[a, b] = {x | a <= x <= b}
 

.

Type Parameters:

T - The type of bounds.

Parameters:

lower - The lower bound, never null.

upper - The upper bound, never null.

Returns:

The closed range.

open

public static <T extends Comparable<?>> Range<T> open(T lower,
                                                      T upper)

Creates the open range with provided bounds.

The mathematical equivalent will be:

(a, b) = {x | a < x < b}
 

Type Parameters:

T - The type of bounds.

Parameters:

lower - The lower bound, never null.

upper - The upper bound, never null.

Returns:

The range.

openClosed

public static <T extends Comparable<?>> Range<T> openClosed(T lower,
                                                            T upper)

Creates the left-open, right-closed range with provided bounds.

The mathematical equivalent will be:

(a, b] = {x | a < x <= b}
 

Type Parameters:

T - The type of bounds.

Parameters:

lower - The lower bound, never null.

upper - The upper bound, never null.

Returns:

The range.

closedOpen

public static <T extends Comparable<?>> Range<T> closedOpen(T lower,
                                                            T upper)

Creates the left-closed, right-open range with provided bounds.

The mathematical equivalent will be:

[a, b) = {x | a <= x < b}
 

Type Parameters:

T - The type of bounds.

Parameters:

lower - The lower bound, never null.

upper - The upper bound, never null.

Returns:

The range.

openInfinite

public static <T extends Comparable<?>> Range<T> openInfinite(T lower)

Creates the left-bounded, left-open and right-unbounded range with provided lower bound.

The mathematical equivalent will be:

(a, +∞) = {x | x > a}
 

Type Parameters:

T - The type of bounds.

Parameters:

lower - The lower bound, never null.

Returns:

The range.

closedInfinite

public static <T extends Comparable<?>> Range<T> closedInfinite(T lower)

Creates the left-bounded, left-closed and right-unbounded range with provided lower bound.

The mathematical equivalent will be:

[a, +∞) = {x | x >= a}
 

Type Parameters:

T - The type of bounds.

Parameters:

lower - The lower bound, never null.

Returns:

The range.

infiniteOpen

public static <T extends Comparable<?>> Range<T> infiniteOpen(T upper)

Creates the left-unbounded, right-bounded and right-open range with provided upper bound.

The mathematical equivalent will be:

(-∞, b) = {x | x < b}
 

Type Parameters:

T - The type of bounds.

Parameters:

upper - The upper bound, never null.

Returns:

The range.

infiniteClosed

public static <T extends Comparable<?>> Range<T> infiniteClosed(T upper)

Creates the left-unbounded, right-bounded and right-closed range with provided upper bound.

The mathematical equivalent will be:

(-∞, b] = {x | x =< b}
 

Type Parameters:

T - The type of bounds.

Parameters:

upper - The upper bound, never null.

Returns:

The range.

infinite

public static <T extends Comparable<?>> Range<T> infinite(Class<T> cls)

Creates the unbounded at both ends range with provided upper bound.

The mathematical equivalent will be:

(-∞, +∞) = ℝ
 

Type Parameters:

T - The type of bounds.

Parameters:

cls - The range class, never null.

Returns:

The infinite range.

ofString

public static <T extends Comparable> Range<T> ofString(String str,
                                                       Range.Function<String,T> converter,
                                                       Class<T> clazz)

bigDecimalRange

public static Range<BigDecimal> bigDecimalRange(String range)

Creates the BigDecimal range from provided string:

Range<BigDecimal> closed = Range.bigDecimalRange("[0.1,1.1]");
     Range<BigDecimal> halfOpen = Range.bigDecimalRange("(0.1,1.1]");
     Range<BigDecimal> open = Range.bigDecimalRange("(0.1,1.1)");
     Range<BigDecimal> leftUnbounded = Range.bigDecimalRange("(,1.1)");
 

Parameters:

range - The range string, for example "[5.5,7.8]".

Returns:

The range of BigDecimals.

Throws:

NumberFormatException - when one of the bounds are invalid.

integerRange

public static Range<Integer> integerRange(String range)

Creates the Integer range from provided string:

Range<Integer> closed = Range.integerRange("[1,5]");
     Range<Integer> halfOpen = Range.integerRange("(-1,1]");
     Range<Integer> open = Range.integerRange("(1,2)");
     Range<Integer> leftUnbounded = Range.integerRange("(,10)");
     Range<Integer> unbounded = Range.integerRange("(,)");
 

Parameters:

range - The range string, for example "[5,7]".

Returns:

The range of Integers.

Throws:

NumberFormatException - when one of the bounds are invalid.

longRange

public static Range<Long> longRange(String range)

Creates the Long range from provided string:

Range<Long> closed = Range.longRange("[1,5]");
     Range<Long> halfOpen = Range.longRange("(-1,1]");
     Range<Long> open = Range.longRange("(1,2)");
     Range<Long> leftUnbounded = Range.longRange("(,10)");
     Range<Long> unbounded = Range.longRange("(,)");
 

Parameters:

range - The range string, for example "[5,7]".

Returns:

The range of Longs.

Throws:

NumberFormatException - when one of the bounds are invalid.

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object

hasMask

public boolean hasMask(int flag)

isLowerBoundClosed

public boolean isLowerBoundClosed()

isUpperBoundClosed

public boolean isUpperBoundClosed()

hasLowerBound

public boolean hasLowerBound()

hasUpperBound

public boolean hasUpperBound()

lower

public T lower()

Returns the lower bound of this range. If null is returned then this range is left-unbounded.

Returns:

The lower bound.

upper

public T upper()

Returns the upper bound of this range. If null is returned then this range is right-unbounded.

Returns:

The upper bound.

contains

public boolean contains(T point)

Determines whether this range contains this point or not.

For example:

assertTrue(integerRange("[1,2]").contains(1))
     assertTrue(integerRange("[1,2]").contains(2))
     assertTrue(integerRange("[-1,1]").contains(0))
     assertTrue(infinity(Integer.class).contains(Integer.MAX_VALUE))
     assertTrue(infinity(Integer.class).contains(Integer.MIN_VALUE))

     assertFalse(integerRange("(1,2]").contains(1))
     assertFalse(integerRange("(1,2]").contains(3))
     assertFalse(integerRange("[-1,1]").contains(0))
 

Parameters:

point - The point to check.

Returns:

Whether point in this range or not.

contains

public boolean contains(Range<T> range)

Determines whether this range contains this point or not.

For example:

assertTrue(integerRange("[-2,2]").contains(integerRange("[-1,1]")))
     assertTrue(integerRange("(,)").contains(integerRange("(,)"))

     assertFalse(integerRange("[-2,2)").contains(integerRange("[-1,2]")))
     assertFalse(integerRange("(-2,2]").contains(1))
 

Parameters:

range - The range to check.

Returns:

Whether range in this range or not.

asString

public String asString()

emptyRange

public static <R extends Comparable<R>> Range<R> emptyRange(Class<R> clazz)