package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.math.IntMath;
import com.google.common.primitives.Ints;
import java.io.Serializable;
import java.math.RoundingMode;
import java.util.AbstractList;
import java.util.AbstractSequentialList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.annotation.Nullable;
import nj;
import qh;

@GwtCompatible(emulated=true)
public final class Lists
{
  @VisibleForTesting
  private static int a(int paramInt)
  {
    nj.a(paramInt, "arraySize");
    return Ints.saturatedCast(5L + paramInt + paramInt / 10);
  }
  
  static int a(List<?> paramList)
  {
    int i = 1;
    paramList = paramList.iterator();
    if (paramList.hasNext())
    {
      Object localObject = paramList.next();
      if (localObject == null) {}
      for (int j = 0;; j = localObject.hashCode())
      {
        i = j + i * 31 ^ 0xFFFFFFFF ^ 0xFFFFFFFF;
        break;
      }
    }
    return i;
  }
  
  static <T> List<T> a(Iterable<T> paramIterable)
  {
    return (List)paramIterable;
  }
  
  static <E> List<E> a(List<E> paramList, int paramInt1, int paramInt2)
  {
    if ((paramList instanceof RandomAccess)) {}
    for (paramList = new e(paramList)
        {
          public final ListIterator<E> listIterator(int paramAnonymousInt)
          {
            return this.a.listIterator(paramAnonymousInt);
          }
        };; paramList = new a(paramList)
        {
          public final ListIterator<E> listIterator(int paramAnonymousInt)
          {
            return this.a.listIterator(paramAnonymousInt);
          }
        }) {
      return paramList.subList(paramInt1, paramInt2);
    }
  }
  
  static <E> ListIterator<E> a(List<E> paramList, int paramInt)
  {
    return new a(paramList).listIterator(paramInt);
  }
  
  static <E> boolean a(List<E> paramList, int paramInt, Iterable<? extends E> paramIterable)
  {
    boolean bool = false;
    paramList = paramList.listIterator(paramInt);
    paramIterable = paramIterable.iterator();
    while (paramIterable.hasNext())
    {
      paramList.add(paramIterable.next());
      bool = true;
    }
    return bool;
  }
  
  static boolean a(List<?> paramList, @Nullable Object paramObject)
  {
    if (paramObject == Preconditions.checkNotNull(paramList)) {}
    do
    {
      return true;
      if (!(paramObject instanceof List)) {
        return false;
      }
      paramObject = (List)paramObject;
    } while ((paramList.size() == ((List)paramObject).size()) && (Iterators.elementsEqual(paramList.iterator(), ((List)paramObject).iterator())));
    return false;
  }
  
  public static <E> List<E> asList(@Nullable E paramE1, @Nullable E paramE2, E[] paramArrayOfE)
  {
    return new l(paramE1, paramE2, paramArrayOfE);
  }
  
  public static <E> List<E> asList(@Nullable E paramE, E[] paramArrayOfE)
  {
    return new c(paramE, paramArrayOfE);
  }
  
  static int b(List<?> paramList, @Nullable Object paramObject)
  {
    paramList = paramList.listIterator();
    while (paramList.hasNext()) {
      if (Objects.equal(paramObject, paramList.next())) {
        return paramList.previousIndex();
      }
    }
    return -1;
  }
  
  static int c(List<?> paramList, @Nullable Object paramObject)
  {
    paramList = paramList.listIterator(paramList.size());
    while (paramList.hasPrevious()) {
      if (Objects.equal(paramObject, paramList.previous())) {
        return paramList.nextIndex();
      }
    }
    return -1;
  }
  
  @Beta
  public static ImmutableList<Character> charactersOf(String paramString)
  {
    return new i((String)Preconditions.checkNotNull(paramString));
  }
  
  @Beta
  public static List<Character> charactersOf(CharSequence paramCharSequence)
  {
    return new b((CharSequence)Preconditions.checkNotNull(paramCharSequence));
  }
  
  @GwtCompatible(serializable=true)
  public static <E> ArrayList<E> newArrayList()
  {
    return new ArrayList();
  }
  
