package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Ints;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import javax.annotation.Nullable;
import op;
import pl;

@GwtCompatible(emulated=true, serializable=true)
public abstract class ImmutableMultiset<E>
  extends ImmutableCollection<E>
  implements Multiset<E>
{
  private static final ImmutableMultiset<Object> a = new pl(ImmutableMap.of(), 0);
  private transient ImmutableSet<Multiset.Entry<E>> b;
  
  private static <E> ImmutableMultiset<E> a(Multiset<? extends E> paramMultiset)
  {
    return a(paramMultiset.entrySet());
  }
  
  static <E> ImmutableMultiset<E> a(Collection<? extends Multiset.Entry<? extends E>> paramCollection)
  {
    ImmutableMap.Builder localBuilder = ImmutableMap.builder();
    paramCollection = paramCollection.iterator();
    long l = 0L;
    if (paramCollection.hasNext())
    {
      Multiset.Entry localEntry = (Multiset.Entry)paramCollection.next();
      int i = localEntry.getCount();
      if (i <= 0) {
        break label98;
      }
      localBuilder.put(localEntry.getElement(), Integer.valueOf(i));
      l = i + l;
    }
    label98:
    for (;;)
    {
      break;
      if (l == 0L) {
        return of();
      }
      return new pl(localBuilder.build(), Ints.saturatedCast(l));
    }
  }
  
  public static <E> Builder<E> builder()
  {
    return new Builder();
  }
  
  public static <E> ImmutableMultiset<E> copyOf(Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof ImmutableMultiset))
    {
      ImmutableMultiset localImmutableMultiset = (ImmutableMultiset)paramIterable;
      if (!localImmutableMultiset.a()) {
        return localImmutableMultiset;
      }
    }
    if ((paramIterable instanceof Multiset)) {}
    for (paramIterable = Multisets.b(paramIterable);; paramIterable = LinkedHashMultiset.create(paramIterable)) {
      return a(paramIterable);
    }
  }
  
  public static <E> ImmutableMultiset<E> copyOf(Iterator<? extends E> paramIterator)
  {
    LinkedHashMultiset localLinkedHashMultiset = LinkedHashMultiset.create();
    Iterators.addAll(localLinkedHashMultiset, paramIterator);
    return a(localLinkedHashMultiset);
  }
  
  public static <E> ImmutableMultiset<E> copyOf(E[] paramArrayOfE)
  {
    return copyOf(Arrays.asList(paramArrayOfE));
  }
  
  public static <E> ImmutableMultiset<E> of()
  {
    return a;
  }
  
  public static <E> ImmutableMultiset<E> of(E paramE)
  {
    return copyOf(Arrays.asList(new Object[] { paramE }));
  }
  
  public static <E> ImmutableMultiset<E> of(E paramE1, E paramE2)
  {
    return copyOf(Arrays.asList(new Object[] { paramE1, paramE2 }));
  }
  
  public static <E> ImmutableMultiset<E> of(E paramE1, E paramE2, E paramE3)
  {
    return copyOf(Arrays.asList(new Object[] { paramE1, paramE2, paramE3 }));
  }
  
  public static <E> ImmutableMultiset<E> of(E paramE1, E paramE2, E paramE3, E paramE4)
  {
    return copyOf(Arrays.asList(new Object[] { paramE1, paramE2, paramE3, paramE4 }));
  }
  
  public static <E> ImmutableMultiset<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5)
  {
    return copyOf(Arrays.asList(new Object[] { paramE1, paramE2, paramE3, paramE4, paramE5 }));
  }
  
  public static <E> ImmutableMultiset<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5, E paramE6, E... paramVarArgs)
  {
    return new Builder().add(paramE1).add(paramE2).add(paramE3).add(paramE4).add(paramE5).add(paramE6).add(paramVarArgs).build();
  }
  
  @GwtIncompatible("not present in emulated superclass")
  protected int a(Object[] paramArrayOfObject, int paramInt)
  {
    Iterator localIterator = entrySet().iterator();
    while (localIterator.hasNext())
    {
      Multiset.Entry localEntry = (Multiset.Entry)localIterator.next();
      Arrays.fill(paramArrayOfObject, paramInt, localEntry.getCount() + paramInt, localEntry.getElement());
      paramInt += localEntry.getCount();
    }
    return paramInt;
  }
  
  public abstract Multiset.Entry<E> a(int paramInt);
  
  @Deprecated
  public final int add(E paramE, int paramInt)
  {
    throw new UnsupportedOperationException();
  }
  
  public boolean contains(@Nullable Object paramObject)
  {
    return count(paramObject) > 0;
  }
  
  public boolean containsAll(Collection<?> paramCollection)
  {
    return elementSet().containsAll(paramCollection);
  }
  
  public ImmutableSet<Multiset.Entry<E>> entrySet()
  {
    ImmutableSet localImmutableSet = this.b;
    Object localObject = localImmutableSet;
    if (localImmutableSet == null) {
      if (!isEmpty()) {
        break label29;
      }
    }
    label29:
    for (localObject = ImmutableSet.of();; localObject = new a((byte)0))
    {
      this.b = ((ImmutableSet)localObject);
      return (ImmutableSet<Multiset.Entry<E>>)localObject;
    }
  }
  
  public boolean equals(@Nullable Object paramObject)
  {
    return Multisets.a(this, paramObject);
  }
  
  public int hashCode()
  {
    return Sets.a(entrySet());
  }
  
  public UnmodifiableIterator<E> iterator()
  {
    new UnmodifiableIterator()
    {
      int a;
      E b;
      
      public final boolean hasNext()
      {
        return (this.a > 0) || (this.c.hasNext());
      }
      
      public final E next()
      {
        if (this.a <= 0)
        {
          Multiset.Entry localEntry = (Multiset.Entry)this.c.next();
          this.b = localEntry.getElement();
          this.a = localEntry.getCount();
        }
        this.a -= 1;
        return (E)this.b;
      }
    };
  }
  
  @Deprecated
  public final int remove(Object paramObject, int paramInt)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final int setCount(E paramE, int paramInt)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final boolean setCount(E paramE, int paramInt1, int paramInt2)
  {
    throw new UnsupportedOperationException();
  }
  
  public String toString()
  {
    return entrySet().toString();
  }
  
  Object writeReplace()
  {
    return new c(this);
  }
  
  public static class Builder<E>
    extends ImmutableCollection.Builder<E>
  {
    final Multiset<E> a;
    
    public Builder()
    {
      this(LinkedHashMultiset.create());
    }
    
    Builder(Multiset<E> paramMultiset)
    {
      this.a = paramMultiset;
    }
    
    public Builder<E> add(E paramE)
    {
      this.a.add(Preconditions.checkNotNull(paramE));
      return this;
    }
    
    public Builder<E> add(E... paramVarArgs)
    {
      super.add(paramVarArgs);
      return this;
    }
    
    public Builder<E> addAll(Iterable<? extends E> paramIterable)
    {
      if ((paramIterable instanceof Multiset))
      {
        paramIterable = Multisets.b(paramIterable).entrySet().iterator();
        while (paramIterable.hasNext())
        {
          Multiset.Entry localEntry = (Multiset.Entry)paramIterable.next();
          addCopies(localEntry.getElement(), localEntry.getCount());
        }
      }
      super.addAll(paramIterable);
      return this;
    }
    
    public Builder<E> addAll(Iterator<? extends E> paramIterator)
    {
      super.addAll(paramIterator);
      return this;
    }
    
    public Builder<E> addCopies(E paramE, int paramInt)
    {
      this.a.add(Preconditions.checkNotNull(paramE), paramInt);
      return this;
    }
    
    public ImmutableMultiset<E> build()
    {
      return ImmutableMultiset.copyOf(this.a);
    }
    
    public Builder<E> setCount(E paramE, int paramInt)
    {
      this.a.setCount(Preconditions.checkNotNull(paramE), paramInt);
      return this;
    }
  }
  
  final class a
    extends ImmutableSet<Multiset.Entry<E>>
  {
    private static final long serialVersionUID = 0L;
    
    private a() {}
    
    final boolean a()
    {
      return ImmutableMultiset.this.a();
    }
    
    final ImmutableList<Multiset.Entry<E>> c()
    {
      new op()
      {
        final ImmutableCollection<Multiset.Entry<E>> b()
        {
          return ImmutableMultiset.a.this;
        }
      };
    }
    
    public final boolean contains(Object paramObject)
    {
      if ((paramObject instanceof Multiset.Entry))
      {
        paramObject = (Multiset.Entry)paramObject;
        if (((Multiset.Entry)paramObject).getCount() > 0) {
          break label23;
        }
      }
      label23:
      while (ImmutableMultiset.this.count(((Multiset.Entry)paramObject).getElement()) != ((Multiset.Entry)paramObject).getCount()) {
        return false;
      }
      return true;
    }
    
    public final int hashCode()
    {
      return ImmutableMultiset.this.hashCode();
    }
    
    public final UnmodifiableIterator<Multiset.Entry<E>> iterator()
    {
      return asList().iterator();
    }
    
    public final int size()
    {
      return ImmutableMultiset.this.elementSet().size();
    }
    
    final Object writeReplace()
    {
      return new ImmutableMultiset.b(ImmutableMultiset.this);
    }
  }
  
  static final class b<E>
    implements Serializable
  {
    final ImmutableMultiset<E> a;
    
    b(ImmutableMultiset<E> paramImmutableMultiset)
    {
      this.a = paramImmutableMultiset;
    }
    
    final Object readResolve()
    {
      return this.a.entrySet();
    }
  }
  
  static final class c
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Object[] a;
    final int[] b;
    
    c(Multiset<?> paramMultiset)
    {
      int i = paramMultiset.entrySet().size();
      this.a = new Object[i];
      this.b = new int[i];
      paramMultiset = paramMultiset.entrySet().iterator();
      i = 0;
      while (paramMultiset.hasNext())
      {
        Multiset.Entry localEntry = (Multiset.Entry)paramMultiset.next();
        this.a[i] = localEntry.getElement();
        this.b[i] = localEntry.getCount();
        i += 1;
      }
    }
    
    final Object readResolve()
    {
      LinkedHashMultiset localLinkedHashMultiset = LinkedHashMultiset.create(this.a.length);
      int i = 0;
      while (i < this.a.length)
      {
        localLinkedHashMultiset.add(this.a[i], this.b[i]);
        i += 1;
      }
      return ImmutableMultiset.copyOf(localLinkedHashMultiset);
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/collect/ImmutableMultiset.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */