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 and 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

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `checkBoundaryCompatibility()` throws IllegalArgumentException if to and from are incompatible, meaning they e.g.
    `protected int` | `compareTo(Comparable first, Comparable second)`
    `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(Object that)`
    `boolean` | `equals(ObjectRange that)` Compares an `ObjectRange` to another `ObjectRange`.
    `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.List

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

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

      `parallelStream, removeIf, stream`

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

      `forEach`

- - ### Constructor Detail

    - #### 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 Detail

    - #### 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()

      Description copied from interface: `Range`
      The lower value in the range.
      Specified by:
        `getFrom` in interface `Range<Comparable>`
      Returns:
        the lower value in the range.

    - #### getTo

          public Comparable getTo()

      Description copied from interface: `Range`
      The upper value in the range.
      Specified by:
        `getTo` in interface `Range<Comparable>`
      Returns:
        the upper value in the range

    - #### isReverse

          public boolean isReverse()

      Description copied from interface: `Range`
      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)

    - #### 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)

      Description copied from interface: `Range`
      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 `Iterable<Comparable>`
      Specified by:
        `iterator` in interface `Collection<Comparable>`
      Specified by:
        `iterator` in interface `List<Comparable>`
      Overrides:
        `iterator` in class `AbstractList<Comparable>`

    - #### step

          public List<Comparable> step(int step)

      Description copied from interface: `Range`
      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