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,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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());
      }
 

Throws:

ObjectStreamException

Class net.time4j.MachineTime extends Object implements Serializable

serialVersionUID:

-4150291820807606229L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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 7 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 = (7 << 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());
      }
 

Throws:

ObjectStreamException

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

serialVersionUID:

-3192884724477742274L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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);
  }
 

Throws:

ObjectStreamException

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

serialVersionUID:

-6698431452072325688L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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);
  }
 

Throws:

ObjectStreamException

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

serialVersionUID:

2780881537313863339L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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);
      }
 

Throws:

ObjectStreamException

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

serialVersionUID:

7458380065762437714L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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. Then the data bytes for date and time component follow. Schematic algorithm:

      out.writeByte(5 << 4);
      out.writeObject(timestamp.getCalendarDate());
      out.writeObject(timestamp.getWallTime());
 

Throws:

ObjectStreamException

Class net.time4j.SPX extends Object implements Serializable

serialVersionUID:

1L

Serialization Methods

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Implementierungsmethode des Interface Externalizable.

Throws:

IOException

ClassNotFoundException

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Implementierungsmethode des Interface Externalizable.

Das erste Byte enthält um 4 Bits nach links verschoben den Typ des zu serialisierenden Objekts. Danach folgen die Daten-Bits in einer bit-komprimierten Darstellung.

Serial Data:

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

Throws:

IOException

Class net.time4j.Weekmodel extends Object implements Serializable

serialVersionUID:

7794495882610436763L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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);
  }
 

Throws:

ObjectStreamException

Package net.time4j.engine

Class net.time4j.engine.AdvancedElement extends BasicElement<V extends Comparable<V>> implements Serializable

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

Serialized Fields

name

String name

Elementname

Class net.time4j.engine.Calendrical extends TimePoint<U,D extends Calendrical<U,D>> implements Serializable

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.TimePoint extends ChronoEntity<T extends TimePoint<U,T>> implements Serializable

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:

IOException

ClassNotFoundException

Serialized Fields

unit

Object unit

time unit

amount

long amount

amount associated with a time unit > 0

Package net.time4j.tz

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

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

serialVersionUID:

-1410512619471503090L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException

Serial Data:

Blocks because a serialization proxy is required.

Throws:

InvalidObjectException - (always)

IOException

ClassNotFoundException

writeReplace

private Object writeReplace()
                     throws ObjectStreamException

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());
  }
 

Throws:

ObjectStreamException

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

ClassNotFoundException

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)