com.google.common.collect

## Interface RangeSet<C extends java.lang.Comparable>

- All Known Implementing Classes:
    ImmutableRangeSet, TreeRangeSet

      @Beta
      public interface RangeSet<C extends java.lang.Comparable>

  A set comprising zero or more nonempty, disconnected ranges of type `C`.

  Implementations that choose to support the `add(Range)` operation are required to ignore empty ranges and coalesce connected ranges. For example:

         RangeSet<Integer> rangeSet = TreeRangeSet.create();
         rangeSet.add(Range.closed(1, 10)); // {[1, 10]}
         rangeSet.add(Range.closedOpen(11, 15)); // disconnected range; {[1, 10], [11, 15)}
         rangeSet.add(Range.closedOpen(15, 20)); // connected range; {[1, 10], [11, 20)}
         rangeSet.add(Range.openClosed(0, 0)); // empty range; {[1, 10], [11, 20)}
         rangeSet.remove(Range.open(5, 10)); // splits [1, 10]; {[1, 5], [10, 10], [11, 20)}

  Note that the behavior of `Range.isEmpty()` and `Range.isConnected(Range)` may not be as expected on discrete ranges. See the Javadoc of those methods for details.

  For a `Set` whose contents are specified by a `Range`, see `ContiguousSet`.

  Since:
    14.0

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(Range<C> range)` Adds the specified range to this `RangeSet` (optional operation).
    `void` | `addAll(RangeSet<C> other)` Adds all of the ranges from the specified range set to this range set (optional operation).
    `java.util.Set<Range<C>>` | `asDescendingSetOfRanges()` Returns a descending view of the disconnected ranges that make up this range set.
    `java.util.Set<Range<C>>` | `asRanges()` Returns a view of the disconnected ranges that make up this range set.
    `void` | `clear()` Removes all ranges from this `RangeSet` (optional operation).
    `RangeSet<C>` | `complement()` Returns a view of the complement of this `RangeSet`.
    `boolean` | `contains(C value)` Determines whether any of this range set's member ranges contains `value`.
    `boolean` | `encloses(Range<C> otherRange)` Returns `true` if there exists a member range in this range set which encloses the specified range.
    `boolean` | `enclosesAll(RangeSet<C> other)` Returns `true` if for each member range in `other` there exists a member range in this range set which encloses it.
    `boolean` | `equals(java.lang.Object obj)` Returns `true` if `obj` is another `RangeSet` that contains the same ranges according to `Range.equals(Object)`.
    `int` | `hashCode()` Returns `asRanges().hashCode()`.
    `boolean` | `isEmpty()` Returns `true` if this range set contains no ranges.
    `Range<C>` | `rangeContaining(C value)` Returns the unique range from this range set that contains `value`, or `null` if this range set does not contain `value`.
    `void` | `remove(Range<C> range)` Removes the specified range from this `RangeSet` (optional operation).
    `void` | `removeAll(RangeSet<C> other)` Removes all of the ranges from the specified range set from this range set (optional operation).
    `Range<C>` | `span()` Returns the minimal range which encloses all ranges in this range set.
    `RangeSet<C>` | `subRangeSet(Range<C> view)` Returns a view of the intersection of this `RangeSet` with the specified range.
    `java.lang.String` | `toString()` Returns a readable string representation of this range set.

- - ### Method Detail

    - #### contains

          boolean contains(C value)

      Determines whether any of this range set's member ranges contains `value`.

    - #### rangeContaining

          Range<C> rangeContaining(C value)

      Returns the unique range from this range set that contains `value`, or `null` if this range set does not contain `value`.

    - #### encloses

          boolean encloses(Range<C> otherRange)

      Returns `true` if there exists a member range in this range set which encloses the specified range.

    - #### enclosesAll

          boolean enclosesAll(RangeSet<C> other)

      Returns `true` if for each member range in `other` there exists a member range in this range set which encloses it. It follows that `this.contains(value)` whenever `other.contains(value)`. Returns `true` if `other` is empty.

      This is equivalent to checking if this range set `encloses(com.google.common.collect.Range<C>)` each of the ranges in `other`.

    - #### isEmpty

          boolean isEmpty()

      Returns `true` if this range set contains no ranges.

    - #### span

          Range<C> span()

      Returns the minimal range which encloses all ranges in this range set.
      Throws:
        `java.util.NoSuchElementException` - if this range set is empty

    - #### asRanges

          java.util.Set<Range<C>> asRanges()

      Returns a view of the disconnected ranges that make up this range set. The returned set may be empty. The iterators returned by its `Iterable.iterator()` method return the ranges in increasing order of lower bound (equivalently, of upper bound).

    - #### asDescendingSetOfRanges

          java.util.Set<Range<C>> asDescendingSetOfRanges()

      Returns a descending view of the disconnected ranges that make up this range set. The returned set may be empty. The iterators returned by its `Iterable.iterator()` method return the ranges in decreasing order of lower bound (equivalently, of upper bound).
      Since:
        19.0

    - #### complement

          RangeSet<C> complement()

      Returns a view of the complement of this `RangeSet`.

      The returned view supports the `add(com.google.common.collect.Range<C>)` operation if this `RangeSet` supports `remove(com.google.common.collect.Range<C>)`, and vice versa.

    - #### subRangeSet

          RangeSet<C> subRangeSet(Range<C> view)

      Returns a view of the intersection of this `RangeSet` with the specified range.

      The returned view supports all optional operations supported by this `RangeSet`, with the caveat that an `IllegalArgumentException` is thrown on an attempt to add any range not enclosed by `view`.

    - #### add

          void add(Range<C> range)

      Adds the specified range to this `RangeSet` (optional operation). That is, for equal range sets a and b, the result of `a.add(range)` is that `a` will be the minimal range set for which both `a.enclosesAll(b)` and `a.encloses(range)`.

      Note that `range` will be coalesced with any ranges in the range set that are connected with it. Moreover, if `range` is empty, this is a no-op.

      Throws:
        `java.lang.UnsupportedOperationException` - if this range set does not support the `add` operation

    - #### remove

          void remove(Range<C> range)

      Removes the specified range from this `RangeSet` (optional operation). After this operation, if `range.contains(c)`, `this.contains(c)` will return `false`.

      If `range` is empty, this is a no-op.

      Throws:
        `java.lang.UnsupportedOperationException` - if this range set does not support the `remove` operation

    - #### clear

          void clear()

      Removes all ranges from this `RangeSet` (optional operation). After this operation, `this.contains(c)` will return false for all `c`.

      This is equivalent to `remove(Range.all())`.

      Throws:
        `java.lang.UnsupportedOperationException` - if this range set does not support the `clear` operation

    - #### addAll

          void addAll(RangeSet<C> other)

      Adds all of the ranges from the specified range set to this range set (optional operation). After this operation, this range set is the minimal range set that encloses both the original range set and `other`.

      This is equivalent to calling `add(com.google.common.collect.Range<C>)` on each of the ranges in `other` in turn.

      Throws:
        `java.lang.UnsupportedOperationException` - if this range set does not support the `addAll` operation

    - #### removeAll

          void removeAll(RangeSet<C> other)

      Removes all of the ranges from the specified range set from this range set (optional operation). After this operation, if `other.contains(c)`, `this.contains(c)` will return `false`.

      This is equivalent to calling `remove(com.google.common.collect.Range<C>)` on each of the ranges in `other` in turn.

      Throws:
        `java.lang.UnsupportedOperationException` - if this range set does not support the `removeAll` operation

    - #### equals

          boolean equals(@Nullable
                       java.lang.Object obj)

      Returns `true` if `obj` is another `RangeSet` that contains the same ranges according to `Range.equals(Object)`.
      Overrides:
        `equals` in class `java.lang.Object`

    - #### hashCode

          int hashCode()

      Returns `asRanges().hashCode()`.
      Overrides:
        `hashCode` in class `java.lang.Object`

    - #### toString

          java.lang.String toString()

      Returns a readable string representation of this range set. For example, if this `RangeSet` consisted of `Range.closed(1, 3)` and `Range.greaterThan(4)`, this might return `" [1‥3](4‥+∞)`"}.
      Overrides:
        `toString` in class `java.lang.Object`