Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 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 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.KeyAbsentBehavior.NEXT_LOWER;
 import static com.google.common.collect.SortedLists.KeyPresentBehavior.ANY_PRESENT;
 
 
 import java.util.List;
 
An immutable sorted multiset with one or more distinct elements.

Author(s):
Louis Wasserman
 
 @SuppressWarnings("serial"// uses writeReplace, not default serialization
   private static final class CumulativeCountEntry<E> extends Multisets.AbstractEntry<E> {
     final E element;
     final int count;
     final long cumulativeCount;
 
     CumulativeCountEntry(E elementint count, @Nullable CumulativeCountEntry<E> previous) {
       this. = element;
       this. = count;
       this. = count + ((previous == null) ? 0 : previous.cumulativeCount);
     }
 
     @Override
     public E getElement() {
       return ;
     }
 
     @Override
     public int getCount() {
       return ;
     }
   }
 
   static <E> RegularImmutableSortedMultiset<E> createFromSorted(Comparator<? super E> comparator,
       List<? extends Multiset.Entry<E>> entries) {
     List<CumulativeCountEntry<E>> newEntries = Lists.newArrayListWithCapacity(entries.size());
     CumulativeCountEntry<E> previous = null;
     for (Multiset.Entry<E> entry : entries) {
       newEntries.add(
           previous = new CumulativeCountEntry<E>(entry.getElement(), entry.getCount(), previous));
     }
     return new RegularImmutableSortedMultiset<E>(comparator, ImmutableList.copyOf(newEntries));
   }
 
   final transient ImmutableList<CumulativeCountEntry<E>> entries;
 
       Comparator<? super E> comparatorImmutableList<CumulativeCountEntry<E>> entries) {
     super(comparator);
     this. = entries;
     assert !entries.isEmpty();
   }
 
     return new TransformedImmutableList<CumulativeCountEntry<E>, E>() {
       @Override
       E transform(CumulativeCountEntry<E> entry) {
         return entry.getElement();
       }
     };
   }
 
   @Override
     return new RegularImmutableSortedSet<E>(elementList(), comparator());
   }
 
   @Override
   }
 
   @Override
    return new EntrySet() {
      @Override
      public int size() {
        return .size();
      }
      @Override
      public UnmodifiableIterator<Entry<E>> iterator() {
        return asList().iterator();
      }
      @SuppressWarnings("unchecked"// upcasting entries is totally safe
      @Override
      ImmutableList<Entry<E>> createAsList() {
        // TODO(user): make this delegate contains() calls to entries
        return (ImmutableList;
      }
    };
  }
  public CumulativeCountEntry<E> firstEntry() {
    return .get(0);
  }
  public CumulativeCountEntry<E> lastEntry() {
    return .get(.size() - 1);
  }
  public int size() {
    CumulativeCountEntry<E> firstEntry = firstEntry();
    CumulativeCountEntry<E> lastEntry = lastEntry();
    return Ints.saturatedCast(
        lastEntry.cumulativeCount - firstEntry.cumulativeCount + firstEntry.count);
  }
  boolean isPartialView() {
    return .isPartialView();
  }
  @SuppressWarnings("unchecked")
  public int count(@Nullable Object element) {
    if (element == null) {
      return 0;
    }
    try {
      int index = SortedLists.binarySearch(
          elementList(), (E) elementcomparator(), );
      return (index >= 0) ? .get(index).getCount() : 0;
    } catch (ClassCastException e) {
      return 0;
    }
  }
  public ImmutableSortedMultiset<E> headMultiset(E upperBoundBoundType boundType) {
    int index;
    switch (boundType) {
      case :
        index = SortedLists.binarySearch(
            elementList(), checkNotNull(upperBound), comparator(), );
        break;
      case :
        index = SortedLists.binarySearch(
            elementList(), checkNotNull(upperBound), comparator(), ) + 1;
        break;
      default:
        throw new AssertionError();
    }
    return createSubMultiset(0, index);
  }
  public ImmutableSortedMultiset<E> tailMultiset(E lowerBoundBoundType boundType) {
    int index;
    switch (boundType) {
      case :
        index = SortedLists.binarySearch(
            elementList(), checkNotNull(lowerBound), comparator(), ) + 1;
        break;
      case :
        index = SortedLists.binarySearch(
            elementList(), checkNotNull(lowerBound), comparator(), );
        break;
      default:
        throw new AssertionError();
    }
    return createSubMultiset(index.size());
  }
  private ImmutableSortedMultiset<E> createSubMultiset(int newFromIndexint newToIndex) {
    if (newFromIndex == 0 && newToIndex == .size()) {
      return this;
    } else if (newFromIndex >= newToIndex) {
      return emptyMultiset(comparator());
    } else {
      return new RegularImmutableSortedMultiset<E>(
          comparator(), .subList(newFromIndexnewToIndex));
    }
  }
New to GrepCode? Check out our FAQ X