package com.google.common.collect;

import com.google.common.base.Function;
import java.util.Comparator;
import java.util.Map;

/* loaded from: classes.dex */
public abstract class Ordering<T> implements Comparator<T> {
    protected Ordering() {
    }

    public static <T> Ordering<T> a(Comparator<T> comparator) {
        return comparator instanceof Ordering ? (Ordering) comparator : new ComparatorOrdering(comparator);
    }

    public static <C extends Comparable> Ordering<C> c() {
        return NaturalOrdering.a;
    }

    public <S extends T> Ordering<S> b() {
        return new ReverseOrdering(this);
    }

    @Override // java.util.Comparator
    public abstract int compare(T t, T t2);

    public <F> Ordering<F> a(Function<F, ? extends T> function) {
        return new ByFunctionOrdering(function, this);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public <E extends T> E b(E e, E e2) {
        return compare(e, e2) <= 0 ? e : e2;
    }

    <T2 extends T> Ordering<Map.Entry<T2, ?>> a() {
        return (Ordering<Map.Entry<T2, ?>>) a(Maps.a());
    }

    /* JADX WARN: Multi-variable type inference failed */
    public <E extends T> E a(E e, E e2) {
        return compare(e, e2) >= 0 ? e : e2;
    }

    public <E extends T> ImmutableList<E> a(Iterable<E> iterable) {
        return ImmutableList.sortedCopyOf(this, iterable);
    }
}