Serialized Form

Package net.time4j

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.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.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.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

dst

int dst

new daylight-saving-shift in seconds (DST)