package org.joda.time.format;

import java.io.IOException;
import java.io.Writer;
import java.util.Locale;
import org.joda.time.MutablePeriod;
import org.joda.time.Period;
import org.joda.time.PeriodType;
import org.joda.time.ReadWritablePeriod;
import org.joda.time.ReadablePeriod;

public class PeriodFormatter
{
  private final PeriodPrinter a;
  private final PeriodParser b;
  private final Locale c;
  private final PeriodType d;
  
  public PeriodFormatter(PeriodPrinter paramPeriodPrinter, PeriodParser paramPeriodParser)
  {
    this.a = paramPeriodPrinter;
    this.b = paramPeriodParser;
    this.c = null;
    this.d = null;
  }
  
  private PeriodFormatter(PeriodPrinter paramPeriodPrinter, PeriodParser paramPeriodParser, Locale paramLocale, PeriodType paramPeriodType)
  {
    this.a = paramPeriodPrinter;
    this.b = paramPeriodParser;
    this.c = paramLocale;
    this.d = paramPeriodType;
  }
  
  private void a()
  {
    if (this.a == null) {
      throw new UnsupportedOperationException("Printing not supported");
    }
  }
  
  private static void a(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod == null) {
      throw new IllegalArgumentException("Period must not be null");
    }
  }
  
  private void b()
  {
    if (this.b == null) {
      throw new UnsupportedOperationException("Parsing not supported");
    }
  }
  
  public Locale getLocale()
  {
    return this.c;
  }
  
  public PeriodType getParseType()
  {
    return this.d;
  }
  
  public PeriodParser getParser()
  {
    return this.b;
  }
  
  public PeriodPrinter getPrinter()
  {
    return this.a;
  }
  
  public boolean isParser()
  {
    return this.b != null;
  }
  
  public boolean isPrinter()
  {
    return this.a != null;
  }
  
  public int parseInto(ReadWritablePeriod paramReadWritablePeriod, String paramString, int paramInt)
  {
    b();
    a(paramReadWritablePeriod);
    return getParser().parseInto(paramReadWritablePeriod, paramString, paramInt, this.c);
  }
  
  public MutablePeriod parseMutablePeriod(String paramString)
  {
    b();
    MutablePeriod localMutablePeriod = new MutablePeriod(0L, this.d);
    int j = getParser().parseInto(localMutablePeriod, paramString, 0, this.c);
    int i;
    if (j >= 0)
    {
      i = j;
      if (j >= paramString.length()) {
        return localMutablePeriod;
      }
    }
    else
    {
      i = j ^ 0xFFFFFFFF;
    }
    throw new IllegalArgumentException(FormatUtils.b(paramString, i));
  }
  
  public Period parsePeriod(String paramString)
  {
    b();
    return parseMutablePeriod(paramString).toPeriod();
  }
  
  public String print(ReadablePeriod paramReadablePeriod)
  {
    a();
    a(paramReadablePeriod);
    PeriodPrinter localPeriodPrinter = getPrinter();
    StringBuffer localStringBuffer = new StringBuffer(localPeriodPrinter.calculatePrintedLength(paramReadablePeriod, this.c));
    localPeriodPrinter.printTo(localStringBuffer, paramReadablePeriod, this.c);
    return localStringBuffer.toString();
  }
  
  public void printTo(Writer paramWriter, ReadablePeriod paramReadablePeriod)
    throws IOException
  {
    a();
    a(paramReadablePeriod);
    getPrinter().printTo(paramWriter, paramReadablePeriod, this.c);
  }
  
  public void printTo(StringBuffer paramStringBuffer, ReadablePeriod paramReadablePeriod)
  {
    a();
    a(paramReadablePeriod);
    getPrinter().printTo(paramStringBuffer, paramReadablePeriod, this.c);
  }
  
  public PeriodFormatter withLocale(Locale paramLocale)
  {
    if ((paramLocale == getLocale()) || ((paramLocale != null) && (paramLocale.equals(getLocale())))) {
      return this;
    }
    return new PeriodFormatter(this.a, this.b, paramLocale, this.d);
  }
  
  public PeriodFormatter withParseType(PeriodType paramPeriodType)
  {
    if (paramPeriodType == this.d) {
      return this;
    }
    return new PeriodFormatter(this.a, this.b, this.c, paramPeriodType);
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/org/joda/time/format/PeriodFormatter.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */