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.base.Function;
import com.google.common.base.Joiner;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;

@GwtCompatible(emulated=true)
public abstract class FluentIterable<E>
  implements Iterable<E>
{
  private final Iterable<E> a;
  
  protected FluentIterable()
  {
    this.a = this;
  }
  
  FluentIterable(Iterable<E> paramIterable)
  {
    this.a = ((Iterable)Preconditions.checkNotNull(paramIterable));
  }
  
  @Deprecated
  public static <E> FluentIterable<E> from(FluentIterable<E> paramFluentIterable)
  {
    return (FluentIterable)Preconditions.checkNotNull(paramFluentIterable);
  }
  
  public static <E> FluentIterable<E> from(final Iterable<E> paramIterable)
  {
    if ((paramIterable instanceof FluentIterable)) {
      return (FluentIterable)paramIterable;
    }
    new FluentIterable(paramIterable)
    {
      public final Iterator<E> iterator()
      {
        return paramIterable.iterator();
      }
    };
  }
  
  @Beta
  public static <E> FluentIterable<E> of(E[] paramArrayOfE)
  {
    return from(Lists.newArrayList(paramArrayOfE));
  }
  
  public final boolean allMatch(Predicate<? super E> paramPredicate)
  {
    return Iterables.all(this.a, paramPredicate);
  }
  
  public final boolean anyMatch(Predicate<? super E> paramPredicate)
  {
    return Iterables.any(this.a, paramPredicate);
  }
  
  @CheckReturnValue
  @Beta
  public final FluentIterable<E> append(Iterable<? extends E> paramIterable)
  {
    return from(Iterables.concat(this.a, paramIterable));
  }
  
  @CheckReturnValue
  @Beta
  public final FluentIterable<E> append(E... paramVarArgs)
  {
    return from(Iterables.concat(this.a, Arrays.asList(paramVarArgs)));
  }
  
  public final boolean contains(@Nullable Object paramObject)
  {
    return Iterables.contains(this.a, paramObject);
  }
  
  public final <C extends Collection<? super E>> C copyInto(C paramC)
  {
    Preconditions.checkNotNull(paramC);
    if ((this.a instanceof Collection)) {
      paramC.addAll(Collections2.a(this.a));
    }
    for (;;)
    {
      return paramC;
      Iterator localIterator = this.a.iterator();
      while (localIterator.hasNext()) {
        paramC.add(localIterator.next());
      }
    }
  }
  
  @CheckReturnValue
  public final FluentIterable<E> cycle()
  {
    return from(Iterables.cycle(this.a));
  }
  
  @CheckReturnValue
  public final FluentIterable<E> filter(Predicate<? super E> paramPredicate)
  {
    return from(Iterables.filter(this.a, paramPredicate));
  }
  
  @CheckReturnValue
  @GwtIncompatible("Class.isInstance")
  public final <T> FluentIterable<T> filter(Class<T> paramClass)
  {
    return from(Iterables.filter(this.a, paramClass));
  }
  
  public final Optional<E> first()
  {
    Iterator localIterator = this.a.iterator();
    if (localIterator.hasNext()) {
      return Optional.of(localIterator.next());
    }
    return Optional.absent();
  }
  
  public final Optional<E> firstMatch(Predicate<? super E> paramPredicate)
  {
    return Iterables.tryFind(this.a, paramPredicate);
  }
  
  public final E get(int paramInt)
  {
    return (E)Iterables.get(this.a, paramInt);
  }
  
  public final <K> ImmutableListMultimap<K, E> index(Function<? super E, K> paramFunction)
  {
    return Multimaps.index(this.a, paramFunction);
  }
  
  public final boolean isEmpty()
  {
    return !this.a.iterator().hasNext();
  }
  
  @Beta
  public final String join(Joiner paramJoiner)
  {
    return paramJoiner.join(this);
  }
  
  public final Optional<E> last()
  {
    if ((this.a instanceof List))
    {
      localObject1 = (List)this.a;
      if (((List)localObject1).isEmpty()) {
        return Optional.absent();
      }
      return Optional.of(((List)localObject1).get(((List)localObject1).size() - 1));
    }
    Object localObject1 = this.a.iterator();
    if (!((Iterator)localObject1).hasNext()) {
      return Optional.absent();
    }
    if ((this.a instanceof SortedSet)) {
      return Optional.of(((SortedSet)this.a).last());
    }
    Object localObject2;
    do
    {
      localObject2 = ((Iterator)localObject1).next();
    } while (((Iterator)localObject1).hasNext());
    return Optional.of(localObject2);
  }
  
  @CheckReturnValue
  public final FluentIterable<E> limit(int paramInt)
  {
    return from(Iterables.limit(this.a, paramInt));
  }
  
  public final int size()
  {
    return Iterables.size(this.a);
  }
  
  @CheckReturnValue
  public final FluentIterable<E> skip(int paramInt)
  {
    return from(Iterables.skip(this.a, paramInt));
  }
  
  @GwtIncompatible("Array.newArray(Class, int)")
  public final E[] toArray(Class<E> paramClass)
  {
    return Iterables.toArray(this.a, paramClass);
  }
  
  public final ImmutableList<E> toList()
  {
    return ImmutableList.copyOf(this.a);
  }
  
  public final <V> ImmutableMap<E, V> toMap(Function<? super E, V> paramFunction)
  {
    return Maps.toMap(this.a, paramFunction);
  }
  
  public final ImmutableSet<E> toSet()
  {
    return ImmutableSet.copyOf(this.a);
  }
  
  public final ImmutableList<E> toSortedList(Comparator<? super E> paramComparator)
  {
    return Ordering.from(paramComparator).immutableSortedCopy(this.a);
  }
  
  public final ImmutableSortedSet<E> toSortedSet(Comparator<? super E> paramComparator)
  {
    return ImmutableSortedSet.copyOf(paramComparator, this.a);
  }
  
  public String toString()
  {
    return Iterables.toString(this.a);
  }
  
  public final <T> FluentIterable<T> transform(Function<? super E, T> paramFunction)
  {
    return from(Iterables.transform(this.a, paramFunction));
  }
  
  public <T> FluentIterable<T> transformAndConcat(Function<? super E, ? extends Iterable<? extends T>> paramFunction)
  {
    return from(Iterables.concat(transform(paramFunction)));
  }
  
  public final <K> ImmutableMap<K, E> uniqueIndex(Function<? super E, K> paramFunction)
  {
    return Maps.uniqueIndex(this.a, paramFunction);
  }
}


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