Serialized Form

Package net.time4j

Class net.time4j.AnnualDate extends ChronoEntity<AnnualDate> implements Serializable

serialVersionUID:

7510648008819092983L

Serialization Methods

readResolve

private Object readResolve()
                    throws InvalidObjectException

Serial Data:

Checks the consistency

Throws:

InvalidObjectException - if the state is inconsistent

Serialized Fields

month

int month

the gregorian month in range 1-12

dayOfMonth

int dayOfMonth

the day of month in range 1-29/30/31

Class net.time4j.DayCycles extends 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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.JSR310DurationAdapter extends Object implements Serializable

Serialized Fields

duration

Duration<U extends IsoUnit> duration

the underlying duration of Time4J

Class net.time4j.MachineTime extends Object implements Serializable

serialVersionUID:

-4150291820807606229L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 5 and as least significant bit the value 1 if this instance uses the UTC-scale. Then the bytes for the seconds and fraction follow. The fraction bytes are only written if the fraction is not zero. In that case, the second least significant bit of the header is set, too. Schematic algorithm:

      byte header = (5 << 4);
      if (scale == TimeScale.UTC) header |= 1;
      if (this.getFraction() > 0) header |= 2;
      out.writeByte(header);
      out.writeLong(getSeconds());
      if (this.getFraction() > 0) {
          out.writeInt(getFraction());
      }
 

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

serialVersionUID:

-3192884724477742274L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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.OldApiTimezone extends TimeZone implements Serializable

serialVersionUID:

-6919910650419401271L

Serialized Fields

tz

Timezone tz

the underlying Time4J-zone

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

serialVersionUID:

-6698431452072325688L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in any case of IO-failures

ClassNotFoundException - if class-loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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:

IOException - in any case of IO-failures

Class net.time4j.Weekcycle extends BasicUnit implements Serializable

serialVersionUID:

-4981215347844372171L

Serialization Methods

readResolve

private Object readResolve()
                    throws ObjectStreamException

Throws:

ObjectStreamException

Class net.time4j.Weekmodel extends Object implements Serializable

serialVersionUID:

7794495882610436763L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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.ChineseCalendar extends EastAsianCalendar<ChineseCalendar.Unit,ChineseCalendar> implements Serializable

serialVersionUID:

8743381746750717307L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 14. Then the cycle, year-of-cycle and the month number are written as byte, finally the leap state of month as boolean and the day-of-month as byte.

Class net.time4j.calendar.CopticCalendar extends Calendrical<CopticCalendar.Unit,CopticCalendar> implements Serializable

serialVersionUID:

-8248846000788617742L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 3. Then the year is written as int, finally month and day-of-month as bytes.

Class net.time4j.calendar.CyclicYear extends SexagesimalName implements Serializable

serialVersionUID:

4908662352833192131L

Serialization Methods

readResolve

Object readResolve()
            throws ObjectStreamException

Serial Data:

Checks the consistency of deserialized data and ensures singleton semantic

Throws:

IllegalArgumentException - if the year is not in range 1-60

ObjectStreamException

Class net.time4j.calendar.EastAsianCalendar extends Calendrical<U,D extends EastAsianCalendar<U,D>> implements Serializable

Class net.time4j.calendar.EastAsianMonth extends Object implements Serializable

serialVersionUID:

7544059597266533279L

Serialization Methods

readResolve

private Object readResolve()
                    throws ObjectStreamException

Serial Data:

Preserves the singleton semantic

Throws:

ObjectStreamException - if deserializing is not possible

Serialized Fields

index

int index

month index (0-11)

leap

boolean leap

leap month flag

Class net.time4j.calendar.EthiopianCalendar extends Calendrical<EthiopianCalendar.Unit,EthiopianCalendar> implements Serializable

serialVersionUID:

-1632000525062084751L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 4. Then the era ordinal is written as byte, the year-of-era is written as int, finally month and day-of-month written as bytes.

Class net.time4j.calendar.EthiopianTime extends TimePoint<EthiopianTime.Unit,EthiopianTime> implements Serializable

serialVersionUID:

3576122091324773241L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 5. Then the time of day in seconds using western format is written as integer.

Class net.time4j.calendar.HebrewCalendar extends Calendrical<HebrewCalendar.Unit,HebrewCalendar> implements Serializable

serialVersionUID:

-4183006723190472312L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 12. Then the year is written as int, finally month.getValue() and day-of-month as bytes.

Class net.time4j.calendar.HebrewTime extends TimePoint<HebrewTime.Unit,HebrewTime> implements Serializable

serialVersionUID:

-6206874394178665128L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 13. Then a boolean flag is written (set to true if day). Finally the hour is written as byte and the part of hour written as short integer.

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

serialVersionUID:

4666707700222367373L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 1. Then the UTF-coded variant and its data version follow. Finally the year is written as int, month and day-of-month as bytes. The successful serialization requires equal versions per variant on both sides.

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

serialVersionUID:

7723641381724201009L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 11. Then the calendar history is written out as UTF-string. Finally the UTC-epoch-days of corresponding gregorian date will be serialized as long.

Serialized Fields

gregorian

PlainDate gregorian

The corresponding gregorian date.

history

ChronoHistory history

The associated calendar history.

Class net.time4j.calendar.IndianCalendar extends Calendrical<IndianCalendar.Unit,IndianCalendar> implements Serializable

serialVersionUID:

7482205842000661998L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 10. Then the year is written as int, finally month and day-of-month as bytes.

Class net.time4j.calendar.JapaneseCalendar extends Calendrical<JapaneseCalendar.Unit,JapaneseCalendar> implements Serializable

serialVersionUID:

-153630575450868922L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 9. Then the related gregorian year and the day-of-year are written as int-primitives. Note that the serialization round-trip might fail for calendar objects created in lax mode due to normalization.

Class net.time4j.calendar.JucheCalendar extends Calendrical<CalendarUnit,JucheCalendar> implements Serializable

serialVersionUID:

757676060690932159L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 17. Then the associated gregorian date is written.

Serialized Fields

iso

PlainDate iso

Class net.time4j.calendar.JulianCalendar extends Calendrical<JulianCalendar.Unit,JulianCalendar> implements Serializable

serialVersionUID:

3038883058279104976L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 7. Then the year is written as int, finally month and day-of-month as bytes.

Class net.time4j.calendar.KoreanCalendar extends EastAsianCalendar<KoreanCalendar.Unit,KoreanCalendar> implements Serializable

serialVersionUID:

-4284841131270593971L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 15. Then the cycle, year-of-cycle and the month number are written as byte, finally the leap state of month as boolean and the day-of-month as byte.

Class net.time4j.calendar.MinguoCalendar extends Calendrical<CalendarUnit,MinguoCalendar> implements Serializable

serialVersionUID:

-6628190121085147706L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 6. Then the associated gregorian date is written.

Serialized Fields

iso

PlainDate iso

Class net.time4j.calendar.Nengo extends Object implements Serializable

serialVersionUID:

5696395761628504723L

Serialization Methods

readResolve

private Object readResolve()
                    throws ObjectStreamException

Serial Data:

Preserves the singleton semantic

Throws:

ObjectStreamException - if deserializing is not possible

Serialized Fields

court

byte court

indicates if this nengo belongs to the northern or southern court of Nanboku-chō period

index

int index

internal array index pointer

Class net.time4j.calendar.PersianCalendar extends Calendrical<PersianCalendar.Unit,PersianCalendar> implements Serializable

serialVersionUID:

-411339992208638290L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 2. Then the year is written as int, finally month and day-of-month as bytes.

Class net.time4j.calendar.SexagesimalName extends Object implements Serializable

serialVersionUID:

-4556668597489844917L

Serialization Methods

readResolve

Object readResolve()
            throws ObjectStreamException

Serial Data:

Checks the consistency of deserialized data and ensures singleton semantic

Throws:

IllegalArgumentException - if the cyclic number is not in range 1-60

ObjectStreamException

Serialized Fields

number

int number

the number of cyclic field (1-60)

Class net.time4j.calendar.SPX extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in any case of IO-failures

ClassNotFoundException - if class loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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 possibly bit-compressed representation.

Serial Data:

data layout see writeReplace()-method of object to be serialized

Throws:

IOException - in any case of IO-failures

Class net.time4j.calendar.ThaiSolarCalendar extends Calendrical<CalendarUnit,ThaiSolarCalendar> implements Serializable

serialVersionUID:

-6628190121085147706L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 8. Then the associated gregorian date is written.

Serialized Fields

iso

PlainDate iso

Class net.time4j.calendar.VietnameseCalendar extends EastAsianCalendar<VietnameseCalendar.Unit,VietnameseCalendar> implements Serializable

serialVersionUID:

-3151525803739185874L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 16. Then the cycle, year-of-cycle and the month number are written as byte, finally the leap state of month as boolean and the day-of-month as byte.

Package net.time4j.calendar.astro

Class net.time4j.calendar.astro.JulianDay extends Object implements Serializable

serialVersionUID:

486345450973062467L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Checks the consistency of deserialized data.

Throws:

StreamCorruptedException - if the data are not consistent

IOException - if the data cannot be read

Serialized Fields

value

double value

the floating decimal value

scale

TimeScale scale

the underlying time scale

Class net.time4j.calendar.astro.LunarTime extends Object implements Serializable

serialVersionUID:

-8029871830105935048L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Checks the sanity of the state.

Throws:

IOException - in any case of I/O-errors

ClassNotFoundException - in any case of I/O-errors

IllegalArgumentException - in any case of inconsistent state

Serialized Fields

latitude

double latitude

the geographical latitude in degrees

Since:

3.38/4.33

longitude

double longitude

the geographical longitude in degrees

Since:

3.38/4.33

altitude

int altitude

the geographical altitude in meters

Since:

3.38/4.33

observerZoneID

TZID observerZoneID

zone identifier for the interpretation of calendar date input

Since:

3.38/4.33

Class net.time4j.calendar.astro.MoonPosition extends Object implements Serializable

serialVersionUID:

5736859564589473324L

Serialized Fields

rightAscension

double rightAscension

the right ascension of moon in degrees

Since:

3.38/4.33

declination

double declination

the declination of moon in degrees

Since:

3.38/4.33

azimuth

double azimuth

the azimuth of moon in degrees (compass orientation)

Since:

3.38/4.33

elevation

double elevation

the elevation of moon above or below the horizon in degrees

Since:

3.38/4.33

distance

double distance

the distance between the centers of earth and moon in kilometers

Since:

3.38/4.33

Class net.time4j.calendar.astro.SolarTime extends Object implements Serializable

serialVersionUID:

-4816619838743247977L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Checks the sanity of the state.

Throws:

IOException - in any case of I/O-errors

ClassNotFoundException - in any case of I/O-errors

IllegalArgumentException - in any case of inconsistent state

Serialized Fields

latitude

double latitude

the geographical latitude in degrees

Since:

3.34/4.29

longitude

double longitude

the geographical longitude in degrees

Since:

3.34/4.29

altitude

int altitude

the geographical altitude in meters

Since:

3.34/4.29

calculator

String calculator

name of the calculator for this instance

Since:

3.34/4.29

observerZoneID

TZID observerZoneID

zone identifier for the interpretation of calendar date input (optional)

Since:

3.38/4.33

Class net.time4j.calendar.astro.SunPosition extends Object implements Serializable

serialVersionUID:

-3023032442869934354L

Serialized Fields

rightAscension

double rightAscension

the right ascension of sun in degrees

Since:

3.38/4.33

declination

double declination

the declination of sun in degrees

Since:

3.38/4.33

azimuth

double azimuth

the azimuth of sun in degrees (compass orientation)

Since:

3.38/4.33

elevation

double elevation

the elevation of sun above or below the horizon in degrees

Since:

3.38/4.33

Package net.time4j.calendar.bahai

Class net.time4j.calendar.bahai.BadiCalendar extends Calendrical<BadiCalendar.Unit,BadiCalendar> implements Serializable

serialVersionUID:

7091925253640345123L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 19. Then the kull-i-shai-cycle, the vahid-cycle, the year of vahid and finally the month and day-of-month as bytes. Ayyam-i-Ha will be modelled as zero.

Class net.time4j.calendar.bahai.SPX extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException

Implementation method of interface Externalizable.

Throws:

IOException - in any case of IO-failures

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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 possibly bit-compressed representation.

Serial Data:

data layout see writeReplace()-method of object to be serialized

Throws:

IOException - in any case of IO-failures

Package net.time4j.calendar.frenchrev

Class net.time4j.calendar.frenchrev.FrenchRepublicanCalendar extends Calendrical<FrenchRepublicanCalendar.Unit,FrenchRepublicanCalendar> implements Serializable

serialVersionUID:

-6054794927532842783L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 18. Then the year is written as int, finally month and day-of-month as bytes.

Class net.time4j.calendar.frenchrev.SPX extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in any case of IO-failures

ClassNotFoundException - if class loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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 possibly bit-compressed representation.

Serial Data:

data layout see writeReplace()-method of object to be serialized

Throws:

IOException - in any case of IO-failures

Package net.time4j.calendar.hindu

Class net.time4j.calendar.hindu.HinduCalendar extends CalendarVariant<HinduCalendar> implements Serializable

serialVersionUID:

4078031838043675524L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 20. Then the variant is written as UTF-String and finally the days since UTC-epoch as long-primitive.

Class net.time4j.calendar.hindu.HinduDay extends HinduPrimitive implements Serializable

Serialized Fields

value

int value

numerical index

leap

boolean leap

leap month flag

Class net.time4j.calendar.hindu.HinduMonth extends HinduPrimitive implements Serializable

Serialized Fields

value

IndianMonth value

month of Indian national calendar

leap

boolean leap

leap month flag

Class net.time4j.calendar.hindu.HinduVariant extends Object implements Serializable

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 21. Then the variant is written as UTF-String.

Class net.time4j.calendar.hindu.SPX extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException

Implementation method of interface Externalizable.

Throws:

IOException - in any case of IO-failures

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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 possibly bit-compressed representation.

Serial Data:

data layout see writeReplace()-method of object to be serialized

Throws:

IOException - in any case of IO-failures

Package net.time4j.engine

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

Serialized Fields

name

String name

name of this element

identity

int identity

identity code

hash

int hash

hash code

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

Serialized Fields

days

long days

count of days

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

serialVersionUID:

-6646794951280971956L

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

serialVersionUID:

-5638437652574160520L

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

serialVersionUID:

1564804888291509484L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Checks the consistency.

Throws:

InvalidObjectException - if the state is inconsistent

ClassNotFoundException - if class-loading fails

IOException

Serialized Fields

unit

Object unit

time unit

amount

long amount

amount associated with a time unit > 0

Package net.time4j.format

Class net.time4j.format.DisplayElement extends BasicElement<V extends Comparable<V>> implements Serializable

Package net.time4j.history

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

serialVersionUID:

4100690610730913643L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 3. 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 PROLEPTIC_BYZANTINE 3, 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. Then the sequence of eventually set ancient julian leap years will be written as int-array (length followed by list of extended years). Then the specific new-year-strategy will be written as count of list of rule-until-pairs followed by the list entries. Finally the era preference will be written such that non-default preferences require the byte 127 and else any other number. If non-default then the preferred era and the start date and the end date will be written.

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

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in any case of IO-failures

ClassNotFoundException - if class loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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:

IOException - in any case of IO-failures

Package net.time4j.range

Class net.time4j.range.Boundary extends Object implements Serializable

serialVersionUID:

