package com.google.common.collect;

import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import java.util.Iterator;

/* loaded from: classes.dex */
public abstract class FluentIterable<E> implements Iterable<E> {
    private final Optional<Iterable<E>> a;

    protected FluentIterable() {
        this.a = Optional.absent();
    }

    public static <T> FluentIterable<T> a(Iterable<? extends T> iterable, Iterable<? extends T> iterable2) {
        return a(ImmutableList.of(iterable, iterable2));
    }

    private Iterable<E> b() {
        return this.a.or((Optional<Iterable<E>>) this);
    }

    public String toString() {
        return Iterables.f(b());
    }

    public static <T> FluentIterable<T> a(final Iterable<? extends Iterable<? extends T>> iterable) {
        Preconditions.a(iterable);
        return new FluentIterable<T>() { // from class: com.google.common.collect.FluentIterable.2
            @Override // java.lang.Iterable
            public Iterator<T> iterator() {
                return Iterators.c(Iterables.a(iterable, Iterables.a()).iterator());
            }
        };
    }

    public static <E> FluentIterable<E> b(final Iterable<E> iterable) {
        return iterable instanceof FluentIterable ? (FluentIterable) iterable : new FluentIterable<E>(iterable) { // from class: com.google.common.collect.FluentIterable.1
            @Override // java.lang.Iterable
            public Iterator<E> iterator() {
                return iterable.iterator();
            }
        };
    }

    FluentIterable(Iterable<E> iterable) {
        Preconditions.a(iterable);
        this.a = Optional.fromNullable(this == iterable ? null : iterable);
    }

    public final FluentIterable<E> a(Predicate<? super E> predicate) {
        return b(Iterables.b(b(), predicate));
    }

    public final ImmutableSet<E> a() {
        return ImmutableSet.copyOf(b());
    }
}