Serialized Form (time4j-android 3.6-2015f API)

Package net.time4j
- Class net.time4j.DayCycles extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4124961309622141228L
  - Serialized Fields
    - days
```
long days
```
      day overflow
    - time
```
PlainTime time
```
      wall time
- Class net.time4j.Duration extends AbstractDuration<U extends IsoUnit> implements Serializable
  
  serialVersionUID:
  
  -6321211763598951499L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The layout is bit-compressed. The first byte contains within the four most significant bits the type id 6 and as least significant bit the value 1 if long should be used for transferring the item amounts (else using int). Then the data bytes for the duration items follow. The byte sequence optionally ends with the sign information. Schematic algorithm:
      boolean useLong = ...; byte header = (6 << 4); if (useLong) header |= 1; out.writeByte(header); out.writeInt(getTotalLength().size()); for (Item<U> item : getTotalLength()) { if (useLong) { out.writeLong(item.getAmount()); } else { out.writeInt((int) item.getAmount()); } out.writeObject(item.getUnit()); } if (getTotalLength().size() > 0) { out.writeBoolean(isNegative()); }
- Class net.time4j.Moment extends TimePoint<java.util.concurrent.TimeUnit,Moment> implements Serializable
  
  serialVersionUID:
  
  -3192884724477742274L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The format is bit-compressed. Overall until 13 data bytes are used. The first byte contains in the four most significant bits the type-ID 4. The lowest bit is 1 if this instance is a positive leap second. The bit (2) will be set if there is a non-zero nanosecond part. After this header byte eight bytes follow containing the unix time (as long) and optional four bytes with the fraction part. Schematic algorithm:
      int header = 4; header <<= 4; if (isLeapSecond()) { header |= 1; } int fraction = getNanosecond(); if (fraction > 0) { header |= 2; } out.writeByte(header); out.writeLong(getPosixTime()); if (fraction > 0) { out.writeInt(fraction); }
- Class net.time4j.PlainDate extends Calendrical<IsoDateUnit,PlainDate> implements Serializable
  
  serialVersionUID:
  
  -6698431452072325688L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the four most significant bits the type-ID 1. The following bits 4-7 contain the month. The second byte contains at the bits 1-2 a year mark: 1 = year in the range 1850-2100, 2 = four-digit-year, 3 = year number with more than four digits. The five least significant bits of second byte contain the day of month. Then the year will be written dependent on the year mark. Is the mark 1 then the year will be written as byte, if the mark is 2 then the year will be written as short else as int with four bytes. Schematic algorithm:
      int range; if (year >= 1850 && year <= 2100) { range = 1; } else if (Math.abs(year) < 10000) { range = 2; } else { range = 3; } int header = 1; header <<= 4; header |= month; out.writeByte(header); int header2 = range; header2 <<= 5; header2 |= dayOfMonth; out.writeByte(header2); if (range == 1) { out.writeByte(year - 1850 - 128); } else if (range == 2) { out.writeShort(year); } else { out.writeInt(year); }
- Class net.time4j.PlainTime extends TimePoint<IsoTimeUnit,PlainTime> implements Serializable
  
  serialVersionUID:
  
  2780881537313863339L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The layout is bit-compressed. The first byte contains within the four most significant bits the type id 2. Then the data bytes for hour, minute, second and nanosecond follow (in last case int instead of byte). Is the precision limited to seconds, minutes or hours then the last non-zero byte will be bit-inverted by the operator (~), and the following bytes will be left out. The hour byte however is always written. Schematic algorithm:
      out.writeByte(2 << 4); if (time.nano == 0) { if (time.second == 0) { if (time.minute == 0) { out.writeByte(~time.hour); } else { out.writeByte(time.hour); out.writeByte(~time.minute); } } else { out.writeByte(time.hour); out.writeByte(time.minute); out.writeByte(~time.second); } } else { out.writeByte(time.hour); out.writeByte(time.minute); out.writeByte(time.second); out.writeInt(time.nano); }
- Class net.time4j.PlainTimestamp extends TimePoint<IsoUnit,PlainTimestamp> implements Serializable
  
  serialVersionUID:
  
  7458380065762437714L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The layout is bit-compressed. The first byte contains within the four most significant bits the type id 8. Then the data bytes for date and time component follow. Schematic algorithm:
      int range; if (year >= 1850 && year <= 2100) { range = 1; } else if (Math.abs(year) < 10000) { range = 2; } else { range = 3; } int header = 8; // type-id header <<= 4; header |= month; out.writeByte(header); int header2 = range; header2 <<= 5; header2 |= dayOfMonth; out.writeByte(header2); if (range == 1) { out.writeByte(year - 1850 - 128); } else if (range == 2) { out.writeShort(year); } else { out.writeInt(year); } if (time.nano == 0) { if (time.second == 0) { if (time.minute == 0) { out.writeByte(~time.hour); } else { out.writeByte(time.hour); out.writeByte(~time.minute); } } else { out.writeByte(time.hour); out.writeByte(time.minute); out.writeByte(~time.second); } } else { out.writeByte(time.hour); out.writeByte(time.minute); out.writeByte(time.second); out.writeInt(time.nano); }
