package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.math.IntMath;
import com.google.common.primitives.Ints;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.Nullable;
import my;
import my.b;
import nj;
import pt;
import pt.a;

public final class ConcurrentHashMultiset<E>
  extends my<E>
  implements Serializable
{
  private static final long serialVersionUID = 1L;
  private final transient ConcurrentMap<E, AtomicInteger> a;
  
  @VisibleForTesting
  private ConcurrentHashMultiset(ConcurrentMap<E, AtomicInteger> paramConcurrentMap)
  {
    Preconditions.checkArgument(paramConcurrentMap.isEmpty());
    this.a = paramConcurrentMap;
  }
  
  public static <E> ConcurrentHashMultiset<E> create()
  {
    return new ConcurrentHashMultiset(new ConcurrentHashMap());
  }
  
  @Beta
  public static <E> ConcurrentHashMultiset<E> create(MapMaker paramMapMaker)
  {
    return new ConcurrentHashMultiset(paramMapMaker.makeMap());
  }
  
  public static <E> ConcurrentHashMultiset<E> create(Iterable<? extends E> paramIterable)
  {
    ConcurrentHashMultiset localConcurrentHashMultiset = create();
    Iterables.addAll(localConcurrentHashMultiset, paramIterable);
    return localConcurrentHashMultiset;
  }
  
  private List<E> d()
  {
    ArrayList localArrayList = Lists.newArrayListWithExpectedSize(size());
    Iterator localIterator = entrySet().iterator();
    while (localIterator.hasNext())
    {
      Multiset.Entry localEntry = (Multiset.Entry)localIterator.next();
      Object localObject = localEntry.getElement();
      int i = localEntry.getCount();
      while (i > 0)
      {
        localArrayList.add(localObject);
        i -= 1;
      }
    }
    return localArrayList;
  }
  
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    paramObjectInputStream = (ConcurrentMap)paramObjectInputStream.readObject();
    b.a.a(this, paramObjectInputStream);
  }
  
  private void writeObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.defaultWriteObject();
    paramObjectOutputStream.writeObject(this.a);
  }
  
  final Iterator<Multiset.Entry<E>> a()
  {
    new ForwardingIterator()
    {
      private Iterator<Map.Entry<E, AtomicInteger>> b = ConcurrentHashMultiset.a(ConcurrentHashMultiset.this).entrySet().iterator();
    }
    {
      private Multiset.Entry<E> c;
      
      protected final Iterator<Multiset.Entry<E>> delegate()
      {
        return this.a;
      }
      
      public final void remove()
      {
        if (this.c != null) {}
        for (boolean bool = true;; bool = false)
        {
          Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
          ConcurrentHashMultiset.this.setCount(this.c.getElement(), 0);
          this.c = null;
          return;
        }
      }
    };
  }
  
  public final int add(E paramE, int paramInt)
  {
    int j = 0;
    Preconditions.checkNotNull(paramE);
    int i;
    if (paramInt == 0)
    {
      i = count(paramE);
      return i;
    }
    boolean bool;
    if (paramInt > 0)
    {
      bool = true;
      label27:
      Preconditions.checkArgument(bool, "Invalid occurrences: %s", new Object[] { Integer.valueOf(paramInt) });
    }
    AtomicInteger localAtomicInteger2;
    AtomicInteger localAtomicInteger1;
    do
    {
      localAtomicInteger2 = (AtomicInteger)Maps.a(this.a, paramE);
      localAtomicInteger1 = localAtomicInteger2;
      if (localAtomicInteger2 == null)
      {
        localAtomicInteger1 = (AtomicInteger)this.a.putIfAbsent(paramE, new AtomicInteger(paramInt));
        i = j;
        if (localAtomicInteger1 == null) {
          break;
        }
      }
      for (;;)
      {
        i = localAtomicInteger1.get();
        if (i == 0) {
          break;
        }
        try
        {
          bool = localAtomicInteger1.compareAndSet(i, IntMath.checkedAdd(i, paramInt));
          if (bool) {
            return i;
          }
        }
        catch (ArithmeticException paramE)
        {
          throw new IllegalArgumentException(65 + "Overflow adding " + paramInt + " occurrences to a count of " + i);
        }
      }
      bool = false;
      break label27;
      localAtomicInteger2 = new AtomicInteger(paramInt);
      i = j;
      if (this.a.putIfAbsent(paramE, localAtomicInteger2) == null) {
        break;
      }
    } while (!this.a.replace(paramE, localAtomicInteger1, localAtomicInteger2));
    return 0;
  }
  
  final int b()
  {
    return this.a.size();
  }
  
  final Set<E> c()
  {
    new ForwardingSet()
    {
      public final boolean contains(@Nullable Object paramAnonymousObject)
      {
        return (paramAnonymousObject != null) && (Collections2.a(this.a, paramAnonymousObject));
      }
      
      public final boolean containsAll(Collection<?> paramAnonymousCollection)
      {
        return standardContainsAll(paramAnonymousCollection);
      }
      
      protected final Set<E> delegate()
      {
        return this.a;
      }
      
      public final boolean remove(Object paramAnonymousObject)
      {
        return (paramAnonymousObject != null) && (Collections2.b(this.a, paramAnonymousObject));
      }
      
      public final boolean removeAll(Collection<?> paramAnonymousCollection)
      {
        return standardRemoveAll(paramAnonymousCollection);
      }
    };
  }
  
  public final void clear()
  {
    this.a.clear();
  }
  
  public final int count(@Nullable Object paramObject)
  {
    paramObject = (AtomicInteger)Maps.a(this.a, paramObject);
    if (paramObject == null) {
      return 0;
    }
    return ((AtomicInteger)paramObject).get();
  }
  
  public final Set<Multiset.Entry<E>> createEntrySet()
  {
    return new a((byte)0);
  }
  
  public final boolean isEmpty()
  {
    return this.a.isEmpty();
  }
  
  public final int remove(@Nullable Object paramObject, int paramInt)
  {
    int j = 0;
    int i;
    if (paramInt == 0)
    {
      i = count(paramObject);
      return i;
    }
    if (paramInt > 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "Invalid occurrences: %s", new Object[] { Integer.valueOf(paramInt) });
      AtomicInteger localAtomicInteger = (AtomicInteger)Maps.a(this.a, paramObject);
      i = j;
      if (localAtomicInteger == null) {
        break;
      }
      int k;
      do
      {
        k = localAtomicInteger.get();
        i = j;
        if (k == 0) {
          break;
        }
        i = Math.max(0, k - paramInt);
      } while (!localAtomicInteger.compareAndSet(k, i));
      if (i == 0) {
        this.a.remove(paramObject, localAtomicInteger);
      }
      return k;
    }
  }
  
  public final boolean removeExactly(@Nullable Object paramObject, int paramInt)
  {
    if (paramInt == 0) {}
    AtomicInteger localAtomicInteger;
    int j;
    do
    {
      return true;
      if (paramInt > 0) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "Invalid occurrences: %s", new Object[] { Integer.valueOf(paramInt) });
        localAtomicInteger = (AtomicInteger)Maps.a(this.a, paramObject);
        if (localAtomicInteger != null) {
          break;
        }
        return false;
      }
      int i;
      do
      {
        i = localAtomicInteger.get();
        if (i < paramInt) {
          return false;
        }
        j = i - paramInt;
      } while (!localAtomicInteger.compareAndSet(i, j));
    } while (j != 0);
    this.a.remove(paramObject, localAtomicInteger);
    return true;
  }
  
  public final int setCount(E paramE, int paramInt)
  {
    Preconditions.checkNotNull(paramE);
    nj.a(paramInt, "count");
    AtomicInteger localAtomicInteger2 = (AtomicInteger)Maps.a(this.a, paramE);
    AtomicInteger localAtomicInteger1 = localAtomicInteger2;
    if (localAtomicInteger2 == null)
    {
      if (paramInt == 0) {
        return 0;
      }
      localAtomicInteger2 = (AtomicInteger)this.a.putIfAbsent(paramE, new AtomicInteger(paramInt));
      localAtomicInteger1 = localAtomicInteger2;
      if (localAtomicInteger2 == null) {
        return 0;
      }
    }
    int i;
    do
    {
      i = localAtomicInteger1.get();
      if (i == 0)
      {
        if (paramInt == 0) {
          return 0;
        }
        localAtomicInteger2 = new AtomicInteger(paramInt);
        if ((this.a.putIfAbsent(paramE, localAtomicInteger2) != null) && (!this.a.replace(paramE, localAtomicInteger1, localAtomicInteger2))) {
          break;
        }
        return 0;
      }
    } while (!localAtomicInteger1.compareAndSet(i, paramInt));
    if (paramInt == 0) {
      this.a.remove(paramE, localAtomicInteger1);
    }
    return i;
  }
  
  public final boolean setCount(E paramE, int paramInt1, int paramInt2)
  {
    Preconditions.checkNotNull(paramE);
    nj.a(paramInt1, "oldCount");
    nj.a(paramInt2, "newCount");
    AtomicInteger localAtomicInteger1 = (AtomicInteger)Maps.a(this.a, paramE);
    if (localAtomicInteger1 == null)
    {
      if (paramInt1 != 0) {
        return false;
      }
      if (paramInt2 == 0) {
        return true;
      }
      return this.a.putIfAbsent(paramE, new AtomicInteger(paramInt2)) == null;
    }
    int i = localAtomicInteger1.get();
    if (i == paramInt1)
    {
      if (i == 0)
      {
        if (paramInt2 == 0)
        {
          this.a.remove(paramE, localAtomicInteger1);
          return true;
        }
        AtomicInteger localAtomicInteger2 = new AtomicInteger(paramInt2);
        return (this.a.putIfAbsent(paramE, localAtomicInteger2) == null) || (this.a.replace(paramE, localAtomicInteger1, localAtomicInteger2));
      }
      if (localAtomicInteger1.compareAndSet(i, paramInt2))
      {
        if (paramInt2 == 0) {
          this.a.remove(paramE, localAtomicInteger1);
        }
        return true;
      }
    }
    return false;
  }
  
  public final int size()
  {
    Iterator localIterator = this.a.values().iterator();
    for (long l = 0L; localIterator.hasNext(); l = ((AtomicInteger)localIterator.next()).get() + l) {}
    return Ints.saturatedCast(l);
  }
  
  public final Object[] toArray()
  {
    return d().toArray();
  }
  
  public final <T> T[] toArray(T[] paramArrayOfT)
  {
    return d().toArray(paramArrayOfT);
  }
  
  final class a
    extends my<E>.b
  {
    private a()
    {
      super();
    }
    
    private List<Multiset.Entry<E>> b()
    {
      ArrayList localArrayList = Lists.newArrayListWithExpectedSize(size());
      Iterators.addAll(localArrayList, iterator());
      return localArrayList;
    }
    
    public final Object[] toArray()
    {
      return b().toArray();
    }
    
    public final <T> T[] toArray(T[] paramArrayOfT)
    {
      return b().toArray(paramArrayOfT);
    }
  }
  
  static final class b
  {
    static final pt.a<ConcurrentHashMultiset> a = pt.a(ConcurrentHashMultiset.class, "countMap");
  }
}


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