Package 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 | 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 | Description
    --- | ---
    `EmptyRange​(T at)` | Creates a new `EmptyRange`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `boolean` | `add​(T o)` | Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `addAll​(int index, Collection<? extends T> c)` | Always throws `UnsupportedOperationException` for an empty range.
    `boolean` | `addAll​(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.Collection

      `parallelStream, removeIf, stream, toArray`

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

      `forEach`

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

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