package com.google.common.base;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import java.io.Serializable;
import java.util.Iterator;
import javax.annotation.Nullable;

@Beta
@GwtCompatible
public abstract class Converter<A, B>
  implements Function<A, B>
{
  private final boolean a = true;
  private transient Converter<B, A> b;
  
  protected Converter()
  {
    this((byte)0);
  }
  
  private Converter(byte paramByte) {}
  
  public static <A, B> Converter<A, B> from(Function<? super A, ? extends B> paramFunction, Function<? super B, ? extends A> paramFunction1)
  {
    return new b(paramFunction, paramFunction1, (byte)0);
  }
  
  public static <T> Converter<T, T> identity()
  {
    return c.a;
  }
  
  <C> Converter<A, C> a(Converter<B, C> paramConverter)
  {
    return new a(this, (Converter)Preconditions.checkNotNull(paramConverter));
  }
  
  @Nullable
  B a(@Nullable A paramA)
  {
    if (this.a)
    {
      if (paramA == null) {
        return null;
      }
      return (B)Preconditions.checkNotNull(doForward(paramA));
    }
    return (B)doForward(paramA);
  }
  
  public final <C> Converter<A, C> andThen(Converter<B, C> paramConverter)
  {
    return a(paramConverter);
  }
  
  @Deprecated
  @Nullable
  public final B apply(@Nullable A paramA)
  {
    return (B)convert(paramA);
  }
  
  @Nullable
  A b(@Nullable B paramB)
  {
    if (this.a)
    {
      if (paramB == null) {
        return null;
      }
      return (A)Preconditions.checkNotNull(doBackward(paramB));
    }
    return (A)doBackward(paramB);
  }
  
  @Nullable
  public final B convert(@Nullable A paramA)
  {
    return (B)a(paramA);
  }
  
  public Iterable<B> convertAll(final Iterable<? extends A> paramIterable)
  {
    Preconditions.checkNotNull(paramIterable, "fromIterable");
    new Iterable()
    {
      public final Iterator<B> iterator()
      {
        new Iterator()
        {
          private final Iterator<? extends A> b = Converter.1.this.a.iterator();
          
          public final boolean hasNext()
          {
            return this.b.hasNext();
          }
          
          public final B next()
          {
            return (B)Converter.this.convert(this.b.next());
          }
          
          public final void remove()
          {
            this.b.remove();
          }
        };
      }
    };
  }
  
  public abstract A doBackward(B paramB);
  
  public abstract B doForward(A paramA);
  
  public boolean equals(@Nullable Object paramObject)
  {
    return super.equals(paramObject);
  }
  
  public Converter<B, A> reverse()
  {
    Converter localConverter = this.b;
    Object localObject = localConverter;
    if (localConverter == null)
    {
      localObject = new d(this);
      this.b = ((Converter)localObject);
    }
    return (Converter<B, A>)localObject;
  }
  
  static final class a<A, B, C>
    extends Converter<A, C>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Converter<A, B> a;
    final Converter<B, C> b;
    
    a(Converter<A, B> paramConverter, Converter<B, C> paramConverter1)
    {
      this.a = paramConverter;
      this.b = paramConverter1;
    }
    
    @Nullable
    final C a(@Nullable A paramA)
    {
      return (C)this.b.a(this.a.a(paramA));
    }
    
    @Nullable
    final A b(@Nullable C paramC)
    {
      return (A)this.a.b(this.b.b(paramC));
    }
    
    protected final A doBackward(C paramC)
    {
      throw new AssertionError();
    }
    
    protected final C doForward(A paramA)
    {
      throw new AssertionError();
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      boolean bool2 = false;
      boolean bool1 = bool2;
      if ((paramObject instanceof a))
      {
        paramObject = (a)paramObject;
        bool1 = bool2;
        if (this.a.equals(((a)paramObject).a))
        {
          bool1 = bool2;
          if (this.b.equals(((a)paramObject).b)) {
            bool1 = true;
          }
        }
      }
      return bool1;
    }
    
    public final int hashCode()
    {
      return this.a.hashCode() * 31 + this.b.hashCode();
    }
    
    public final String toString()
    {
      String str1 = String.valueOf(String.valueOf(this.a));
      String str2 = String.valueOf(String.valueOf(this.b));
      return str1.length() + 10 + str2.length() + str1 + ".andThen(" + str2 + ")";
    }
  }
  
  static final class b<A, B>
    extends Converter<A, B>
    implements Serializable
  {
    private final Function<? super A, ? extends B> a;
    private final Function<? super B, ? extends A> b;
    
    private b(Function<? super A, ? extends B> paramFunction, Function<? super B, ? extends A> paramFunction1)
    {
      this.a = ((Function)Preconditions.checkNotNull(paramFunction));
      this.b = ((Function)Preconditions.checkNotNull(paramFunction1));
    }
    
    protected final A doBackward(B paramB)
    {
      return (A)this.b.apply(paramB);
    }
    
    protected final B doForward(A paramA)
    {
      return (B)this.a.apply(paramA);
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      boolean bool2 = false;
      boolean bool1 = bool2;
      if ((paramObject instanceof b))
      {
        paramObject = (b)paramObject;
        bool1 = bool2;
        if (this.a.equals(((b)paramObject).a))
        {
          bool1 = bool2;
          if (this.b.equals(((b)paramObject).b)) {
            bool1 = true;
          }
        }
      }
      return bool1;
    }
    
    public final int hashCode()
    {
      return this.a.hashCode() * 31 + this.b.hashCode();
    }
    
    public final String toString()
    {
      String str1 = String.valueOf(String.valueOf(this.a));
      String str2 = String.valueOf(String.valueOf(this.b));
      return str1.length() + 18 + str2.length() + "Converter.from(" + str1 + ", " + str2 + ")";
    }
  }
  
  static final class c<T>
    extends Converter<T, T>
    implements Serializable
  {
    static final c a = new c();
    private static final long serialVersionUID = 0L;
    
    private Object readResolve()
    {
      return a;
    }
    
    final <S> Converter<T, S> a(Converter<T, S> paramConverter)
    {
      return (Converter)Preconditions.checkNotNull(paramConverter, "otherConverter");
    }
    
    protected final T doBackward(T paramT)
    {
      return paramT;
    }
    
    protected final T doForward(T paramT)
    {
      return paramT;
    }
    
    public final String toString()
    {
      return "Converter.identity()";
    }
  }
  
  static final class d<A, B>
    extends Converter<B, A>
    implements Serializable
  {
    private static final long serialVersionUID = 0L;
    final Converter<A, B> a;
    
    d(Converter<A, B> paramConverter)
    {
      this.a = paramConverter;
    }
    
    @Nullable
    final A a(@Nullable B paramB)
    {
      return (A)this.a.b(paramB);
    }
    
    @Nullable
    final B b(@Nullable A paramA)
    {
      return (B)this.a.a(paramA);
    }
    
    protected final B doBackward(A paramA)
    {
      throw new AssertionError();
    }
    
    protected final A doForward(B paramB)
    {
      throw new AssertionError();
    }
    
    public final boolean equals(@Nullable Object paramObject)
    {
      if ((paramObject instanceof d))
      {
        paramObject = (d)paramObject;
        return this.a.equals(((d)paramObject).a);
      }
      return false;
    }
    
    public final int hashCode()
    {
      return this.a.hashCode() ^ 0xFFFFFFFF;
    }
    
    public final Converter<A, B> reverse()
    {
      return this.a;
    }
    
    public final String toString()
    {
      String str = String.valueOf(String.valueOf(this.a));
      return str.length() + 10 + str + ".reverse()";
    }
  }
}


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