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

  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 Details

  - ### at

    protected T extends Comparable at
    The value at which the range originates (may be `null`).

- ## Constructor Details

  - ### EmptyRange

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

- ## Method Details

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