package com.google.common.base;

import java.io.Serializable;

/* loaded from: classes.dex */
public abstract class Equivalence<T> {

    static final class Equals extends Equivalence<Object> implements Serializable {
        static final Equals a = new Equals();

        Equals() {
        }

        private Object readResolve() {
            return a;
        }

        @Override // com.google.common.base.Equivalence
        protected boolean a(Object obj, Object obj2) {
            return obj.equals(obj2);
        }

        @Override // com.google.common.base.Equivalence
        protected int a(Object obj) {
            return obj.hashCode();
        }
    }

    static final class Identity extends Equivalence<Object> implements Serializable {
        static final Identity a = new Identity();

        Identity() {
        }

        private Object readResolve() {
            return a;
        }

        @Override // com.google.common.base.Equivalence
        protected int a(Object obj) {
            return System.identityHashCode(obj);
        }

        @Override // com.google.common.base.Equivalence
        protected boolean a(Object obj, Object obj2) {
            return false;
        }
    }

    public static final class Wrapper<T> implements Serializable {
        private static final long serialVersionUID = 0;
        private final Equivalence<? super T> equivalence;
        private final T reference;

        public boolean equals(Object obj) {
            if (obj == this) {
                return true;
            }
            if (!(obj instanceof Wrapper)) {
                return false;
            }
            Wrapper wrapper = (Wrapper) obj;
            if (this.equivalence.equals(wrapper.equivalence)) {
                return this.equivalence.b(this.reference, wrapper.reference);
            }
            return false;
        }

        public T get() {
            return this.reference;
        }

        public int hashCode() {
            return this.equivalence.b(this.reference);
        }

        public String toString() {
            return this.equivalence + ".wrap(" + this.reference + ")";
        }

        private Wrapper(Equivalence<? super T> equivalence, T t) {
            Preconditions.a(equivalence);
            this.equivalence = equivalence;
            this.reference = t;
        }
    }

    protected Equivalence() {
    }

    public static Equivalence<Object> a() {
        return Equals.a;
    }

    protected abstract int a(T t);

    protected abstract boolean a(T t, T t2);

    public final boolean b(T t, T t2) {
        if (t == t2) {
            return true;
        }
        if (t == null || t2 == null) {
            return false;
        }
        return a(t, t2);
    }

    public final int b(T t) {
        if (t == null) {
            return 0;
        }
        return a(t);
    }

    public static Equivalence<Object> b() {
        return Identity.a;
    }
}