package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@GwtCompatible
public final class AtomicLongMap<K>
{
  private final ConcurrentHashMap<K, AtomicLong> a;
  private transient Map<K, Long> b;
  
  private AtomicLongMap(ConcurrentHashMap<K, AtomicLong> paramConcurrentHashMap)
  {
    this.a = ((ConcurrentHashMap)Preconditions.checkNotNull(paramConcurrentHashMap));
  }
  
  public static <K> AtomicLongMap<K> create()
  {
    return new AtomicLongMap(new ConcurrentHashMap());
  }
  
  public static <K> AtomicLongMap<K> create(Map<? extends K, ? extends Long> paramMap)
  {
    AtomicLongMap localAtomicLongMap = create();
    localAtomicLongMap.putAll(paramMap);
    return localAtomicLongMap;
  }
  
  public final long addAndGet(K paramK, long paramLong)
  {
    AtomicLong localAtomicLong2 = (AtomicLong)this.a.get(paramK);
    AtomicLong localAtomicLong1 = localAtomicLong2;
    if (localAtomicLong2 == null)
    {
      localAtomicLong2 = (AtomicLong)this.a.putIfAbsent(paramK, new AtomicLong(paramLong));
      localAtomicLong1 = localAtomicLong2;
      if (localAtomicLong2 == null) {
        return paramLong;
      }
    }
    long l1;
    long l2;
    do
    {
      l1 = localAtomicLong1.get();
      if (l1 == 0L)
      {
        if (!this.a.replace(paramK, localAtomicLong1, new AtomicLong(paramLong))) {
          break;
        }
        return paramLong;
      }
      l2 = l1 + paramLong;
    } while (!localAtomicLong1.compareAndSet(l1, l2));
    return l2;
  }
  
  public final Map<K, Long> asMap()
  {
    Map localMap2 = this.b;
    Map localMap1 = localMap2;
    if (localMap2 == null)
    {
      localMap1 = Collections.unmodifiableMap(Maps.transformValues(this.a, new Function() {}));
      this.b = localMap1;
    }
    return localMap1;
  }
  
  public final void clear()
  {
    this.a.clear();
  }
  
  public final boolean containsKey(Object paramObject)
  {
    return this.a.containsKey(paramObject);
  }
  
  public final long decrementAndGet(K paramK)
  {
    return addAndGet(paramK, -1L);
  }
  
  public final long get(K paramK)
  {
    paramK = (AtomicLong)this.a.get(paramK);
    if (paramK == null) {
      return 0L;
    }
    return paramK.get();
  }
  
  public final long getAndAdd(K paramK, long paramLong)
  {
    AtomicLong localAtomicLong2 = (AtomicLong)this.a.get(paramK);
    AtomicLong localAtomicLong1 = localAtomicLong2;
    if (localAtomicLong2 == null)
    {
      localAtomicLong2 = (AtomicLong)this.a.putIfAbsent(paramK, new AtomicLong(paramLong));
      localAtomicLong1 = localAtomicLong2;
      if (localAtomicLong2 == null) {
        return 0L;
      }
    }
    long l;
    do
    {
      l = localAtomicLong1.get();
      if (l == 0L)
      {
        if (!this.a.replace(paramK, localAtomicLong1, new AtomicLong(paramLong))) {
          break;
        }
        return 0L;
      }
    } while (!localAtomicLong1.compareAndSet(l, l + paramLong));
    return l;
  }
  
  public final long getAndDecrement(K paramK)
  {
    return getAndAdd(paramK, -1L);
  }
  
  public final long getAndIncrement(K paramK)
  {
    return getAndAdd(paramK, 1L);
  }
  
  public final long incrementAndGet(K paramK)
  {
    return addAndGet(paramK, 1L);
  }
  
  public final boolean isEmpty()
  {
    return this.a.isEmpty();
  }
  
  public final long put(K paramK, long paramLong)
  {
    AtomicLong localAtomicLong2 = (AtomicLong)this.a.get(paramK);
    AtomicLong localAtomicLong1 = localAtomicLong2;
    if (localAtomicLong2 == null)
    {
      localAtomicLong2 = (AtomicLong)this.a.putIfAbsent(paramK, new AtomicLong(paramLong));
      localAtomicLong1 = localAtomicLong2;
      if (localAtomicLong2 == null) {
        return 0L;
      }
    }
    long l;
    do
    {
      l = localAtomicLong1.get();
      if (l == 0L)
      {
        if (!this.a.replace(paramK, localAtomicLong1, new AtomicLong(paramLong))) {
          break;
        }
        return 0L;
      }
    } while (!localAtomicLong1.compareAndSet(l, paramLong));
    return l;
  }
  
  public final void putAll(Map<? extends K, ? extends Long> paramMap)
  {
    paramMap = paramMap.entrySet().iterator();
    while (paramMap.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)paramMap.next();
      put(localEntry.getKey(), ((Long)localEntry.getValue()).longValue());
    }
  }
  
  public final long remove(K paramK)
  {
    AtomicLong localAtomicLong = (AtomicLong)this.a.get(paramK);
    if (localAtomicLong == null) {
      return 0L;
    }
    long l;
    do
    {
      l = localAtomicLong.get();
    } while ((l != 0L) && (!localAtomicLong.compareAndSet(l, 0L)));
    this.a.remove(paramK, localAtomicLong);
    return l;
  }
  
  public final void removeAllZeros()
  {
    Iterator localIterator = this.a.keySet().iterator();
    while (localIterator.hasNext())
    {
      Object localObject = localIterator.next();
      AtomicLong localAtomicLong = (AtomicLong)this.a.get(localObject);
      if ((localAtomicLong != null) && (localAtomicLong.get() == 0L)) {
        this.a.remove(localObject, localAtomicLong);
      }
    }
  }
  
  public final int size()
  {
    return this.a.size();
  }
  
  public final long sum()
  {
    Iterator localIterator = this.a.values().iterator();
    for (long l = 0L; localIterator.hasNext(); l = ((AtomicLong)localIterator.next()).get() + l) {}
    return l;
  }
  
  public final String toString()
  {
    return this.a.toString();
  }
}


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