  @GwtCompatible(serializable=true)
  public static <E> ArrayList<E> newArrayList(Iterable<? extends E> paramIterable)
  {
    Preconditions.checkNotNull(paramIterable);
    if ((paramIterable instanceof Collection)) {
      return new ArrayList(Collections2.a(paramIterable));
    }
    return newArrayList(paramIterable.iterator());
  }
  
  @GwtCompatible(serializable=true)
  public static <E> ArrayList<E> newArrayList(Iterator<? extends E> paramIterator)
  {
    ArrayList localArrayList = newArrayList();
    Iterators.addAll(localArrayList, paramIterator);
    return localArrayList;
  }
  
  @GwtCompatible(serializable=true)
  public static <E> ArrayList<E> newArrayList(E... paramVarArgs)
  {
    Preconditions.checkNotNull(paramVarArgs);
    ArrayList localArrayList = new ArrayList(a(paramVarArgs.length));
    Collections.addAll(localArrayList, paramVarArgs);
    return localArrayList;
  }
  
  @GwtCompatible(serializable=true)
  public static <E> ArrayList<E> newArrayListWithCapacity(int paramInt)
  {
    nj.a(paramInt, "initialArraySize");
    return new ArrayList(paramInt);
  }
  
  @GwtCompatible(serializable=true)
  public static <E> ArrayList<E> newArrayListWithExpectedSize(int paramInt)
  {
    return new ArrayList(a(paramInt));
  }
  
  @GwtIncompatible("CopyOnWriteArrayList")
  public static <E> CopyOnWriteArrayList<E> newCopyOnWriteArrayList()
  {
    return new CopyOnWriteArrayList();
  }
  
  @GwtIncompatible("CopyOnWriteArrayList")
  public static <E> CopyOnWriteArrayList<E> newCopyOnWriteArrayList(Iterable<? extends E> paramIterable)
  {
    if ((paramIterable instanceof Collection)) {}
    for (paramIterable = Collections2.a(paramIterable);; paramIterable = newArrayList(paramIterable)) {
      return new CopyOnWriteArrayList(paramIterable);
    }
  }
  
  @GwtCompatible(serializable=true)
  public static <E> LinkedList<E> newLinkedList()
  {
    return new LinkedList();
  }
  
  @GwtCompatible(serializable=true)
  public static <E> LinkedList<E> newLinkedList(Iterable<? extends E> paramIterable)
  {
    LinkedList localLinkedList = newLinkedList();
    Iterables.addAll(localLinkedList, paramIterable);
    return localLinkedList;
  }
  
