package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.Nullable;
import mu;
import nz;
import pt;
import pt.a;

@GwtCompatible(emulated=true, serializable=true)
public class ImmutableSetMultimap<K, V>
  extends ImmutableMultimap<K, V>
  implements SetMultimap<K, V>
{
  @GwtIncompatible("not needed in emulated source.")
  private static final long serialVersionUID = 0L;
  private final transient ImmutableSet<V> a;
  private transient ImmutableSetMultimap<V, K> d;
  private transient ImmutableSet<Map.Entry<K, V>> e;
  
  protected ImmutableSetMultimap(ImmutableMap<K, ImmutableSet<V>> paramImmutableMap, int paramInt, @Nullable Comparator<? super V> paramComparator)
  {
    super(paramImmutableMap, paramInt);
    this.a = a(paramComparator);
  }
  
  private static <V> ImmutableSet<V> a(@Nullable Comparator<? super V> paramComparator)
  {
    if (paramComparator == null) {
      return ImmutableSet.of();
    }
    return ImmutableSortedSet.a(paramComparator);
  }
  
  private static <V> ImmutableSet<V> a(@Nullable Comparator<? super V> paramComparator, Collection<? extends V> paramCollection)
  {
    if (paramComparator == null) {
      return ImmutableSet.copyOf(paramCollection);
    }
    return ImmutableSortedSet.copyOf(paramComparator, paramCollection);
  }
  
  private static <K, V> ImmutableSetMultimap<K, V> b(Multimap<? extends K, ? extends V> paramMultimap, Comparator<? super V> paramComparator)
  {
    Preconditions.checkNotNull(paramMultimap);
    if ((paramMultimap.isEmpty()) && (paramComparator == null)) {
      localObject1 = of();
    }
    Object localObject2;
    do
    {
      return (ImmutableSetMultimap<K, V>)localObject1;
      if (!(paramMultimap instanceof ImmutableSetMultimap)) {
        break;
      }
      localObject2 = (ImmutableSetMultimap)paramMultimap;
      localObject1 = localObject2;
    } while (!((ImmutableMultimap)localObject2).b.b());
    Object localObject1 = ImmutableMap.builder();
    paramMultimap = paramMultimap.asMap().entrySet().iterator();
    int i = 0;
    if (paramMultimap.hasNext())
    {
      Object localObject3 = (Map.Entry)paramMultimap.next();
      localObject2 = ((Map.Entry)localObject3).getKey();
      localObject3 = a(paramComparator, (Collection)((Map.Entry)localObject3).getValue());
      if (((ImmutableSet)localObject3).isEmpty()) {
        break label161;
      }
      ((ImmutableMap.Builder)localObject1).put(localObject2, localObject3);
      i = ((ImmutableSet)localObject3).size() + i;
    }
    label161:
    for (;;)
    {
      break;
      return new ImmutableSetMultimap(((ImmutableMap.Builder)localObject1).build(), i, paramComparator);
    }
  }
  
  public static <K, V> Builder<K, V> builder()
  {
    return new Builder();
  }
  
  public static <K, V> ImmutableSetMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> paramMultimap)
  {
    return b(paramMultimap, null);
  }
  
  public static <K, V> ImmutableSetMultimap<K, V> of()
  {
    return nz.a;
  }
  
  public static <K, V> ImmutableSetMultimap<K, V> of(K paramK, V paramV)
  {
    Builder localBuilder = builder();
    localBuilder.put(paramK, paramV);
    return localBuilder.build();
  }
  
  public static <K, V> ImmutableSetMultimap<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> ImmutableSetMultimap<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> ImmutableSetMultimap<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> ImmutableSetMultimap<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();
    Comparator localComparator = (Comparator)paramObjectInputStream.readObject();
    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;
      }
      ImmutableSet localImmutableSet = a(localComparator, Arrays.asList(arrayOfObject));
      if (localImmutableSet.size() != arrayOfObject.length)
      {
        paramObjectInputStream = String.valueOf(String.valueOf(localObject));
        throw new InvalidObjectException(paramObjectInputStream.length() + 40 + "Duplicate key-value pairs exist for key " + paramObjectInputStream);
      }
      localBuilder.put(localObject, localImmutableSet);
      j += n;
      i += 1;
    }
    try
    {
      paramObjectInputStream = localBuilder.build();
      ImmutableMultimap.c.a.a(this, paramObjectInputStream);
      ImmutableMultimap.c.b.a(this, j);
      ImmutableMultimap.c.c.a(this, a(localComparator));
      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();
    if ((this.a instanceof ImmutableSortedSet)) {}
    for (Comparator localComparator = ((ImmutableSortedSet)this.a).comparator();; localComparator = null)
    {
      paramObjectOutputStream.writeObject(localComparator);
      pt.a(this, paramObjectOutputStream);
      return;
    }
  }
  
  public ImmutableSet<Map.Entry<K, V>> entries()
  {
    ImmutableSet localImmutableSet = this.e;
    Object localObject = localImmutableSet;
    if (localImmutableSet == null)
    {
      localObject = new b(this);
      this.e = ((ImmutableSet)localObject);
    }
    return (ImmutableSet<Map.Entry<K, V>>)localObject;
  }
  
  public ImmutableSet<V> get(@Nullable K paramK)
  {
    return (ImmutableSet)MoreObjects.firstNonNull((ImmutableSet)this.b.get(paramK), this.a);
  }
  
  public ImmutableSetMultimap<V, K> inverse()
  {
    Object localObject2 = this.d;
    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();
      ((ImmutableSetMultimap)localObject1).d = this;
      this.d = ((ImmutableSetMultimap)localObject1);
    }
    return (ImmutableSetMultimap<V, K>)localObject1;
  }
  
  @Deprecated
  public ImmutableSet<V> removeAll(Object paramObject)
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public ImmutableSet<V> replaceValues(K paramK, Iterable<? extends V> paramIterable)
  {
    throw new UnsupportedOperationException();
  }
  
  public static final class Builder<K, V>
    extends ImmutableMultimap.Builder<K, V>
  {
    public Builder()
    {
      this.a = new ImmutableSetMultimap.a();
    }
    
    public final ImmutableSetMultimap<K, V> build()
    {
      if (this.b != null)
      {
        ImmutableSetMultimap.a locala = new ImmutableSetMultimap.a();
        Object localObject = Lists.newArrayList(this.a.asMap().entrySet());
        Collections.sort((List)localObject, Ordering.from(this.b).onResultOf(Maps.a()));
        localObject = ((List)localObject).iterator();
        while (((Iterator)localObject).hasNext())
        {
          Map.Entry localEntry = (Map.Entry)((Iterator)localObject).next();
          locala.putAll(localEntry.getKey(), (Iterable)localEntry.getValue());
        }
        this.a = locala;
      }
      return ImmutableSetMultimap.a(this.a, this.c);
    }
    
    public final Builder<K, V> orderKeysBy(Comparator<? super K> paramComparator)
    {
      this.b = ((Comparator)Preconditions.checkNotNull(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)
    {
      this.a.put(Preconditions.checkNotNull(paramK), Preconditions.checkNotNull(paramV));
      return this;
    }
    
    public final Builder<K, V> put(Map.Entry<? extends K, ? extends V> paramEntry)
    {
      this.a.put(Preconditions.checkNotNull(paramEntry.getKey()), Preconditions.checkNotNull(paramEntry.getValue()));
      return this;
    }
    
    public final Builder<K, V> putAll(Multimap<? extends K, ? extends V> paramMultimap)
    {
      paramMultimap = paramMultimap.asMap().entrySet().iterator();
      while (paramMultimap.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)paramMultimap.next();
        putAll(localEntry.getKey(), (Iterable)localEntry.getValue());
      }
      return this;
    }
    
    public final Builder<K, V> putAll(K paramK, Iterable<? extends V> paramIterable)
    {
      paramK = this.a.get(Preconditions.checkNotNull(paramK));
      paramIterable = paramIterable.iterator();
      while (paramIterable.hasNext()) {
        paramK.add(Preconditions.checkNotNull(paramIterable.next()));
      }
      return this;
    }
    
    public final Builder<K, V> putAll(K paramK, V... paramVarArgs)
    {
      return putAll(paramK, Arrays.asList(paramVarArgs));
    }
  }
  
  static final class a<K, V>
    extends mu<K, V>
  {
    private static final long serialVersionUID = 0L;
    
    a()
    {
      super();
    }
    
    final Collection<V> b()
    {
      return Sets.newLinkedHashSet();
    }
  }
  
  static final class b<K, V>
    extends ImmutableSet<Map.Entry<K, V>>
  {
    private final transient ImmutableSetMultimap<K, V> a;
    
    b(ImmutableSetMultimap<K, V> paramImmutableSetMultimap)
    {
      this.a = paramImmutableSetMultimap;
    }
    
    final boolean a()
    {
      return false;
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      if ((paramObject instanceof Map.Entry))
      {
        paramObject = (Map.Entry)paramObject;
        return this.a.containsEntry(((Map.Entry)paramObject).getKey(), ((Map.Entry)paramObject).getValue());
      }
      return false;
    }
    
    public final UnmodifiableIterator<Map.Entry<K, V>> iterator()
    {
      return this.a.a();
    }
    
    public final int size()
    {
      return this.a.size();
    }
  }
}


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