jdk/src/share/classes/java/time/Ser.java
changeset 15658 55b829ca2334
parent 15289 3ac550392e43
child 17474 8c100beabcc0
equal deleted inserted replaced
15657:c588664d547e 15658:55b829ca2334
    54  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    54  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    55  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    55  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    56  */
    56  */
    57 package java.time;
    57 package java.time;
    58 
    58 
    59 import java.io.DataInput;
       
    60 import java.io.DataOutput;
       
    61 import java.io.Externalizable;
    59 import java.io.Externalizable;
    62 import java.io.IOException;
    60 import java.io.IOException;
    63 import java.io.InvalidClassException;
    61 import java.io.InvalidClassException;
    64 import java.io.ObjectInput;
    62 import java.io.ObjectInput;
    65 import java.io.ObjectOutput;
    63 import java.io.ObjectOutput;
   101     static final byte LOCAL_TIME_TYPE = 4;
    99     static final byte LOCAL_TIME_TYPE = 4;
   102     static final byte LOCAL_DATE_TIME_TYPE = 5;
   100     static final byte LOCAL_DATE_TIME_TYPE = 5;
   103     static final byte ZONE_DATE_TIME_TYPE = 6;
   101     static final byte ZONE_DATE_TIME_TYPE = 6;
   104     static final byte ZONE_REGION_TYPE = 7;
   102     static final byte ZONE_REGION_TYPE = 7;
   105     static final byte ZONE_OFFSET_TYPE = 8;
   103     static final byte ZONE_OFFSET_TYPE = 8;
       
   104     static final byte OFFSET_TIME_TYPE = 9;
       
   105     static final byte OFFSET_DATE_TIME_TYPE = 10;
       
   106     static final byte YEAR_TYPE = 11;
       
   107     static final byte YEAR_MONTH_TYPE = 12;
       
   108     static final byte MONTH_DAY_TYPE = 13;
       
   109     static final byte PERIOD_TYPE = 14;
   106 
   110 
   107     /** The type being serialized. */
   111     /** The type being serialized. */
   108     private byte type;
   112     private byte type;
   109     /** The object being serialized. */
   113     /** The object being serialized. */
   110     private Object object;
   114     private Object object;
   130     /**
   134     /**
   131      * Implements the {@code Externalizable} interface to write the object.
   135      * Implements the {@code Externalizable} interface to write the object.
   132      *
   136      *
   133      * @param out  the data stream to write to, not null
   137      * @param out  the data stream to write to, not null
   134      */
   138      */
       
   139     @Override
   135     public void writeExternal(ObjectOutput out) throws IOException {
   140     public void writeExternal(ObjectOutput out) throws IOException {
   136         writeInternal(type, object, out);
   141         writeInternal(type, object, out);
   137     }
   142     }
   138 
   143 
   139     static void writeInternal(byte type, Object object, DataOutput out) throws IOException {
   144     static void writeInternal(byte type, Object object, ObjectOutput out) throws IOException {
   140         out.writeByte(type);
   145         out.writeByte(type);
   141         switch (type) {
   146         switch (type) {
   142             case DURATION_TYPE:
   147             case DURATION_TYPE:
   143                 ((Duration) object).writeExternal(out);
   148                 ((Duration) object).writeExternal(out);
   144                 break;
   149                 break;
   161                 ((ZoneOffset) object).writeExternal(out);
   166                 ((ZoneOffset) object).writeExternal(out);
   162                 break;
   167                 break;
   163             case ZONE_DATE_TIME_TYPE:
   168             case ZONE_DATE_TIME_TYPE:
   164                 ((ZonedDateTime) object).writeExternal(out);
   169                 ((ZonedDateTime) object).writeExternal(out);
   165                 break;
   170                 break;
       
   171             case OFFSET_TIME_TYPE:
       
   172                 ((OffsetTime) object).writeExternal(out);
       
   173                 break;
       
   174             case OFFSET_DATE_TIME_TYPE:
       
   175                 ((OffsetDateTime) object).writeExternal(out);
       
   176                 break;
       
   177             case YEAR_TYPE:
       
   178                 ((Year) object).writeExternal(out);
       
   179                 break;
       
   180             case YEAR_MONTH_TYPE:
       
   181                 ((YearMonth) object).writeExternal(out);
       
   182                 break;
       
   183             case MONTH_DAY_TYPE:
       
   184                 ((MonthDay) object).writeExternal(out);
       
   185                 break;
       
   186             case PERIOD_TYPE:
       
   187                 ((Period) object).writeExternal(out);
       
   188                 break;
   166             default:
   189             default:
   167                 throw new InvalidClassException("Unknown serialized type");
   190                 throw new InvalidClassException("Unknown serialized type");
   168         }
   191         }
   169     }
   192     }
   170 
   193 
   172     /**
   195     /**
   173      * Implements the {@code Externalizable} interface to read the object.
   196      * Implements the {@code Externalizable} interface to read the object.
   174      *
   197      *
   175      * @param in  the data to read, not null
   198      * @param in  the data to read, not null
   176      */
   199      */
   177     public void readExternal(ObjectInput in) throws IOException {
   200     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
   178         type = in.readByte();
   201         type = in.readByte();
   179         object = readInternal(type, in);
   202         object = readInternal(type, in);
   180     }
   203     }
   181 
   204 
   182     static Object read(DataInput in) throws IOException {
   205     static Object read(ObjectInput in) throws IOException, ClassNotFoundException {
   183         byte type = in.readByte();
   206         byte type = in.readByte();
   184         return readInternal(type, in);
   207         return readInternal(type, in);
   185     }
   208     }
   186 
   209 
   187     private static Object readInternal(byte type, DataInput in) throws IOException {
   210     private static Object readInternal(byte type, ObjectInput in) throws IOException, ClassNotFoundException {
   188         switch (type) {
   211         switch (type) {
   189             case DURATION_TYPE: return Duration.readExternal(in);
   212             case DURATION_TYPE: return Duration.readExternal(in);
   190             case INSTANT_TYPE: return Instant.readExternal(in);
   213             case INSTANT_TYPE: return Instant.readExternal(in);
   191             case LOCAL_DATE_TYPE: return LocalDate.readExternal(in);
   214             case LOCAL_DATE_TYPE: return LocalDate.readExternal(in);
   192             case LOCAL_DATE_TIME_TYPE: return LocalDateTime.readExternal(in);
   215             case LOCAL_DATE_TIME_TYPE: return LocalDateTime.readExternal(in);
   193             case LOCAL_TIME_TYPE: return LocalTime.readExternal(in);
   216             case LOCAL_TIME_TYPE: return LocalTime.readExternal(in);
   194             case ZONE_DATE_TIME_TYPE: return ZonedDateTime.readExternal(in);
   217             case ZONE_DATE_TIME_TYPE: return ZonedDateTime.readExternal(in);
   195             case ZONE_OFFSET_TYPE: return ZoneOffset.readExternal(in);
   218             case ZONE_OFFSET_TYPE: return ZoneOffset.readExternal(in);
   196             case ZONE_REGION_TYPE: return ZoneRegion.readExternal(in);
   219             case ZONE_REGION_TYPE: return ZoneRegion.readExternal(in);
       
   220             case OFFSET_TIME_TYPE: return OffsetTime.readExternal(in);
       
   221             case OFFSET_DATE_TIME_TYPE: return OffsetDateTime.readExternal(in);
       
   222             case YEAR_TYPE: return Year.readExternal(in);
       
   223             case YEAR_MONTH_TYPE: return YearMonth.readExternal(in);
       
   224             case MONTH_DAY_TYPE: return MonthDay.readExternal(in);
       
   225             case PERIOD_TYPE: return Period.readExternal(in);
   197             default:
   226             default:
   198                 throw new StreamCorruptedException("Unknown serialized type");
   227                 throw new StreamCorruptedException("Unknown serialized type");
   199         }
   228         }
   200     }
   229     }
   201 
   230