package org.apache.commons.lang3.builder;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class DiffBuilder
  implements Builder<DiffResult>
{
  private final List<Diff<?>> a;
  private final boolean b;
  private final Object c;
  private final Object d;
  private final ToStringStyle e;
  
  public DiffBuilder(Object paramObject1, Object paramObject2, ToStringStyle paramToStringStyle)
  {
    this(paramObject1, paramObject2, paramToStringStyle, true);
  }
  
  public DiffBuilder(Object paramObject1, Object paramObject2, ToStringStyle paramToStringStyle, boolean paramBoolean)
  {
    if (paramObject1 == null) {
      throw new IllegalArgumentException("lhs cannot be null");
    }
    if (paramObject2 == null) {
      throw new IllegalArgumentException("rhs cannot be null");
    }
    this.a = new ArrayList();
    this.c = paramObject1;
    this.d = paramObject2;
    this.e = paramToStringStyle;
    if ((paramBoolean) && ((paramObject1 == paramObject2) || (paramObject1.equals(paramObject2)))) {}
    for (paramBoolean = true;; paramBoolean = false)
    {
      this.b = paramBoolean;
      return;
    }
  }
  
  public DiffBuilder append(String paramString, final byte paramByte1, final byte paramByte2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (paramByte1 == paramByte2) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final char paramChar1, final char paramChar2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (paramChar1 == paramChar2) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final double paramDouble1, double paramDouble2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Double.doubleToLongBits(paramDouble1) == Double.doubleToLongBits(paramDouble2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final float paramFloat1, final float paramFloat2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Float.floatToIntBits(paramFloat1) == Float.floatToIntBits(paramFloat2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final int paramInt1, final int paramInt2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (paramInt1 == paramInt2) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final long paramLong1, long paramLong2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (paramLong1 == paramLong2) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final Object paramObject1, final Object paramObject2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    do
    {
      do
      {
        return this;
      } while (paramObject1 == paramObject2);
      Object localObject;
      if (paramObject1 != null) {
        localObject = paramObject1;
      }
      while (localObject.getClass().isArray()) {
        if ((localObject instanceof boolean[]))
        {
          return append(paramString, (boolean[])paramObject1, (boolean[])paramObject2);
          localObject = paramObject2;
        }
        else
        {
          if ((localObject instanceof byte[])) {
            return append(paramString, (byte[])paramObject1, (byte[])paramObject2);
          }
          if ((localObject instanceof char[])) {
            return append(paramString, (char[])paramObject1, (char[])paramObject2);
          }
          if ((localObject instanceof double[])) {
            return append(paramString, (double[])paramObject1, (double[])paramObject2);
          }
          if ((localObject instanceof float[])) {
            return append(paramString, (float[])paramObject1, (float[])paramObject2);
          }
          if ((localObject instanceof int[])) {
            return append(paramString, (int[])paramObject1, (int[])paramObject2);
          }
          if ((localObject instanceof long[])) {
            return append(paramString, (long[])paramObject1, (long[])paramObject2);
          }
          if ((localObject instanceof short[])) {
            return append(paramString, (short[])paramObject1, (short[])paramObject2);
          }
          return append(paramString, (Object[])paramObject1, (Object[])paramObject2);
        }
      }
    } while ((paramObject1 != null) && (paramObject1.equals(paramObject2)));
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
      
      public final Object getLeft()
      {
        return paramObject1;
      }
      
      public final Object getRight()
      {
        return paramObject2;
      }
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, DiffResult paramDiffResult)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (paramDiffResult == null) {
      throw new IllegalArgumentException("Diff result cannot be null");
    }
    if (this.b) {}
    for (;;)
    {
      return this;
      paramDiffResult = paramDiffResult.getDiffs().iterator();
      while (paramDiffResult.hasNext())
      {
        Diff localDiff = (Diff)paramDiffResult.next();
        append(paramString + "." + localDiff.getFieldName(), localDiff.getLeft(), localDiff.getRight());
      }
    }
  }
  
  public DiffBuilder append(String paramString, final short paramShort1, final short paramShort2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (paramShort1 == paramShort2) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final boolean paramBoolean1, final boolean paramBoolean2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (paramBoolean1 == paramBoolean2) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final byte[] paramArrayOfByte1, final byte[] paramArrayOfByte2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfByte1, paramArrayOfByte2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final char[] paramArrayOfChar1, final char[] paramArrayOfChar2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfChar1, paramArrayOfChar2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final double[] paramArrayOfDouble1, final double[] paramArrayOfDouble2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfDouble1, paramArrayOfDouble2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final float[] paramArrayOfFloat1, final float[] paramArrayOfFloat2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfFloat1, paramArrayOfFloat2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final int[] paramArrayOfInt1, final int[] paramArrayOfInt2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfInt1, paramArrayOfInt2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final long[] paramArrayOfLong1, final long[] paramArrayOfLong2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfLong1, paramArrayOfLong2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final Object[] paramArrayOfObject1, final Object[] paramArrayOfObject2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfObject1, paramArrayOfObject2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final short[] paramArrayOfShort1, final short[] paramArrayOfShort2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfShort1, paramArrayOfShort2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffBuilder append(String paramString, final boolean[] paramArrayOfBoolean1, final boolean[] paramArrayOfBoolean2)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Field name cannot be null");
    }
    if (this.b) {}
    while (Arrays.equals(paramArrayOfBoolean1, paramArrayOfBoolean2)) {
      return this;
    }
    this.a.add(new Diff(paramString)
    {
      private static final long serialVersionUID = 1L;
    });
    return this;
  }
  
  public DiffResult build()
  {
    return new DiffResult(this.c, this.d, this.a, this.e);
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/org/apache/commons/lang3/builder/DiffBuilder.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */