package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.SortedSet;
import javax.annotation.Nullable;
import nt;
import oc;
import pa;
import pp;
import py;
import pz;

@GwtCompatible(emulated=true, serializable=true)
public abstract class ImmutableSortedSet<E>
  extends pa<E>
  implements NavigableSet<E>, py<E>
{
  private static final Comparator<Comparable> a = ;
  private static final ImmutableSortedSet<Comparable> d = new oc(a);
  protected final transient Comparator<? super E> b;
  @GwtIncompatible("NavigableSet")
  transient ImmutableSortedSet<E> c;
  
  protected ImmutableSortedSet(Comparator<? super E> paramComparator)
  {
    this.b = paramComparator;
  }
  
  public static <E> ImmutableSortedSet<E> a(Comparator<? super E> paramComparator)
  {
    if (a.equals(paramComparator)) {
      return d;
    }
    return new oc(paramComparator);
  }
  
  static <E> ImmutableSortedSet<E> a(Comparator<? super E> paramComparator, int paramInt, E... paramVarArgs)
  {
    if (paramInt == 0) {
      return a(paramComparator);
    }
    ObjectArrays.b(paramVarArgs, paramInt);
    Arrays.sort(paramVarArgs, 0, paramInt, paramComparator);
    int j = 1;
    int i = 1;
    if (j < paramInt)
    {
      E ? = paramVarArgs[j];
      if (paramComparator.compare(?, paramVarArgs[(i - 1)]) == 0) {
        break label98;
      }
      int k = i + 1;
      paramVarArgs[i] = ?;
      i = k;
    }
    label98:
    for (;;)
    {
      j += 1;
      break;
      Arrays.fill(paramVarArgs, i, paramInt, null);
      return new pp(ImmutableList.b(paramVarArgs, i), paramComparator);
    }
  }
  
  public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> paramIterable)
  {
    return copyOf(Ordering.natural(), paramIterable);
  }
  
  public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> paramCollection)
  {
    return copyOf(Ordering.natural(), paramCollection);
  }
  
  public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> paramComparator, Iterable<? extends E> paramIterable)
  {
    Preconditions.checkNotNull(paramComparator);
    if ((pz.a(paramComparator, paramIterable)) && ((paramIterable instanceof ImmutableSortedSet)))
    {
      ImmutableSortedSet localImmutableSortedSet = (ImmutableSortedSet)paramIterable;
      if (!localImmutableSortedSet.a()) {
        return localImmutableSortedSet;
      }
    }
    paramIterable = (Object[])Iterables.a(paramIterable);
    return a(paramComparator, paramIterable.length, paramIterable);
  }
  
  public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> paramComparator, Collection<? extends E> paramCollection)
  {
    return copyOf(paramComparator, paramCollection);
  }
  
  public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> paramComparator, Iterator<? extends E> paramIterator)
  {
    return new Builder(paramComparator).addAll(paramIterator).build();
  }
  
  public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> paramIterator)
  {
    return copyOf(Ordering.natural(), paramIterator);
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> copyOf(E[] paramArrayOfE)
  {
    return a(Ordering.natural(), paramArrayOfE.length, (Object[])paramArrayOfE.clone());
  }
  
  public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> paramSortedSet)
  {
    Comparator localComparator = pz.a(paramSortedSet);
    paramSortedSet = ImmutableList.copyOf(paramSortedSet);
    if (paramSortedSet.isEmpty()) {
      return a(localComparator);
    }
    return new pp(paramSortedSet, localComparator);
  }
  
  public static <E extends Comparable<?>> Builder<E> naturalOrder()
  {
    return new Builder(Ordering.natural());
  }
  
  public static <E> ImmutableSortedSet<E> of()
  {
    return d;
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E paramE)
  {
    return new pp(ImmutableList.of(paramE), Ordering.natural());
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E paramE1, E paramE2)
  {
    return a(Ordering.natural(), 2, new Comparable[] { paramE1, paramE2 });
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E paramE1, E paramE2, E paramE3)
  {
    return a(Ordering.natural(), 3, new Comparable[] { paramE1, paramE2, paramE3 });
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E paramE1, E paramE2, E paramE3, E paramE4)
  {
    return a(Ordering.natural(), 4, new Comparable[] { paramE1, paramE2, paramE3, paramE4 });
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5)
  {
    return a(Ordering.natural(), 5, new Comparable[] { paramE1, paramE2, paramE3, paramE4, paramE5 });
  }
  
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E paramE1, E paramE2, E paramE3, E paramE4, E paramE5, E paramE6, E... paramVarArgs)
  {
    Comparable[] arrayOfComparable = new Comparable[paramVarArgs.length + 6];
    arrayOfComparable[0] = paramE1;
    arrayOfComparable[1] = paramE2;
    arrayOfComparable[2] = paramE3;
    arrayOfComparable[3] = paramE4;
    arrayOfComparable[4] = paramE5;
    arrayOfComparable[5] = paramE6;
    System.arraycopy(paramVarArgs, 0, arrayOfComparable, 6, paramVarArgs.length);
    return a(Ordering.natural(), arrayOfComparable.length, (Comparable[])arrayOfComparable);
  }
  
  public static <E> Builder<E> orderedBy(Comparator<E> paramComparator)
  {
    return new Builder(paramComparator);
  }
  
  private void readObject(ObjectInputStream paramObjectInputStream)
    throws InvalidObjectException
  {
    throw new InvalidObjectException("Use SerializedForm");
  }
  
  public static <E extends Comparable<?>> Builder<E> reverseOrder()
  {
    return new Builder(Ordering.natural().reverse());
  }
  
  public abstract int a(@Nullable Object paramObject);
  
  protected final int a(Object paramObject1, Object paramObject2)
  {
    return this.b.compare(paramObject1, paramObject2);
  }
  
  protected abstract ImmutableSortedSet<E> a(E paramE, boolean paramBoolean);
  
  protected abstract ImmutableSortedSet<E> a(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2);
  
  @GwtIncompatible("NavigableSet")
  protected ImmutableSortedSet<E> b()
  {
    return new nt(this);
  }
  
  protected abstract ImmutableSortedSet<E> b(E paramE, boolean paramBoolean);
  
  @GwtIncompatible("NavigableSet")
  public E ceiling(E paramE)
  {
    return (E)Iterables.getFirst(tailSet(paramE, true), null);
  }
  
  public Comparator<? super E> comparator()
  {
    return this.b;
  }
  
  @GwtIncompatible("NavigableSet")
  public abstract UnmodifiableIterator<E> descendingIterator();
  
  @GwtIncompatible("NavigableSet")
  public ImmutableSortedSet<E> descendingSet()
  {
    ImmutableSortedSet localImmutableSortedSet2 = this.c;
    ImmutableSortedSet localImmutableSortedSet1 = localImmutableSortedSet2;
    if (localImmutableSortedSet2 == null)
    {
      localImmutableSortedSet1 = b();
      this.c = localImmutableSortedSet1;
      localImmutableSortedSet1.c = this;
    }
    return localImmutableSortedSet1;
  }
  
  public E first()
  {
    return (E)iterator().next();
  }
  
  @GwtIncompatible("NavigableSet")
  public E floor(E paramE)
  {
    return (E)Iterators.getNext(headSet(paramE, true).descendingIterator(), null);
  }
  
  public ImmutableSortedSet<E> headSet(E paramE)
  {
    return headSet(paramE, false);
  }
  
  @GwtIncompatible("NavigableSet")
  public ImmutableSortedSet<E> headSet(E paramE, boolean paramBoolean)
  {
    return b(Preconditions.checkNotNull(paramE), paramBoolean);
  }
  
  @GwtIncompatible("NavigableSet")
  public E higher(E paramE)
  {
    return (E)Iterables.getFirst(tailSet(paramE, false), null);
  }
  
  public abstract UnmodifiableIterator<E> iterator();
  
  public E last()
  {
    return (E)descendingIterator().next();
  }
  
  @GwtIncompatible("NavigableSet")
  public E lower(E paramE)
  {
    return (E)Iterators.getNext(headSet(paramE, false).descendingIterator(), null);
  }
  
  @Deprecated
  @GwtIncompatible("NavigableSet")
  public final E pollFirst()
  {
    throw new UnsupportedOperationException();
  }
  
  @Deprecated
  @GwtIncompatible("NavigableSet")
  public final E pollLast()
  {
    throw new UnsupportedOperationException();
  }
  
  public ImmutableSortedSet<E> subSet(E paramE1, E paramE2)
  {
    return subSet(paramE1, true, paramE2, false);
  }
  
  @GwtIncompatible("NavigableSet")
  public ImmutableSortedSet<E> subSet(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2)
  {
    Preconditions.checkNotNull(paramE1);
    Preconditions.checkNotNull(paramE2);
    if (this.b.compare(paramE1, paramE2) <= 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      return a(paramE1, paramBoolean1, paramE2, paramBoolean2);
    }
  }
  
  public ImmutableSortedSet<E> tailSet(E paramE)
  {
    return tailSet(paramE, true);
  }
  
  @GwtIncompatible("NavigableSet")
  public ImmutableSortedSet<E> tailSet(E paramE, boolean paramBoolean)
  {
    return a(Preconditions.checkNotNull(paramE), paramBoolean);
  }
  
  protected Object writeReplace()
  {
    return new a(this.b, toArray());
  }
  
  public static final class Builder<E>
    extends ImmutableSet.Builder<E>
  {
    private final Comparator<? super E> c;
    
    public Builder(Comparator<? super E> paramComparator)
    {
      this.c = ((Comparator)Preconditions.checkNotNull(paramComparator));
    }
    
    public final Builder<E> add(E paramE)
    {
      super.add(paramE);
      return this;
    }
    
    public final Builder<E> add(E... paramVarArgs)
    {
      super.add(paramVarArgs);
      return this;
    }
    
    public final Builder<E> addAll(Iterable<? extends E> paramIterable)
    {
      super.addAll(paramIterable);
      return this;
    }
    
    public final Builder<E> addAll(Iterator<? extends E> paramIterator)
    {
      super.addAll(paramIterator);
      return this;
    }
    
    public final ImmutableSortedSet<E> build()
    {
      Object localObject = (Object[])this.a;
      localObject = ImmutableSortedSet.a(this.c, this.b, (Object[])localObject);
      this.b = ((ImmutableSortedSet)localObject).size();
      return (ImmutableSortedSet<E>)localObject;
    }
  }
  
  static final class a<E>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Comparator<? super E> a;
    final Object[] b;
    
    public a(Comparator<? super E> paramComparator, Object[] paramArrayOfObject)
    {
      this.a = paramComparator;
      this.b = paramArrayOfObject;
    }
    
    final Object readResolve()
    {
      return new ImmutableSortedSet.Builder(this.a).add((Object[])this.b).build();
    }
  }
}


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