- Class net.time4j.SPX extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
      Implementation method of interface Externalizable.
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
      
      java.lang.ClassNotFoundException - if class-loading fails
    - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
      Implementation method of interface Externalizable.
      
      The first byte contains within the 4 most-significant bits the type of the object to be serialized. Then the data bytes follow in a bit-compressed representation.
      
      Serial Data:
      
      data layout see writeReplace()-method of object to be serialized
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
- Class net.time4j.Weekmodel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7794495882610436763L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The format is bit-compressed. Two data bytes are used, sometimes also three. The first byte contains in the four most significant bits the type-ID 3. If the weekend is not saturday and sunday then the four least significant bits will be set to 1. The second byte has in the four most significant bits the first day of week, in the other four bits the minimum days of first calendar week. If there is no standard weekend then a third byte follows which contains in the four most significant bits the start and the four least significant bits the end of weekend. Schematic algorithm:
      boolean isoWeekend = ( (getStartOfWeekend() == Weekday.SATURDAY) && (getEndOfWeekend() == Weekday.SUNDAY) ); int header = 3; header <<= 4; if (!isoWeekend) { header |= 1; } out.writeByte(header); int state = getFirstDayOfWeek().getValue(); state <<= 4; state |= getMinimalDaysInFirstWeek(); out.writeByte(state); if (!isoWeekend) { state = getStartOfWeekend().getValue(); state <<= 4; state |= getEndOfWeekend().getValue(); out.writeByte(state); }
Package net.time4j.calendar
- Class net.time4j.calendar.HijriCalendar extends CalendarVariant<HijriCalendar> implements Serializable
  - Serialized Fields
    - hyear
```
int hyear
```
    - hmonth
```
int hmonth
```
    - hdom
```
int hdom
```
    - variant
```
java.lang.String variant
```
Package net.time4j.engine
- Class net.time4j.engine.BasicElement extends java.lang.Object implements Serializable
  - Serialized Fields
    - name
```
java.lang.String name
```
      name of this element
- Class net.time4j.engine.CalendarDays extends java.lang.Object implements Serializable
  - Serialized Fields
    - days
```
long days
```
      count of days
- Class net.time4j.engine.ChronoException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -6646794951280971956L
- Class net.time4j.engine.RuleNotFoundException extends ChronoException implements Serializable
  
  serialVersionUID:
  
  -5638437652574160520L
- Class net.time4j.engine.TimeSpan.Item extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1564804888291509484L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Serial Data:
      
      Checks the consistency.
      
      Throws:
      
      java.io.InvalidObjectException - if the state is inconsistent
      
      java.lang.ClassNotFoundException - if class loading fails
      
      java.io.IOException
  - Serialized Fields
    - unit
```
java.lang.Object unit
```
      time unit
    - amount
```
long amount
```
      amount associated with a time unit > 0
Package net.time4j.history
- Class net.time4j.history.ChronoHistory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4100690610730913643L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the four most significant bits the type-ID 1. The following bits 4-7 contain the variant of history. The variant is usually zero, but for PROLEPTIC_GREGORIAN 1, for PROLEPTIC_JULIAN 2, for SWEDEN 4 and for the first gregorian reform 7. If the variant is zero then the cutover date in question will be written as long (modified julian date) into the stream.
- Class net.time4j.history.SPX extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
      Implementation method of interface Externalizable.
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
      
      java.lang.ClassNotFoundException - if class loading fails
    - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
      Implementation method of interface Externalizable.
      
      The first byte contains within the 4 most-significant bits the type of the object to be serialized. Then the data bytes follow in a bit-compressed representation.
      
      Serial Data:
      
      data layout see writeReplace()-method of object to be serialized
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
Package net.time4j.tz
- Class net.time4j.tz.FallbackTimezone extends Timezone implements Serializable
  
  serialVersionUID:
  
  -2894726563499525332L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains in the four most significant bits the type id 12. Then the data bits for the id and the fallback timezone follow. Schematic algorithm:
      int header = (12 << 4); out.writeByte(header); out.writeObject(getID()); out.writeObject(getFallback());
  - Serialized Fields
    - tzid
```
TZID tzid
```
    - fallback
```
Timezone fallback
```
- Class net.time4j.tz.HistorizedTimezone extends Timezone implements Serializable
  
  serialVersionUID:
  
  1738909257417361021L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
      
      java.io.IOException
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains in the four most significant bits the type id 14. If there is a non-default transition strategy then the lowest bit is set to 1 else to 0. After that the data bits for the id, history and optionally the special strategy follow. Schematic algorithm:
      boolean specialStrategy = (getStrategy() != Timezone.DEFAULT_CONFLICT_STRATEGY); int header = (14 << 4); if (specialStrategy) { header |= 1; } out.writeByte(header); out.writeObject(tz.getID()); out.writeObject(tz.getHistory()); if (specialStrategy) { out.writeObject(tz.getStrategy()); }
- Class net.time4j.tz.PlatformTimezone extends Timezone implements Serializable
  
  serialVersionUID:
  
  -8432968264242113551L
  - Serialization Methods
    - readResolve
```
private java.lang.Object readResolve()
```
      Serial Data:
      
      Asserts consistency of model.
  - Serialized Fields
    - id
```
TZID id
```
      timezone id
    - tz
```
java.util.TimeZone tz
```
      timezone of old JDK
    - strict
```
boolean strict
```
      strict resolving of offset transitions
- Class net.time4j.tz.SingleOffsetTimezone extends Timezone implements Serializable
  
  serialVersionUID:
  
  7807230388259573234L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Serial Data:
      
      Checks the consistency.
      
      Throws:
      
      java.io.InvalidObjectException - in case of inconsistencies
      
      java.lang.ClassNotFoundException - if class loading fails
      
      java.io.IOException
  - Serialized Fields
    - offset
```
ZonalOffset offset
```
      fixed zone shift in full seconds
- Class net.time4j.tz.SPX extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1000776907354520172L
  - Serialization Methods
    - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
      Implementation method of interface Externalizable.
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
      
      java.lang.ClassNotFoundException - if class loading fails
    - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
      Implementation method of interface Externalizable.
      
      The first byte contains within the 4 most-significant bits the type of the object to be serialized. Then the data bytes follow in a bit-compressed representation.
      
      Serial Data:
      
      data layout see writeReplace()-method of object to be serialized
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
- Class net.time4j.tz.TransitionResolver extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1790434289322009750L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains in the four most significant bits the type id 13. The lower 4 bits contain the concrete value of this strategy. Schematic algorithm:
      int key = getGapResolver().ordinal() * 2 + getOverlapResolver().ordinal(); int header = (13 << 4); header |= key; out.writeByte(header);
- Class net.time4j.tz.ZonalOffset extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1410512619471503090L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains in the four most significant bits the type id 15. If there is any fractional part then the four least significant bits are 1 else 0. After that the data bits for the integral total shift and optionally the fractional part follow. Schematic algorithm:
      boolean hasFraction = (this.getFractionalAmount() != 0); int header = (15 << 4); if (hasFraction) { header |= 1; } out.writeByte(header); out.writeInt(this.getIntegralAmount()); if (hasFraction) { out.writeInt(this.getFractionalAmount()); }
- Class net.time4j.tz.ZonalTransition extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4594838367057225304L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Serial Data:
      
      Checks the consistency.
      
      Throws:
      
      java.io.IOException - in any case of inconsistencies
      
      java.lang.ClassNotFoundException - if class loading fails
  - Serialized Fields
    - posix
```
long posix
```
      POSIX time in seconds since 1970-01-01T00:00:00Z
    - previous
```
int previous
```
      previous total shift in seconds
    - total
```
int total
```
      new total shift in seconds
    - dst
```
int dst
```
      new daylight-saving-shift in seconds (DST)
Package net.time4j.tz.model
- Class net.time4j.tz.model.ArrayTransitionModel extends TransitionModel implements Serializable
  
  serialVersionUID:
  
  -5264909488983076587L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains the type id 126. Then the data bytes for the internal transitions follow. The complex algorithm exploits the fact that allmost all transitions happen at full hours around midnight in local standard time. Insight in details see source code.
- Class net.time4j.tz.model.CompositeTransitionModel extends TransitionModel implements Serializable
  
  serialVersionUID:
  
  1749643877954103721L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains the type id 127. Then the data bytes for the internal transitions and rules follow. The complex algorithm exploits the fact that allmost all transitions happen at full hours around midnight in local standard time. Insight in details see source code.
- Class net.time4j.tz.model.DayOfWeekInMonthPattern extends GregorianTimezoneRule implements Serializable
  
  serialVersionUID:
  
  -7354650946442523175L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains the type id of the concrete subclass. Then the data bytes for the internal state follow. The complex algorithm exploits the fact that allmost all transitions happen at full hours around midnight. Insight in details see source code.
