Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 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.List;
 
GWT emulation of ImmutableSortedSet.

Author(s):
Hayward Chan
 
 public abstract class ImmutableSortedSet<E>
     extends ForwardingImmutableSet<E> implements SortedSet<E>, SortedIterable<E> {
   // TODO(cpovirk): split into ImmutableSortedSet/ForwardingImmutableSortedSet?
 
   // In the non-emulated source, this is in ImmutableSortedSetFauxverideShim,
   // which overrides ImmutableSet & which ImmutableSortedSet extends.
   // It is necessary here because otherwise the builder() method
   // would be inherited from the emulated ImmutableSet.
   // TODO(cpovirk): should we be including other methods from the shim here and
   // in ImmutableSortedMap?
   @Deprecated public static <E> ImmutableSortedSet.Builder<E> builder() {
     throw new UnsupportedOperationException();
   }
 
   // TODO: Can we find a way to remove this @SuppressWarnings even for eclipse?
   @SuppressWarnings("unchecked")
   private static final Comparator NATURAL_ORDER = Ordering.natural();
 
   @SuppressWarnings("unchecked")
   private static final ImmutableSortedSet<ObjectNATURAL_EMPTY_SET =
 
   @SuppressWarnings("unchecked")
   private static <E> ImmutableSortedSet<E> emptySet() {
     return (ImmutableSortedSet<E>) ;
   }
 
   static <E> ImmutableSortedSet<E> emptySet(
       Comparator<? super E> comparator) {
     checkNotNull(comparator);
     if (.equals(comparator)) {
       return emptySet();
     } else {
       return new EmptyImmutableSortedSet<E>(comparator);
     }
   }
 
   public static <E> ImmutableSortedSet<E> of() {
     return emptySet();
   }
 
   public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
       E element) {
     return ofInternal(Ordering.natural(), element);
   }
 
   @SuppressWarnings("unchecked")
   public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
       E e1, E e2) {
     return ofInternal(Ordering.natural(), e1e2);
   }
 
   @SuppressWarnings("unchecked")
   public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
       E e1, E e2, E e3) {
     return ofInternal(Ordering.natural(), e1e2e3);
   }
 
   @SuppressWarnings("unchecked")
   public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
       E e1, E e2, E e3, E e4) {
     return ofInternal(Ordering.natural(), e1e2e3e4);
  }
  @SuppressWarnings("unchecked")
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
      E e1, E e2, E e3, E e4, E e5) {
    return ofInternal(Ordering.natural(), e1e2e3e4e5);
  }
  @SuppressWarnings("unchecked")
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
      E e1, E e2, E e3, E e4, E e5, E e6, E... remaining) {
    int size = remaining.length + 6;
    List<E> all = new ArrayList<E>(size);
    Collections.addAll(alle1e2e3e4e5e6);
    Collections.addAll(allremaining);
    // This is messed up. See TODO at top of file.
    return ofInternal(Ordering.natural(), (E[]) all.toArray(new Comparable[0]));
  }
  public
  static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(
      E[] elements) {
    return copyOf(elements);
  }
  private static <E> ImmutableSortedSet<E> ofInternal(
      Comparator<? super E> comparator, E... elements) {
    checkNotNull(elements);
    switch (elements.length) {
      case 0:
        return emptySet(comparator);
      default:
        SortedSet<E> delegate = new TreeSet<E>(comparator);
        for (E element : elements) {
          checkNotNull(element);
          delegate.add(element);
        }
        return new RegularImmutableSortedSet<E>(delegatefalse);
    }
  }
  public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> elements) {
    return copyOfInternal((Ordering<E>) Ordering.natural(), (Collectionelementsfalse);
  }
  public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> elements) {
    return copyOfInternal((Ordering<E>) Ordering.natural(), (Iterableelementsfalse);
  }
  public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> elements) {
    return copyOfInternal((Ordering<E>) Ordering.natural(), (Iteratorelements);
  }
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> copyOf(
      E[] elements) {
    return ofInternal(Ordering.natural(), elements);
  }
  public static <E> ImmutableSortedSet<E> copyOf(
      Comparator<? super E> comparatorIterable<? extends E> elements) {
    checkNotNull(comparator);
    return copyOfInternal(comparatorelementsfalse);
  }
  public static <E> ImmutableSortedSet<E> copyOf(
      Comparator<? super E> comparatorCollection<? extends E> elements) {
    checkNotNull(comparator);
    return copyOfInternal(comparatorelementsfalse);
  }
  public static <E> ImmutableSortedSet<E> copyOf(
      Comparator<? super E> comparatorIterator<? extends E> elements) {
    checkNotNull(comparator);
    return copyOfInternal(comparatorelements);
  }
  @SuppressWarnings("unchecked")
  public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> sortedSet) {
    Comparator<? super E> comparator = sortedSet.comparator();
    if (comparator == null) {
      comparator = ;
    }
    return copyOfInternal(comparatorsortedSet.iterator());
  }
  private static <E> ImmutableSortedSet<E> copyOfInternal(
      Comparator<? super E> comparatorIterable<? extends E> elements,
      boolean fromSortedSet) {
    checkNotNull(comparator);
    boolean hasSameComparator
        = fromSortedSet || hasSameComparator(elementscomparator);
    if (hasSameComparator && (elements instanceof ImmutableSortedSet)) {
      @SuppressWarnings("unchecked")
      ImmutableSortedSet<E> result = (ImmutableSortedSet<E>) elements;
      boolean isSubset = (result instanceof RegularImmutableSortedSet)
          && ((RegularImmutableSortedSetresult).;
      if (!isSubset) {
        // Only return the original copy if this immutable sorted set isn't
        // a subset of another, to avoid memory leak.
        return result;
      }
    }
    return copyOfInternal(comparatorelements.iterator());
  }
  private static <E> ImmutableSortedSet<E> copyOfInternal(
      Comparator<? super E> comparatorIterator<? extends E> elements) {
    checkNotNull(comparator);
    if (!elements.hasNext()) {
      return emptySet(comparator);
    }
    SortedSet<E> delegate = new TreeSet<E>(comparator);
    while (elements.hasNext()) {
      E element = elements.next();
      checkNotNull(element);
      delegate.add(element);
    }
    return new RegularImmutableSortedSet<E>(delegatefalse);
  }
  private static boolean hasSameComparator(
      Iterable<?> elementsComparator<?> comparator) {
    if (elements instanceof SortedSet) {
      SortedSet<?> sortedSet = (SortedSet<?>) elements;
      Comparator<?> comparator2 = sortedSet.comparator();
      return (comparator2 == null)
          ? comparator == Ordering.natural()
          : comparator.equals(comparator2);
    }
    return false;
  }
  // Assumes that delegate doesn't have null elements and comparator.
      SortedSet<E> delegateboolean isSubset) {
    return delegate.isEmpty()
        ? emptySet(delegate.comparator())
        : new RegularImmutableSortedSet<E>(delegateisSubset);
  }
  // This reference is only used by GWT compiler to infer the elements of the
  // set that needs to be serialized.
  private transient final SortedSet<E> sortedDelegate;

  
