package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.Nullable;
import ng;
import nh;
import nj;
import nk;
import nl;
import od;
import pb;
import pd;
import pe;
import pf;
import ps;
import qj;

@GwtCompatible
public abstract class Ordering<T>
  implements Comparator<T>
{
  @GwtCompatible(serializable=true)
  public static Ordering<Object> allEqual()
  {
    return ng.a;
  }
  
  public static Ordering<Object> arbitrary()
  {
    return b.a;
  }
  
  @GwtCompatible(serializable=true)
  public static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> paramIterable)
  {
    return new nl(paramIterable);
  }
  
  @GwtCompatible(serializable=true)
  public static <T> Ordering<T> explicit(T paramT, T... paramVarArgs)
  {
    return explicit(Lists.asList(paramT, paramVarArgs));
  }
  
  @GwtCompatible(serializable=true)
  public static <T> Ordering<T> explicit(List<T> paramList)
  {
    return new od(paramList);
  }
  
  @Deprecated
  @GwtCompatible(serializable=true)
  public static <T> Ordering<T> from(Ordering<T> paramOrdering)
  {
    return (Ordering)Preconditions.checkNotNull(paramOrdering);
  }
  
  @GwtCompatible(serializable=true)
  public static <T> Ordering<T> from(Comparator<T> paramComparator)
  {
    if ((paramComparator instanceof Ordering)) {
      return (Ordering)paramComparator;
    }
    return new nk(paramComparator);
  }
  
  @GwtCompatible(serializable=true)
  public static <C extends Comparable> Ordering<C> natural()
  {
    return pd.a;
  }
  
  @GwtCompatible(serializable=true)
  public static Ordering<Object> usingToString()
  {
    return qj.a;
  }
  
  public int binarySearch(List<? extends T> paramList, @Nullable T paramT)
  {
    return Collections.binarySearch(paramList, paramT, this);
  }
  
  public abstract int compare(@Nullable T paramT1, @Nullable T paramT2);
  
  @GwtCompatible(serializable=true)
  public <U extends T> Ordering<U> compound(Comparator<? super U> paramComparator)
  {
    return new nl(this, (Comparator)Preconditions.checkNotNull(paramComparator));
  }
  
  public <E extends T> List<E> greatestOf(Iterable<E> paramIterable, int paramInt)
  {
    return reverse().leastOf(paramIterable, paramInt);
  }
  
  public <E extends T> List<E> greatestOf(Iterator<E> paramIterator, int paramInt)
  {
    return reverse().leastOf(paramIterator, paramInt);
  }
  
  public <E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> paramIterable)
  {
    paramIterable = (Object[])Iterables.a(paramIterable);
    int j = paramIterable.length;
    int i = 0;
    while (i < j)
    {
      Preconditions.checkNotNull(paramIterable[i]);
      i += 1;
    }
    Arrays.sort(paramIterable, this);
    return ImmutableList.a(paramIterable);
  }
  
  public boolean isOrdered(Iterable<? extends T> paramIterable)
  {
    Iterator localIterator = paramIterable.iterator();
    if (localIterator.hasNext())
    {
      Object localObject;
      for (paramIterable = localIterator.next(); localIterator.hasNext(); paramIterable = (Iterable<? extends T>)localObject)
      {
        localObject = localIterator.next();
        if (compare(paramIterable, localObject) > 0) {
          return false;
        }
      }
    }
    return true;
  }
  
  public boolean isStrictlyOrdered(Iterable<? extends T> paramIterable)
  {
    Iterator localIterator = paramIterable.iterator();
    if (localIterator.hasNext())
    {
      Object localObject;
      for (paramIterable = localIterator.next(); localIterator.hasNext(); paramIterable = (Iterable<? extends T>)localObject)
      {
        localObject = localIterator.next();
        if (compare(paramIterable, localObject) >= 0) {
          return false;
        }
      }
    }
    return true;
  }
  
  public <E extends T> List<E> leastOf(Iterable<E> paramIterable, int paramInt)
  {
    if ((paramIterable instanceof Collection))
    {
      Object localObject = (Collection)paramIterable;
      if (((Collection)localObject).size() <= 2L * paramInt)
      {
        localObject = (Object[])((Collection)localObject).toArray();
        Arrays.sort((Object[])localObject, this);
        paramIterable = (Iterable<E>)localObject;
        if (localObject.length > paramInt) {
          paramIterable = ObjectArrays.a((Object[])localObject, paramInt);
        }
        return Collections.unmodifiableList(Arrays.asList(paramIterable));
      }
    }
    return leastOf(paramIterable.iterator(), paramInt);
  }
  
  public <E extends T> List<E> leastOf(Iterator<E> paramIterator, int paramInt)
  {
    Preconditions.checkNotNull(paramIterator);
    nj.a(paramInt, "k");
    if ((paramInt == 0) || (!paramIterator.hasNext())) {
      return ImmutableList.of();
    }
    if (paramInt >= 1073741823)
    {
      paramIterator = Lists.newArrayList(paramIterator);
      Collections.sort(paramIterator, this);
      if (paramIterator.size() > paramInt) {
        paramIterator.subList(paramInt, paramIterator.size()).clear();
      }
      paramIterator.trimToSize();
      return Collections.unmodifiableList(paramIterator);
    }
    int i2 = paramInt * 2;
    Object[] arrayOfObject = (Object[])new Object[i2];
    Object localObject1 = paramIterator.next();
    arrayOfObject[0] = localObject1;
    int j = 1;
    for (;;)
    {
      i = j;
      localObject2 = localObject1;
      if (j >= paramInt) {
        break;
      }
      i = j;
      localObject2 = localObject1;
      if (!paramIterator.hasNext()) {
        break;
      }
      localObject2 = paramIterator.next();
      arrayOfObject[j] = localObject2;
      localObject1 = max(localObject1, localObject2);
      j += 1;
    }
    int i = paramInt;
    Object localObject2 = localObject1;
    for (;;)
    {
      if (paramIterator.hasNext())
      {
        localObject1 = paramIterator.next();
        if (compare(localObject1, localObject2) >= 0) {
          continue;
        }
        j = i + 1;
        arrayOfObject[i] = localObject1;
        if (j != i2) {
          break label440;
        }
        int m = 0;
        int k = i2 - 1;
        i = 0;
        while (i < k)
        {
          j = i + k + 1 >>> 1;
          localObject1 = arrayOfObject[j];
          arrayOfObject[j] = arrayOfObject[k];
          arrayOfObject[k] = localObject1;
          j = i;
          int n = i;
          while (n < k)
          {
            int i1 = j;
            if (compare(arrayOfObject[n], localObject1) < 0)
            {
              ObjectArrays.a(arrayOfObject, j, n);
              i1 = j + 1;
            }
            n += 1;
            j = i1;
          }
          ObjectArrays.a(arrayOfObject, k, j);
          if (j > paramInt)
          {
            k = j - 1;
          }
          else
          {
            if (j >= paramInt) {
              break;
            }
            i = Math.max(j, i + 1);
            m = j;
          }
        }
        localObject1 = arrayOfObject[m];
        i = m + 1;
        while (i < paramInt)
        {
          localObject1 = max(localObject1, arrayOfObject[i]);
          i += 1;
        }
        break;
      }
      Arrays.sort(arrayOfObject, 0, i, this);
      return Collections.unmodifiableList(Arrays.asList(ObjectArrays.a(arrayOfObject, Math.min(i, paramInt))));
      label440:
      i = j;
    }
  }
  
  @GwtCompatible(serializable=true)
  public <S extends T> Ordering<Iterable<S>> lexicographical()
  {
    return new pb(this);
  }
  
  public <E extends T> E max(Iterable<E> paramIterable)
  {
    return (E)max(paramIterable.iterator());
  }
  
  public <E extends T> E max(@Nullable E paramE1, @Nullable E paramE2)
  {
    if (compare(paramE1, paramE2) >= 0) {
      return paramE1;
    }
    return paramE2;
  }
  
  public <E extends T> E max(@Nullable E paramE1, @Nullable E paramE2, @Nullable E paramE3, E... paramVarArgs)
  {
    paramE1 = max(max(paramE1, paramE2), paramE3);
    int j = paramVarArgs.length;
    int i = 0;
    while (i < j)
    {
      paramE1 = max(paramE1, paramVarArgs[i]);
      i += 1;
    }
    return paramE1;
  }
  
  public <E extends T> E max(Iterator<E> paramIterator)
  {
    for (Object localObject = paramIterator.next(); paramIterator.hasNext(); localObject = max(localObject, paramIterator.next())) {}
    return (E)localObject;
  }
  
  public <E extends T> E min(Iterable<E> paramIterable)
  {
    return (E)min(paramIterable.iterator());
  }
  
  public <E extends T> E min(@Nullable E paramE1, @Nullable E paramE2)
  {
    if (compare(paramE1, paramE2) <= 0) {
      return paramE1;
    }
    return paramE2;
  }
  
  public <E extends T> E min(@Nullable E paramE1, @Nullable E paramE2, @Nullable E paramE3, E... paramVarArgs)
  {
    paramE1 = min(min(paramE1, paramE2), paramE3);
    int j = paramVarArgs.length;
    int i = 0;
    while (i < j)
    {
      paramE1 = min(paramE1, paramVarArgs[i]);
      i += 1;
    }
    return paramE1;
  }
  
  public <E extends T> E min(Iterator<E> paramIterator)
  {
    for (Object localObject = paramIterator.next(); paramIterator.hasNext(); localObject = min(localObject, paramIterator.next())) {}
    return (E)localObject;
  }
  
  @GwtCompatible(serializable=true)
  public <S extends T> Ordering<S> nullsFirst()
  {
    return new pe(this);
  }
  
  @GwtCompatible(serializable=true)
  public <S extends T> Ordering<S> nullsLast()
  {
    return new pf(this);
  }
  
  @GwtCompatible(serializable=true)
  public <F> Ordering<F> onResultOf(Function<F, ? extends T> paramFunction)
  {
    return new nh(paramFunction, this);
  }
  
  @GwtCompatible(serializable=true)
  public <S extends T> Ordering<S> reverse()
  {
    return new ps(this);
  }
  
  public <E extends T> List<E> sortedCopy(Iterable<E> paramIterable)
  {
    paramIterable = (Object[])Iterables.a(paramIterable);
    Arrays.sort(paramIterable, this);
    return Lists.newArrayList(Arrays.asList(paramIterable));
  }
  
  @VisibleForTesting
  static final class a
    extends Ordering<Object>
  {
    private Map<Object, Integer> a = new MapMaker().weakKeys().a(new Function()
    {
      final AtomicInteger a = new AtomicInteger(0);
    });
    
    public final int compare(Object paramObject1, Object paramObject2)
    {
      int j = -1;
      int i;
      if (paramObject1 == paramObject2) {
        i = 0;
      }
      do
      {
        int k;
        int m;
        do
        {
          do
          {
            return i;
            i = j;
          } while (paramObject1 == null);
          if (paramObject2 == null) {
            return 1;
          }
          k = System.identityHashCode(paramObject1);
          m = System.identityHashCode(paramObject2);
          if (k == m) {
            break;
          }
          i = j;
        } while (k < m);
        return 1;
        j = ((Integer)this.a.get(paramObject1)).compareTo((Integer)this.a.get(paramObject2));
        i = j;
      } while (j != 0);
      throw new AssertionError();
    }
    
    public final String toString()
    {
      return "Ordering.arbitrary()";
    }
  }
  
  static final class b
  {
    static final Ordering<Object> a = new Ordering.a();
  }
  
  @VisibleForTesting
  public static final class c
    extends ClassCastException
  {
    private static final long serialVersionUID = 0L;
    final Object a;
    
    public c(Object paramObject)
    {
      super();
      this.a = paramObject;
    }
  }
}


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