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.checkNotNull;
 
 import java.util.List;
 import java.util.Set;

GWT emulated version of ImmutableSet. For the unsorted sets, they are thin wrapper around java.util.Collections.emptySet(), java.util.Collections.singleton(java.lang.Object) and java.util.LinkedHashSet for empty, singleton and regular sets respectively. For the sorted sets, it's a thin wrapper around java.util.TreeSet.

Author(s):
Hayward Chan
See also:
ImmutableSortedSet
 
 @SuppressWarnings("serial")  // Serialization only done in GWT.
 public abstract class ImmutableSet<E> extends ImmutableCollection<E> implements Set<E> {
   ImmutableSet() {}
 
   // Casting to any type is safe because the set will never hold any elements.
   @SuppressWarnings({"unchecked"})
   public static <E> ImmutableSet<E> of() {
     return (ImmutableSet<E>) .;
   }
 
   public static <E> ImmutableSet<E> of(E element) {
     return new SingletonImmutableSet<E>(element);
   }
 
   @SuppressWarnings("unchecked")
   public static <E> ImmutableSet<E> of(E e1, E e2) {
     return create(e1e2);
   }
 
   @SuppressWarnings("unchecked")
   public static <E> ImmutableSet<E> of(E e1, E e2, E e3) {
     return create(e1e2e3);
   }
 
   @SuppressWarnings("unchecked")
   public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4) {
     return create(e1e2e3e4);
   }
 
   @SuppressWarnings("unchecked")
   public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4, E e5) {
     return create(e1e2e3e4e5);
   }
 
   @SuppressWarnings("unchecked")
   public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E... others) {
     int size = others.length + 6;
     List<E> all = new ArrayList<E>(size);
     Collections.addAll(alle1e2e3e4e5e6);
     Collections.addAll(allothers);
     return copyOf(all.iterator());
   }
 
   public static <E> ImmutableSet<E> copyOf(E[] elements) {
     checkNotNull(elements);
     switch (elements.length) {
       case 0:
         return of();
       case 1:
         return of(elements[0]);
       default:
         return create(elements);
     }
   }
 
   public static <E> ImmutableSet<E> copyOf(Collection<? extends E> elements) {
     Iterable<? extends E> iterable = elements;
     return copyOf(iterable);
   }
 
   public static <E> ImmutableSet<E> copyOf(Iterable<? extends E> elements) {
    if (elements instanceof ImmutableSet && !(elements instanceof ImmutableSortedSet)) {
      @SuppressWarnings("unchecked"// all supported methods are covariant
      ImmutableSet<E> set = (ImmutableSet<E>) elements;
      return set;
    }
    return copyOf(elements.iterator());
  }
  public static <E> ImmutableSet<E> copyOf(Iterator<? extends E> elements) {
    if (!elements.hasNext()) {
      return of();
    }
    E first = elements.next();
    if (!elements.hasNext()) {
      // TODO: Remove "ImmutableSet.<E>" when eclipse bug is fixed.
      return ImmutableSet.<E>of(first);
    }
    Set<E> delegate = Sets.newLinkedHashSet();
    delegate.add(checkNotNull(first));
    do {
      delegate.add(checkNotNull(elements.next()));
    } while (elements.hasNext());
    return unsafeDelegate(delegate);
  }
  // Factory methods that skips the null checks on elements, only used when
  // the elements are known to be non-null.
  static <E> ImmutableSet<E> unsafeDelegate(Set<E> delegate) {
    switch (delegate.size()) {
      case 0:
        return of();
      case 1:
        return new SingletonImmutableSet<E>(delegate.iterator().next());
      default:
        return new RegularImmutableSet<E>(delegate);
    }
  }
  private static <E> ImmutableSet<E> create(E... elements) {
    // Create the set first, to remove duplicates if necessary.
    Set<E> set = Sets.newLinkedHashSet();
    Collections.addAll(setelements);
    for (E element : set) {
      checkNotNull(element);
    }
    switch (set.size()) {
      case 0:
        return of();
      case 1:
        return new SingletonImmutableSet<E>(set.iterator().next());
      default:
        return new RegularImmutableSet<E>(set);
    }
  }
  @Override public boolean equals(Object obj) {
    return Sets.equalsImpl(thisobj);
  }
  @Override public int hashCode() {
    return Sets.hashCodeImpl(this);
  }
  
  abstract static class Indexed<E> extends ImmutableSet<E> {
    abstract E get(int index);
    @Override
    public UnmodifiableIterator<E> iterator() {
      return asList().iterator();
    }
    @Override
      return new ImmutableAsList<E>() {
        @Override
        public E get(int index) {
          return Indexed.this.get(index);
        }
        @Override
        Indexed<E> delegateCollection() {
          return Indexed.this;
        }
      };
    }
  }
  public static <E> Builder<E> builder() {
    return new Builder<E>();
  }
  public static class Builder<E> extends ImmutableCollection.Builder<E> {
    // accessed directly by ImmutableSortedSet
    final ArrayList<E> contents;
    public Builder() {
      this. = Lists.newArrayList();
    }
    
    Builder(int initialCapacity) {
      this. = Lists.newArrayListWithCapacity(initialCapacity);
    }
    @Override public Builder<E> add(E element) {
      .add(checkNotNull(element));
      return this;
    }
    @Override public Builder<E> add(E... elements) {
      checkNotNull(elements); // for GWT
      .ensureCapacity(.size() + elements.length);
      super.add(elements);
      return this;
    }
    @Override public Builder<E> addAll(Iterable<? extends E> elements) {
      if (elements instanceof Collection) {
        Collection<?> collection = (Collection<?>) elements;
        .ensureCapacity(.size() + collection.size());
      }
      super.addAll(elements);
      return this;
    }
    @Override public Builder<E> addAll(Iterator<? extends E> elements) {
      super.addAll(elements);
      return this;
    }
    @Override public ImmutableSet<E> build() {
      return copyOf(.iterator());
    }
  }
New to GrepCode? Check out our FAQ X