Scary constructor for ContiguousSet. This constructor (in this file, the GWT emulation of ImmutableSortedSet) creates an empty sortedDelegate, which, in a vacuum, sets this object's contents to empty. By contrast, the non-GWT constructor with the same signature uses the comparator only as a comparator. It does NOT assume empty contents. (It requires an implementation of iterator() to define its contents, and methods like contains() are implemented in terms of that method (though they will likely be overridden by subclasses for performance reasons).) This means that a call to this method have can different behavior in GWT and non-GWT environments UNLESS subclasses are careful to always override all methods implemented in terms of sortedDelegate (except comparator()).
  ImmutableSortedSet(Comparator<? super E> comparator) {
    this(Sets.newTreeSet(comparator));
  }
  ImmutableSortedSet(SortedSet<E> sortedDelegate) {
    super(sortedDelegate);
    this. = Collections.unmodifiableSortedSet(sortedDelegate);
  }
  public Comparator<? super E> comparator() {
    return .comparator();
  }
  @Override // needed to unify SortedIterable and Collection iterator() methods
  public UnmodifiableIterator<E> iterator() {
    return super.iterator();
  }
  public Object[] toArray() {
    return ObjectArrays.toArrayImpl(this);
  }
  public <T> T[] toArray(T[] other) {
    return ObjectArrays.toArrayImpl(thisother);
  }
  @Override public boolean contains(@Nullable Object object) {
    try {
      // This set never contains null.  We need to explicitly check here
      // because some comparator might throw NPE (e.g. the natural ordering).
      return object != null && .contains(object);
    } catch (ClassCastException e) {
      return false;
    }
  }
  @Override public boolean containsAll(Collection<?> targets) {
    for (Object target : targets) {
      if (target == null) {
        // This set never contains null.  We need to explicitly check here
        // because some comparator might throw NPE (e.g. the natural ordering).
        return false;
      }
    }
    try {
      return .containsAll(targets);
    } catch (ClassCastException e) {
      return false;
    }
  }
  public E first() {
    return .first();
  }
  public ImmutableSortedSet<E> headSet(E toElement) {
    checkNotNull(toElement);
    try {
      return unsafeDelegateSortedSet(.headSet(toElement), true);
    } catch (IllegalArgumentException e) {
      return emptySet(comparator());
    }
  }
  E higher(E e) {
    checkNotNull(e);
    Iterator<E> iterator = tailSet(e).iterator();
    while (iterator.hasNext()) {
      E higher = iterator.next();
      if (comparator().compare(ehigher) < 0) {
        return higher;
      }
    }
    return null;
  }
  ImmutableSortedSet<E> headSet(E toElementboolean inclusive) {
    checkNotNull(toElement);
    if (inclusive) {
      E tmp = higher(toElement);
      if (tmp == null) {
        return this;
      }
      toElement = tmp;
    }
    return headSet(toElement);
  }
  public E last() {
    return .last();
  }
  public ImmutableSortedSet<E> subSet(E fromElement, E toElement) {
    return subSet(fromElementtruetoElementfalse);
  }
  ImmutableSortedSet<E> subSet(E fromElementboolean fromInclusive, E toElement,
      boolean toInclusive) {
    checkNotNull(fromElement);
    checkNotNull(toElement);
    int cmp = comparator().compare(fromElementtoElement);
    checkArgument(cmp <= 0, "fromElement (%s) is less than toElement (%s)"fromElementtoElement);
    if (cmp == 0 && !(fromInclusive && toInclusive)) {
      return emptySet(comparator());
    }
    return tailSet(fromElementfromInclusive).headSet(toElementtoInclusive);
  }
  public ImmutableSortedSet<E> tailSet(E fromElement) {
    checkNotNull(fromElement);
    try {
      return unsafeDelegateSortedSet(.tailSet(fromElement), true);
    } catch (IllegalArgumentException e) {
      return emptySet(comparator());
    }
  }
  ImmutableSortedSet<E> tailSet(E fromElementboolean inclusive) {
    checkNotNull(fromElement);
    if (!inclusive) {
      E tmp = higher(fromElement);
      if (tmp == null) {
        return emptySet(comparator());
      }
      fromElement = tmp;
    }
    return tailSet(fromElement);
  }
  public static <E> Builder<E> orderedBy(Comparator<E> comparator) {
    return new Builder<E>(comparator);
  }
  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
    return new Builder<E>(Ordering.natural().reverse());
  }
  public static <E extends Comparable<?>> Builder<E> naturalOrder() {
    return new Builder<E>(Ordering.natural());
  }
  public static final class Builder<E> extends ImmutableSet.Builder<E> {
    private final Comparator<? super E> comparator;
    public Builder(Comparator<? super E> comparator) {
      this. = checkNotNull(comparator);
    }
    @Override public Builder<E> add(E element) {
      super.add(element);
      return this;
    }
    @Override public Builder<E> add(E... elements) {
      super.add(elements);
      return this;
    }
    @Override public Builder<E> addAll(Iterable<? extends E> elements) {
      super.addAll(elements);
      return this;
    }
    @Override public Builder<E> addAll(Iterator<? extends E> elements) {
      super.addAll(elements);
      return this;
    }
    @Override public ImmutableSortedSet<E> build() {
      return copyOfInternal(.iterator());
    }
  }
New to GrepCode? Check out our FAQ X