-8193246842948266154L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the six most significant bits the type-ID 57. The lowest bit is 1 if this instance is infinite past. The bit (2) will be set if this instance is infinite future. After this header byte and in case of finite boundary, one byte follows describing the open/closed-state. Finally the bytes for the temporal follow. Schematic algorithm:

       int header = 57;
       header <<= 2;

       if (this == Boundary.infinitePast()) {
           header |= 1;
           out.writeByte(header);
       } else if (this == Boundary.infiniteFuture()) {
           header |= 2;
           out.writeByte(header);
       } else {
           out.writeByte(header);
           out.writeByte(isOpen() ? 1 : 0);
           out.writeObject(getTemporal());
       }
      

Class net.time4j.range.CalendarMonth extends FixedCalendarInterval<CalendarMonth> implements Serializable

serialVersionUID:

-5097347953941448741L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the six most significant bits the type-ID 38. Then the year number and the month number are written as int-primitives. Schematic algorithm:

  int header = 38;
  header <<= 2;
  out.writeByte(header);
  out.writeInt(getYear());
  out.writeInt(getMonthOfYear().getValue());
 

Class net.time4j.range.CalendarPeriod extends Object implements Serializable

serialVersionUID:

-1570485272742024241L

Serialized Fields

t1

Object t1

the start of this interval (inclusive)

t2

Object t2

the end of this interval (inclusive)

Class net.time4j.range.CalendarQuarter extends FixedCalendarInterval<CalendarQuarter> implements Serializable

serialVersionUID:

-4871348693353897858L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the six most significant bits the type-ID 37. Then the year number and the quarter number are written as int-primitives. Schematic algorithm:

  int header = 37;
  header <<= 2;
  out.writeByte(header);
  out.writeInt(getYear());
  out.writeInt(getQuarterOfYear().getValue());
 

Class net.time4j.range.CalendarWeek extends FixedCalendarInterval<CalendarWeek> implements Serializable

serialVersionUID:

-3948942660009645060L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the six most significant bits the type-ID 39. Then the year number and the quarter number are written as int-primitives. Schematic algorithm:

  int header = 39;
  header <<= 2;
  out.writeByte(header);
  out.writeInt(getYear());
  out.writeInt(getWeek());
 

Class net.time4j.range.CalendarYear extends FixedCalendarInterval<CalendarYear> implements Serializable

serialVersionUID:

2151327270599436439L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The format is bit-compressed. The first byte contains in the six most significant bits the type-ID 36. Then the year number is written as int-primitive. Schematic algorithm:

  int header = 36;
  header <<= 2;
  out.writeByte(header);
  out.writeInt(getValue());
 

Class net.time4j.range.ClockInterval extends IsoInterval<PlainTime,ClockInterval> implements Serializable

serialVersionUID:

