--- /dev/null 2013-01-18 16:17:08.886776012 -0800 +++ new/src/share/classes/java/time/temporal/Ser.java 2013-01-22 16:58:15.000000000 -0800 @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * Copyright (c) 2011-2012, Stephen Colebourne & Michael Nascimento Santos + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of JSR-310 nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package java.time.temporal; + +import java.io.Externalizable; +import java.io.IOException; +import java.io.InvalidClassException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.io.StreamCorruptedException; +import java.time.LocalDate; +import java.time.LocalDateTime; + +/** + * The shared serialization delegate for this package. + * + *
+ * In order to serialise the object it writes its byte and then calls back to the appropriate class where + * the serialisation is performed. In order to deserialise the object it read in the type byte, switching + * in order to select which class to call back into. + *
+ * The serialisation format is determined on a per class basis. In the case of field based classes each + * of the fields is written out with an appropriate size format in descending order of the field's size. For + * example in the case of {@link LocalDate} year is written before month. Composite classes, such as + * {@link LocalDateTime} are serialised as one object. Enum classes are serialised using the index of their + * element. + *
+ * This class is mutable and should be created once per serialization. + * + * @serial include + * @since 1.8 + */ +final class Ser implements Externalizable { + + /** + * Serialization version. + */ + private static final long serialVersionUID = -6103370247208168577L; + + static final byte OFFSET_DATE_TYPE = 1; + static final byte OFFSET_TIME_TYPE = 2; + static final byte OFFSET_DATE_TIME_TYPE = 3; + static final byte YEAR_TYPE = 4; + static final byte YEAR_MONTH_TYPE = 5; + static final byte MONTH_DAY_TYPE = 6; + static final byte CHRONO_TYPE = 7; + static final byte CHRONO_LOCAL_DATE_TIME_TYPE = 8; + static final byte CHRONO_ZONE_DATE_TIME_TYPE = 9; + static final byte SIMPLE_PERIOD_TYPE = 10; + + /** The type being serialized. */ + private byte type; + /** The object being serialized. */ + private Object object; + + /** + * Constructor for deserialization. + */ + public Ser() { + } + + /** + * Creates an instance for serialization. + * + * @param type the type + * @param object the object + */ + Ser(byte type, Object object) { + this.type = type; + this.object = object; + } + + //----------------------------------------------------------------------- + /** + * Implements the {@code Externalizable} interface to write the object. + * + * @param out the data stream to write to, not null + */ + @Override + public void writeExternal(ObjectOutput out) throws IOException { + writeInternal(type, object, out); + } + + private static void writeInternal(byte type, Object object, ObjectOutput out) throws IOException { + out.writeByte(type); + switch (type) { + case OFFSET_DATE_TYPE: + ((OffsetDate) object).writeExternal(out); + break; + case OFFSET_TIME_TYPE: + ((OffsetTime) object).writeExternal(out); + break; + case OFFSET_DATE_TIME_TYPE: + ((OffsetDateTime) object).writeExternal(out); + break; + case YEAR_TYPE: + ((Year) object).writeExternal(out); + break; + case YEAR_MONTH_TYPE: + ((YearMonth) object).writeExternal(out); + break; + case MONTH_DAY_TYPE: + ((MonthDay) object).writeExternal(out); + break; + case CHRONO_TYPE: + ((Chrono>) object).writeExternal(out); + break; + case CHRONO_LOCAL_DATE_TIME_TYPE: + ((ChronoLocalDateTimeImpl>) object).writeExternal(out); + break; + case CHRONO_ZONE_DATE_TIME_TYPE: + ((ChronoZonedDateTimeImpl>) object).writeExternal(out); + break; + case SIMPLE_PERIOD_TYPE: + ((SimplePeriod) object).writeExternal(out); + break; + default: + throw new InvalidClassException("Unknown serialized type"); + } + } + + //----------------------------------------------------------------------- + /** + * Implements the {@code Externalizable} interface to read the object. + * + * @param in the data to read, not null + */ + @Override + public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + type = in.readByte(); + object = readInternal(type, in); + } + + static Object read(ObjectInput in) throws IOException, ClassNotFoundException { + byte type = in.readByte(); + return readInternal(type, in); + } + + private static Object readInternal(byte type, ObjectInput in) throws IOException, ClassNotFoundException { + switch (type) { + case OFFSET_DATE_TYPE: return OffsetDate.readExternal(in); + case OFFSET_TIME_TYPE: return OffsetTime.readExternal(in); + case OFFSET_DATE_TIME_TYPE: return OffsetDateTime.readExternal(in); + case YEAR_TYPE: return Year.readExternal(in); + case YEAR_MONTH_TYPE: return YearMonth.readExternal(in); + case MONTH_DAY_TYPE: return MonthDay.readExternal(in); + case CHRONO_TYPE: return Chrono.readExternal(in); + case CHRONO_LOCAL_DATE_TIME_TYPE: return ChronoLocalDateTimeImpl.readExternal(in); + case CHRONO_ZONE_DATE_TIME_TYPE: return ChronoZonedDateTimeImpl.readExternal(in); + case SIMPLE_PERIOD_TYPE: return SimplePeriod.readExternal(in); + default: throw new StreamCorruptedException("Unknown serialized type"); + } + } + + /** + * Returns the object that will replace this one. + * + * @return the read object, should never be null + */ + private Object readResolve() { + return object; + } + +}