package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;
import nx;
import pt;
import pt.a;

@GwtCompatible(emulated=true, serializable=true)
public class ImmutableListMultimap<K, V>
  extends ImmutableMultimap<K, V>
  implements ListMultimap<K, V>
{
  @GwtIncompatible("Not needed in emulated source")
  private static final long serialVersionUID = 0L;
  private transient ImmutableListMultimap<V, K> a;
  
  protected ImmutableListMultimap(ImmutableMap<K, ImmutableList<V>> paramImmutableMap, int paramInt)
  {
    super(paramImmutableMap, paramInt);
  }
  
  public static <K, V> Builder<K, V> builder()
  {
    return new Builder();
  }
  
  public static <K, V> ImmutableListMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> paramMultimap)
  {
    if (paramMultimap.isEmpty()) {
      localObject1 = of();
    }
    Object localObject2;
    do
    {
      return (ImmutableListMultimap<K, V>)localObject1;
      if (!(paramMultimap instanceof ImmutableListMultimap)) {
        break;
      }
      localObject2 = (ImmutableListMultimap)paramMultimap;
      localObject1 = localObject2;
    } while (!((ImmutableMultimap)localObject2).b.b());
    Object localObject1 = ImmutableMap.builder();
    paramMultimap = paramMultimap.asMap().entrySet().iterator();
    int i = 0;
    if (paramMultimap.hasNext())
    {
      localObject2 = (Map.Entry)paramMultimap.next();
      ImmutableList localImmutableList = ImmutableList.copyOf((Collection)((Map.Entry)localObject2).getValue());
      if (localImmutableList.isEmpty()) {
        break label140;
      }
      ((ImmutableMap.Builder)localObject1).put(((Map.Entry)localObject2).getKey(), localImmutableList);
      i = localImmutableList.size() + i;
    }
    label140:
    for (;;)
    {
      break;
      return new ImmutableListMultimap(((ImmutableMap.Builder)localObject1).build(), i);
    }
  }
  
  public static <K, V> ImmutableListMultimap<K, V> of()
  {
    return nx.a;
  }
  
  public static <K, V> ImmutableListMultimap<K, V> of(K paramK, V paramV)
  {
    Builder localBuilder = builder();
    localBuilder.put(paramK, paramV);
    return localBuilder.build();
  }
  
  public static <K, V> ImmutableListMultimap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2)
  {
    Builder localBuilder = builder();
    localBuilder.put(paramK1, paramV1);
    localBuilder.put(paramK2, paramV2);
    return localBuilder.build();
  }
  
  public static <K, V> ImmutableListMultimap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3)
  {
    Builder localBuilder = builder();
    localBuilder.put(paramK1, paramV1);
    localBuilder.put(paramK2, paramV2);
    localBuilder.put(paramK3, paramV3);
    return localBuilder.build();
  }
  
  public static <K, V> ImmutableListMultimap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3, K paramK4, V paramV4)
  {
    Builder localBuilder = builder();
    localBuilder.put(paramK1, paramV1);
    localBuilder.put(paramK2, paramV2);
    localBuilder.put(paramK3, paramV3);
    localBuilder.put(paramK4, paramV4);
    return localBuilder.build();
  }
  
  public static <K, V> ImmutableListMultimap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3, K paramK4, V paramV4, K paramK5, V paramV5)
  {
    Builder localBuilder = builder();
    localBuilder.put(paramK1, paramV1);
    localBuilder.put(paramK2, paramV2);
    localBuilder.put(paramK3, paramV3);
    localBuilder.put(paramK4, paramV4);
    localBuilder.put(paramK5, paramV5);
    return localBuilder.build();
  }
  
  @GwtIncompatible("java.io.ObjectInputStream")
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    paramObjectInputStream.defaultReadObject();
    int m = paramObjectInputStream.readInt();
    if (m < 0) {
      throw new InvalidObjectException(29 + "Invalid key count " + m);
    }
    ImmutableMap.Builder localBuilder = ImmutableMap.builder();
    int i = 0;
    int j = 0;
    while (i < m)
    {
      Object localObject = paramObjectInputStream.readObject();
      int n = paramObjectInputStream.readInt();
      if (n <= 0) {
        throw new InvalidObjectException(31 + "Invalid value count " + n);
      }
      Object[] arrayOfObject = new Object[n];
      int k = 0;
      while (k < n)
      {
        arrayOfObject[k] = paramObjectInputStream.readObject();
        k += 1;
      }
      localBuilder.put(localObject, ImmutableList.copyOf(arrayOfObject));
      j += n;
      i += 1;
    }
    try
    {
      paramObjectInputStream = localBuilder.build();
      ImmutableMultimap.c.a.a(this, paramObjectInputStream);
      ImmutableMultimap.c.b.a(this, j);
      return;
    }
    catch (IllegalArgumentException paramObjectInputStream)
    {
      throw ((InvalidObjectException)new InvalidObjectException(paramObjectInputStream.getMessage()).initCause(paramObjectInputStream));
    }
  }
  
  @GwtIncompatible("java.io.ObjectOutputStream")
  private void writeObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    paramObjectOutputStream.defaultWriteObject();
    pt.a(this, paramObjectOutputStream);
  }
  
  public ImmutableList<V> get(@Nullable K paramK)
  {
    ImmutableList localImmutableList = (ImmutableList)this.b.get(paramK);
    paramK = localImmutableList;
    if (localImmutableList == null) {
      paramK = ImmutableList.of();
    }
    return paramK;
  }
  
  public ImmutableListMultimap<V, K> inverse()
  {
    Object localObject2 = this.a;
    Object localObject1 = localObject2;
    if (localObject2 == null)
    {
      localObject1 = builder();
      localObject2 = entries().iterator();
      while (((Iterator)localObject2).hasNext())
      {
        Map.Entry localEntry = (Map.Entry)((Iterator)localObject2).next();
        ((Builder)localObject1).put(localEntry.getValue(), localEntry.getKey());
      }
      localObject1 = ((Builder)localObject1).build();
      ((ImmutableListMultimap)localObject1).a = this;
      this.a = ((ImmutableListMultimap)localObject1);
    }
    return (ImmutableListMultimap<V, K>)localObject1;
  }
  
  @Deprecated
  public ImmutableList<V> removeAll(Object paramObject)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public ImmutableList<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
  {
    throw new UnsupportedOperationException();
  }
  
  public static final class Builder<K, V>
    extends ImmutableMultimap.Builder<K, V>
  {
    public final ImmutableListMultimap<K, V> build()
    {
      return (ImmutableListMultimap)super.build();
    }
    
    public final Builder<K, V> orderKeysBy(Comparator<? super K> paramComparator)
    {
      super.orderKeysBy(paramComparator);
      return this;
    }
    
    public final Builder<K, V> orderValuesBy(Comparator<? super V> paramComparator)
    {
      super.orderValuesBy(paramComparator);
      return this;
    }
    
    public final Builder<K, V> put(K paramK, V paramV)
    {
      super.put(paramK, paramV);
      return this;
    }
    
    public final Builder<K, V> put(Map.Entry<? extends K, ? extends V> paramEntry)
    {
      super.put(paramEntry);
      return this;
    }
    
    public final Builder<K, V> putAll(Multimap<? extends K, ? extends V> paramMultimap)
    {
      super.putAll(paramMultimap);
      return this;
    }
    
    public final Builder<K, V> putAll(K paramK, Iterable<? extends V> paramIterable)
    {
      super.putAll(paramK, paramIterable);
      return this;
    }
    
    public final Builder<K, V> putAll(K paramK, V... paramVarArgs)
    {
      super.putAll(paramK, paramVarArgs);
      return this;
    }
  }
}


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