Package groovy.lang

# Class ObjectRange

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<Comparable>
groovy.lang.ObjectRange

All Implemented Interfaces:
  `Range<Comparable>`, `Iterable<Comparable>`, `Collection<Comparable>`, `List<Comparable>`

public class ObjectRange extends AbstractList<Comparable> implements Range<Comparable>
Represents an inclusive list of objects from a value to a value using comparators.

Note: This class is similar to `IntRange`. If you make any changes to this class, you might consider making parallel changes to `IntRange`.

- ## Field Summary

  ### Fields inherited from class java.util.AbstractList

  `modCount`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `ObjectRange(Comparable from, Comparable to)`
  Creates a new `ObjectRange`.
  `ObjectRange(Comparable smaller, Comparable larger, boolean reverse)`
  Creates a new `ObjectRange` assumes smaller <= larger, else behavior is undefined.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected void`
  `checkBoundaryCompatibility()`
  throws IllegalArgumentException if to and from are incompatible, meaning they e.g.
  `protected int`
  `compareTo(Comparable first, Comparable second)`
  Compares two values using Groovy's number-aware comparison.
  `boolean`
  `contains(Object value)`
  Iterates over all values and returns true if one value matches.
  `boolean`
  `containsWithinBounds(Object value)`
  Checks whether a value is between the from and to values of a Range
  `protected Object`
  `decrement(Object value)`
  Decrements by one
  `boolean`
  `equals(ObjectRange that)`
  Compares an `ObjectRange` to another `ObjectRange`.
  `boolean`
  `equals(Object that)`
  `Comparable`
  `get(int index)`
  `Comparable`
  `getFrom()`
  The lower value in the range.
  `Comparable`
  `getTo()`
  The upper value in the range.
  `protected Object`
  `increment(Object value)`
  Increments by one
  `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
  `Iterator<Comparable>`
  `iterator()`
  `int`
  `size()`
  `List<Comparable>`
  `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.
  `List<Comparable>`
  `subList(int fromIndex, int toIndex)`
  `String`
  `toString()`

  ### Methods inherited from class java.util.AbstractList

  `add, add, addAll, clear, hashCode, indexOf, lastIndexOf, listIterator, listIterator, remove, removeRange, set`

  ### Methods inherited from class java.util.AbstractCollection

  `addAll, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray`

  ### Methods inherited from class java.lang.Object

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

  ### Methods inherited from interface java.util.Collection

  `parallelStream, removeIf, stream, toArray`

  ### Methods inherited from interface java.lang.Iterable

  `forEach`

  ### Methods inherited from interface java.util.List

  `add, add, addAll, addAll, clear, containsAll, hashCode, indexOf, isEmpty, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, replaceAll, retainAll, set, sort, spliterator, toArray, toArray`

- ## Constructor Details

  - ### ObjectRange

    public ObjectRange(Comparable from, Comparable to)
    Creates a new `ObjectRange`. Creates a reversed range if `from` < `to`.
    Parameters:
      `from` - the first value in the range.
      `to` - the last value in the range.

  - ### ObjectRange

    public ObjectRange(Comparable smaller, Comparable larger, boolean reverse)
    Creates a new `ObjectRange` assumes smaller <= larger, else behavior is undefined. Caution: Prefer the other constructor when in doubt.

    Optimized Constructor avoiding initial computation of comparison.

- ## Method Details

  - ### checkBoundaryCompatibility

    protected void checkBoundaryCompatibility()
    throws IllegalArgumentException if to and from are incompatible, meaning they e.g. (likely) produce infinite sequences. Called at construction time, subclasses may override cautiously (using only members to and from).

  - ### equals

    public boolean equals(Object that)
    Specified by:
      `equals` in interface `Collection<Comparable>`
    Specified by:
      `equals` in interface `List<Comparable>`
    Overrides:
      `equals` in class `AbstractList<Comparable>`

  - ### equals

    public boolean equals(ObjectRange that)
    Compares an `ObjectRange` to another `ObjectRange`.
    Parameters:
      `that` - the object to check equality with
    Returns:
      `true` if the ranges are equal

  - ### getFrom

    public Comparable getFrom()
    The lower value in the range.
    Specified by:
      `getFrom` in interface `Range<Comparable>`
    Returns:
      the lower value in the range.

  - ### getTo

    public Comparable getTo()
    The upper value in the range.
    Specified by:
      `getTo` in interface `Range<Comparable>`
    Returns:
      the upper value in the range

  - ### isReverse

    public boolean isReverse()
    Indicates whether this is a reverse range which iterates backwards starting from the to value and ending on the from value
    Specified by:
      `isReverse` in interface `Range<Comparable>`
    Returns:
      `true` if this is a reverse range

  - ### get

    public Comparable get(int index)
    Specified by:
      `get` in interface `List<Comparable>`
    Specified by:
      `get` in class `AbstractList<Comparable>`

  - ### containsWithinBounds

    public boolean containsWithinBounds(Object value)
    Checks whether a value is between the from and to values of a Range
    Specified by:
      `containsWithinBounds` in interface `Range<Comparable>`
    Parameters:
      `value` - the value of interest
    Returns:
      true if the value is within the bounds

  - ### compareTo

    protected int compareTo(Comparable first, Comparable second)
    Compares two values using Groovy's number-aware comparison.
    Parameters:
      `first` - the first value
      `second` - the second value
    Returns:
      the comparison result

  - ### size

    public int size()
    Specified by:
      `size` in interface `Collection<Comparable>`
    Specified by:
      `size` in interface `List<Comparable>`
    Specified by:
      `size` in class `AbstractCollection<Comparable>`

  - ### subList

    public List<Comparable> subList(int fromIndex, int toIndex)
    Specified by:
      `subList` in interface `List<Comparable>`
    Overrides:
      `subList` in class `AbstractList<Comparable>`

  - ### toString

    public String toString()
    Overrides:
      `toString` in class `AbstractCollection<Comparable>`

  - ### inspect

    public String inspect()
    Specified by:
      `inspect` in interface `Range<Comparable>`
    Returns:
      the verbose `String` representation of this `Range` as would be typed into a console to create the `Range` instance

  - ### contains

    public boolean contains(Object value)
    Iterates over all values and returns true if one value matches.
    Specified by:
      `contains` in interface `Collection<Comparable>`
    Specified by:
      `contains` in interface `List<Comparable>`
    Overrides:
      `contains` in class `AbstractCollection<Comparable>`
    See Also:
      - `containsWithinBounds(Object)`

  - ### step

    public void step(int step, Closure closure)
    Steps through the range, calling a closure for each item.
    Specified by:
      `step` in interface `Range<Comparable>`
    Parameters:
      `step` - the amount by which to step. If negative, steps through the range backwards.
      `closure` - the `Closure` to call

  - ### iterator

    public Iterator<Comparable> iterator()
    Specified by:
      `iterator` in interface `Collection<Comparable>`
    Specified by:
      `iterator` in interface `Iterable<Comparable>`
    Specified by:
      `iterator` in interface `List<Comparable>`
    Overrides:
      `iterator` in class `AbstractList<Comparable>`

  - ### step

    public List<Comparable> step(int step)
    Forms a list by stepping through the range by the indicated interval.
    Specified by:
      `step` in interface `Range<Comparable>`
    Parameters:
      `step` - the amount by which to step. If negative, steps through the range backwards.
    Returns:
      the list formed by stepping through the range by the indicated interval.

  - ### increment

    protected Object increment(Object value)
    Increments by one
    Parameters:
      `value` - the value to increment
    Returns:
      the incremented value

  - ### decrement

    protected Object decrement(Object value)
    Decrements by one
    Parameters:
      `value` - the value to decrement
    Returns:
      the decremented value