  public static <T> List<List<T>> partition(List<T> paramList, int paramInt)
  {
    Preconditions.checkNotNull(paramList);
    if (paramInt > 0) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      if (!(paramList instanceof RandomAccess)) {
        break;
      }
      return new f(paramList, paramInt);
    }
    return new d(paramList, paramInt);
  }
  
  public static <T> List<T> reverse(List<T> paramList)
  {
    if ((paramList instanceof ImmutableList)) {
      return ((ImmutableList)paramList).reverse();
    }
    if ((paramList instanceof h)) {
      return ((h)paramList).a;
    }
    if ((paramList instanceof RandomAccess)) {
      return new g(paramList);
    }
    return new h(paramList);
  }
  
  public static <F, T> List<T> transform(List<F> paramList, Function<? super F, ? extends T> paramFunction)
  {
    if ((paramList instanceof RandomAccess)) {
      return new j(paramList, paramFunction);
    }
    return new k(paramList, paramFunction);
  }
  
  static class a<E>
    extends AbstractList<E>
  {
    final List<E> a;
    
    a(List<E> paramList)
    {
      this.a = ((List)Preconditions.checkNotNull(paramList));
    }
    
    public void add(int paramInt, E paramE)
    {
      this.a.add(paramInt, paramE);
    }
    
    public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
    {
      return this.a.addAll(paramInt, paramCollection);
    }
    
    public boolean contains(Object paramObject)
    {
      return this.a.contains(paramObject);
    }
    
    public E get(int paramInt)
    {
      return (E)this.a.get(paramInt);
    }
    
    public E remove(int paramInt)
    {
      return (E)this.a.remove(paramInt);
    }
    
    public E set(int paramInt, E paramE)
    {
      return (E)this.a.set(paramInt, paramE);
    }
    
    public int size()
    {
      return this.a.size();
    }
  }
  
  static final class b
    extends AbstractList<Character>
  {
    private final CharSequence a;
    
    b(CharSequence paramCharSequence)
    {
      this.a = paramCharSequence;
    }
    
    public final int size()
    {
      return this.a.length();
    }
  }
  
  static final class c<E>
    extends AbstractList<E>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final E a;
    final E[] b;
    
    c(@Nullable E paramE, E[] paramArrayOfE)
    {
      this.a = paramE;
      this.b = ((Object[])Preconditions.checkNotNull(paramArrayOfE));
    }
    
    public final E get(int paramInt)
    {
      Preconditions.checkElementIndex(paramInt, size());
      if (paramInt == 0) {
        return (E)this.a;
      }
      return (E)this.b[(paramInt - 1)];
    }
    
    public final int size()
    {
      return this.b.length + 1;
    }
  }
  
  static class d<T>
    extends AbstractList<List<T>>
  {
    final List<T> a;
    final int b;
    
    d(List<T> paramList, int paramInt)
    {
      this.a = paramList;
      this.b = paramInt;
    }
    
    public boolean isEmpty()
    {
      return this.a.isEmpty();
    }
    
    public int size()
    {
      return IntMath.divide(this.a.size(), this.b, RoundingMode.CEILING);
    }
  }
  
  static class e<E>
    extends Lists.a<E>
    implements RandomAccess
  {
    e(List<E> paramList)
    {
      super();
    }
  }
  
  static final class f<T>
    extends Lists.d<T>
    implements RandomAccess
  {
    f(List<T> paramList, int paramInt)
    {
      super(paramInt);
    }
  }
  
  static final class g<T>
    extends Lists.h<T>
    implements RandomAccess
  {
    g(List<T> paramList)
    {
      super();
    }
  }
  
  static class h<T>
    extends AbstractList<T>
  {
    final List<T> a;
    
    h(List<T> paramList)
    {
      this.a = ((List)Preconditions.checkNotNull(paramList));
    }
    
    private int a(int paramInt)
    {
      int i = size();
      Preconditions.checkElementIndex(paramInt, i);
      return i - 1 - paramInt;
    }
    
    private int b(int paramInt)
    {
      int i = size();
      Preconditions.checkPositionIndex(paramInt, i);
      return i - paramInt;
    }
    
    public void add(int paramInt, @Nullable T paramT)
    {
      this.a.add(b(paramInt), paramT);
    }
    
    public void clear()
    {
      this.a.clear();
    }
    
    public T get(int paramInt)
    {
      return (T)this.a.get(a(paramInt));
    }
    
    public Iterator<T> iterator()
    {
      return listIterator();
    }
    
    public ListIterator<T> listIterator(int paramInt)
    {
      paramInt = b(paramInt);
      new ListIterator()
      {
        boolean a;
        
        public final void add(T paramAnonymousT)
        {
          this.b.add(paramAnonymousT);
          this.b.previous();
          this.a = false;
        }
        
        public final boolean hasNext()
        {
          return this.b.hasPrevious();
        }
        
        public final boolean hasPrevious()
        {
          return this.b.hasNext();
        }
        
        public final T next()
        {
          if (!hasNext()) {
            throw new NoSuchElementException();
          }
          this.a = true;
          return (T)this.b.previous();
        }
        
        public final int nextIndex()
        {
          return Lists.h.a(Lists.h.this, this.b.nextIndex());
        }
        
        public final T previous()
        {
          if (!hasPrevious()) {
            throw new NoSuchElementException();
          }
          this.a = true;
          return (T)this.b.next();
        }
        
        public final int previousIndex()
        {
          return nextIndex() - 1;
        }
        
        public final void remove()
        {
          Preconditions.checkState(this.a, "no calls to next() since the last call to remove()");
          this.b.remove();
          this.a = false;
        }
        
        public final void set(T paramAnonymousT)
        {
          Preconditions.checkState(this.a);
          this.b.set(paramAnonymousT);
        }
      };
    }
    
    public T remove(int paramInt)
    {
      return (T)this.a.remove(a(paramInt));
    }
    
    protected void removeRange(int paramInt1, int paramInt2)
    {
      subList(paramInt1, paramInt2).clear();
    }
    
    public T set(int paramInt, @Nullable T paramT)
    {
      return (T)this.a.set(a(paramInt), paramT);
    }
    
    public int size()
    {
      return this.a.size();
    }
    
    public List<T> subList(int paramInt1, int paramInt2)
    {
      Preconditions.checkPositionIndexes(paramInt1, paramInt2, size());
      return Lists.reverse(this.a.subList(b(paramInt2), b(paramInt1)));
    }
  }
  
  static final class i
    extends ImmutableList<Character>
  {
    private final String a;
    
    i(String paramString)
    {
      this.a = paramString;
    }
    
    final boolean a()
    {
      return false;
    }
    
    public final int indexOf(@Nullable Object paramObject)
    {
      if ((paramObject instanceof Character)) {
        return this.a.indexOf(((Character)paramObject).charValue());
      }
      return -1;
    }
    
    public final int lastIndexOf(@Nullable Object paramObject)
    {
      if ((paramObject instanceof Character)) {
        return this.a.lastIndexOf(((Character)paramObject).charValue());
      }
      return -1;
    }
    
    public final int size()
    {
      return this.a.length();
    }
    
    public final ImmutableList<Character> subList(int paramInt1, int paramInt2)
    {
      Preconditions.checkPositionIndexes(paramInt1, paramInt2, size());
      return Lists.charactersOf(this.a.substring(paramInt1, paramInt2));
    }
  }
  
  static final class j<F, T>
    extends AbstractList<T>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final List<F> a;
    final Function<? super F, ? extends T> b;
    
    j(List<F> paramList, Function<? super F, ? extends T> paramFunction)
    {
      this.a = ((List)Preconditions.checkNotNull(paramList));
      this.b = ((Function)Preconditions.checkNotNull(paramFunction));
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final T get(int paramInt)
    {
      return (T)this.b.apply(this.a.get(paramInt));
    }
    
    public final boolean isEmpty()
    {
      return this.a.isEmpty();
    }
    
    public final Iterator<T> iterator()
    {
      return listIterator();
    }
    
    public final ListIterator<T> listIterator(int paramInt)
    {
      new qh(this.a.listIterator(paramInt))
      {
        final T a(F paramAnonymousF)
        {
          return (T)Lists.j.this.b.apply(paramAnonymousF);
        }
      };
    }
    
    public final T remove(int paramInt)
    {
      return (T)this.b.apply(this.a.remove(paramInt));
    }
    
    public final int size()
    {
      return this.a.size();
    }
  }
  
  static final class k<F, T>
    extends AbstractSequentialList<T>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final List<F> a;
    final Function<? super F, ? extends T> b;
    
    k(List<F> paramList, Function<? super F, ? extends T> paramFunction)
    {
      this.a = ((List)Preconditions.checkNotNull(paramList));
      this.b = ((Function)Preconditions.checkNotNull(paramFunction));
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final ListIterator<T> listIterator(int paramInt)
    {
      new qh(this.a.listIterator(paramInt))
      {
        final T a(F paramAnonymousF)
        {
          return (T)Lists.k.this.b.apply(paramAnonymousF);
        }
      };
    }
    
    public final int size()
    {
      return this.a.size();
    }
  }
  
  static final class l<E>
    extends AbstractList<E>
    implements Serializable, RandomAccess
  {
    private static final long serialVersionUID = 0L;
    final E a;
    final E b;
    final E[] c;
    
    l(@Nullable E paramE1, @Nullable E paramE2, E[] paramArrayOfE)
    {
      this.a = paramE1;
      this.b = paramE2;
      this.c = ((Object[])Preconditions.checkNotNull(paramArrayOfE));
    }
    
    public final E get(int paramInt)
    {
      switch (paramInt)
      {
      default: 
        Preconditions.checkElementIndex(paramInt, size());
        return (E)this.c[(paramInt - 2)];
      case 0: 
        return (E)this.a;
      }
      return (E)this.b;
    }
    
    public final int size()
    {
      return this.c.length + 2;
    }
  }
}


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