Class ContiguousSet<C extends java.lang.Comparable>

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Iterable<C>, java.util.Collection<C>, java.util.NavigableSet<C>, java.util.Set<C>, java.util.SortedSet<C>

    @Beta
    @GwtCompatible(emulated=true)
    public abstract class ContiguousSet<C extends java.lang.Comparable>
    extends ImmutableSortedSet<C>
    A sorted set of contiguous values in a given DiscreteDomain.

    Warning: Be extremely careful what you do with conceptually large instances (such as ContiguousSet.create(Range.greaterThan(0), DiscreteDomain.integers()). Certain operations on such a set can be performed efficiently, but others (such as Set.hashCode() or Collections.frequency(java.util.Collection<?>, java.lang.Object)) can cause major performance problems.

    Since:
    10.0
    See Also:
    Serialized Form
    • Method Detail

      • create

        public static <C extends java.lang.Comparable> ContiguousSet<C> create​(Range<C> range,
                                                                               DiscreteDomain<C> domain)
        Returns a ContiguousSet containing the same values in the given domain contained by the range.
        Throws:
        java.lang.IllegalArgumentException - if neither range nor the domain has a lower bound, or if neither has an upper bound
        Since:
        13.0
      • headSet

        public ContiguousSet<C> headSet​(C toElement)
        Description copied from class: ImmutableSortedSet

        This method returns a serializable ImmutableSortedSet.

        The SortedSet.headSet(E) documentation states that a subset of a subset throws an IllegalArgumentException if passed a toElement greater than an earlier toElement. However, this method doesn't throw an exception in that situation, but instead keeps the original toElement.

        Specified by:
        headSet in interface java.util.NavigableSet<C extends java.lang.Comparable>
        Specified by:
        headSet in interface java.util.SortedSet<C extends java.lang.Comparable>
        Overrides:
        headSet in class ImmutableSortedSet<C extends java.lang.Comparable>
      • headSet

        @GwtIncompatible("NavigableSet")
        public ContiguousSet<C> headSet​(C toElement,
                                        boolean inclusive)
        Specified by:
        headSet in interface java.util.NavigableSet<C extends java.lang.Comparable>
        Overrides:
        headSet in class ImmutableSortedSet<C extends java.lang.Comparable>
        Since:
        12.0
      • subSet

        public ContiguousSet<C> subSet​(C fromElement,
                                       C toElement)
        Description copied from class: ImmutableSortedSet

        This method returns a serializable ImmutableSortedSet.

        The SortedSet.subSet(E, E) documentation states that a subset of a subset throws an IllegalArgumentException if passed a fromElement smaller than an earlier fromElement. However, this method doesn't throw an exception in that situation, but instead keeps the original fromElement. Similarly, this method keeps the original toElement, instead of throwing an exception, if passed a toElement greater than an earlier toElement.

        Specified by:
        subSet in interface java.util.NavigableSet<C extends java.lang.Comparable>
        Specified by:
        subSet in interface java.util.SortedSet<C extends java.lang.Comparable>
        Overrides:
        subSet in class ImmutableSortedSet<C extends java.lang.Comparable>
      • subSet

        @GwtIncompatible("NavigableSet")
        public ContiguousSet<C> subSet​(C fromElement,
                                       boolean fromInclusive,
                                       C toElement,
                                       boolean toInclusive)
        Specified by:
        subSet in interface java.util.NavigableSet<C extends java.lang.Comparable>
        Overrides:
        subSet in class ImmutableSortedSet<C extends java.lang.Comparable>
        Since:
        12.0
      • tailSet

        public ContiguousSet<C> tailSet​(C fromElement)
        Description copied from class: ImmutableSortedSet

        This method returns a serializable ImmutableSortedSet.

        The SortedSet.tailSet(E) documentation states that a subset of a subset throws an IllegalArgumentException if passed a fromElement smaller than an earlier fromElement. However, this method doesn't throw an exception in that situation, but instead keeps the original fromElement.

        Specified by:
        tailSet in interface java.util.NavigableSet<C extends java.lang.Comparable>
        Specified by:
        tailSet in interface java.util.SortedSet<C extends java.lang.Comparable>
        Overrides:
        tailSet in class ImmutableSortedSet<C extends java.lang.Comparable>
      • tailSet

        @GwtIncompatible("NavigableSet")
        public ContiguousSet<C> tailSet​(C fromElement,
                                        boolean inclusive)
        Specified by:
        tailSet in interface java.util.NavigableSet<C extends java.lang.Comparable>
        Overrides:
        tailSet in class ImmutableSortedSet<C extends java.lang.Comparable>
        Since:
        12.0
      • range

        public abstract Range<C> range()
        Returns a range, closed on both ends, whose endpoints are the minimum and maximum values contained in this set. This is equivalent to range(CLOSED, CLOSED).
        Throws:
        java.util.NoSuchElementException - if this set is empty
      • range

        public abstract Range<C> range​(BoundType lowerBoundType,
                                       BoundType upperBoundType)
        Returns the minimal range with the given boundary types for which all values in this set are contained within the range.

        Note that this method will return ranges with unbounded endpoints if BoundType.OPEN is requested for a domain minimum or maximum. For example, if set was created from the range [1..Integer.MAX_VALUE] then set.range(CLOSED, OPEN) must return [1..∞).

        Throws:
        java.util.NoSuchElementException - if this set is empty
      • toString

        public java.lang.String toString()
        Returns a short-hand representation of the contents such as "[1..100]".
        Overrides:
        toString in class java.util.AbstractCollection<C extends java.lang.Comparable>
      • of

        @Deprecated
        public static <E> ImmutableSortedSet<E> of​(E element)
        Deprecated.
        Pass a parameter of type Comparable to use ImmutableSortedSet.of(Comparable).
        Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
        Throws:
        java.lang.UnsupportedOperationException - always
      • of

        @Deprecated
        public static <E> ImmutableSortedSet<E> of​(E e1,
                                                   E e2)
        Deprecated.
        Pass the parameters of type Comparable to use ImmutableSortedSet.of(Comparable, Comparable).
        Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
        Throws:
        java.lang.UnsupportedOperationException - always
      • of

        @Deprecated
        public static <E> ImmutableSortedSet<E> of​(E e1,
                                                   E e2,
                                                   E e3)
        Deprecated.
        Pass the parameters of type Comparable to use ImmutableSortedSet.of(Comparable, Comparable, Comparable).
        Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
        Throws:
        java.lang.UnsupportedOperationException - always
      • of

        @Deprecated
        public static <E> ImmutableSortedSet<E> of​(E e1,
                                                   E e2,
                                                   E e3,
                                                   E e4)
        Deprecated.
        Pass the parameters of type Comparable to use ImmutableSortedSet.of(Comparable, Comparable, Comparable, Comparable).
        Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
        Throws:
        java.lang.UnsupportedOperationException - always
      • copyOf

        @Deprecated
        public static <E> ImmutableSortedSet<E> copyOf​(E[] elements)
        Deprecated.
        Pass parameters of type Comparable to use ImmutableSortedSet.copyOf(Comparable[]).
        Not supported. You are attempting to create a set that may contain non-Comparable elements. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
        Throws:
        java.lang.UnsupportedOperationException - always