- Class net.time4j.tz.model.EmptyTransitionModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1374714021808040253L
  - Serialized Fields
    - offset
```
ZonalOffset offset
```
      fixed offset in seconds
- Class net.time4j.tz.model.FixedDayPattern extends GregorianTimezoneRule implements Serializable
  
  serialVersionUID:
  
  3957240859230862745L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains the type id of the concrete subclass. Then the data bytes for the internal state follow. The complex algorithm exploits the fact that allmost all transitions happen at full hours around midnight. Insight in details see source code.
- Class net.time4j.tz.model.GregorianTimezoneRule extends DaylightSavingRule implements Serializable
  
  serialVersionUID:
  
  1L
- Class net.time4j.tz.model.LastWeekdayPattern extends GregorianTimezoneRule implements Serializable
  
  serialVersionUID:
  
  -946839310332554772L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains the type id of the concrete subclass. Then the data bytes for the internal state follow. The complex algorithm exploits the fact that allmost all transitions happen at full hours around midnight. Insight in details see source code.
- Class net.time4j.tz.model.RuleBasedTransitionModel extends TransitionModel implements Serializable
  
  serialVersionUID:
  
  2456700806862862287L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.InvalidObjectException
```
      Serial Data:
      
      Blocks because a serialization proxy is required.
      
      Throws:
      
      java.io.InvalidObjectException - (always)
    - writeReplace
```
private java.lang.Object writeReplace()
```
      Serial Data:
      
      Uses a specialized serialisation form as proxy. The format is bit-compressed. The first byte contains the type id 125. Then the data bytes for the internal rules follow. The complex algorithm exploits the fact that allmost all transitions happen at full hours around midnight. Insight in details see source code.
- Class net.time4j.tz.model.SPX extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6526945678752534989L
  - Serialization Methods
    - readExternal
```
public void readExternal(java.io.ObjectInput in)
                  throws java.io.IOException,
                         java.lang.ClassNotFoundException
```
      Implementation method of interface Externalizable.
      
      Throws:
      
      java.io.IOException - in any case of IO-failures
      
      java.lang.ClassNotFoundException - if class loading fails
    - writeExternal
```
public void writeExternal(java.io.ObjectOutput out)
                   throws java.io.IOException
```
      Implementation method of interface Externalizable.
      
      The first byte contains the type of the object to be serialized. Then the data bytes follow in a bit-compressed representation.
      
      Serial Data:
      
      data layout see writeReplace()-method of object to be serialized
      
      Throws:
      
      java.io.IOException - in any case of IO-failures

Serialized Form

Package net.time4j

Class net.time4j.DayCycles extends java.lang.Object implements Serializable

Serialized Fields

days

time

Class net.time4j.Duration extends AbstractDuration<U extends IsoUnit> implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.Moment extends TimePoint<java.util.concurrent.TimeUnit,Moment> implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.PlainDate extends Calendrical<IsoDateUnit,PlainDate> implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.PlainTime extends TimePoint<IsoTimeUnit,PlainTime> implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.PlainTimestamp extends TimePoint<IsoUnit,PlainTimestamp> implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.SPX extends java.lang.Object implements Serializable

Serialization Methods

readExternal

writeExternal

Class net.time4j.Weekmodel extends java.lang.Object implements Serializable

Serialization Methods

readObject

writeReplace

Package net.time4j.calendar

Class net.time4j.calendar.HijriCalendar extends CalendarVariant<HijriCalendar> implements Serializable

Serialized Fields

hyear

hmonth

hdom

variant

Package net.time4j.engine

Class net.time4j.engine.BasicElement extends java.lang.Object implements Serializable

Serialized Fields

name

Class net.time4j.engine.CalendarDays extends java.lang.Object implements Serializable

Serialized Fields

days

Class net.time4j.engine.ChronoException extends java.lang.RuntimeException implements Serializable

Class net.time4j.engine.RuleNotFoundException extends ChronoException implements Serializable

Class net.time4j.engine.TimeSpan.Item extends java.lang.Object implements Serializable

Serialization Methods

readObject

Serialized Fields

unit

amount

Package net.time4j.history

Class net.time4j.history.ChronoHistory extends java.lang.Object implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.history.SPX extends java.lang.Object implements Serializable

Serialization Methods

readExternal

writeExternal

Package net.time4j.tz

Class net.time4j.tz.FallbackTimezone extends Timezone implements Serializable

Serialization Methods

readObject

writeReplace

Serialized Fields

tzid

fallback

Class net.time4j.tz.HistorizedTimezone extends Timezone implements Serializable

Serialization Methods

readObject

writeReplace

Class net.time4j.tz.PlatformTimezone extends Timezone implements Serializable

Serialization Methods

readResolve