package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
import javax.annotation.Nullable;
import nb;
import nj;
import oo;
import oq;

@GwtCompatible(emulated=true, serializable=true)
public final class LinkedHashMultimap<K, V>
  extends nb<K, V>
{
  @GwtIncompatible("java serialization not supported")
  private static final long serialVersionUID = 1L;
  @VisibleForTesting
  transient int a = 2;
  private transient a<K, V> b;
  
  private LinkedHashMultimap(int paramInt1, int paramInt2)
  {
    super(new LinkedHashMap(paramInt1));
    nj.a(paramInt2, "expectedValuesPerKey");
    this.a = paramInt2;
    this.b = new a(null, null, 0, null);
    b(this.b, this.b);
  }
  
  private static <K, V> void b(a<K, V> parama1, a<K, V> parama2)
  {
    parama1.h = parama2;
    parama2.g = parama1;
  }
  
  private static <K, V> void b(c<K, V> paramc1, c<K, V> paramc2)
  {
    paramc1.b(paramc2);
    paramc2.a(paramc1);
  }
  
  public static <K, V> LinkedHashMultimap<K, V> create()
  {
    return new LinkedHashMultimap(16, 2);
  }
  
  public static <K, V> LinkedHashMultimap<K, V> create(int paramInt1, int paramInt2)
  {
    return new LinkedHashMultimap(Maps.a(paramInt1), Maps.a(paramInt2));
  }
  
  public static <K, V> LinkedHashMultimap<K, V> create(Multimap<? extends K, ? extends V> paramMultimap)
  {
    LinkedHashMultimap localLinkedHashMultimap = create(paramMultimap.keySet().size(), 2);
    localLinkedHashMultimap.putAll(paramMultimap);
    return localLinkedHashMultimap;
  }
  
  @GwtIncompatible("java.io.ObjectInputStream")
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    this.b = new a(null, null, 0, null);
    b(this.b, this.b);
    this.a = paramObjectInputStream.readInt();
    int j = paramObjectInputStream.readInt();
    LinkedHashMap localLinkedHashMap = new LinkedHashMap(Maps.a(j));
    int i = 0;
    Object localObject1;
    while (i < j)
    {
      localObject1 = paramObjectInputStream.readObject();
      localLinkedHashMap.put(localObject1, a(localObject1));
      i += 1;
    }
    j = paramObjectInputStream.readInt();
    i = 0;
    while (i < j)
    {
      localObject1 = paramObjectInputStream.readObject();
      Object localObject2 = paramObjectInputStream.readObject();
      ((Collection)localLinkedHashMap.get(localObject1)).add(localObject2);
      i += 1;
    }
    a(localLinkedHashMap);
  }
  
  @GwtIncompatible("java.io.ObjectOutputStream")
  private void writeObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.defaultWriteObject();
    paramObjectOutputStream.writeInt(this.a);
    paramObjectOutputStream.writeInt(keySet().size());
    Iterator localIterator = keySet().iterator();
    while (localIterator.hasNext()) {
      paramObjectOutputStream.writeObject(localIterator.next());
    }
    paramObjectOutputStream.writeInt(size());
    localIterator = entries().iterator();
    while (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      paramObjectOutputStream.writeObject(localEntry.getKey());
      paramObjectOutputStream.writeObject(localEntry.getValue());
    }
  }
  
  final Collection<V> a(K paramK)
  {
    return new b(paramK, this.a);
  }
  
  final Set<V> a()
  {
    return new LinkedHashSet(this.a);
  }
  
  public final void clear()
  {
    super.clear();
    b(this.b, this.b);
  }
  
  public final Set<Map.Entry<K, V>> entries()
  {
    return super.entries();
  }
  
  final Iterator<V> f()
  {
    return Maps.b(g());
  }
  
  final Iterator<Map.Entry<K, V>> g()
  {
    new Iterator()
    {
      LinkedHashMultimap.a<K, V> a = LinkedHashMultimap.a(LinkedHashMultimap.this).h;
      LinkedHashMultimap.a<K, V> b;
      
      public final boolean hasNext()
      {
        return this.a != LinkedHashMultimap.a(LinkedHashMultimap.this);
      }
      
      public final void remove()
      {
        if (this.b != null) {}
        for (boolean bool = true;; bool = false)
        {
          Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
          LinkedHashMultimap.this.remove(this.b.getKey(), this.b.getValue());
          this.b = null;
          return;
        }
      }
    };
  }
  
  public final Set<V> replaceValues(@Nullable K paramK, Iterable<? extends V> paramIterable)
  {
    return super.replaceValues(paramK, paramIterable);
  }
  
  public final Collection<V> values()
  {
    return super.values();
  }
  
  @VisibleForTesting
  static final class a<K, V>
    extends oq<K, V>
    implements LinkedHashMultimap.c<K, V>
  {
    final int a;
    @Nullable
    a<K, V> b;
    LinkedHashMultimap.c<K, V> c;
    LinkedHashMultimap.c<K, V> d;
    a<K, V> g;
    a<K, V> h;
    
    a(@Nullable K paramK, @Nullable V paramV, int paramInt, @Nullable a<K, V> parama)
    {
      super(paramV);
      this.a = paramInt;
      this.b = parama;
    }
    
    public final LinkedHashMultimap.c<K, V> a()
    {
      return this.c;
    }
    
    public final void a(LinkedHashMultimap.c<K, V> paramc)
    {
      this.c = paramc;
    }
    
    final boolean a(@Nullable Object paramObject, int paramInt)
    {
      return (this.a == paramInt) && (Objects.equal(getValue(), paramObject));
    }
    
    public final LinkedHashMultimap.c<K, V> b()
    {
      return this.d;
    }
    
    public final void b(LinkedHashMultimap.c<K, V> paramc)
    {
      this.d = paramc;
    }
  }
  
  @VisibleForTesting
  final class b
    extends Sets.f<V>
    implements LinkedHashMultimap.c<K, V>
  {
    @VisibleForTesting
    LinkedHashMultimap.a<K, V>[] a;
    private final K c;
    private int d = 0;
    private int e = 0;
    private LinkedHashMultimap.c<K, V> f;
    private LinkedHashMultimap.c<K, V> g;
    
    b(int paramInt)
    {
      this.c = paramInt;
      this.f = this;
      this.g = this;
      int i;
      this.a = new LinkedHashMultimap.a[oo.a(i, 1.0D)];
    }
    
    public final LinkedHashMultimap.c<K, V> a()
    {
      return this.g;
    }
    
    public final void a(LinkedHashMultimap.c<K, V> paramc)
    {
      this.g = paramc;
    }
    
    public final boolean add(@Nullable V paramV)
    {
      int i = oo.a(paramV);
      int j = i & this.a.length - 1;
      LinkedHashMultimap.a locala = this.a[j];
      for (Object localObject = locala; localObject != null; localObject = ((LinkedHashMultimap.a)localObject).b) {
        if (((LinkedHashMultimap.a)localObject).a(paramV, i)) {
          return false;
        }
      }
      paramV = new LinkedHashMultimap.a(this.c, paramV, i, locala);
      LinkedHashMultimap.a(this.g, paramV);
      LinkedHashMultimap.a(paramV, this);
      LinkedHashMultimap.a(LinkedHashMultimap.a(LinkedHashMultimap.this).g, paramV);
      LinkedHashMultimap.a(paramV, LinkedHashMultimap.a(LinkedHashMultimap.this));
      this.a[j] = paramV;
      this.d += 1;
      this.e += 1;
      if (oo.a(this.d, this.a.length))
      {
        localObject = new LinkedHashMultimap.a[this.a.length * 2];
        this.a = ((LinkedHashMultimap.a[])localObject);
        i = localObject.length;
        for (paramV = this.f; paramV != this; paramV = paramV.b())
        {
          locala = (LinkedHashMultimap.a)paramV;
          j = locala.a & i - 1;
          locala.b = localObject[j];
          localObject[j] = locala;
        }
      }
      return true;
    }
    
    public final LinkedHashMultimap.c<K, V> b()
    {
      return this.f;
    }
    
    public final void b(LinkedHashMultimap.c<K, V> paramc)
    {
      this.f = paramc;
    }
    
    public final void clear()
    {
      Arrays.fill(this.a, null);
      this.d = 0;
      for (LinkedHashMultimap.c localc = this.f; localc != this; localc = localc.b()) {
        LinkedHashMultimap.a((LinkedHashMultimap.a)localc);
      }
      LinkedHashMultimap.a(this, this);
      this.e += 1;
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      int i = oo.a(paramObject);
      for (LinkedHashMultimap.a locala = this.a[(this.a.length - 1 & i)]; locala != null; locala = locala.b) {
        if (locala.a(paramObject, i)) {
          return true;
        }
      }
      return false;
    }
    
    public final Iterator<V> iterator()
    {
      new Iterator()
      {
        LinkedHashMultimap.c<K, V> a = LinkedHashMultimap.b.a(LinkedHashMultimap.b.this);
        LinkedHashMultimap.a<K, V> b;
        int c = LinkedHashMultimap.b.b(LinkedHashMultimap.b.this);
        
        private void a()
        {
          if (LinkedHashMultimap.b.b(LinkedHashMultimap.b.this) != this.c) {
            throw new ConcurrentModificationException();
          }
        }
        
        public final boolean hasNext()
        {
          a();
          return this.a != LinkedHashMultimap.b.this;
        }
        
        public final V next()
        {
          if (!hasNext()) {
            throw new NoSuchElementException();
          }
          LinkedHashMultimap.a locala = (LinkedHashMultimap.a)this.a;
          Object localObject = locala.getValue();
          this.b = locala;
          this.a = locala.d;
          return (V)localObject;
        }
        
        public final void remove()
        {
          a();
          if (this.b != null) {}
          for (boolean bool = true;; bool = false)
          {
            Preconditions.checkState(bool, "no calls to next() since the last call to remove()");
            LinkedHashMultimap.b.this.remove(this.b.getValue());
            this.c = LinkedHashMultimap.b.b(LinkedHashMultimap.b.this);
            this.b = null;
            return;
          }
        }
      };
    }
    
    public final boolean remove(@Nullable Object paramObject)
    {
      int i = oo.a(paramObject);
      int j = i & this.a.length - 1;
      Object localObject2 = null;
      LinkedHashMultimap.a locala;
      for (Object localObject1 = this.a[j]; localObject1 != null; localObject1 = locala)
      {
        if (((LinkedHashMultimap.a)localObject1).a(paramObject, i))
        {
          if (localObject2 == null) {
            this.a[j] = ((LinkedHashMultimap.a)localObject1).b;
          }
          for (;;)
          {
            LinkedHashMultimap.a((LinkedHashMultimap.c)localObject1);
            LinkedHashMultimap.a((LinkedHashMultimap.a)localObject1);
            this.d -= 1;
            this.e += 1;
            return true;
            ((LinkedHashMultimap.a)localObject2).b = ((LinkedHashMultimap.a)localObject1).b;
          }
        }
        locala = ((LinkedHashMultimap.a)localObject1).b;
        localObject2 = localObject1;
      }
      return false;
    }
    
    public final int size()
    {
      return this.d;
    }
  }
  
  static abstract interface c<K, V>
  {
    public abstract c<K, V> a();
    
    public abstract void a(c<K, V> paramc);
    
    public abstract c<K, V> b();
    
    public abstract void b(c<K, V> paramc);
  }
}


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