package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.Set;
import java.util.SortedMap;
import javax.annotation.Nullable;
import oa;
import oy;
import pn;
import pp;

@GwtCompatible(emulated=true, serializable=true)
public abstract class ImmutableSortedMap<K, V>
  extends oy<K, V>
  implements NavigableMap<K, V>
{
  private static final Comparator<Comparable> a = ;
  private static final ImmutableSortedMap<Comparable, Object> b = new oa(a);
  private static final long serialVersionUID = 0L;
  private transient ImmutableSortedMap<K, V> c;
  
  protected ImmutableSortedMap() {}
  
  protected ImmutableSortedMap(ImmutableSortedMap<K, V> paramImmutableSortedMap)
  {
    this.c = paramImmutableSortedMap;
  }
  
  protected static <K, V> ImmutableSortedMap<K, V> a(ImmutableSortedSet<K> paramImmutableSortedSet, ImmutableList<V> paramImmutableList)
  {
    if (paramImmutableSortedSet.isEmpty()) {
      return a(paramImmutableSortedSet.comparator());
    }
    return new pn((pp)paramImmutableSortedSet, paramImmutableList);
  }
  
  protected static <K, V> ImmutableSortedMap<K, V> a(Comparator<? super K> paramComparator)
  {
    if (Ordering.natural().equals(paramComparator)) {
      return of();
    }
    return new oa(paramComparator);
  }
  
  static <K, V> ImmutableSortedMap<K, V> a(Comparator<? super K> paramComparator, boolean paramBoolean, int paramInt, Map.Entry<K, V>... paramVarArgs)
  {
    int j = 0;
    int i = 0;
    while (i < paramInt)
    {
      localObject = paramVarArgs[i];
      paramVarArgs[i] = a(((Map.Entry)localObject).getKey(), ((Map.Entry)localObject).getValue());
      i += 1;
    }
    if (!paramBoolean)
    {
      Arrays.sort(paramVarArgs, 0, paramInt, Ordering.from(paramComparator).onResultOf(Maps.a()));
      i = 1;
      if (i < paramInt)
      {
        if (paramComparator.compare(paramVarArgs[(i - 1)].getKey(), paramVarArgs[i].getKey()) != 0) {}
        for (paramBoolean = true;; paramBoolean = false)
        {
          a(paramBoolean, "key", paramVarArgs[(i - 1)], paramVarArgs[i]);
          i += 1;
          break;
        }
      }
    }
    if (paramInt == 0) {
      return a(paramComparator);
    }
    Object localObject = ImmutableList.builder();
    ImmutableList.Builder localBuilder = ImmutableList.builder();
    i = j;
    while (i < paramInt)
    {
      Map.Entry<K, V> localEntry = paramVarArgs[i];
      ((ImmutableList.Builder)localObject).add(localEntry.getKey());
      localBuilder.add(localEntry.getValue());
      i += 1;
    }
    return new pn(new pp(((ImmutableList.Builder)localObject).build(), paramComparator), localBuilder.build());
  }
  
  private static <K, V> ImmutableSortedMap<K, V> a(Map<? extends K, ? extends V> paramMap, Comparator<? super K> paramComparator)
  {
    Object localObject;
    boolean bool;
    if ((paramMap instanceof SortedMap))
    {
      localObject = ((SortedMap)paramMap).comparator();
      if (localObject == null) {
        if (paramComparator == a) {
          bool = true;
        }
      }
    }
    for (;;)
    {
      if ((bool) && ((paramMap instanceof ImmutableSortedMap)))
      {
        localObject = (ImmutableSortedMap)paramMap;
        if (!((ImmutableSortedMap)localObject).b())
        {
          return (ImmutableSortedMap<K, V>)localObject;
          bool = false;
          continue;
          bool = paramComparator.equals(localObject);
          continue;
        }
      }
      paramMap = (Map.Entry[])paramMap.entrySet().toArray(new Map.Entry[0]);
      return a(paramComparator, bool, paramMap.length, paramMap);
      bool = false;
    }
  }
  
  public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> paramMap)
  {
    return a(paramMap, Ordering.natural());
  }
  
  public static <K, V> ImmutableSortedMap<K, V> copyOf(Map<? extends K, ? extends V> paramMap, Comparator<? super K> paramComparator)
  {
    return a(paramMap, (Comparator)Preconditions.checkNotNull(paramComparator));
  }
  
  public static <K, V> ImmutableSortedMap<K, V> copyOfSorted(SortedMap<K, ? extends V> paramSortedMap)
  {
    Comparator localComparator2 = paramSortedMap.comparator();
    Comparator localComparator1 = localComparator2;
    if (localComparator2 == null) {
      localComparator1 = a;
    }
    return a(paramSortedMap, localComparator1);
  }
  
  public static <K extends Comparable<?>, V> Builder<K, V> naturalOrder()
  {
    return new Builder(Ordering.natural());
  }
  
  public static <K, V> ImmutableSortedMap<K, V> of()
  {
    return b;
  }
  
  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K paramK, V paramV)
  {
    return a(ImmutableSortedSet.of(paramK), ImmutableList.of(paramV));
  }
  
  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2)
  {
    return a(Ordering.natural(), false, 2, new Map.Entry[] { a(paramK1, paramV1), a(paramK2, paramV2) });
  }
  
  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3)
  {
    return a(Ordering.natural(), false, 3, new Map.Entry[] { a(paramK1, paramV1), a(paramK2, paramV2), a(paramK3, paramV3) });
  }
  
  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3, K paramK4, V paramV4)
  {
    return a(Ordering.natural(), false, 4, new Map.Entry[] { a(paramK1, paramV1), a(paramK2, paramV2), a(paramK3, paramV3), a(paramK4, paramV4) });
  }
  
  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(K paramK1, V paramV1, K paramK2, V paramV2, K paramK3, V paramV3, K paramK4, V paramV4, K paramK5, V paramV5)
  {
    return a(Ordering.natural(), false, 5, new Map.Entry[] { a(paramK1, paramV1), a(paramK2, paramV2), a(paramK3, paramV3), a(paramK4, paramV4), a(paramK5, paramV5) });
  }
  
  public static <K, V> Builder<K, V> orderedBy(Comparator<K> paramComparator)
  {
    return new Builder(paramComparator);
  }
  
  public static <K extends Comparable<?>, V> Builder<K, V> reverseOrder()
  {
    return new Builder(Ordering.natural().reverse());
  }
  
  protected abstract ImmutableSortedMap<K, V> a();
  
  protected boolean b()
  {
    return (keySet().a()) || (values().a());
  }
  
  public Map.Entry<K, V> ceilingEntry(K paramK)
  {
    return tailMap(paramK, true).firstEntry();
  }
  
  public K ceilingKey(K paramK)
  {
    return (K)Maps.b(ceilingEntry(paramK));
  }
  
  public Comparator<? super K> comparator()
  {
    return keySet().comparator();
  }
  
  public boolean containsValue(@Nullable Object paramObject)
  {
    return values().contains(paramObject);
  }
  
  public ImmutableSortedSet<K> descendingKeySet()
  {
    return keySet().descendingSet();
  }
  
  public ImmutableSortedMap<K, V> descendingMap()
  {
    ImmutableSortedMap localImmutableSortedMap2 = this.c;
    ImmutableSortedMap localImmutableSortedMap1 = localImmutableSortedMap2;
    if (localImmutableSortedMap2 == null)
    {
      localImmutableSortedMap1 = a();
      this.c = localImmutableSortedMap1;
    }
    return localImmutableSortedMap1;
  }
  
  public ImmutableSet<Map.Entry<K, V>> entrySet()
  {
    return super.entrySet();
  }
  
  public Map.Entry<K, V> firstEntry()
  {
    if (isEmpty()) {
      return null;
    }
    return (Map.Entry)entrySet().asList().get(0);
  }
  
  public K firstKey()
  {
    return (K)keySet().first();
  }
  
  public Map.Entry<K, V> floorEntry(K paramK)
  {
    return headMap(paramK, true).lastEntry();
  }
  
  public K floorKey(K paramK)
  {
    return (K)Maps.b(floorEntry(paramK));
  }
  
  public ImmutableSortedMap<K, V> headMap(K paramK)
  {
    return headMap(paramK, false);
  }
  
  public abstract ImmutableSortedMap<K, V> headMap(K paramK, boolean paramBoolean);
  
  public Map.Entry<K, V> higherEntry(K paramK)
  {
    return tailMap(paramK, false).firstEntry();
  }
  
  public K higherKey(K paramK)
  {
    return (K)Maps.b(higherEntry(paramK));
  }
  
  public abstract ImmutableSortedSet<K> keySet();
  
  public Map.Entry<K, V> lastEntry()
  {
    if (isEmpty()) {
      return null;
    }
    return (Map.Entry)entrySet().asList().get(size() - 1);
  }
  
  public K lastKey()
  {
    return (K)keySet().last();
  }
  
  public Map.Entry<K, V> lowerEntry(K paramK)
  {
    return headMap(paramK, false).lastEntry();
  }
  
  public K lowerKey(K paramK)
  {
    return (K)Maps.b(lowerEntry(paramK));
  }
  
  public ImmutableSortedSet<K> navigableKeySet()
  {
    return keySet();
  }
  
  @Deprecated
  public final Map.Entry<K, V> pollFirstEntry()
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  public final Map.Entry<K, V> pollLastEntry()
  {
    throw new UnsupportedOperationException();
  }
  
  public int size()
  {
    return values().size();
  }
  
  public ImmutableSortedMap<K, V> subMap(K paramK1, K paramK2)
  {
    return subMap(paramK1, true, paramK2, false);
  }
  
  public ImmutableSortedMap<K, V> subMap(K paramK1, boolean paramBoolean1, K paramK2, boolean paramBoolean2)
  {
    Preconditions.checkNotNull(paramK1);
    Preconditions.checkNotNull(paramK2);
    if (comparator().compare(paramK1, paramK2) <= 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool, "expected fromKey <= toKey but %s > %s", new Object[] { paramK1, paramK2 });
      return headMap(paramK2, paramBoolean2).tailMap(paramK1, paramBoolean1);
    }
  }
  
  public ImmutableSortedMap<K, V> tailMap(K paramK)
  {
    return tailMap(paramK, true);
  }
  
  public abstract ImmutableSortedMap<K, V> tailMap(K paramK, boolean paramBoolean);
  
  public abstract ImmutableCollection<V> values();
  
  Object writeReplace()
  {
    return new a(this);
  }
  
  public static class Builder<K, V>
    extends ImmutableMap.Builder<K, V>
  {
    private final Comparator<? super K> c;
    
    public Builder(Comparator<? super K> paramComparator)
    {
      this.c = ((Comparator)Preconditions.checkNotNull(paramComparator));
    }
    
    public ImmutableSortedMap<K, V> build()
    {
      return ImmutableSortedMap.a(this.c, false, this.b, this.a);
    }
    
    public Builder<K, V> put(K paramK, V paramV)
    {
      super.put(paramK, paramV);
      return this;
    }
    
    public Builder<K, V> put(Map.Entry<? extends K, ? extends V> paramEntry)
    {
      super.put(paramEntry);
      return this;
    }
    
    public Builder<K, V> putAll(Map<? extends K, ? extends V> paramMap)
    {
      super.putAll(paramMap);
      return this;
    }
  }
  
  static final class a
    extends ImmutableMap.b
  {
    private static final long serialVersionUID = 0L;
    private final Comparator<Object> a;
    
    a(ImmutableSortedMap<?, ?> paramImmutableSortedMap)
    {
      super();
      this.a = paramImmutableSortedMap.comparator();
    }
    
    final Object readResolve()
    {
      return a(new ImmutableSortedMap.Builder(this.a));
    }
  }
}


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