package com.google.common.collect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.math.IntMath;
import com.google.common.math.LongMath;
import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import javax.annotation.Nullable;
import nj;

@GwtCompatible
public final class Collections2
{
  static final Joiner a = Joiner.on(", ").useForNull("null");
  
  static String a(Collection<?> paramCollection)
  {
    StringBuilder localStringBuilder = a(paramCollection.size()).append('[');
    a.appendTo(localStringBuilder, Iterables.transform(paramCollection, new Function()
    {
      public final Object apply(Object paramAnonymousObject)
      {
        Object localObject = paramAnonymousObject;
        if (paramAnonymousObject == this.a) {
          localObject = "(this Collection)";
        }
        return localObject;
      }
    }));
    return ']';
  }
  
  static StringBuilder a(int paramInt)
  {
    nj.a(paramInt, "size");
    return new StringBuilder((int)Math.min(paramInt * 8L, 1073741824L));
  }
  
  static <T> Collection<T> a(Iterable<T> paramIterable)
  {
    return (Collection)paramIterable;
  }
  
  public static boolean a(Collection<?> paramCollection, @Nullable Object paramObject)
  {
    Preconditions.checkNotNull(paramCollection);
    try
    {
      boolean bool = paramCollection.contains(paramObject);
      return bool;
    }
    catch (ClassCastException paramCollection)
    {
      return false;
    }
    catch (NullPointerException paramCollection) {}
    return false;
  }
  
  public static boolean a(Collection<?> paramCollection1, Collection<?> paramCollection2)
  {
    return Iterables.all(paramCollection2, Predicates.in(paramCollection1));
  }
  
  public static boolean b(Collection<?> paramCollection, @Nullable Object paramObject)
  {
    Preconditions.checkNotNull(paramCollection);
    try
    {
      boolean bool = paramCollection.remove(paramObject);
      return bool;
    }
    catch (ClassCastException paramCollection)
    {
      return false;
    }
    catch (NullPointerException paramCollection) {}
    return false;
  }
  
  public static <E> Collection<E> filter(Collection<E> paramCollection, Predicate<? super E> paramPredicate)
  {
    if ((paramCollection instanceof a))
    {
      paramCollection = (a)paramCollection;
      return new a(paramCollection.a, Predicates.and(paramCollection.b, paramPredicate));
    }
    return new a((Collection)Preconditions.checkNotNull(paramCollection), (Predicate)Preconditions.checkNotNull(paramPredicate));
  }
  
  @Beta
  public static <E extends Comparable<? super E>> Collection<List<E>> orderedPermutations(Iterable<E> paramIterable)
  {
    return orderedPermutations(paramIterable, Ordering.natural());
  }
  
  @Beta
  public static <E> Collection<List<E>> orderedPermutations(Iterable<E> paramIterable, Comparator<? super E> paramComparator)
  {
    return new b(paramIterable, paramComparator);
  }
  
  @Beta
  public static <E> Collection<List<E>> permutations(Collection<E> paramCollection)
  {
    return new d(ImmutableList.copyOf(paramCollection));
  }
  
  public static <F, T> Collection<T> transform(Collection<F> paramCollection, Function<? super F, T> paramFunction)
  {
    return new f(paramCollection, paramFunction);
  }
  
  static class a<E>
    extends AbstractCollection<E>
  {
    final Collection<E> a;
    final Predicate<? super E> b;
    
    a(Collection<E> paramCollection, Predicate<? super E> paramPredicate)
    {
      this.a = paramCollection;
      this.b = paramPredicate;
    }
    
    public boolean add(E paramE)
    {
      Preconditions.checkArgument(this.b.apply(paramE));
      return this.a.add(paramE);
    }
    
    public boolean addAll(Collection<? extends E> paramCollection)
    {
      Iterator localIterator = paramCollection.iterator();
      while (localIterator.hasNext())
      {
        Object localObject = localIterator.next();
        Preconditions.checkArgument(this.b.apply(localObject));
      }
      return this.a.addAll(paramCollection);
    }
    
    public void clear()
    {
      Iterables.removeIf(this.a, this.b);
    }
    
    public boolean contains(@Nullable Object paramObject)
    {
      if (Collections2.a(this.a, paramObject)) {
        return this.b.apply(paramObject);
      }
      return false;
    }
    
    public boolean containsAll(Collection<?> paramCollection)
    {
      return Collections2.a(this, paramCollection);
    }
    
    public boolean isEmpty()
    {
      return !Iterables.any(this.a, this.b);
    }
    
    public Iterator<E> iterator()
    {
      return Iterators.filter(this.a.iterator(), this.b);
    }
    
    public boolean remove(Object paramObject)
    {
      return (contains(paramObject)) && (this.a.remove(paramObject));
    }
    
    public boolean removeAll(Collection<?> paramCollection)
    {
      return Iterables.removeIf(this.a, Predicates.and(this.b, Predicates.in(paramCollection)));
    }
    
    public boolean retainAll(Collection<?> paramCollection)
    {
      return Iterables.removeIf(this.a, Predicates.and(this.b, Predicates.not(Predicates.in(paramCollection))));
    }
    
    public int size()
    {
      return Iterators.size(iterator());
    }
    
    public Object[] toArray()
    {
      return Lists.newArrayList(iterator()).toArray();
    }
    
    public <T> T[] toArray(T[] paramArrayOfT)
    {
      return Lists.newArrayList(iterator()).toArray(paramArrayOfT);
    }
  }
  
