package com.google.common.base;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import java.io.Serializable;
import javax.annotation.Nullable;
import mi;
import mj;

@GwtCompatible
public abstract class Equivalence<T>
{
  public static Equivalence<Object> equals()
  {
    return a.a;
  }
  
  public static Equivalence<Object> identity()
  {
    return c.a;
  }
  
  public abstract boolean doEquivalent(T paramT1, T paramT2);
  
  public abstract int doHash(T paramT);
  
  public final boolean equivalent(@Nullable T paramT1, @Nullable T paramT2)
  {
    if (paramT1 == paramT2) {
      return true;
    }
    if ((paramT1 == null) || (paramT2 == null)) {
      return false;
    }
    return doEquivalent(paramT1, paramT2);
  }
  
  @Beta
  public final Predicate<T> equivalentTo(@Nullable T paramT)
  {
    return new b(this, paramT);
  }
  
  public final int hash(@Nullable T paramT)
  {
    if (paramT == null) {
      return 0;
    }
    return doHash(paramT);
  }
  
  public final <F> Equivalence<F> onResultOf(Function<F, ? extends T> paramFunction)
  {
    return new mi(paramFunction, this);
  }
  
  @GwtCompatible(serializable=true)
  public final <S extends T> Equivalence<Iterable<S>> pairwise()
  {
    return new mj(this);
  }
  
  public final <S extends T> Wrapper<S> wrap(@Nullable S paramS)
  {
    return new Wrapper(this, paramS, (byte)0);
  }
  
  public static final class Wrapper<T>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    private final Equivalence<? super T> a;
    @Nullable
    private final T b;
    
    private Wrapper(Equivalence<? super T> paramEquivalence, @Nullable T paramT)
    {
      this.a = ((Equivalence)Preconditions.checkNotNull(paramEquivalence));
      this.b = paramT;
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      if (paramObject == this) {
        return true;
      }
      if ((paramObject instanceof Wrapper))
      {
        paramObject = (Wrapper)paramObject;
        if (this.a.equals(((Wrapper)paramObject).a)) {
          return this.a.equivalent(this.b, ((Wrapper)paramObject).b);
        }
      }
      return false;
    }
    
    @Nullable
    public final T get()
    {
      return (T)this.b;
    }
    
    public final int hashCode()
    {
      return this.a.hash(this.b);
    }
    
    public final String toString()
    {
      String str1 = String.valueOf(String.valueOf(this.a));
      String str2 = String.valueOf(String.valueOf(this.b));
      return str1.length() + 7 + str2.length() + str1 + ".wrap(" + str2 + ")";
    }
  }
  
  static final class a
    extends Equivalence<Object>
    implements Serializable
  {
    static final a a = new a();
    private static final long serialVersionUID = 1L;
    
    private Object readResolve()
    {
      return a;
    }
    
    protected final boolean doEquivalent(Object paramObject1, Object paramObject2)
    {
      return paramObject1.equals(paramObject2);
    }
    
    protected final int doHash(Object paramObject)
    {
      return paramObject.hashCode();
    }
  }
  
  static final class b<T>
    implements Predicate<T>, Serializable
  {
    private static final long serialVersionUID = 0L;
    private final Equivalence<T> a;
    @Nullable
    private final T b;
    
    b(Equivalence<T> paramEquivalence, @Nullable T paramT)
    {
      this.a = ((Equivalence)Preconditions.checkNotNull(paramEquivalence));
      this.b = paramT;
    }
    
    public final boolean apply(@Nullable T paramT)
    {
      return this.a.equivalent(paramT, this.b);
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      if (this == paramObject) {}
      do
      {
        return true;
        if (!(paramObject instanceof b)) {
          break;
        }
        paramObject = (b)paramObject;
      } while ((this.a.equals(((b)paramObject).a)) && (Objects.equal(this.b, ((b)paramObject).b)));
      return false;
      return false;
    }
    
    public final int hashCode()
    {
      return Objects.hashCode(new Object[] { this.a, this.b });
    }
    
    public final String toString()
    {
      String str1 = String.valueOf(String.valueOf(this.a));
      String str2 = String.valueOf(String.valueOf(this.b));
      return str1.length() + 15 + str2.length() + str1 + ".equivalentTo(" + str2 + ")";
    }
  }
  
  static final class c
    extends Equivalence<Object>
    implements Serializable
  {
    static final c a = new c();
    private static final long serialVersionUID = 1L;
    
    private Object readResolve()
    {
      return a;
    }
    
    protected final boolean doEquivalent(Object paramObject1, Object paramObject2)
    {
      return false;
    }
    
    protected final int doHash(Object paramObject)
    {
      return System.identityHashCode(paramObject);
    }
  }
}


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