|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.vladmihalcea.hibernate.type.range.Range<T>
public final class Range<T extends Comparable>
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.
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
|
closed(T lower,
T upper)
Creates the closed range with provided bounds. |
|
static
|
closedInfinite(T lower)
Creates the left-bounded, left-closed and right-unbounded range with provided lower bound. |
|
static
|
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
|
emptyRange(Class<R> clazz)
|
|
boolean |
equals(Object o)
|
|
int |
hashCode()
|
|
boolean |
hasLowerBound()
|
|
boolean |
hasMask(int flag)
|
|
boolean |
hasUpperBound()
|
|
static
|
infinite(Class<T> cls)
Creates the unbounded at both ends range with provided upper bound. |
|
static
|
infiniteClosed(T upper)
Creates the left-unbounded, right-bounded and right-closed range with provided upper bound. |
|
static
|
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
|
ofString(String str,
Range.Function<String,T> converter,
Class<T> clazz)
|
|
static
|
open(T lower,
T upper)
Creates the open range with provided bounds. |
|
static
|
openClosed(T lower,
T upper)
Creates the left-open, right-closed range with provided bounds. |
|
static
|
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 |
---|
public static final int LOWER_INCLUSIVE
public static final int LOWER_EXCLUSIVE
public static final int UPPER_INCLUSIVE
public static final int UPPER_EXCLUSIVE
public static final int LOWER_INFINITE
public static final int UPPER_INFINITE
public static final String EMPTY
public static final String INFINITY
Method Detail |
---|
public static <T extends Comparable<?>> Range<T> closed(T lower, T upper)
The mathematical equivalent will be:
[a, b] = {x | a <= x <= b}
.
T
- The type of bounds.lower
- The lower bound, never null.upper
- The upper bound, never null.
public static <T extends Comparable<?>> Range<T> open(T lower, T upper)
The mathematical equivalent will be:
(a, b) = {x | a < x < b}
T
- The type of bounds.lower
- The lower bound, never null.upper
- The upper bound, never null.
public static <T extends Comparable<?>> Range<T> openClosed(T lower, T upper)
The mathematical equivalent will be:
(a, b] = {x | a < x <= b}
T
- The type of bounds.lower
- The lower bound, never null.upper
- The upper bound, never null.
public static <T extends Comparable<?>> Range<T> closedOpen(T lower, T upper)
The mathematical equivalent will be:
[a, b) = {x | a <= x < b}
T
- The type of bounds.lower
- The lower bound, never null.upper
- The upper bound, never null.
public static <T extends Comparable<?>> Range<T> openInfinite(T lower)
The mathematical equivalent will be:
(a, +∞) = {x | x > a}
T
- The type of bounds.lower
- The lower bound, never null.
public static <T extends Comparable<?>> Range<T> closedInfinite(T lower)
The mathematical equivalent will be:
[a, +∞) = {x | x >= a}
T
- The type of bounds.lower
- The lower bound, never null.
public static <T extends Comparable<?>> Range<T> infiniteOpen(T upper)
The mathematical equivalent will be:
(-∞, b) = {x | x < b}
T
- The type of bounds.upper
- The upper bound, never null.
public static <T extends Comparable<?>> Range<T> infiniteClosed(T upper)
The mathematical equivalent will be:
(-∞, b] = {x | x =< b}
T
- The type of bounds.upper
- The upper bound, never null.
public static <T extends Comparable<?>> Range<T> infinite(Class<T> cls)
The mathematical equivalent will be:
(-∞, +∞) = ℝ
T
- The type of bounds.cls
- The range class, never null.
public static <T extends Comparable> Range<T> ofString(String str, Range.Function<String,T> converter, Class<T> clazz)
public static Range<BigDecimal> bigDecimalRange(String range)
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)");
range
- The range string, for example "[5.5,7.8]".
BigDecimal
s.
NumberFormatException
- when one of the bounds are invalid.public static Range<Integer> integerRange(String range)
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("(,)");
range
- The range string, for example "[5,7]".
Integer
s.
NumberFormatException
- when one of the bounds are invalid.public static Range<Long> longRange(String range)
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("(,)");
range
- The range string, for example "[5,7]".
Long
s.
NumberFormatException
- when one of the bounds are invalid.public boolean equals(Object o)
equals
in class Object
public int hashCode()
hashCode
in class Object
public String toString()
toString
in class Object
public boolean hasMask(int flag)
public boolean isLowerBoundClosed()
public boolean isUpperBoundClosed()
public boolean hasLowerBound()
public boolean hasUpperBound()
public T lower()
null
is returned then this range is left-unbounded.
public T upper()
null
is returned then this range is right-unbounded.
public boolean contains(T point)
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))
point
- The point to check.
point
in this range or not.public boolean contains(Range<T> range)
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))
range
- The range to check.
range
in this range or not.public String asString()
public static <R extends Comparable<R>> Range<R> emptyRange(Class<R> clazz)
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |