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;
 
 
 
Implementation of com.google.common.collect.ImmutableMultiset with zero or more elements.

Author(s):
Jared Levy
Louis Wasserman
 
 @GwtCompatible(serializable = true)
 @SuppressWarnings("serial"// uses writeReplace(), not default serialization
 class RegularImmutableMultiset<E> extends ImmutableMultiset<E> {
   static final RegularImmutableMultiset<ObjectEMPTY =
       new RegularImmutableMultiset<Object>(ImmutableList.<Entry<Object>>of());
 
   private final transient Multisets.ImmutableEntry<E>[] entries;
   private final transient Multisets.ImmutableEntry<E>[] hashTable;
   private final transient int size;
   private final transient int hashCode;
 
   private transient ImmutableSet<E> elementSet;
 
   RegularImmutableMultiset(Collection<? extends Entry<? extends E>> entries) {
     int distinct = entries.size();
     @SuppressWarnings("unchecked")
     Multisets.ImmutableEntry<E>[] entryArray = new Multisets.ImmutableEntry[distinct];
     if (distinct == 0) {
       this. = entryArray;
       this. = null;
       this. = 0;
       this. = 0;
       this. = ImmutableSet.of();
     } else {
       int tableSize = Hashing.closedTableSize(distinct, 1.0);
       int mask = tableSize - 1;
       @SuppressWarnings("unchecked")
       Multisets.ImmutableEntry<E>[] hashTable = new Multisets.ImmutableEntry[tableSize];
 
       int index = 0;
       int hashCode = 0;
       long size = 0;
       for (Entry<? extends E> entry : entries) {
         E element = checkNotNull(entry.getElement());
         int count = entry.getCount();
         int hash = element.hashCode();
         int bucket = Hashing.smear(hash) & mask;
         Multisets.ImmutableEntry<E> bucketHead = hashTable[bucket];
         Multisets.ImmutableEntry<E> newEntry;
         if (bucketHead == null) {
           boolean canReuseEntry = entry instanceof Multisets.ImmutableEntry
               && !(entry instanceof NonTerminalEntry);
           newEntry = canReuseEntry
                   ? (Multisets.ImmutableEntry<E>) entry
                   : new Multisets.ImmutableEntry<E>(elementcount);
         } else {
           newEntry = new NonTerminalEntry<E>(elementcountbucketHead);
         }
         hashCode += hash ^ count;
         entryArray[index++] = newEntry;
         hashTable[bucket] = newEntry;
         size += count;
       }
       this. = entryArray;
       this. = hashTable;
       this. = Ints.saturatedCast(size);
       this. = hashCode;
     }
   }
 
   private static final class NonTerminalEntry<E> extends Multisets.ImmutableEntry<E> {
     private final Multisets.ImmutableEntry<E> nextInBucket;
 
     NonTerminalEntry(E elementint countImmutableEntry<E> nextInBucket) {
       super(elementcount);
      this. = nextInBucket;
    }
    @Override
    public ImmutableEntry<E> nextInBucket() {
      return ;
    }
  }
  boolean isPartialView() {
    return false;
  }
  public int count(@Nullable Object element) {
    Multisets.ImmutableEntry<E>[] hashTable = this.;
    if (element == null || hashTable == null) {
      return 0;
    }
    int hash = Hashing.smearedHash(element);
    int mask = hashTable.length - 1;
    for (Multisets.ImmutableEntry<E> entry = hashTable[hash & mask]; entry != null;
        entry = entry.nextInBucket()) {
      if (Objects.equal(elemententry.getElement())) {
        return entry.getCount();
      }
    }
    return 0;
  }
  public int size() {
    return ;
  }
  public ImmutableSet<E> elementSet() {
    ImmutableSet<E> result = ;
    return (result == null) ?  = new ElementSet() : result;
  }
  private final class ElementSet extends ImmutableSet.Indexed<E> {
    @Override
    E get(int index) {
      return [index].getElement();
    }
    @Override
    public boolean contains(@Nullable Object object) {
      return RegularImmutableMultiset.this.contains(object);
    }
    @Override
    boolean isPartialView() {
      return true;
    }
    @Override
    public int size() {
      return .;
    }
  }
  Entry<E> getEntry(int index) {
    return [index];
  }
  public int hashCode() {
    return ;
  }
New to GrepCode? Check out our FAQ X