Serialized Form

  • Package net.time4j

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

      serialVersionUID:
      7510648008819092983L

      • Serialization Methods

      • Serialized Fields

        • dayOfMonth
          int dayOfMonth
          the day of month in range 1-29/30/31
        • month
          int month
          the gregorian month in range 1-12

    • 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<?> 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

    • Class net.time4j.Weekcycle extends BasicUnit implements Serializable

      serialVersionUID:
      -4981215347844372171L

    • 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

  • Package net.time4j.calendar.astro

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

      serialVersionUID:
      486345450973062467L

      • Serialization Methods

      • Serialized Fields

        • scale
          TimeScale scale
          the underlying time scale
        • value
          double value
          the floating decimal value

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

      serialVersionUID:
      -8029871830105935048L

      • Serialization Methods

      • Serialized Fields

        • altitude
          int altitude
          the geographical altitude in meters
          Since:
          3.38/4.33
        • 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
        • 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

        • azimuth
          double azimuth
          the azimuth of moon in degrees (compass orientation)
          Since:
          3.38/4.33
        • declination
          double declination
          the declination of moon 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
        • elevation
          double elevation
          the elevation of moon above or below the horizon in degrees
          Since:
          3.38/4.33
        • rightAscension
          double rightAscension
          the right ascension of moon in degrees
          Since:
          3.38/4.33

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

      serialVersionUID:
      -4816619838743247977L

      • Serialization Methods

      • Serialized Fields

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

        • azimuth
          double azimuth
          the azimuth of sun in degrees (compass orientation)
          Since:
          3.38/4.33
        • declination
          double declination
          the declination of sun in degrees
          Since:
          3.38/4.33
        • elevation
          double elevation
          the elevation of sun above or below the horizon in degrees
          Since:
          3.38/4.33
        • rightAscension
          double rightAscension
          the right ascension of sun in degrees
          Since:
          3.38/4.33

  • Package net.time4j.calendar.bahai

  • Package net.time4j.calendar.frenchrev

  • Package net.time4j.calendar.hindu

  • Package net.time4j.engine

  • Package net.time4j.format

  • 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

  • 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
          T t1
          the start of this interval (inclusive)
        • t2
          T 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

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

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

      serialVersionUID:
      3484703887286756207L

      • Serialized Fields

        • end
          Weekday end
          the end of the span of weekdays
        • start
          Weekday start
          the start of the span of weekdays

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

      serialVersionUID:
      1L

    • 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

      • Serialized Fields

        • interval
          I extends ChronoInterval<T> interval
          interval delegate
        • value
          V 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

    • 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
        • strict
          boolean strict
          strict resolving of offset transitions
        • tz
          TimeZone tz
          timezone of old JDK

    • Class net.time4j.tz.SingleOffsetTimezone extends Timezone implements Serializable

      serialVersionUID:
      7807230388259573234L

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

      serialVersionUID:
      -1000776907354520172L

    • 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

      • Serialized Fields

        • extra
          int extra
          new extra shift in seconds (typically DST)
        • 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

  • 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

    • 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

  • Package net.time4j.tz.other