  static final class b<E>
    extends AbstractCollection<List<E>>
  {
    final ImmutableList<E> a;
    final Comparator<? super E> b;
    final int c;
    
    b(Iterable<E> paramIterable, Comparator<? super E> paramComparator)
    {
      this.a = Ordering.from(paramComparator).immutableSortedCopy(paramIterable);
      this.b = paramComparator;
      this.c = a(this.a, paramComparator);
    }
    
    private static <E> int a(List<E> paramList, Comparator<? super E> paramComparator)
    {
      int i = 1;
      long l2 = 1L;
      int j = 1;
      while (j < paramList.size())
      {
        int k = i;
        l1 = l2;
        if (paramComparator.compare(paramList.get(j - 1), paramList.get(j)) < 0)
        {
          l2 *= LongMath.binomial(j, i);
          k = 0;
          l1 = l2;
          if (!Collections2.a(l2)) {
            return Integer.MAX_VALUE;
          }
        }
        j += 1;
        i = k + 1;
        l2 = l1;
      }
      long l1 = LongMath.binomial(j, i) * l2;
      if (!Collections2.a(l1)) {
        return Integer.MAX_VALUE;
      }
      return (int)l1;
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      if ((paramObject instanceof List))
      {
        paramObject = (List)paramObject;
        return Collections2.a(this.a, (List)paramObject);
      }
      return false;
    }
    
    public final boolean isEmpty()
    {
      return false;
    }
    
    public final Iterator<List<E>> iterator()
    {
      return new Collections2.c(this.a, this.b);
    }
    
    public final int size()
    {
      return this.c;
    }
    
    public final String toString()
    {
      String str = String.valueOf(String.valueOf(this.a));
      return str.length() + 30 + "orderedPermutationCollection(" + str + ")";
    }
  }
  
  static final class c<E>
    extends AbstractIterator<List<E>>
  {
    List<E> a;
    final Comparator<? super E> b;
    
    c(List<E> paramList, Comparator<? super E> paramComparator)
    {
      this.a = Lists.newArrayList(paramList);
      this.b = paramComparator;
    }
  }
  
  static final class d<E>
    extends AbstractCollection<List<E>>
  {
    final ImmutableList<E> a;
    
    d(ImmutableList<E> paramImmutableList)
    {
      this.a = paramImmutableList;
    }
    
    public final boolean contains(@Nullable Object paramObject)
    {
      if ((paramObject instanceof List))
      {
        paramObject = (List)paramObject;
        return Collections2.a(this.a, (List)paramObject);
      }
      return false;
    }
    
    public final boolean isEmpty()
    {
      return false;
    }
    
    public final Iterator<List<E>> iterator()
    {
      return new Collections2.e(this.a);
    }
    
    public final int size()
    {
      return IntMath.factorial(this.a.size());
    }
    
    public final String toString()
    {
      String str = String.valueOf(String.valueOf(this.a));
      return str.length() + 14 + "permutations(" + str + ")";
    }
  }
  
  static final class e<E>
    extends AbstractIterator<List<E>>
  {
    final List<E> a;
    final int[] b;
    final int[] c;
    int d;
    
    e(List<E> paramList)
    {
      this.a = new ArrayList(paramList);
      int i = paramList.size();
      this.b = new int[i];
      this.c = new int[i];
      Arrays.fill(this.b, 0);
      Arrays.fill(this.c, 1);
      this.d = Integer.MAX_VALUE;
    }
    
    private void a()
    {
      this.c[this.d] = (-this.c[this.d]);
      this.d -= 1;
    }
  }
  
  static final class f<F, T>
    extends AbstractCollection<T>
  {
    final Collection<F> a;
    final Function<? super F, ? extends T> b;
    
    f(Collection<F> paramCollection, Function<? super F, ? extends T> paramFunction)
    {
      this.a = ((Collection)Preconditions.checkNotNull(paramCollection));
      this.b = ((Function)Preconditions.checkNotNull(paramFunction));
    }
    
    public final void clear()
    {
      this.a.clear();
    }
    
    public final boolean isEmpty()
    {
      return this.a.isEmpty();
    }
    
    public final Iterator<T> iterator()
    {
      return Iterators.transform(this.a.iterator(), this.b);
    }
    
    public final int size()
    {
      return this.a.size();
    }
  }
}


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