package org.joda.time;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.Locale;
import java.util.Set;
import java.util.TimeZone;
import org.joda.convert.FromString;
import org.joda.convert.ToString;
import org.joda.time.base.BaseLocal;
import org.joda.time.chrono.ISOChronology;
import org.joda.time.convert.ConverterManager;
import org.joda.time.convert.PartialConverter;
import org.joda.time.field.AbstractReadableInstantFieldProperty;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;

public final class LocalDate
  extends BaseLocal
  implements Serializable, ReadablePartial
{
  private static final Set<DurationFieldType> a;
  private static final long serialVersionUID = -8775358157899L;
  private final long b;
  private final Chronology c;
  private volatile transient int d;
  
  static
  {
    HashSet localHashSet = new HashSet();
    a = localHashSet;
    localHashSet.add(DurationFieldType.days());
    a.add(DurationFieldType.weeks());
    a.add(DurationFieldType.months());
    a.add(DurationFieldType.weekyears());
    a.add(DurationFieldType.years());
    a.add(DurationFieldType.centuries());
    a.add(DurationFieldType.eras());
  }
  
  public LocalDate()
  {
    this(DateTimeUtils.currentTimeMillis(), ISOChronology.getInstance());
  }
  
  public LocalDate(int paramInt1, int paramInt2, int paramInt3)
  {
    this(paramInt1, paramInt2, paramInt3, ISOChronology.getInstanceUTC());
  }
  
  public LocalDate(int paramInt1, int paramInt2, int paramInt3, Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology).withUTC();
    long l = paramChronology.getDateTimeMillis(paramInt1, paramInt2, paramInt3, 0);
    this.c = paramChronology;
    this.b = l;
  }
  
  public LocalDate(long paramLong)
  {
    this(paramLong, ISOChronology.getInstance());
  }
  
  public LocalDate(long paramLong, Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology);
    paramLong = paramChronology.getZone().getMillisKeepLocal(DateTimeZone.UTC, paramLong);
    paramChronology = paramChronology.withUTC();
    this.b = paramChronology.dayOfMonth().roundFloor(paramLong);
    this.c = paramChronology;
  }
  
  public LocalDate(long paramLong, DateTimeZone paramDateTimeZone)
  {
    this(paramLong, ISOChronology.getInstance(paramDateTimeZone));
  }
  
  public LocalDate(Object paramObject)
  {
    this(paramObject, null);
  }
  
  public LocalDate(Object paramObject, Chronology paramChronology)
  {
    PartialConverter localPartialConverter = ConverterManager.getInstance().getPartialConverter(paramObject);
    paramChronology = DateTimeUtils.getChronology(localPartialConverter.getChronology(paramObject, paramChronology));
    this.c = paramChronology.withUTC();
    paramObject = localPartialConverter.getPartialValues(this, paramObject, paramChronology, ISODateTimeFormat.localDateParser());
    this.b = this.c.getDateTimeMillis(paramObject[0], paramObject[1], paramObject[2], 0);
  }
  
  public LocalDate(Object paramObject, DateTimeZone paramDateTimeZone)
  {
    PartialConverter localPartialConverter = ConverterManager.getInstance().getPartialConverter(paramObject);
    paramDateTimeZone = DateTimeUtils.getChronology(localPartialConverter.getChronology(paramObject, paramDateTimeZone));
    this.c = paramDateTimeZone.withUTC();
    paramObject = localPartialConverter.getPartialValues(this, paramObject, paramDateTimeZone, ISODateTimeFormat.localDateParser());
    this.b = this.c.getDateTimeMillis(paramObject[0], paramObject[1], paramObject[2], 0);
  }
  
  public LocalDate(Chronology paramChronology)
  {
    this(DateTimeUtils.currentTimeMillis(), paramChronology);
  }
  
  public LocalDate(DateTimeZone paramDateTimeZone)
  {
    this(DateTimeUtils.currentTimeMillis(), ISOChronology.getInstance(paramDateTimeZone));
  }
  
  public static LocalDate fromCalendarFields(Calendar paramCalendar)
  {
    if (paramCalendar == null) {
      throw new IllegalArgumentException("The calendar must not be null");
    }
    int j = paramCalendar.get(0);
    int i = paramCalendar.get(1);
    if (j == 1) {}
    for (;;)
    {
      return new LocalDate(i, paramCalendar.get(2) + 1, paramCalendar.get(5));
      i = 1 - i;
    }
  }
  
  public static LocalDate fromDateFields(Date paramDate)
  {
    if (paramDate == null) {
      throw new IllegalArgumentException("The date must not be null");
    }
    if (paramDate.getTime() < 0L)
    {
      GregorianCalendar localGregorianCalendar = new GregorianCalendar();
      localGregorianCalendar.setTime(paramDate);
      return fromCalendarFields(localGregorianCalendar);
    }
    return new LocalDate(paramDate.getYear() + 1900, paramDate.getMonth() + 1, paramDate.getDate());
  }
  
  public static LocalDate now()
  {
    return new LocalDate();
  }
  
  public static LocalDate now(Chronology paramChronology)
  {
    if (paramChronology == null) {
      throw new NullPointerException("Chronology must not be null");
    }
    return new LocalDate(paramChronology);
  }
  
  public static LocalDate now(DateTimeZone paramDateTimeZone)
  {
    if (paramDateTimeZone == null) {
      throw new NullPointerException("Zone must not be null");
    }
    return new LocalDate(paramDateTimeZone);
  }
  
  @FromString
  public static LocalDate parse(String paramString)
  {
    return parse(paramString, ISODateTimeFormat.localDateParser());
  }
  
  public static LocalDate parse(String paramString, DateTimeFormatter paramDateTimeFormatter)
  {
    return paramDateTimeFormatter.parseLocalDate(paramString);
  }
  
  private Object readResolve()
  {
    LocalDate localLocalDate;
    if (this.c == null) {
      localLocalDate = new LocalDate(this.b, ISOChronology.getInstanceUTC());
    }
    do
    {
      return localLocalDate;
      localLocalDate = this;
    } while (DateTimeZone.UTC.equals(this.c.getZone()));
    return new LocalDate(this.b, this.c.withUTC());
  }
  
  final LocalDate a(long paramLong)
  {
    paramLong = this.c.dayOfMonth().roundFloor(paramLong);
    if (paramLong == getLocalMillis()) {
      return this;
    }
    return new LocalDate(paramLong, getChronology());
  }
  
  public final Property centuryOfEra()
  {
    return new Property(this, getChronology().centuryOfEra());
  }
  
  public final int compareTo(ReadablePartial paramReadablePartial)
  {
    if (this == paramReadablePartial) {
      return 0;
    }
    if ((paramReadablePartial instanceof LocalDate))
    {
      LocalDate localLocalDate = (LocalDate)paramReadablePartial;
      if (this.c.equals(localLocalDate.c))
      {
        if (this.b < localLocalDate.b) {
          return -1;
        }
        if (this.b == localLocalDate.b) {
          return 0;
        }
        return 1;
      }
    }
    return super.compareTo(paramReadablePartial);
  }
  
  public final Property dayOfMonth()
  {
    return new Property(this, getChronology().dayOfMonth());
  }
  
  public final Property dayOfWeek()
  {
    return new Property(this, getChronology().dayOfWeek());
  }
  
  public final Property dayOfYear()
  {
    return new Property(this, getChronology().dayOfYear());
  }
  
  public final boolean equals(Object paramObject)
  {
    if (this == paramObject) {
      return true;
    }
    if ((paramObject instanceof LocalDate))
    {
      LocalDate localLocalDate = (LocalDate)paramObject;
      if (this.c.equals(localLocalDate.c)) {
        return this.b == localLocalDate.b;
      }
    }
    return super.equals(paramObject);
  }
  
  public final Property era()
  {
    return new Property(this, getChronology().era());
  }
  
  public final int get(DateTimeFieldType paramDateTimeFieldType)
  {
    if (paramDateTimeFieldType == null) {
      throw new IllegalArgumentException("The DateTimeFieldType must not be null");
    }
    if (!isSupported(paramDateTimeFieldType)) {
      throw new IllegalArgumentException("Field '" + paramDateTimeFieldType + "' is not supported");
    }
    return paramDateTimeFieldType.getField(getChronology()).get(getLocalMillis());
  }
  
  public final int getCenturyOfEra()
  {
    return getChronology().centuryOfEra().get(getLocalMillis());
  }
  
  public final Chronology getChronology()
  {
    return this.c;
  }
  
  public final int getDayOfMonth()
  {
    return getChronology().dayOfMonth().get(getLocalMillis());
  }
  
  public final int getDayOfWeek()
  {
    return getChronology().dayOfWeek().get(getLocalMillis());
  }
  
  public final int getDayOfYear()
  {
    return getChronology().dayOfYear().get(getLocalMillis());
  }
  
  public final int getEra()
  {
    return getChronology().era().get(getLocalMillis());
  }
  
  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();
  }
  
  protected final long getLocalMillis()
  {
    return this.b;
  }
  
  public final int getMonthOfYear()
  {
    return getChronology().monthOfYear().get(getLocalMillis());
  }
  
  public final int getValue(int paramInt)
  {
    switch (paramInt)
    {
    default: 
      throw new IndexOutOfBoundsException("Invalid index: " + paramInt);
    case 0: 
      return getChronology().year().get(getLocalMillis());
    case 1: 
      return getChronology().monthOfYear().get(getLocalMillis());
    }
    return getChronology().dayOfMonth().get(getLocalMillis());
  }
  
  public final int getWeekOfWeekyear()
  {
    return getChronology().weekOfWeekyear().get(getLocalMillis());
  }
  
  public final int getWeekyear()
  {
    return getChronology().weekyear().get(getLocalMillis());
  }
  
  public final int getYear()
  {
    return getChronology().year().get(getLocalMillis());
  }
  
  public final int getYearOfCentury()
  {
    return getChronology().yearOfCentury().get(getLocalMillis());
  }
  
  public final int getYearOfEra()
  {
    return getChronology().yearOfEra().get(getLocalMillis());
  }
  
  public final int hashCode()
  {
    int j = this.d;
    int i = j;
    if (j == 0)
    {
      i = super.hashCode();
      this.d = i;
    }
    return i;
  }
  
  public final boolean isSupported(DateTimeFieldType paramDateTimeFieldType)
  {
    if (paramDateTimeFieldType == null) {}
    DurationFieldType localDurationFieldType;
    do
    {
      return false;
      localDurationFieldType = paramDateTimeFieldType.getDurationType();
    } while ((!a.contains(localDurationFieldType)) && (localDurationFieldType.getField(getChronology()).getUnitMillis() < getChronology().days().getUnitMillis()));
    return paramDateTimeFieldType.getField(getChronology()).isSupported();
  }
  
  public final boolean isSupported(DurationFieldType paramDurationFieldType)
  {
    if (paramDurationFieldType == null) {}
    DurationField localDurationField;
    do
    {
      return false;
      localDurationField = paramDurationFieldType.getField(getChronology());
    } while ((!a.contains(paramDurationFieldType)) && (localDurationField.getUnitMillis() < getChronology().days().getUnitMillis()));
    return localDurationField.isSupported();
  }
  
  public final LocalDate minus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, -1);
  }
  
  public final LocalDate minusDays(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().days().subtract(getLocalMillis(), paramInt));
  }
  
  public final LocalDate minusMonths(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().months().subtract(getLocalMillis(), paramInt));
  }
  
  public final LocalDate minusWeeks(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().weeks().subtract(getLocalMillis(), paramInt));
  }
  
  public final LocalDate minusYears(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().years().subtract(getLocalMillis(), paramInt));
  }
  
  public final Property monthOfYear()
  {
    return new Property(this, getChronology().monthOfYear());
  }
  
  public final LocalDate plus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, 1);
  }
  
  public final LocalDate plusDays(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().days().add(getLocalMillis(), paramInt));
  }
  
  public final LocalDate plusMonths(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().months().add(getLocalMillis(), paramInt));
  }
  
  public final LocalDate plusWeeks(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().weeks().add(getLocalMillis(), paramInt));
  }
  
  public final LocalDate plusYears(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().years().add(getLocalMillis(), paramInt));
  }
  
  public final Property property(DateTimeFieldType paramDateTimeFieldType)
  {
    if (paramDateTimeFieldType == null) {
      throw new IllegalArgumentException("The DateTimeFieldType must not be null");
    }
    if (!isSupported(paramDateTimeFieldType)) {
      throw new IllegalArgumentException("Field '" + paramDateTimeFieldType + "' is not supported");
    }
    return new Property(this, paramDateTimeFieldType.getField(getChronology()));
  }
  
  public final int size()
  {
    return 3;
  }
  
  public final Date toDate()
  {
    int i = getDayOfMonth();
    Date localDate1 = new Date(getYear() - 1900, getMonthOfYear() - 1, i);
    Object localObject = fromDateFields(localDate1);
    if (((LocalDate)localObject).isBefore(this))
    {
      while (!((LocalDate)localObject).equals(this))
      {
        localDate1.setTime(localDate1.getTime() + 3600000L);
        localObject = fromDateFields(localDate1);
      }
      while (localDate1.getDate() == i) {
        localDate1.setTime(localDate1.getTime() - 1000L);
      }
      localDate1.setTime(localDate1.getTime() + 1000L);
      localObject = localDate1;
    }
    Date localDate2;
    do
    {
      return (Date)localObject;
      if (!((LocalDate)localObject).equals(this)) {
        break;
      }
      localDate2 = new Date(localDate1.getTime() - TimeZone.getDefault().getDSTSavings());
      localObject = localDate2;
    } while (localDate2.getDate() == i);
    return localDate1;
  }
  
  public final DateMidnight toDateMidnight()
  {
    return toDateMidnight(null);
  }
  
  public final DateMidnight toDateMidnight(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = DateTimeUtils.getZone(paramDateTimeZone);
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateMidnight(getYear(), getMonthOfYear(), getDayOfMonth(), paramDateTimeZone);
  }
  
  public final DateTime toDateTime(LocalTime paramLocalTime)
  {
    return toDateTime(paramLocalTime, null);
  }
  
  public final DateTime toDateTime(LocalTime paramLocalTime, DateTimeZone paramDateTimeZone)
  {
    if ((paramLocalTime != null) && (getChronology() != paramLocalTime.getChronology())) {
      throw new IllegalArgumentException("The chronology of the time does not match");
    }
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    long l2 = paramDateTimeZone.set(this, DateTimeUtils.currentTimeMillis());
    long l1 = l2;
    if (paramLocalTime != null) {
      l1 = paramDateTimeZone.set(paramLocalTime, l2);
    }
    return new DateTime(l1, paramDateTimeZone);
  }
  
  public final DateTime toDateTimeAtCurrentTime()
  {
    return toDateTimeAtCurrentTime(null);
  }
  
  public final DateTime toDateTimeAtCurrentTime(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = DateTimeUtils.getZone(paramDateTimeZone);
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateTime(paramDateTimeZone.set(this, DateTimeUtils.currentTimeMillis()), paramDateTimeZone);
  }
  
  @Deprecated
  public final DateTime toDateTimeAtMidnight()
  {
    return toDateTimeAtMidnight(null);
  }
  
  @Deprecated
  public final DateTime toDateTimeAtMidnight(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = DateTimeUtils.getZone(paramDateTimeZone);
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateTime(getYear(), getMonthOfYear(), getDayOfMonth(), 0, 0, 0, 0, paramDateTimeZone);
  }
  
  public final DateTime toDateTimeAtStartOfDay()
  {
    return toDateTimeAtStartOfDay(null);
  }
  
  public final DateTime toDateTimeAtStartOfDay(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = DateTimeUtils.getZone(paramDateTimeZone);
    Chronology localChronology = getChronology().withZone(paramDateTimeZone);
    long l = paramDateTimeZone.convertLocalToUTC(getLocalMillis() + 21600000L, false);
    return new DateTime(localChronology.dayOfMonth().roundFloor(l), localChronology);
  }
  
  public final Interval toInterval()
  {
    return toInterval(null);
  }
  
  public final Interval toInterval(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = DateTimeUtils.getZone(paramDateTimeZone);
    return new Interval(toDateTimeAtStartOfDay(paramDateTimeZone), plusDays(1).toDateTimeAtStartOfDay(paramDateTimeZone));
  }
  
  public final LocalDateTime toLocalDateTime(LocalTime paramLocalTime)
  {
    if (paramLocalTime == null) {
      throw new IllegalArgumentException("The time must not be null");
    }
    if (getChronology() != paramLocalTime.getChronology()) {
      throw new IllegalArgumentException("The chronology of the time does not match");
    }
    return new LocalDateTime(getLocalMillis() + paramLocalTime.getLocalMillis(), getChronology());
  }
  
  @ToString
  public final String toString()
  {
    return ISODateTimeFormat.date().print(this);
  }
  
  public final String toString(String paramString)
  {
    if (paramString == null) {
      return toString();
    }
    return DateTimeFormat.forPattern(paramString).print(this);
  }
  
  public final String toString(String paramString, Locale paramLocale)
    throws IllegalArgumentException
  {
    if (paramString == null) {
      return toString();
    }
    return DateTimeFormat.forPattern(paramString).withLocale(paramLocale).print(this);
  }
  
  public final Property weekOfWeekyear()
  {
    return new Property(this, getChronology().weekOfWeekyear());
  }
  
  public final Property weekyear()
  {
    return new Property(this, getChronology().weekyear());
  }
  
  public final LocalDate withCenturyOfEra(int paramInt)
  {
    return a(getChronology().centuryOfEra().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withDayOfMonth(int paramInt)
  {
    return a(getChronology().dayOfMonth().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withDayOfWeek(int paramInt)
  {
    return a(getChronology().dayOfWeek().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withDayOfYear(int paramInt)
  {
    return a(getChronology().dayOfYear().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withEra(int paramInt)
  {
    return a(getChronology().era().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withField(DateTimeFieldType paramDateTimeFieldType, int paramInt)
  {
    if (paramDateTimeFieldType == null) {
      throw new IllegalArgumentException("Field must not be null");
    }
    if (!isSupported(paramDateTimeFieldType)) {
      throw new IllegalArgumentException("Field '" + paramDateTimeFieldType + "' is not supported");
    }
    return a(paramDateTimeFieldType.getField(getChronology()).set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withFieldAdded(DurationFieldType paramDurationFieldType, int paramInt)
  {
    if (paramDurationFieldType == null) {
      throw new IllegalArgumentException("Field must not be null");
    }
    if (!isSupported(paramDurationFieldType)) {
      throw new IllegalArgumentException("Field '" + paramDurationFieldType + "' is not supported");
    }
    if (paramInt == 0) {
      return this;
    }
    return a(paramDurationFieldType.getField(getChronology()).add(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withFields(ReadablePartial paramReadablePartial)
  {
    if (paramReadablePartial == null) {
      return this;
    }
    return a(getChronology().set(paramReadablePartial, getLocalMillis()));
  }
  
  public final LocalDate withMonthOfYear(int paramInt)
  {
    return a(getChronology().monthOfYear().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withPeriodAdded(ReadablePeriod paramReadablePeriod, int paramInt)
  {
    if ((paramReadablePeriod == null) || (paramInt == 0)) {
      return this;
    }
    long l1 = getLocalMillis();
    Chronology localChronology = getChronology();
    int i = 0;
    while (i < paramReadablePeriod.size())
    {
      long l3 = FieldUtils.safeMultiply(paramReadablePeriod.getValue(i), paramInt);
      DurationFieldType localDurationFieldType = paramReadablePeriod.getFieldType(i);
      long l2 = l1;
      if (isSupported(localDurationFieldType)) {
        l2 = localDurationFieldType.getField(localChronology).add(l1, l3);
      }
      i += 1;
      l1 = l2;
    }
    return a(l1);
  }
  
  public final LocalDate withWeekOfWeekyear(int paramInt)
  {
    return a(getChronology().weekOfWeekyear().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withWeekyear(int paramInt)
  {
    return a(getChronology().weekyear().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withYear(int paramInt)
  {
    return a(getChronology().year().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withYearOfCentury(int paramInt)
  {
    return a(getChronology().yearOfCentury().set(getLocalMillis(), paramInt));
  }
  
  public final LocalDate withYearOfEra(int paramInt)
  {
    return a(getChronology().yearOfEra().set(getLocalMillis(), paramInt));
  }
  
  public final Property year()
  {
    return new Property(this, getChronology().year());
  }
  
  public final Property yearOfCentury()
  {
    return new Property(this, getChronology().yearOfCentury());
  }
  
  public final Property yearOfEra()
  {
    return new Property(this, getChronology().yearOfEra());
  }
  
  public static final class Property
    extends AbstractReadableInstantFieldProperty
  {
    private static final long serialVersionUID = -3193829732634L;
    private transient LocalDate a;
    private transient DateTimeField b;
    
    Property(LocalDate paramLocalDate, DateTimeField paramDateTimeField)
    {
      this.a = paramLocalDate;
      this.b = paramDateTimeField;
    }
    
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      this.a = ((LocalDate)paramObjectInputStream.readObject());
      this.b = ((DateTimeFieldType)paramObjectInputStream.readObject()).getField(this.a.getChronology());
    }
    
    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      paramObjectOutputStream.writeObject(this.a);
      paramObjectOutputStream.writeObject(this.b.getType());
    }
    
    public final LocalDate addToCopy(int paramInt)
    {
      return this.a.a(this.b.add(this.a.getLocalMillis(), paramInt));
    }
    
    public final LocalDate addWrapFieldToCopy(int paramInt)
    {
      return this.a.a(this.b.addWrapField(this.a.getLocalMillis(), paramInt));
    }
    
    protected final Chronology getChronology()
    {
      return this.a.getChronology();
    }
    
    public final DateTimeField getField()
    {
      return this.b;
    }
    
    public final LocalDate getLocalDate()
    {
      return this.a;
    }
    
    protected final long getMillis()
    {
      return this.a.getLocalMillis();
    }
    
    public final LocalDate roundCeilingCopy()
    {
      return this.a.a(this.b.roundCeiling(this.a.getLocalMillis()));
    }
    
    public final LocalDate roundFloorCopy()
    {
      return this.a.a(this.b.roundFloor(this.a.getLocalMillis()));
    }
    
    public final LocalDate roundHalfCeilingCopy()
    {
      return this.a.a(this.b.roundHalfCeiling(this.a.getLocalMillis()));
    }
    
    public final LocalDate roundHalfEvenCopy()
    {
      return this.a.a(this.b.roundHalfEven(this.a.getLocalMillis()));
    }
    
    public final LocalDate roundHalfFloorCopy()
    {
      return this.a.a(this.b.roundHalfFloor(this.a.getLocalMillis()));
    }
    
    public final LocalDate setCopy(int paramInt)
    {
      return this.a.a(this.b.set(this.a.getLocalMillis(), paramInt));
    }
    
    public final LocalDate setCopy(String paramString)
    {
      return setCopy(paramString, null);
    }
    
    public final LocalDate setCopy(String paramString, Locale paramLocale)
    {
      return this.a.a(this.b.set(this.a.getLocalMillis(), paramString, paramLocale));
    }
    
    public final LocalDate withMaximumValue()
    {
      return setCopy(getMaximumValue());
    }
    
    public final LocalDate withMinimumValue()
    {
      return setCopy(getMinimumValue());
    }
  }
}


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