package org.joda.time;

import java.io.Serializable;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import org.joda.time.base.BasePartial;
import org.joda.time.chrono.ISOChronology;
import org.joda.time.field.AbstractPartialFieldProperty;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;

@Deprecated
public final class YearMonthDay
  extends BasePartial
  implements Serializable, ReadablePartial
{
  public static final int DAY_OF_MONTH = 2;
  public static final int MONTH_OF_YEAR = 1;
  public static final int YEAR = 0;
  private static final DateTimeFieldType[] a = { DateTimeFieldType.year(), DateTimeFieldType.monthOfYear(), DateTimeFieldType.dayOfMonth() };
  private static final long serialVersionUID = 797544782896179L;
  
  public YearMonthDay() {}
  
  public YearMonthDay(int paramInt1, int paramInt2, int paramInt3)
  {
    this(paramInt1, paramInt2, paramInt3, null);
  }
  
  public YearMonthDay(int paramInt1, int paramInt2, int paramInt3, Chronology paramChronology)
  {
    super(new int[] { paramInt1, paramInt2, paramInt3 }, paramChronology);
  }
  
  public YearMonthDay(long paramLong)
  {
    super(paramLong);
  }
  
  public YearMonthDay(long paramLong, Chronology paramChronology)
  {
    super(paramLong, paramChronology);
  }
  
  public YearMonthDay(Object paramObject)
  {
    super(paramObject, null, ISODateTimeFormat.dateOptionalTimeParser());
  }
  
  public YearMonthDay(Object paramObject, Chronology paramChronology)
  {
    super(paramObject, DateTimeUtils.getChronology(paramChronology), ISODateTimeFormat.dateOptionalTimeParser());
  }
  
  public YearMonthDay(Chronology paramChronology)
  {
    super(paramChronology);
  }
  
  public YearMonthDay(DateTimeZone paramDateTimeZone)
  {
    super(ISOChronology.getInstance(paramDateTimeZone));
  }
  
  private YearMonthDay(YearMonthDay paramYearMonthDay, Chronology paramChronology)
  {
    super(paramYearMonthDay, paramChronology);
  }
  
  YearMonthDay(YearMonthDay paramYearMonthDay, int[] paramArrayOfInt)
  {
    super(paramYearMonthDay, paramArrayOfInt);
  }
  
  public static YearMonthDay fromCalendarFields(Calendar paramCalendar)
  {
    if (paramCalendar == null) {
      throw new IllegalArgumentException("The calendar must not be null");
    }
    return new YearMonthDay(paramCalendar.get(1), paramCalendar.get(2) + 1, paramCalendar.get(5));
  }
  
  public static YearMonthDay fromDateFields(Date paramDate)
  {
    if (paramDate == null) {
      throw new IllegalArgumentException("The date must not be null");
    }
    return new YearMonthDay(paramDate.getYear() + 1900, paramDate.getMonth() + 1, paramDate.getDate());
  }
  
  public final Property dayOfMonth()
  {
    return new Property(this, 2);
  }
  
  public final int getDayOfMonth()
  {
    return getValue(2);
  }
  
  protected final DateTimeField getField(int paramInt, Chronology paramChronology)
  {
    switch (paramInt)
    {
    default: 
      throw new IndexOutOfBoundsException("Invalid index: " + paramInt);
    case 0: 
      return paramChronology.year();
    case 1: 
      return paramChronology.monthOfYear();
    }
    return paramChronology.dayOfMonth();
  }
  
  public final DateTimeFieldType getFieldType(int paramInt)
  {
    return a[paramInt];
  }
  
  public final DateTimeFieldType[] getFieldTypes()
  {
    return (DateTimeFieldType[])a.clone();
  }
  
  public final int getMonthOfYear()
  {
    return getValue(1);
  }
  
  public final int getYear()
  {
    return getValue(0);
  }
  
  public final YearMonthDay minus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, -1);
  }
  
  public final YearMonthDay minusDays(int paramInt)
  {
    return withFieldAdded(DurationFieldType.days(), FieldUtils.safeNegate(paramInt));
  }
  
  public final YearMonthDay minusMonths(int paramInt)
  {
    return withFieldAdded(DurationFieldType.months(), FieldUtils.safeNegate(paramInt));
  }
  
  public final YearMonthDay minusYears(int paramInt)
  {
    return withFieldAdded(DurationFieldType.years(), FieldUtils.safeNegate(paramInt));
  }
  
  public final Property monthOfYear()
  {
    return new Property(this, 1);
  }
  
  public final YearMonthDay plus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, 1);
  }
  
  public final YearMonthDay plusDays(int paramInt)
  {
    return withFieldAdded(DurationFieldType.days(), paramInt);
  }
  
  public final YearMonthDay plusMonths(int paramInt)
  {
    return withFieldAdded(DurationFieldType.months(), paramInt);
  }
  
  public final YearMonthDay plusYears(int paramInt)
  {
    return withFieldAdded(DurationFieldType.years(), paramInt);
  }
  
  public final Property property(DateTimeFieldType paramDateTimeFieldType)
  {
    return new Property(this, indexOfSupported(paramDateTimeFieldType));
  }
  
  public final int size()
  {
    return 3;
  }
  
  public final DateMidnight toDateMidnight()
  {
    return toDateMidnight(null);
  }
  
  public final DateMidnight toDateMidnight(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateMidnight(getYear(), getMonthOfYear(), getDayOfMonth(), paramDateTimeZone);
  }
  
  public final DateTime toDateTime(TimeOfDay paramTimeOfDay)
  {
    return toDateTime(paramTimeOfDay, null);
  }
  
  public final DateTime toDateTime(TimeOfDay paramTimeOfDay, DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    long l2 = paramDateTimeZone.set(this, DateTimeUtils.currentTimeMillis());
    long l1 = l2;
    if (paramTimeOfDay != null) {
      l1 = paramDateTimeZone.set(paramTimeOfDay, l2);
    }
    return new DateTime(l1, paramDateTimeZone);
  }
  
  public final DateTime toDateTimeAtCurrentTime()
  {
    return toDateTimeAtCurrentTime(null);
  }
  
  public final DateTime toDateTimeAtCurrentTime(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateTime(paramDateTimeZone.set(this, DateTimeUtils.currentTimeMillis()), paramDateTimeZone);
  }
  
  public final DateTime toDateTimeAtMidnight()
  {
    return toDateTimeAtMidnight(null);
  }
  
  public final DateTime toDateTimeAtMidnight(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateTime(getYear(), getMonthOfYear(), getDayOfMonth(), 0, 0, 0, 0, paramDateTimeZone);
  }
  
  public final Interval toInterval()
  {
    return toInterval(null);
  }
  
  public final Interval toInterval(DateTimeZone paramDateTimeZone)
  {
    return toDateMidnight(DateTimeUtils.getZone(paramDateTimeZone)).toInterval();
  }
  
  public final LocalDate toLocalDate()
  {
    return new LocalDate(getYear(), getMonthOfYear(), getDayOfMonth(), getChronology());
  }
  
  public final String toString()
  {
    return ISODateTimeFormat.yearMonthDay().print(this);
  }
  
  public final YearMonthDay withChronologyRetainFields(Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology).withUTC();
    if (paramChronology == getChronology()) {
      return this;
    }
    YearMonthDay localYearMonthDay = new YearMonthDay(this, paramChronology);
    paramChronology.validate(localYearMonthDay, getValues());
    return localYearMonthDay;
  }
  
  public final YearMonthDay withDayOfMonth(int paramInt)
  {
    int[] arrayOfInt = getValues();
    return new YearMonthDay(this, getChronology().dayOfMonth().set(this, 2, arrayOfInt, paramInt));
  }
  
  public final YearMonthDay withField(DateTimeFieldType paramDateTimeFieldType, int paramInt)
  {
    int i = indexOfSupported(paramDateTimeFieldType);
    if (paramInt == getValue(i)) {
      return this;
    }
    paramDateTimeFieldType = getValues();
    return new YearMonthDay(this, getField(i).set(this, i, paramDateTimeFieldType, paramInt));
  }
  
  public final YearMonthDay withFieldAdded(DurationFieldType paramDurationFieldType, int paramInt)
  {
    int i = indexOfSupported(paramDurationFieldType);
    if (paramInt == 0) {
      return this;
    }
    paramDurationFieldType = getValues();
    return new YearMonthDay(this, getField(i).add(this, i, paramDurationFieldType, paramInt));
  }
  
  public final YearMonthDay withMonthOfYear(int paramInt)
  {
    int[] arrayOfInt = getValues();
    return new YearMonthDay(this, getChronology().monthOfYear().set(this, 1, arrayOfInt, paramInt));
  }
  
  public final YearMonthDay withPeriodAdded(ReadablePeriod paramReadablePeriod, int paramInt)
  {
    if ((paramReadablePeriod == null) || (paramInt == 0)) {
      return this;
    }
    Object localObject1 = getValues();
    int i = 0;
    while (i < paramReadablePeriod.size())
    {
      int j = indexOf(paramReadablePeriod.getFieldType(i));
      Object localObject2 = localObject1;
      if (j >= 0) {
        localObject2 = getField(j).add(this, j, (int[])localObject1, FieldUtils.safeMultiply(paramReadablePeriod.getValue(i), paramInt));
      }
      i += 1;
      localObject1 = localObject2;
    }
    return new YearMonthDay(this, (int[])localObject1);
  }
  
  public final YearMonthDay withYear(int paramInt)
  {
    int[] arrayOfInt = getValues();
    return new YearMonthDay(this, getChronology().year().set(this, 0, arrayOfInt, paramInt));
  }
  
  public final Property year()
  {
    return new Property(this, 0);
  }
  
  @Deprecated
  public static class Property
    extends AbstractPartialFieldProperty
    implements Serializable
  {
    private static final long serialVersionUID = 5727734012190224363L;
    private final YearMonthDay a;
    private final int b;
    
    Property(YearMonthDay paramYearMonthDay, int paramInt)
    {
      this.a = paramYearMonthDay;
      this.b = paramInt;
    }
    
    public YearMonthDay addToCopy(int paramInt)
    {
      int[] arrayOfInt = this.a.getValues();
      arrayOfInt = getField().add(this.a, this.b, arrayOfInt, paramInt);
      return new YearMonthDay(this.a, arrayOfInt);
    }
    
    public YearMonthDay addWrapFieldToCopy(int paramInt)
    {
      int[] arrayOfInt = this.a.getValues();
      arrayOfInt = getField().addWrapField(this.a, this.b, arrayOfInt, paramInt);
      return new YearMonthDay(this.a, arrayOfInt);
    }
    
    public int get()
    {
      return this.a.getValue(this.b);
    }
    
    public DateTimeField getField()
    {
      return this.a.getField(this.b);
    }
    
    protected ReadablePartial getReadablePartial()
    {
      return this.a;
    }
    
    public YearMonthDay getYearMonthDay()
    {
      return this.a;
    }
    
    public YearMonthDay setCopy(int paramInt)
    {
      int[] arrayOfInt = this.a.getValues();
      arrayOfInt = getField().set(this.a, this.b, arrayOfInt, paramInt);
      return new YearMonthDay(this.a, arrayOfInt);
    }
    
    public YearMonthDay setCopy(String paramString)
    {
      return setCopy(paramString, null);
    }
    
    public YearMonthDay setCopy(String paramString, Locale paramLocale)
    {
      int[] arrayOfInt = this.a.getValues();
      paramString = getField().set(this.a, this.b, arrayOfInt, paramString, paramLocale);
      return new YearMonthDay(this.a, paramString);
    }
    
    public YearMonthDay withMaximumValue()
    {
      return setCopy(getMaximumValue());
    }
    
    public YearMonthDay withMinimumValue()
    {
      return setCopy(getMinimumValue());
    }
  }
}


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