public interface Range<T extends java.lang.Comparable>
extends java.util.List<T>
from
)
value and working up towards some ending (or to
) value.
For a reverse range, the list is obtained by starting at the to
value and
working down towards the from
value.
The concept of working up and working down is dependent on the range implementation.
In the general case, working up involves successive calls to the first item's next()
method while working down involves calling the previous()
method. Optimized
numerical ranges may apply numeric addition or subtraction of some numerical step size.
Particular range implementations may also support the notion of inclusivity
and exclusivity with respect to the ending value in the range.
E.g. 1..3 == [1, 2, 3]
; but 1..<3 == [1, 2]
.
In general, the second boundary may not be contained in the range,
and a..b
may produce a different set of elements than (b..a).reversed()
.
E.g. 1..2.5 == [1, 2]
; but 2.5..1 == [2.5, 1.5]
.
Implementations can be memory efficient by storing just the from
and to
boundary
values rather than eagerly creating all discrete items in the conceptual list. The actual discrete items
can be lazily calculated on an as needed basis (e.g. when calling methods from the java.util.List
interface or the additional step
methods in the Range
interface).
In addition to the methods related to a Range's "discrete items" abstraction, there is a method,
containsWithinBounds
which, for numerical ranges, allows checking within the continuous
interval between the Range's boundary values.Modifier and Type  Method and Description 

boolean 
containsWithinBounds(java.lang.Object o)
Indicates whether an object is greater than or equal to the
from
value for the range and less than or equal to the to value. 
T 
getFrom()
The lower value in the range.

T 
getTo()
The upper value in the range.

java.lang.String 
inspect() 
boolean 
isReverse()
Indicates whether this is a reverse range which iterates backwards
starting from the to value and ending on the from value

java.util.List<T> 
step(int step)
Forms a list by stepping through the range by the indicated interval.

void 
step(int step,
Closure closure)
Steps through the range, calling a closure for each item.

add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray
T getFrom()
T getTo()
boolean isReverse()
true
if this is a reverse rangeboolean containsWithinBounds(java.lang.Object o)
from
value for the range and less than or equal to the to
value.
This may be true even for values not contained in the range. Example: from = 1.5, to = 3, next() increments by 1 containsWithinBounds(2) == true contains(2) == false
o
 the object to check against the boundaries of the rangetrue
if the object is between the from and to valuesvoid step(int step, Closure closure)
step
 the amount by which to step. If negative, steps through the range backwards.closure
 the Closure
to calljava.util.List<T> step(int step)
step
 the amount by which to step. If negative, steps through the range backwards.