package com.google.common.collect;

import com.google.common.base.Preconditions;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.SortedSet;
import javax.annotation.Nullable;

public abstract class ImmutableSortedSet<E> extends ImmutableSortedSetFauxverideShim<E>
  implements SortedIterable<E>, SortedSet<E>
{
  private static final ImmutableSortedSet<Comparable> NATURAL_EMPTY_SET = new EmptyImmutableSortedSet(NATURAL_ORDER);
  private static final Comparator<Comparable> NATURAL_ORDER = Ordering.natural();
  final transient Comparator<? super E> comparator;

  ImmutableSortedSet(Comparator<? super E> paramComparator)
  {
    this.comparator = paramComparator;
  }

  static <E> ImmutableSortedSet<E> construct(Comparator<? super E> paramComparator, int paramInt, E[] paramArrayOfE)
  {
    int i = sortAndUnique(paramComparator, paramInt, paramArrayOfE);
    if (i == 0)
      return emptySet(paramComparator);
    if (i < paramArrayOfE.length)
      paramArrayOfE = ObjectArrays.arraysCopyOf(paramArrayOfE, i);
    return new RegularImmutableSortedSet(ImmutableList.asImmutableList(paramArrayOfE), paramComparator);
  }

  public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> paramComparator, Iterable<? extends E> paramIterable)
  {
    Preconditions.checkNotNull(paramComparator);
    if ((SortedIterables.hasSameComparator(paramComparator, paramIterable)) && ((paramIterable instanceof ImmutableSortedSet)))
    {
      ImmutableSortedSet localImmutableSortedSet = (ImmutableSortedSet)paramIterable;
      if (!localImmutableSortedSet.isPartialView())
        return localImmutableSortedSet;
    }
    Object[] arrayOfObject = (Object[])Iterables.toArray(paramIterable);
    return construct(paramComparator, arrayOfObject.length, arrayOfObject);
  }

  public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> paramComparator, Collection<? extends E> paramCollection)
  {
    return copyOf(paramComparator, paramCollection);
  }

  private static <E> ImmutableSortedSet<E> emptySet()
  {
    return NATURAL_EMPTY_SET;
  }

  static <E> ImmutableSortedSet<E> emptySet(Comparator<? super E> paramComparator)
  {
    if (NATURAL_ORDER.equals(paramComparator))
      return emptySet();
    return new EmptyImmutableSortedSet(paramComparator);
  }

  static <E> int sortAndUnique(Comparator<? super E> paramComparator, int paramInt, E[] paramArrayOfE)
  {
    if (paramInt == 0)
      return 0;
    for (int i = 0; i < paramInt; i++)
      ObjectArrays.checkElementNotNull(paramArrayOfE[i], i);
    Arrays.sort(paramArrayOfE, 0, paramInt, paramComparator);
    int j = 1;
    int k = 1;
    int m;
    if (j < paramInt)
    {
      E ? = paramArrayOfE[j];
      if (paramComparator.compare(?, paramArrayOfE[(k - 1)]) == 0)
        break label102;
      m = k + 1;
      paramArrayOfE[k] = ?;
    }
    while (true)
    {
      j++;
      k = m;
      break;
      Arrays.fill(paramArrayOfE, k, paramInt, null);
      return k;
      label102: m = k;
    }
  }

  static int unsafeCompare(Comparator<?> paramComparator, Object paramObject1, Object paramObject2)
  {
    return paramComparator.compare(paramObject1, paramObject2);
  }

  public Comparator<? super E> comparator()
  {
    return this.comparator;
  }

  public abstract UnmodifiableIterator<E> descendingIterator();

  public E first()
  {
    return iterator().next();
  }

  public ImmutableSortedSet<E> headSet(E paramE)
  {
    return headSet(paramE, false);
  }

  public ImmutableSortedSet<E> headSet(E paramE, boolean paramBoolean)
  {
    return headSetImpl(Preconditions.checkNotNull(paramE), paramBoolean);
  }

  abstract ImmutableSortedSet<E> headSetImpl(E paramE, boolean paramBoolean);

  abstract int indexOf(@Nullable Object paramObject);

  public abstract UnmodifiableIterator<E> iterator();

  public E last()
  {
    return descendingIterator().next();
  }

  public ImmutableSortedSet<E> subSet(E paramE1, E paramE2)
  {
    return subSet(paramE1, true, paramE2, false);
  }

  public ImmutableSortedSet<E> subSet(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2)
  {
    Preconditions.checkNotNull(paramE1);
    Preconditions.checkNotNull(paramE2);
    if (this.comparator.compare(paramE1, paramE2) <= 0);
    for (boolean bool = true; ; bool = false)
    {
      Preconditions.checkArgument(bool);
      return subSetImpl(paramE1, paramBoolean1, paramE2, paramBoolean2);
    }
  }

  abstract ImmutableSortedSet<E> subSetImpl(E paramE1, boolean paramBoolean1, E paramE2, boolean paramBoolean2);

  public ImmutableSortedSet<E> tailSet(E paramE)
  {
    return tailSet(paramE, true);
  }

  public ImmutableSortedSet<E> tailSet(E paramE, boolean paramBoolean)
  {
    return tailSetImpl(Preconditions.checkNotNull(paramE), paramBoolean);
  }

  abstract ImmutableSortedSet<E> tailSetImpl(E paramE, boolean paramBoolean);

  int unsafeCompare(Object paramObject1, Object paramObject2)
  {
    return unsafeCompare(this.comparator, paramObject1, paramObject2);
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.google.common.collect.ImmutableSortedSet
 * JD-Core Version:    0.6.2
 */