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.HashSet;
import java.util.Locale;
import java.util.Set;
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.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;

public final class LocalTime
  extends BaseLocal
  implements Serializable, ReadablePartial
{
  public static final LocalTime MIDNIGHT = new LocalTime(0, 0, 0, 0);
  private static final Set<DurationFieldType> a;
  private static final long serialVersionUID = -12873158713873L;
  private final long b;
  private final Chronology c;
  
  static
  {
    HashSet localHashSet = new HashSet();
    a = localHashSet;
    localHashSet.add(DurationFieldType.millis());
    a.add(DurationFieldType.seconds());
    a.add(DurationFieldType.minutes());
    a.add(DurationFieldType.hours());
  }
  
  public LocalTime()
  {
    this(DateTimeUtils.currentTimeMillis(), ISOChronology.getInstance());
  }
  
  public LocalTime(int paramInt1, int paramInt2)
  {
    this(paramInt1, paramInt2, 0, 0, ISOChronology.getInstanceUTC());
  }
  
  public LocalTime(int paramInt1, int paramInt2, int paramInt3)
  {
    this(paramInt1, paramInt2, paramInt3, 0, ISOChronology.getInstanceUTC());
  }
  
  public LocalTime(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    this(paramInt1, paramInt2, paramInt3, paramInt4, ISOChronology.getInstanceUTC());
  }
  
  public LocalTime(int paramInt1, int paramInt2, int paramInt3, int paramInt4, Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology).withUTC();
    long l = paramChronology.getDateTimeMillis(0L, paramInt1, paramInt2, paramInt3, paramInt4);
    this.c = paramChronology;
    this.b = l;
  }
  
  public LocalTime(long paramLong)
  {
    this(paramLong, ISOChronology.getInstance());
  }
  
  public LocalTime(long paramLong, Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology);
    paramLong = paramChronology.getZone().getMillisKeepLocal(DateTimeZone.UTC, paramLong);
    paramChronology = paramChronology.withUTC();
    this.b = paramChronology.millisOfDay().get(paramLong);
    this.c = paramChronology;
  }
  
  public LocalTime(long paramLong, DateTimeZone paramDateTimeZone)
  {
    this(paramLong, ISOChronology.getInstance(paramDateTimeZone));
  }
  
  public LocalTime(Object paramObject)
  {
    this(paramObject, null);
  }
  
  public LocalTime(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.localTimeParser());
    this.b = this.c.getDateTimeMillis(0L, paramObject[0], paramObject[1], paramObject[2], paramObject[3]);
  }
  
  public LocalTime(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.localTimeParser());
    this.b = this.c.getDateTimeMillis(0L, paramObject[0], paramObject[1], paramObject[2], paramObject[3]);
  }
  
  public LocalTime(Chronology paramChronology)
  {
    this(DateTimeUtils.currentTimeMillis(), paramChronology);
  }
  
  public LocalTime(DateTimeZone paramDateTimeZone)
  {
    this(DateTimeUtils.currentTimeMillis(), ISOChronology.getInstance(paramDateTimeZone));
  }
  
  public static LocalTime fromCalendarFields(Calendar paramCalendar)
  {
    if (paramCalendar == null) {
      throw new IllegalArgumentException("The calendar must not be null");
    }
    return new LocalTime(paramCalendar.get(11), paramCalendar.get(12), paramCalendar.get(13), paramCalendar.get(14));
  }
  
  public static LocalTime fromDateFields(Date paramDate)
  {
    if (paramDate == null) {
      throw new IllegalArgumentException("The date must not be null");
    }
    return new LocalTime(paramDate.getHours(), paramDate.getMinutes(), paramDate.getSeconds(), ((int)(paramDate.getTime() % 1000L) + 1000) % 1000);
  }
  
  public static LocalTime fromMillisOfDay(long paramLong)
  {
    return fromMillisOfDay(paramLong, null);
  }
  
  public static LocalTime fromMillisOfDay(long paramLong, Chronology paramChronology)
  {
    return new LocalTime(paramLong, DateTimeUtils.getChronology(paramChronology).withUTC());
  }
  
  public static LocalTime now()
  {
    return new LocalTime();
  }
  
  public static LocalTime now(Chronology paramChronology)
  {
    if (paramChronology == null) {
      throw new NullPointerException("Chronology must not be null");
    }
    return new LocalTime(paramChronology);
  }
  
  public static LocalTime now(DateTimeZone paramDateTimeZone)
  {
    if (paramDateTimeZone == null) {
      throw new NullPointerException("Zone must not be null");
    }
    return new LocalTime(paramDateTimeZone);
  }
  
  @FromString
  public static LocalTime parse(String paramString)
  {
    return parse(paramString, ISODateTimeFormat.localTimeParser());
  }
  
  public static LocalTime parse(String paramString, DateTimeFormatter paramDateTimeFormatter)
  {
    return paramDateTimeFormatter.parseLocalTime(paramString);
  }
  
  private Object readResolve()
  {
    LocalTime localLocalTime;
    if (this.c == null) {
      localLocalTime = new LocalTime(this.b, ISOChronology.getInstanceUTC());
    }
    do
    {
      return localLocalTime;
      localLocalTime = this;
    } while (DateTimeZone.UTC.equals(this.c.getZone()));
    return new LocalTime(this.b, this.c.withUTC());
  }
  
  final LocalTime a(long paramLong)
  {
    if (paramLong == getLocalMillis()) {
      return this;
    }
    return new LocalTime(paramLong, getChronology());
  }
  
  public final int compareTo(ReadablePartial paramReadablePartial)
  {
    if (this == paramReadablePartial) {
      return 0;
    }
    if ((paramReadablePartial instanceof LocalTime))
    {
      LocalTime localLocalTime = (LocalTime)paramReadablePartial;
      if (this.c.equals(localLocalTime.c))
      {
        if (this.b < localLocalTime.b) {
          return -1;
        }
        if (this.b == localLocalTime.b) {
          return 0;
        }
        return 1;
      }
    }
    return super.compareTo(paramReadablePartial);
  }
  
  public final boolean equals(Object paramObject)
  {
    if (this == paramObject) {
      return true;
    }
    if ((paramObject instanceof LocalTime))
    {
      LocalTime localLocalTime = (LocalTime)paramObject;
      if (this.c.equals(localLocalTime.c)) {
        return this.b == localLocalTime.b;
      }
    }
    return super.equals(paramObject);
  }
  
  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 Chronology getChronology()
  {
    return this.c;
  }
  
  protected final DateTimeField getField(int paramInt, Chronology paramChronology)
  {
    switch (paramInt)
    {
    default: 
      throw new IndexOutOfBoundsException("Invalid index: " + paramInt);
    case 0: 
      return paramChronology.hourOfDay();
    case 1: 
      return paramChronology.minuteOfHour();
    case 2: 
      return paramChronology.secondOfMinute();
    }
    return paramChronology.millisOfSecond();
  }
  
  public final int getHourOfDay()
  {
    return getChronology().hourOfDay().get(getLocalMillis());
  }
  
  protected final long getLocalMillis()
  {
    return this.b;
  }
  
  public final int getMillisOfDay()
  {
    return getChronology().millisOfDay().get(getLocalMillis());
  }
  
  public final int getMillisOfSecond()
  {
    return getChronology().millisOfSecond().get(getLocalMillis());
  }
  
  public final int getMinuteOfHour()
  {
    return getChronology().minuteOfHour().get(getLocalMillis());
  }
  
  public final int getSecondOfMinute()
  {
    return getChronology().secondOfMinute().get(getLocalMillis());
  }
  
  public final int getValue(int paramInt)
  {
    switch (paramInt)
    {
    default: 
      throw new IndexOutOfBoundsException("Invalid index: " + paramInt);
    case 0: 
      return getChronology().hourOfDay().get(getLocalMillis());
    case 1: 
      return getChronology().minuteOfHour().get(getLocalMillis());
    case 2: 
      return getChronology().secondOfMinute().get(getLocalMillis());
    }
    return getChronology().millisOfSecond().get(getLocalMillis());
  }
  
  public final Property hourOfDay()
  {
    return new Property(this, getChronology().hourOfDay());
  }
  
  public final boolean isSupported(DateTimeFieldType paramDateTimeFieldType)
  {
    if (paramDateTimeFieldType == null) {}
    do
    {
      do
      {
        return false;
      } while (!isSupported(paramDateTimeFieldType.getDurationType()));
      paramDateTimeFieldType = paramDateTimeFieldType.getRangeDurationType();
    } while ((!isSupported(paramDateTimeFieldType)) && (paramDateTimeFieldType != DurationFieldType.days()));
    return true;
  }
  
  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 Property millisOfDay()
  {
    return new Property(this, getChronology().millisOfDay());
  }
  
  public final Property millisOfSecond()
  {
    return new Property(this, getChronology().millisOfSecond());
  }
  
  public final LocalTime minus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, -1);
  }
  
  public final LocalTime minusHours(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().hours().subtract(getLocalMillis(), paramInt));
  }
  
  public final LocalTime minusMillis(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().millis().subtract(getLocalMillis(), paramInt));
  }
  
  public final LocalTime minusMinutes(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().minutes().subtract(getLocalMillis(), paramInt));
  }
  
  public final LocalTime minusSeconds(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().seconds().subtract(getLocalMillis(), paramInt));
  }
  
  public final Property minuteOfHour()
  {
    return new Property(this, getChronology().minuteOfHour());
  }
  
  public final LocalTime plus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, 1);
  }
  
  public final LocalTime plusHours(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().hours().add(getLocalMillis(), paramInt));
  }
  
  public final LocalTime plusMillis(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().millis().add(getLocalMillis(), paramInt));
  }
  
  public final LocalTime plusMinutes(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().minutes().add(getLocalMillis(), paramInt));
  }
  
  public final LocalTime plusSeconds(int paramInt)
  {
    if (paramInt == 0) {
      return this;
    }
    return a(getChronology().seconds().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 Property secondOfMinute()
  {
    return new Property(this, getChronology().secondOfMinute());
  }
  
  public final int size()
  {
    return 4;
  }
  
  public final DateTime toDateTimeToday()
  {
    return toDateTimeToday(null);
  }
  
  public final DateTime toDateTimeToday(DateTimeZone paramDateTimeZone)
  {
    paramDateTimeZone = getChronology().withZone(paramDateTimeZone);
    return new DateTime(paramDateTimeZone.set(this, DateTimeUtils.currentTimeMillis()), paramDateTimeZone);
  }
  
  @ToString
  public final String toString()
  {
    return ISODateTimeFormat.time().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 LocalTime 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 LocalTime 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 LocalTime withFields(ReadablePartial paramReadablePartial)
  {
    if (paramReadablePartial == null) {
      return this;
    }
    return a(getChronology().set(paramReadablePartial, getLocalMillis()));
  }
  
  public final LocalTime withHourOfDay(int paramInt)
  {
    return a(getChronology().hourOfDay().set(getLocalMillis(), paramInt));
  }
  
  public final LocalTime withMillisOfDay(int paramInt)
  {
    return a(getChronology().millisOfDay().set(getLocalMillis(), paramInt));
  }
  
  public final LocalTime withMillisOfSecond(int paramInt)
  {
    return a(getChronology().millisOfSecond().set(getLocalMillis(), paramInt));
  }
  
  public final LocalTime withMinuteOfHour(int paramInt)
  {
    return a(getChronology().minuteOfHour().set(getLocalMillis(), paramInt));
  }
  
  public final LocalTime withPeriodAdded(ReadablePeriod paramReadablePeriod, int paramInt)
  {
    if ((paramReadablePeriod == null) || (paramInt == 0)) {
      return this;
    }
    return a(getChronology().add(paramReadablePeriod, getLocalMillis(), paramInt));
  }
  
  public final LocalTime withSecondOfMinute(int paramInt)
  {
    return a(getChronology().secondOfMinute().set(getLocalMillis(), paramInt));
  }
  
  public static final class Property
    extends AbstractReadableInstantFieldProperty
  {
    private static final long serialVersionUID = -325842547277223L;
    private transient LocalTime a;
    private transient DateTimeField b;
    
    Property(LocalTime paramLocalTime, DateTimeField paramDateTimeField)
    {
      this.a = paramLocalTime;
      this.b = paramDateTimeField;
    }
    
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException, ClassNotFoundException
    {
      this.a = ((LocalTime)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 LocalTime addCopy(int paramInt)
    {
      return this.a.a(this.b.add(this.a.getLocalMillis(), paramInt));
    }
    
    public final LocalTime addCopy(long paramLong)
    {
      return this.a.a(this.b.add(this.a.getLocalMillis(), paramLong));
    }
    
    public final LocalTime addNoWrapToCopy(int paramInt)
    {
      long l = this.b.add(this.a.getLocalMillis(), paramInt);
      if (this.a.getChronology().millisOfDay().get(l) != l) {
        throw new IllegalArgumentException("The addition exceeded the boundaries of LocalTime");
      }
      return this.a.a(l);
    }
    
    public final LocalTime 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 LocalTime getLocalTime()
    {
      return this.a;
    }
    
    protected final long getMillis()
    {
      return this.a.getLocalMillis();
    }
    
    public final LocalTime roundCeilingCopy()
    {
      return this.a.a(this.b.roundCeiling(this.a.getLocalMillis()));
    }
    
    public final LocalTime roundFloorCopy()
    {
      return this.a.a(this.b.roundFloor(this.a.getLocalMillis()));
    }
    
    public final LocalTime roundHalfCeilingCopy()
    {
      return this.a.a(this.b.roundHalfCeiling(this.a.getLocalMillis()));
    }
    
    public final LocalTime roundHalfEvenCopy()
    {
      return this.a.a(this.b.roundHalfEven(this.a.getLocalMillis()));
    }
    
    public final LocalTime roundHalfFloorCopy()
    {
      return this.a.a(this.b.roundHalfFloor(this.a.getLocalMillis()));
    }
    
    public final LocalTime setCopy(int paramInt)
    {
      return this.a.a(this.b.set(this.a.getLocalMillis(), paramInt));
    }
    
    public final LocalTime setCopy(String paramString)
    {
      return setCopy(paramString, null);
    }
    
    public final LocalTime setCopy(String paramString, Locale paramLocale)
    {
      return this.a.a(this.b.set(this.a.getLocalMillis(), paramString, paramLocale));
    }
    
    public final LocalTime withMaximumValue()
    {
      return setCopy(getMaximumValue());
    }
    
    public final LocalTime withMinimumValue()
    {
      return setCopy(getMinimumValue());
    }
  }
}


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