groovy.lang

## Class EmptyRange<T extends Comparable>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - java.util.AbstractList<T>
    - - groovy.lang.EmptyRange<T>

- All Implemented Interfaces:
    Range<T>, Iterable<T>, Collection<T>, List<T>

      public class EmptyRange<T extends Comparable>
      extends AbstractList<T>
      implements Range<T>

  Constructing Ranges like 0..<0

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected T` | `at` The value at which the range originates (may be `null`).

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

      `modCount`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `EmptyRange(T at)` Creates a new `EmptyRange`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `add(T o)` Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `addAll(Collection<? extends T> c)` Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `addAll(int index, Collection<? extends T> c)` Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `containsWithinBounds(Object o)` Never true for an empty range.
    `T` | `get(int index)` Always throws `IndexOutOfBoundsException` for an empty range.
    `T` | `getFrom()` The lower value in the range.
    `T` | `getTo()` The upper value in the range.
    `String` | `inspect()`
    `boolean` | `isReverse()` Never true for an empty range.
    `T` | `remove(int index)` Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `remove(Object o)` Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `removeAll(Collection<?> c)` Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `retainAll(Collection<?> c)` Always throws `UnsupportedOperationException` for an empty range.
    `T` | `set(int index, T element)` Always throws `UnsupportedOperationException` for an empty range.
    `int` | `size()` Always 0 for an empty range.
    `List<T>` | `step(int step)` Always returns an empty list for an empty range.
    `void` | `step(int step, Closure closure)` Always does nothing for an empty range.
    `String` | `toString()`

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

      `add, clear, equals, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator, removeRange, subList`

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

      `contains, containsAll, isEmpty, 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, clear, contains, containsAll, equals, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, replaceAll, sort, spliterator, subList, toArray, toArray`

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

      `parallelStream, removeIf, stream`

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

      `forEach`

- - ### Field Detail

    - #### at

          protected T extends Comparable at

      The value at which the range originates (may be `null`).

  - ### Constructor Detail

    - #### EmptyRange

          public EmptyRange(T at)

      Creates a new `EmptyRange`.
      Parameters:
        `at` - the value at which the range starts (may be `null`).

  - ### Method Detail

    - #### getFrom

          public T getFrom()

      The lower value in the range.
      Specified by:
        `getFrom` in interface `Range<T extends Comparable>`
      Returns:
        the lower value in the range.

    - #### getTo

          public T getTo()

      The upper value in the range.
      Specified by:
        `getTo` in interface `Range<T extends Comparable>`
      Returns:
        the upper value in the range

    - #### isReverse

          public boolean isReverse()

      Never true for an empty range.
      Specified by:
        `isReverse` in interface `Range<T extends Comparable>`
      Returns:
        `false`

    - #### containsWithinBounds

          public boolean containsWithinBounds(Object o)

      Never true for an empty range.
      Specified by:
        `containsWithinBounds` in interface `Range<T extends Comparable>`
      Parameters:
        `o` - the object to check against the boundaries of the range
      Returns:
        `false`

    - #### inspect

          public String inspect()

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

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `AbstractCollection<T extends Comparable>`

    - #### size

          public int size()

      Always 0 for an empty range.
      Specified by:
        `size` in interface `Collection<T extends Comparable>`
      Specified by:
        `size` in interface `List<T extends Comparable>`
      Specified by:
        `size` in class `AbstractCollection<T extends Comparable>`
      Returns:
        0

    - #### get

          public T get(int index)

      Always throws `IndexOutOfBoundsException` for an empty range.
      Specified by:
        `get` in interface `List<T extends Comparable>`
      Specified by:
        `get` in class `AbstractList<T extends Comparable>`
      Throws:
        `IndexOutOfBoundsException` - always

    - #### add

          public boolean add(T o)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `add` in interface `Collection<T extends Comparable>`
      Specified by:
        `add` in interface `List<T extends Comparable>`
      Overrides:
        `add` in class `AbstractList<T extends Comparable>`
      Throws:
        `UnsupportedOperationException` - always

    - #### addAll

          public boolean addAll(int index,
                                Collection<? extends T> c)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `addAll` in interface `List<T extends Comparable>`
      Overrides:
        `addAll` in class `AbstractList<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### addAll

          public boolean addAll(Collection<? extends T> c)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `addAll` in interface `Collection<T extends Comparable>`
      Specified by:
        `addAll` in interface `List<T extends Comparable>`
      Overrides:
        `addAll` in class `AbstractCollection<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### remove

          public boolean remove(Object o)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `remove` in interface `Collection<T extends Comparable>`
      Specified by:
        `remove` in interface `List<T extends Comparable>`
      Overrides:
        `remove` in class `AbstractCollection<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### remove

          public T remove(int index)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `remove` in interface `List<T extends Comparable>`
      Overrides:
        `remove` in class `AbstractList<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### removeAll

          public boolean removeAll(Collection<?> c)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `removeAll` in interface `Collection<T extends Comparable>`
      Specified by:
        `removeAll` in interface `List<T extends Comparable>`
      Overrides:
        `removeAll` in class `AbstractCollection<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### retainAll

          public boolean retainAll(Collection<?> c)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `retainAll` in interface `Collection<T extends Comparable>`
      Specified by:
        `retainAll` in interface `List<T extends Comparable>`
      Overrides:
        `retainAll` in class `AbstractCollection<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### set

          public T set(int index,
                       T element)

      Always throws `UnsupportedOperationException` for an empty range.
      Specified by:
        `set` in interface `List<T extends Comparable>`
      Overrides:
        `set` in class `AbstractList<T extends Comparable>`
      Throws:
        `UnsupportedOperationException`

    - #### step

          public void step(int step,
                           Closure closure)

      Always does nothing for an empty range.
      Specified by:
        `step` in interface `Range<T extends Comparable>`
      Parameters:
        `step` - the amount by which to step. If negative, steps through the range backwards.
        `closure` - the `Closure` to call

    - #### step

          public List<T> step(int step)

      Always returns an empty list for an empty range.
      Specified by:
        `step` in interface `Range<T extends 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.