-6020908050362634577L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 33 in the six most significant bits. The next bytes represent the start and the end boundary. Schematic algorithm:

       int header = 33;
       header <<= 2;
       out.writeByte(header);
       writeBoundary(getStart(), out);
       writeBoundary(getEnd(), out);

       private static void writeBoundary(
           Boundary<?> boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.ClockWindows extends IntervalCollection<PlainTime> implements Serializable

serialVersionUID:

9141581122183129703L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 41 in the six most significant bits. The next bytes represent all contained intervals. Schematic algorithm:

       int header = 41;
       header <<= 2;
       out.writeByte(header);
       out.writeInt(getIntervals().size());

       for (ChronoInterval<?> part : getIntervals()) {
           writeBoundary(part.getStart(), out);
           writeBoundary(part.getEnd(), out);
       }

       private static void writeBoundary(
           Boundary<?> boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.DateInterval extends IsoInterval<PlainDate,DateInterval> implements Serializable

serialVersionUID:

8074261825266036014L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 32 in the six most significant bits. The next bytes represent the start and the end boundary. Schematic algorithm:

       int header = 32;
       header <<= 2;
       out.writeByte(header);
       writeBoundary(getStart(), out);
       writeBoundary(getEnd(), out);

       private static void writeBoundary(
           Boundary<?> boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.DateWindows extends IntervalCollection<PlainDate> implements Serializable

serialVersionUID:

5540919343133887473L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 40 in the six most significant bits. The next bytes represent all contained intervals. Schematic algorithm:

       int header = 40;
       header <<= 2;
       out.writeByte(header);
       out.writeInt(getIntervals().size());

       for (ChronoInterval<?> part : getIntervals()) {
           writeBoundary(part.getStart(), out);
           writeBoundary(part.getEnd(), out);
       }

       private static void writeBoundary(
           Boundary<?> boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.FixedCalendarInterval extends ChronoEntity<T extends FixedCalendarInterval<T>> implements Serializable

Class net.time4j.range.GenericWindows extends IntervalCollection<T> implements Serializable

serialVersionUID:

7068295351485872982L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 44 in the six most significant bits. The next bytes represent the timeline and then all contained intervals. Schematic algorithm:

       int header = 44;
       header <<= 2;
       out.writeByte(header);
       out.writeObject(getTimeLine());
       out.writeInt(getIntervals().size());

       for (ChronoInterval<?< part : getIntervals()) {
           out.writeObject(part.getStart().getTemporal());
           out.writeObject(part.getEnd().getTemporal());
       }
      

Class net.time4j.range.MomentInterval extends IsoInterval<Moment,MomentInterval> implements Serializable

serialVersionUID:

-5403584519478162113L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 35 in the six most significant bits. The next bytes represent the start and the end boundary. Schematic algorithm:

       int header = 35;
       header <<= 2;
       out.writeByte(header);
       writeBoundary(getStart(), out);
       writeBoundary(getEnd(), out);

       private static void writeBoundary(
           Boundary<?> boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.MomentWindows extends IntervalCollection<Moment> implements Serializable

serialVersionUID:

6628458032332509882L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 43 in the six most significant bits. The next bytes represent all contained intervals. Schematic algorithm:

       int header = 43;
       header <<= 2;
       out.writeByte(header);
       out.writeInt(getIntervals().size());

       for (ChronoInterval<?< part : getIntervals()) {
           writeBoundary(part.getStart(), out);
           writeBoundary(part.getEnd(), out);
       }

       private static void writeBoundary(
           Boundary<?< boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.Months extends SingleUnitTimeSpan<CalendarUnit,Months> implements Serializable

serialVersionUID:

6367060429891625338L

Class net.time4j.range.Quarters extends SingleUnitTimeSpan<CalendarUnit,Quarters> implements Serializable

serialVersionUID:

-2100419304667904214L

Class net.time4j.range.SimpleInterval extends Object implements Serializable

serialVersionUID:

-3508139527445140226L

Serialized Fields

start

Boundary<T> start

start boundary

end

Boundary<T> end

end boundary

timeLine

TimeLine<T> timeLine

the underlying timeline

Class net.time4j.range.SingleUnitTimeSpan extends Object implements Serializable

Serialization Methods

readObject

final void readObject(ObjectInputStream in)
               throws IOException

Serial Data:

Checks the consistency

Throws:

InvalidObjectException - in any case of inconsistencies

IOException

Serialized Fields

amount

int amount

count of units

unit

IsoDateUnit unit

type of unit

Class net.time4j.range.SpanOfWeekdays extends ChronoEntity<SpanOfWeekdays> implements Serializable

serialVersionUID:

3484703887286756207L

Serialized Fields

start

Weekday start

the start of the span of weekdays

end

Weekday end

the end of the span of weekdays

Class net.time4j.range.SPX extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in case of I/O-problems

ClassNotFoundException - if class-loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Implementation method of interface Externalizable.

The first byte contains within the 6 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:

IOException - in case of I/O-problems

Class net.time4j.range.TimestampInterval extends IsoInterval<PlainTimestamp,TimestampInterval> implements Serializable

serialVersionUID:

-3965530927182499606L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 34 in the six most significant bits. The next bytes represent the start and the end boundary. Schematic algorithm:

       int header = 34;
       header <<= 2;
       out.writeByte(header);
       writeBoundary(getStart(), out);
       writeBoundary(getEnd(), out);

       private static void writeBoundary(
           Boundary<?< boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.TimestampWindows extends IntervalCollection<PlainTimestamp> implements Serializable

serialVersionUID:

5075857786753409078L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private Object writeReplace()

Serial Data:

Uses a dedicated serialization form as proxy. The first byte contains the type-ID 42 in the six most significant bits. The next bytes represent all contained intervals. Schematic algorithm:

       int header = 42;
       header <<= 2;
       out.writeByte(header);
       out.writeInt(getIntervals().size());

       for (ChronoInterval<?> part : getIntervals()) {
           writeBoundary(part.getStart(), out);
           writeBoundary(part.getEnd(), out);
       }

       private static void writeBoundary(
           Boundary<?> boundary,
           ObjectOutput out
       ) throws IOException {
           if (boundary.equals(Boundary.infinitePast())) {
               out.writeByte(1);
           } else if (boundary.equals(Boundary.infiniteFuture())) {
               out.writeByte(2);
           } else {
               out.writeByte(boundary.isOpen() ? 4 : 0);
               out.writeObject(boundary.getTemporal());
           }
       }
      

Class net.time4j.range.ValueInterval extends Object implements Serializable

serialVersionUID:

-5542033333136556857L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Checks the consistency.

Throws:

IOException - if the data are not consistent

Serialized Fields

interval

ChronoInterval<T> interval

interval delegate

value

Object value

assigned value

Class net.time4j.range.Weeks extends SingleUnitTimeSpan<CalendarUnit,Weeks> implements Serializable

serialVersionUID:

78946640166405240L

Class net.time4j.range.Years extends SingleUnitTimeSpan<U extends IsoDateUnit,Years<U extends IsoDateUnit>> implements Serializable

serialVersionUID:

6288717039772347252L

Package net.time4j.tz

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

serialVersionUID:

-2894726563499525332L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 Object readResolve()

Serial Data:

Asserts consistency of model.

Serialized Fields

id

TZID id

timezone id

tz

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(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Checks the consistency.

Throws:

InvalidObjectException - in case of inconsistencies

ClassNotFoundException - if class-loading fails

IOException

Serialized Fields

offset

ZonalOffset offset

fixed zone shift in full seconds

Class net.time4j.tz.SPX extends Object implements Serializable

serialVersionUID:

-1000776907354520172L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in case of I/O-problems

ClassNotFoundException - if class-loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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:

IOException - in case of I/O-problems

Class net.time4j.tz.TransitionResolver extends Object implements Serializable

serialVersionUID:

1790434289322009750L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 Object implements Serializable

serialVersionUID:

-1410512619471503090L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 Object implements Serializable

serialVersionUID:

4594838367057225304L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Checks the consistency.

Throws:

IOException - in any case of inconsistencies

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

extra

int extra

new extra shift in seconds (typically DST)

Package net.time4j.tz.model

Class net.time4j.tz.model.ArrayTransitionModel extends TransitionModel implements Serializable

serialVersionUID:

-5264909488983076587L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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(ObjectInputStream in)
                 throws IOException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

writeReplace

private 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 Object implements Serializable

serialVersionUID:

6526945678752534989L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementation method of interface Externalizable.

Throws:

IOException - in case of I/O-problems

ClassNotFoundException - if class-loading fails

writeExternal

public void writeExternal(ObjectOutput out)
                   throws 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:

IOException - in case of I/O-problems

Package net.time4j.tz.other

Class net.time4j.tz.other.WindowsZone extends Object implements Serializable

serialVersionUID:

-6071278077083785308L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Checks the consistency.

Throws:

ClassNotFoundException - if the class of a serialized object could not be found.

IOException - if an I/O error occurs.

IllegalArgumentException - in case of inconsistencies

Serialized Fields

name

String name

name of windows zone