package org.joda.time;

import java.io.Serializable;
import org.joda.convert.FromString;
import org.joda.time.base.BasePeriod;
import org.joda.time.chrono.ISOChronology;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.ISOPeriodFormat;
import org.joda.time.format.PeriodFormatter;

public final class Period
  extends BasePeriod
  implements Serializable, ReadablePeriod
{
  public static final Period ZERO = new Period();
  private static final long serialVersionUID = 741052353876488155L;
  
  public Period()
  {
    super(0L, null, null);
  }
  
  public Period(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    super(0, 0, 0, 0, paramInt1, paramInt2, paramInt3, paramInt4, PeriodType.standard());
  }
  
  public Period(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, int paramInt7, int paramInt8)
  {
    super(paramInt1, paramInt2, paramInt3, paramInt4, paramInt5, paramInt6, paramInt7, paramInt8, PeriodType.standard());
  }
  
  public Period(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, int paramInt7, int paramInt8, PeriodType paramPeriodType)
  {
    super(paramInt1, paramInt2, paramInt3, paramInt4, paramInt5, paramInt6, paramInt7, paramInt8, paramPeriodType);
  }
  
  public Period(long paramLong)
  {
    super(paramLong);
  }
  
  public Period(long paramLong1, long paramLong2)
  {
    super(paramLong1, paramLong2, null, null);
  }
  
  public Period(long paramLong1, long paramLong2, Chronology paramChronology)
  {
    super(paramLong1, paramLong2, null, paramChronology);
  }
  
  public Period(long paramLong1, long paramLong2, PeriodType paramPeriodType)
  {
    super(paramLong1, paramLong2, paramPeriodType, null);
  }
  
  public Period(long paramLong1, long paramLong2, PeriodType paramPeriodType, Chronology paramChronology)
  {
    super(paramLong1, paramLong2, paramPeriodType, paramChronology);
  }
  
  public Period(long paramLong, Chronology paramChronology)
  {
    super(paramLong, null, paramChronology);
  }
  
  public Period(long paramLong, PeriodType paramPeriodType)
  {
    super(paramLong, paramPeriodType, null);
  }
  
  public Period(long paramLong, PeriodType paramPeriodType, Chronology paramChronology)
  {
    super(paramLong, paramPeriodType, paramChronology);
  }
  
  public Period(Object paramObject)
  {
    super(paramObject, null, null);
  }
  
  public Period(Object paramObject, Chronology paramChronology)
  {
    super(paramObject, null, paramChronology);
  }
  
  public Period(Object paramObject, PeriodType paramPeriodType)
  {
    super(paramObject, paramPeriodType, null);
  }
  
  public Period(Object paramObject, PeriodType paramPeriodType, Chronology paramChronology)
  {
    super(paramObject, paramPeriodType, paramChronology);
  }
  
  public Period(ReadableDuration paramReadableDuration, ReadableInstant paramReadableInstant)
  {
    super(paramReadableDuration, paramReadableInstant, null);
  }
  
  public Period(ReadableDuration paramReadableDuration, ReadableInstant paramReadableInstant, PeriodType paramPeriodType)
  {
    super(paramReadableDuration, paramReadableInstant, paramPeriodType);
  }
  
  public Period(ReadableInstant paramReadableInstant, ReadableDuration paramReadableDuration)
  {
    super(paramReadableInstant, paramReadableDuration, null);
  }
  
  public Period(ReadableInstant paramReadableInstant, ReadableDuration paramReadableDuration, PeriodType paramPeriodType)
  {
    super(paramReadableInstant, paramReadableDuration, paramPeriodType);
  }
  
  public Period(ReadableInstant paramReadableInstant1, ReadableInstant paramReadableInstant2)
  {
    super(paramReadableInstant1, paramReadableInstant2, null);
  }
  
  public Period(ReadableInstant paramReadableInstant1, ReadableInstant paramReadableInstant2, PeriodType paramPeriodType)
  {
    super(paramReadableInstant1, paramReadableInstant2, paramPeriodType);
  }
  
  public Period(ReadablePartial paramReadablePartial1, ReadablePartial paramReadablePartial2)
  {
    super(paramReadablePartial1, paramReadablePartial2, null);
  }
  
  public Period(ReadablePartial paramReadablePartial1, ReadablePartial paramReadablePartial2, PeriodType paramPeriodType)
  {
    super(paramReadablePartial1, paramReadablePartial2, paramPeriodType);
  }
  
  private Period(int[] paramArrayOfInt, PeriodType paramPeriodType)
  {
    super(paramArrayOfInt, paramPeriodType);
  }
  
  private void a(String paramString)
  {
    if (getMonths() != 0) {
      throw new UnsupportedOperationException("Cannot convert to " + paramString + " as this period contains months and months vary in length");
    }
    if (getYears() != 0) {
      throw new UnsupportedOperationException("Cannot convert to " + paramString + " as this period contains years and years vary in length");
    }
  }
  
  public static Period days(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, 0, 0, paramInt, 0, 0, 0, 0 }, localPeriodType);
  }
  
  public static Period fieldDifference(ReadablePartial paramReadablePartial1, ReadablePartial paramReadablePartial2)
  {
    if ((paramReadablePartial1 == null) || (paramReadablePartial2 == null)) {
      throw new IllegalArgumentException("ReadablePartial objects must not be null");
    }
    if (paramReadablePartial1.size() != paramReadablePartial2.size()) {
      throw new IllegalArgumentException("ReadablePartial objects must have the same set of fields");
    }
    DurationFieldType[] arrayOfDurationFieldType = new DurationFieldType[paramReadablePartial1.size()];
    int[] arrayOfInt = new int[paramReadablePartial1.size()];
    int i = 0;
    int j = paramReadablePartial1.size();
    while (i < j)
    {
      if (paramReadablePartial1.getFieldType(i) != paramReadablePartial2.getFieldType(i)) {
        throw new IllegalArgumentException("ReadablePartial objects must have the same set of fields");
      }
      arrayOfDurationFieldType[i] = paramReadablePartial1.getFieldType(i).getDurationType();
      if ((i > 0) && (arrayOfDurationFieldType[(i - 1)] == arrayOfDurationFieldType[i])) {
        throw new IllegalArgumentException("ReadablePartial objects must not have overlapping fields");
      }
      arrayOfInt[i] = (paramReadablePartial2.getValue(i) - paramReadablePartial1.getValue(i));
      i += 1;
    }
    return new Period(arrayOfInt, PeriodType.forFields(arrayOfDurationFieldType));
  }
  
  public static Period hours(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, 0, 0, 0, paramInt, 0, 0, 0 }, localPeriodType);
  }
  
  public static Period millis(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, 0, 0, 0, 0, 0, 0, paramInt }, localPeriodType);
  }
  
  public static Period minutes(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, 0, 0, 0, 0, paramInt, 0, 0 }, localPeriodType);
  }
  
  public static Period months(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, paramInt, 0, 0, 0, 0, 0, 0 }, localPeriodType);
  }
  
  @FromString
  public static Period parse(String paramString)
  {
    return parse(paramString, ISOPeriodFormat.standard());
  }
  
  public static Period parse(String paramString, PeriodFormatter paramPeriodFormatter)
  {
    return paramPeriodFormatter.parsePeriod(paramString);
  }
  
  public static Period seconds(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, 0, 0, 0, 0, 0, paramInt, 0 }, localPeriodType);
  }
  
  public static Period weeks(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { 0, 0, paramInt, 0, 0, 0, 0, 0 }, localPeriodType);
  }
  
  public static Period years(int paramInt)
  {
    PeriodType localPeriodType = PeriodType.standard();
    return new Period(new int[] { paramInt, 0, 0, 0, 0, 0, 0, 0, 0 }, localPeriodType);
  }
  
  public final int getDays()
  {
    return getPeriodType().a(this, PeriodType.d);
  }
  
  public final int getHours()
  {
    return getPeriodType().a(this, PeriodType.e);
  }
  
  public final int getMillis()
  {
    return getPeriodType().a(this, PeriodType.h);
  }
  
  public final int getMinutes()
  {
    return getPeriodType().a(this, PeriodType.f);
  }
  
  public final int getMonths()
  {
    return getPeriodType().a(this, PeriodType.b);
  }
  
  public final int getSeconds()
  {
    return getPeriodType().a(this, PeriodType.g);
  }
  
  public final int getWeeks()
  {
    return getPeriodType().a(this, PeriodType.c);
  }
  
  public final int getYears()
  {
    return getPeriodType().a(this, PeriodType.a);
  }
  
  public final Period minus(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod == null) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.a, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.d));
    getPeriodType().b(PeriodType.b, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.e));
    getPeriodType().b(PeriodType.c, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.f));
    getPeriodType().b(PeriodType.d, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.g));
    getPeriodType().b(PeriodType.e, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.i));
    getPeriodType().b(PeriodType.f, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.j));
    getPeriodType().b(PeriodType.g, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.k));
    getPeriodType().b(PeriodType.h, arrayOfInt, -paramReadablePeriod.get(DurationFieldType.l));
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period minusDays(int paramInt)
  {
    return plusDays(-paramInt);
  }
  
  public final Period minusHours(int paramInt)
  {
    return plusHours(-paramInt);
  }
  
  public final Period minusMillis(int paramInt)
  {
    return plusMillis(-paramInt);
  }
  
  public final Period minusMinutes(int paramInt)
  {
    return plusMinutes(-paramInt);
  }
  
  public final Period minusMonths(int paramInt)
  {
    return plusMonths(-paramInt);
  }
  
  public final Period minusSeconds(int paramInt)
  {
    return plusSeconds(-paramInt);
  }
  
  public final Period minusWeeks(int paramInt)
  {
    return plusWeeks(-paramInt);
  }
  
  public final Period minusYears(int paramInt)
  {
    return plusYears(-paramInt);
  }
  
  public final Period multipliedBy(int paramInt)
  {
    if ((this == ZERO) || (paramInt == 1)) {
      return this;
    }
    int[] arrayOfInt = getValues();
    int i = 0;
    while (i < arrayOfInt.length)
    {
      arrayOfInt[i] = FieldUtils.safeMultiply(arrayOfInt[i], paramInt);
      i += 1;
    }
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period negated()
  {
    return multipliedBy(-1);
  }
  
  public final Period normalizedStandard()
  {
    return normalizedStandard(PeriodType.standard());
  }
  
  public final Period normalizedStandard(PeriodType paramPeriodType)
  {
    long l1 = getMillis();
    long l2 = getSeconds();
    long l3 = getMinutes();
    long l4 = getHours();
    long l5 = getDays();
    Period localPeriod = new Period(getWeeks() * 604800000L + (l1 + l2 * 1000L + l3 * 60000L + l4 * 3600000L + l5 * 86400000L), DateTimeUtils.getPeriodType(paramPeriodType), ISOChronology.getInstanceUTC());
    int j = getYears();
    int i = getMonths();
    Object localObject;
    if (j == 0)
    {
      localObject = localPeriod;
      if (i == 0) {}
    }
    else
    {
      j = FieldUtils.safeAdd(j, i / 12);
      i %= 12;
      paramPeriodType = localPeriod;
      if (j != 0) {
        paramPeriodType = localPeriod.withYears(j);
      }
      localObject = paramPeriodType;
      if (i != 0) {
        localObject = paramPeriodType.withMonths(i);
      }
    }
    return (Period)localObject;
  }
  
  public final Period plus(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod == null) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.a, arrayOfInt, paramReadablePeriod.get(DurationFieldType.d));
    getPeriodType().b(PeriodType.b, arrayOfInt, paramReadablePeriod.get(DurationFieldType.e));
    getPeriodType().b(PeriodType.c, arrayOfInt, paramReadablePeriod.get(DurationFieldType.f));
    getPeriodType().b(PeriodType.d, arrayOfInt, paramReadablePeriod.get(DurationFieldType.g));
    getPeriodType().b(PeriodType.e, arrayOfInt, paramReadablePeriod.get(DurationFieldType.i));
    getPeriodType().b(PeriodType.f, arrayOfInt, paramReadablePeriod.get(DurationFieldType.j));
    getPeriodType().b(PeriodType.g, arrayOfInt, paramReadablePeriod.get(DurationFieldType.k));
    getPeriodType().b(PeriodType.h, arrayOfInt, paramReadablePeriod.get(DurationFieldType.l));
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusDays(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.d, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusHours(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.e, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusMillis(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.h, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusMinutes(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.f, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusMonths(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.b, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusSeconds(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.g, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusWeeks(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.c, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period plusYears(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    getPeriodType().b(PeriodType.a, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period toPeriod()
  {
    return this;
  }
  
  public final Days toStandardDays()
  {
    a("Days");
    return Days.days(FieldUtils.safeToInt(FieldUtils.safeAdd(FieldUtils.safeAdd((getMillis() + getSeconds() * 1000L + getMinutes() * 60000L + getHours() * 3600000L) / 86400000L, getDays()), getWeeks() * 7L)));
  }
  
  public final Duration toStandardDuration()
  {
    a("Duration");
    return new Duration(getMillis() + getSeconds() * 1000L + getMinutes() * 60000L + getHours() * 3600000L + getDays() * 86400000L + getWeeks() * 604800000L);
  }
  
  public final Hours toStandardHours()
  {
    a("Hours");
    return Hours.hours(FieldUtils.safeToInt(FieldUtils.safeAdd(FieldUtils.safeAdd(FieldUtils.safeAdd((getMillis() + getSeconds() * 1000L + getMinutes() * 60000L) / 3600000L, getHours()), getDays() * 24L), getWeeks() * 168L)));
  }
  
  public final Minutes toStandardMinutes()
  {
    a("Minutes");
    return Minutes.minutes(FieldUtils.safeToInt(FieldUtils.safeAdd(FieldUtils.safeAdd(FieldUtils.safeAdd(FieldUtils.safeAdd((getMillis() + getSeconds() * 1000L) / 60000L, getMinutes()), getHours() * 60L), getDays() * 1440L), getWeeks() * 10080L)));
  }
  
  public final Seconds toStandardSeconds()
  {
    a("Seconds");
    return Seconds.seconds(FieldUtils.safeToInt(FieldUtils.safeAdd(FieldUtils.safeAdd(FieldUtils.safeAdd(FieldUtils.safeAdd(FieldUtils.safeAdd(getMillis() / 1000, getSeconds()), getMinutes() * 60L), getHours() * 3600L), getDays() * 86400L), getWeeks() * 604800L)));
  }
  
  public final Weeks toStandardWeeks()
  {
    a("Weeks");
    long l1 = getMillis();
    long l2 = getSeconds();
    long l3 = getMinutes();
    long l4 = getHours();
    long l5 = getDays();
    long l6 = getWeeks();
    return Weeks.weeks(FieldUtils.safeToInt((l1 + l2 * 1000L + l3 * 60000L + l4 * 3600000L + l5 * 86400000L) / 604800000L + l6));
  }
  
  public final Period withDays(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.d, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withField(DurationFieldType paramDurationFieldType, int paramInt)
  {
    if (paramDurationFieldType == null) {
      throw new IllegalArgumentException("Field must not be null");
    }
    int[] arrayOfInt = getValues();
    super.setFieldInto(arrayOfInt, paramDurationFieldType, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withFieldAdded(DurationFieldType paramDurationFieldType, int paramInt)
  {
    if (paramDurationFieldType == null) {
      throw new IllegalArgumentException("Field must not be null");
    }
    if (paramInt == 0) {
      return this;
    }
    int[] arrayOfInt = getValues();
    super.addFieldInto(arrayOfInt, paramDurationFieldType, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withFields(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod == null) {
      return this;
    }
    return new Period(super.mergePeriodInto(getValues(), paramReadablePeriod), getPeriodType());
  }
  
  public final Period withHours(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.e, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withMillis(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.h, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withMinutes(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.f, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withMonths(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.b, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withPeriodType(PeriodType paramPeriodType)
  {
    paramPeriodType = DateTimeUtils.getPeriodType(paramPeriodType);
    if (paramPeriodType.equals(getPeriodType())) {
      return this;
    }
    return new Period(this, paramPeriodType);
  }
  
  public final Period withSeconds(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.g, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withWeeks(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.c, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
  
  public final Period withYears(int paramInt)
  {
    int[] arrayOfInt = getValues();
    getPeriodType().a(PeriodType.a, arrayOfInt, paramInt);
    return new Period(arrayOfInt, getPeriodType());
  }
}


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