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.base.Preconditions.checkPositionIndexes;
 import static com.google.common.collect.BoundType.CLOSED;
 
 
An immutable sorted multiset with one or more distinct elements.

Author(s):
Louis Wasserman
 
 @SuppressWarnings("serial"// uses writeReplace, not default serialization
   private final transient RegularImmutableSortedSet<E> elementSet;
   private final transient int[] counts;
   private final transient long[] cumulativeCounts;
   private final transient int offset;
   private final transient int length;
 
       RegularImmutableSortedSet<E> elementSet,
       int[] counts,
       long[] cumulativeCounts,
       int offset,
       int length) {
     this. = elementSet;
     this. = counts;
     this. = cumulativeCounts;
     this. = offset;
     this. = length;
   }
 
   private Entry<E> getEntry(int index) {
     return Multisets.immutableEntry(
         .asList().get(index),
         [ + index]);
   }
 
   @Override
   public Entry<E> firstEntry() {
     return getEntry(0);
   }
 
   @Override
   public Entry<E> lastEntry() {
     return getEntry( - 1);
   }
 
   @Override
   public int count(@Nullable Object element) {
     int index = .indexOf(element);
     return (index == -1) ? 0 : [index + ];
   }
 
   @Override
   public int size() {
     long size = [ + ] - [];
     return Ints.saturatedCast(size);
   }
 
   @Override
   public ImmutableSortedSet<E> elementSet() {
     return ;
   }
 
   @Override
   public ImmutableSortedMultiset<E> headMultiset(E upperBoundBoundType boundType) {
     return getSubMultiset(0, .headIndex(upperBoundcheckNotNull(boundType) == ));
   }
 
   @Override
   public ImmutableSortedMultiset<E> tailMultiset(E lowerBoundBoundType boundType) {
     return getSubMultiset(.tailIndex(lowerBoundcheckNotNull(boundType) == ),
         );
   }
 
   ImmutableSortedMultiset<E> getSubMultiset(int fromint to) {
     checkPositionIndexes(fromto);
     if (from == to) {
       return emptyMultiset(comparator());
     } else if (from == 0 && to == ) {
      return this;
    } else {
      RegularImmutableSortedSet<E> subElementSet =
          (RegularImmutableSortedSet<E>) .getSubSet(fromto);
      return new RegularImmutableSortedMultiset<E>(
          subElementSet + fromto - from);
    }
  }
    return new EntrySet();
  }
  private final class EntrySet extends ImmutableMultiset<E>.EntrySet {
    @Override
    public int size() {
      return ;
    }
    @Override
    public UnmodifiableIterator<Entry<E>> iterator() {
      return asList().iterator();
    }
    @Override
      return new ImmutableAsList<Entry<E>>() {
        @Override
        public Entry<E> get(int index) {
          return getEntry(index);
        }
        @Override
          return EntrySet.this;
        }
      };
    }
  }
  boolean isPartialView() {
    return  > 0 ||  < .;
  }
New to GrepCode? Check out our FAQ X