Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2010 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   * in compliance with the License. You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 
 package com.google.common.collect;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.util.Set;

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(Ranges.greaterThan(0), DiscreteDomains.integers()). Certain operations on such a set can be performed efficiently, but others (such as java.util.Set.hashCode() or java.util.Collections.frequency(java.util.Collection,java.lang.Object)) can cause major performance problems.

Author(s):
Gregory Kick
Since:
10.0
 
 @GwtCompatible(emulated = true)
 @SuppressWarnings("rawtypes"// allow ungenerified Comparable types
 public abstract class ContiguousSet<C extends Comparableextends ImmutableSortedSet<C> {
  
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
 
   public static <C extends ComparableContiguousSet<C> create(
       Range<C> rangeDiscreteDomain<C> domain) {
     checkNotNull(range);
     checkNotNull(domain);
     Range<C> effectiveRange = range;
     try {
       if (!range.hasLowerBound()) {
         effectiveRange = effectiveRange.intersection(Ranges.atLeast(domain.minValue()));
       }
       if (!range.hasUpperBound()) {
         effectiveRange = effectiveRange.intersection(Ranges.atMost(domain.maxValue()));
       }
     } catch (NoSuchElementException e) {
       throw new IllegalArgumentException(e);
     }
 
     // Per class spec, we are allowed to throw CCE if necessary
     boolean empty = effectiveRange.isEmpty()
         || Range.compareOrThrow(
             range.lowerBound.leastValueAbove(domain),
             range.upperBound.greatestValueBelow(domain)) > 0;
 
     return empty
         ? new EmptyContiguousSet<C>(domain)
         : new RegularContiguousSet<C>(effectiveRangedomain);
   }
 
   final DiscreteDomain<C> domain;
 
   ContiguousSet(DiscreteDomain<C> domain) {
     super(Ordering.natural());
     this. = domain;
   }
 
   @Override public ContiguousSet<C> headSet(C toElement) {
     return headSetImpl(checkNotNull(toElement), false);
   }

  

Since:
12.0
 
   @GwtIncompatible("NavigableSet")
   @Override public ContiguousSet<C> headSet(C toElementboolean inclusive) {
     return headSetImpl(checkNotNull(toElement), inclusive);
   }
 
   @Override public ContiguousSet<C> subSet(C fromElement, C toElement) {
     checkNotNull(fromElement);
    checkNotNull(toElement);
    checkArgument(comparator().compare(fromElementtoElement) <= 0);
    return subSetImpl(fromElementtruetoElementfalse);
  }

  

Since:
12.0
  @GwtIncompatible("NavigableSet")
  @Override public ContiguousSet<C> subSet(C fromElementboolean fromInclusive, C toElement,
      boolean toInclusive) {
    checkNotNull(fromElement);
    checkNotNull(toElement);
    checkArgument(comparator().compare(fromElementtoElement) <= 0);
    return subSetImpl(fromElementfromInclusivetoElementtoInclusive);
  }
  @Override public ContiguousSet<C> tailSet(C fromElement) {
    return tailSetImpl(checkNotNull(fromElement), true);
  }

  

Since:
12.0
  @GwtIncompatible("NavigableSet")
  @Override public ContiguousSet<C> tailSet(C fromElementboolean inclusive) {
    return tailSetImpl(checkNotNull(fromElement), inclusive);
  }
  /*
   * These methods perform most headSet, subSet, and tailSet logic, besides parameter validation.
   */
  /*@Override*/ abstract ContiguousSet<C> headSetImpl(C toElementboolean inclusive);
  /*@Override*/ abstract ContiguousSet<C> subSetImpl(C fromElementboolean fromInclusive,
      C toElementboolean toInclusive);
  /*@Override*/ abstract ContiguousSet<C> tailSetImpl(C fromElementboolean inclusive);

  
Returns the set of values that are contained in both this set and the other.

This method should always be used instead of com.google.common.collect.Sets.intersection(java.util.Set,java.util.Set) for ContiguousSet instances.

  public abstract ContiguousSet<C> intersection(ContiguousSet<C> other);

  
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
  public abstract Range<C> range();

  
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 com.google.common.collect.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
  public abstract Range<C> range(BoundType lowerBoundTypeBoundType upperBoundType);

  
Returns a short-hand representation of the contents such as "[1..100]".
  @Override public String toString() {
    return range().toString();
  }
New to GrepCode? Check out our FAQ X