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 static com.google.common.collect.SortedLists.KeyAbsentBehavior.INVERTED_INSERTION_INDEX;
 import static com.google.common.collect.SortedLists.KeyAbsentBehavior.NEXT_HIGHER;
 import static com.google.common.collect.SortedLists.KeyPresentBehavior.ANY_PRESENT;
 import static com.google.common.collect.SortedLists.KeyPresentBehavior.FIRST_AFTER;
 import static com.google.common.collect.SortedLists.KeyPresentBehavior.FIRST_PRESENT;
 
 
 import java.util.Set;
 
 import  javax.annotation.Nullable;

An immutable sorted set with one or more elements. TODO(jlevy): Consider separate class for a single-element sorted set.

Author(s):
Jared Levy
Louis Wasserman
 
 @GwtCompatible(serializable = true, emulated = true)
 @SuppressWarnings("serial")
 final class RegularImmutableSortedSet<E> extends ImmutableSortedSet<E> {
 
   private transient final ImmutableList<E> elements;
 
       ImmutableList<E> elementsComparator<? super E> comparator) {
     super(comparator);
     this. = elements;
     checkArgument(!elements.isEmpty());
   }
 
   @Override public UnmodifiableIterator<E> iterator() {
     return .iterator();
   }
 
   @GwtIncompatible("NavigableSet")
     return .reverse().iterator();
   }
 
   @Override public boolean isEmpty() {
     return false;
   }
 
   @Override
   public int size() {
     return .size();
   }
 
   @Override public boolean contains(Object o) {
     try {
       return o != null && unsafeBinarySearch(o) >= 0;
     } catch (ClassCastException e) {
       return false;
     }
   }
 
   @Override public boolean containsAll(Collection<?> targets) {
     // TODO(jlevy): For optimal performance, use a binary search when
     // targets.size() < size() / log(size())
     // TODO(kevinb): see if we can share code with OrderedIterator after it
     // graduates from labs.
     if (!SortedIterables.hasSameComparator(comparator(), targets)
         || (targets.size() <= 1)) {
       return super.containsAll(targets);
     }
 
     /*
      * If targets is a sorted set with the same comparator, containsAll can run
      * in O(n) time stepping through the two collections.
      */
     Iterator<E> thisIterator = iterator();
    Iterator<?> thatIterator = targets.iterator();
    Object target = thatIterator.next();
    try {
      while (thisIterator.hasNext()) {
        int cmp = unsafeCompare(thisIterator.next(), target);
        if (cmp == 0) {
          if (!thatIterator.hasNext()) {
            return true;
          }
          target = thatIterator.next();
        } else if (cmp > 0) {
          return false;
        }
      }
    } catch (NullPointerException e) {
      return false;
    } catch (ClassCastException e) {
      return false;
    }
    return false;
  }
  private int unsafeBinarySearch(Object keythrows ClassCastException {
    return Collections.binarySearch(keyunsafeComparator());
  }
  @Override boolean isPartialView() {
    return .isPartialView();
  }
  @Override public Object[] toArray() {
    return .toArray();
  }
  @Override public <T> T[] toArray(T[] array) {
    return .toArray(array);
  }
  @Override public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (!(object instanceof Set)) {
      return false;
    }
    Set<?> that = (Set<?>) object;
    if (size() != that.size()) {
      return false;
    }
    if (SortedIterables.hasSameComparator(that)) {
      Iterator<?> otherIterator = that.iterator();
      try {
        Iterator<E> iterator = iterator();
        while (iterator.hasNext()) {
          Object element = iterator.next();
          Object otherElement = otherIterator.next();
          if (otherElement == null
              || unsafeCompare(elementotherElement) != 0) {
            return false;
          }
        }
        return true;
      } catch (ClassCastException e) {
        return false;
      } catch (NoSuchElementException e) {
        return false// concurrent change to other set
      }
    }
    return this.containsAll(that);
  }
  public E first() {
    return .get(0);
  }
  public E last() {
    return .get(size() - 1);
  }
  public E lower(E element) {
    int index = headIndex(elementfalse) - 1;
    return (index == -1) ? null : .get(index);
  }
  public E floor(E element) {
    int index = headIndex(elementtrue) - 1;
    return (index == -1) ? null : .get(index);
  }
  public E ceiling(E element) {
    int index = tailIndex(elementtrue);
    return (index == size()) ? null : .get(index);
  }
  public E higher(E element) {
    int index = tailIndex(elementfalse);
    return (index == size()) ? null : .get(index);
  }
  ImmutableSortedSet<E> headSetImpl(E toElementboolean inclusive) {
    return getSubSet(0, headIndex(toElementinclusive));
  }
  int headIndex(E toElementboolean inclusive) {
    return SortedLists.binarySearch(
        checkNotNull(toElement), comparator(),
        inclusive ?  : );
  }
      E fromElementboolean fromInclusive, E toElementboolean toInclusive) {
    return tailSetImpl(fromElementfromInclusive)
        .headSetImpl(toElementtoInclusive);
  }
  ImmutableSortedSet<E> tailSetImpl(E fromElementboolean inclusive) {
    return getSubSet(tailIndex(fromElementinclusive), size());
  }
  int tailIndex(E fromElementboolean inclusive) {
    return SortedLists.binarySearch(
        ,
        checkNotNull(fromElement),
        comparator(),
        inclusive ?  : );
  }
  // Pretend the comparator can compare anything. If it turns out it can't
  // compare two elements, it'll throw a CCE. Only methods that are specified to
  // throw CCE should call this.
  @SuppressWarnings("unchecked")
    return (Comparator<Object>) ;
  }
  ImmutableSortedSet<E> getSubSet(int newFromIndexint newToIndex) {
    if (newFromIndex == 0 && newToIndex == size()) {
      return this;
    } else if (newFromIndex < newToIndex) {
      return new RegularImmutableSortedSet<E>(
          .subList(newFromIndexnewToIndex), );
    } else {
      return emptySet();
    }
  }
  @Override int indexOf(@Nullable Object target) {
    if (target == null) {
      return -1;
    }
    int position;
    try {
      position = SortedLists.binarySearch(targetunsafeComparator(),
    } catch (ClassCastException e) {
      return -1;
    }
    return (position >= 0) ? position : -1;
  }
    return new ImmutableSortedAsList<E>(this);
  }
    return new RegularImmutableSortedSet<E>(.reverse(),
        Ordering.from().reverse());
  }
New to GrepCode? Check out our FAQ X