jdk-sandbox: comparison src/java.base/share/classes/java/io/ObjectOutputStream.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1996, 2019, 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
 *
 * @param   out output stream to write to
 * @throws  IOException if an I/O error occurs while writing stream header
 * @throws  SecurityException if untrusted subclass illegally overrides
 *          security-sensitive methods
-* @throws  NullPointerException if <code>out</code> is <code>null</code>
+* @throws  NullPointerException if {@code out} is {@code null}
 * @since   1.4
 * @see     ObjectOutputStream#ObjectOutputStream()
 * @see     ObjectOutputStream#putFields()
 * @see     ObjectInputStream#ObjectInputStream(InputStream)
 */
 * Provide a way for subclasses that are completely reimplementing
 * ObjectOutputStream to not have to allocate private data just used by
 * this implementation of ObjectOutputStream.
 *
 * <p>If there is a security manager installed, this method first calls the
-* security manager's <code>checkPermission</code> method with a
+* security manager's {@code checkPermission} method with a
-* <code>SerializablePermission("enableSubclassImplementation")</code>
+* {@code SerializablePermission("enableSubclassImplementation")}
 * permission to ensure it's ok to enable subclassing.
 *
 * @throws  SecurityException if a security manager exists and its
-*          <code>checkPermission</code> method denies enabling
+*          {@code checkPermission} method denies enabling
 *          subclassing.
 * @throws  IOException if an I/O error occurs while creating this stream
 * @see SecurityManager#checkPermission
 * @see java.io.SerializablePermission
 */
 }
 }
 /**
 * Method used by subclasses to override the default writeObject method.
-* This method is called by trusted subclasses of ObjectInputStream that
+* This method is called by trusted subclasses of ObjectOutputStream that
-* constructed ObjectInputStream using the protected no-arg constructor.
+* constructed ObjectOutputStream using the protected no-arg constructor.
 * The subclass is expected to provide an override method with the modifier
 * "final".
 *
 * @param   obj object to be written to the underlying stream
 * @throws  IOException if there are I/O errors while writing to the
 * this stream.  This may only be called from the writeObject method of the
 * class being serialized. It will throw the NotActiveException if it is
 * called otherwise.
 *
 * @throws  IOException if I/O errors occur while writing to the underlying
-*          <code>OutputStream</code>
+*          {@code OutputStream}
 */
 public void defaultWriteObject() throws IOException {
 SerialCallbackContext ctx = curContext;
 if (ctx == null) {
 throw new NotActiveException("not in call to writeObject");
 * Subclasses may implement this method to store custom data in the stream
 * along with descriptors for dynamic proxy classes.
 *
 * <p>This method is called exactly once for each unique proxy class
 * descriptor in the stream.  The default implementation of this method in
-* <code>ObjectOutputStream</code> does nothing.
+* {@code ObjectOutputStream} does nothing.
 *
-* <p>The corresponding method in <code>ObjectInputStream</code> is
+* <p>The corresponding method in {@code ObjectInputStream} is
-* <code>resolveProxyClass</code>.  For a given subclass of
+* {@code resolveProxyClass}.  For a given subclass of
-* <code>ObjectOutputStream</code> that overrides this method, the
+* {@code ObjectOutputStream} that overrides this method, the
-* <code>resolveProxyClass</code> method in the corresponding subclass of
+* {@code resolveProxyClass} method in the corresponding subclass of
-* <code>ObjectInputStream</code> must read any data or objects written by
+* {@code ObjectInputStream} must read any data or objects written by
-* <code>annotateProxyClass</code>.
+* {@code annotateProxyClass}.
 *
 * @param   cl the proxy class to annotate custom data for
 * @throws  IOException any exception thrown by the underlying
-*          <code>OutputStream</code>
+*          {@code OutputStream}
 * @see ObjectInputStream#resolveProxyClass(String[])
 * @since   1.3
 */
 protected void annotateProxyClass(Class<?> cl) throws IOException {
 }
 * Write the specified class descriptor to the ObjectOutputStream.  Class
 * descriptors are used to identify the classes of objects written to the
 * stream.  Subclasses of ObjectOutputStream may override this method to
 * customize the way in which class descriptors are written to the
 * serialization stream.  The corresponding method in ObjectInputStream,
-* <code>readClassDescriptor</code>, should then be overridden to
+* {@code readClassDescriptor}, should then be overridden to
 * reconstitute the class descriptor from its custom stream representation.
 * By default, this method writes class descriptors according to the format
 * defined in the Object Serialization specification.
 *
 * <p>Note that this method will only be called if the ObjectOutputStream
 * is not using the old serialization stream format (set by calling
-* ObjectOutputStream's <code>useProtocolVersion</code> method).  If this
+* ObjectOutputStream's {@code useProtocolVersion} method).  If this
 * serialization stream is using the old format
-* (<code>PROTOCOL_VERSION_1</code>), the class descriptor will be written
+* ({@code PROTOCOL_VERSION_1}), the class descriptor will be written
 * internally in a manner that cannot be overridden or customized.
 *
 * @param   desc class descriptor to write to the stream
 * @throws  IOException If an I/O error has occurred.
 * @see java.io.ObjectInputStream#readClassDescriptor()
 * to ObjectOutput.
 *
 * @since 1.2
 */
 public abstract static class PutField {
+/**
+* Constructor for subclasses to call.
+*/
+public PutField() {}
 /**
 * Put the value of the named boolean field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>boolean</code>
+* {@code boolean}
 */
 public abstract void put(String name, boolean val);
 /**
 * Put the value of the named byte field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>byte</code>
+* {@code byte}
 */
 public abstract void put(String name, byte val);
 /**
 * Put the value of the named char field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>char</code>
+* {@code char}
 */
 public abstract void put(String name, char val);
 /**
 * Put the value of the named short field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>short</code>
+* {@code short}
 */
 public abstract void put(String name, short val);
 /**
 * Put the value of the named int field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>int</code>
+* {@code int}
 */
 public abstract void put(String name, int val);
 /**
 * Put the value of the named long field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>long</code>
+* {@code long}
 */
 public abstract void put(String name, long val);
 /**
 * Put the value of the named float field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>float</code>
+* {@code float}
 */
 public abstract void put(String name, float val);
 /**
 * Put the value of the named double field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>double</code>
+* {@code double}
 */
 public abstract void put(String name, double val);
 /**
 * Put the value of the named Object field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-*         (which may be <code>null</code>)
+*         (which may be {@code null})
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not a
 * reference type
 */
 public abstract void put(String name, Object val);
 /**
 * Write the data and fields to the specified ObjectOutput stream,
 * which must be the same stream that produced this
-* <code>PutField</code> object.
+* {@code PutField} object.
 *
 * @param  out the stream to write the data and fields to
 * @throws IOException if I/O errors occur while writing to the
 *         underlying stream
 * @throws IllegalArgumentException if the specified stream is not
-*         the same stream that produced this <code>PutField</code>
+*         the same stream that produced this {@code PutField}
 *         object
 * @deprecated This method does not write the values contained by this
-*         <code>PutField</code> object in a proper format, and may
+*         {@code PutField} object in a proper format, and may
 *         result in corruption of the serialization stream.  The
-*         correct way to write <code>PutField</code> data is by
+*         correct way to write {@code PutField} data is by
 *         calling the {@link java.io.ObjectOutputStream#writeFields()}
 *         method.
 */
 @Deprecated
 public abstract void write(ObjectOutput out) throws IOException;
 bout.setBlockDataMode(oldMode);
 }
 }
 /**
-* Converts specified span of float values into byte values.
-*/
-// REMIND: remove once hotspot inlines Float.floatToIntBits
-private static native void floatsToBytes(float[] src, int srcpos,
-byte[] dst, int dstpos,
-int nfloats);
-/**
-* Converts specified span of double values into byte values.
-*/
-// REMIND: remove once hotspot inlines Double.doubleToLongBits
-private static native void doublesToBytes(double[] src, int srcpos,
-byte[] dst, int dstpos,
-int ndoubles);
-/**
 * Default PutField implementation.
 */
 private class PutFieldImpl extends PutField {
 /** class descriptor describing serializable fields */
 int limit = MAX_BLOCK_SIZE - 4;
 int endoff = off + len;
 while (off < endoff) {
 if (pos <= limit) {
 int avail = (MAX_BLOCK_SIZE - pos) >> 2;
-int chunklen = Math.min(endoff - off, avail);
+int stop = Math.min(endoff, off + avail);
-floatsToBytes(v, off, buf, pos, chunklen);
+while (off < stop) {
-off += chunklen;
+Bits.putFloat(buf, pos, v[off++]);
-pos += chunklen << 2;
+pos += 4;
+}
 } else {
 dout.writeFloat(v[off++]);
 }
 }
 }
 int limit = MAX_BLOCK_SIZE - 8;
 int endoff = off + len;
 while (off < endoff) {
 if (pos <= limit) {
 int avail = (MAX_BLOCK_SIZE - pos) >> 3;
-int chunklen = Math.min(endoff - off, avail);
+int stop = Math.min(endoff, off + avail);
-doublesToBytes(v, off, buf, pos, chunklen);
+while (off < stop) {
-off += chunklen;
+Bits.putDouble(buf, pos, v[off++]);
-pos += chunklen << 3;
+pos += 8;
+}
 } else {
 dout.writeDouble(v[off++]);
 }
 }
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 47216	71c04702a3d5
child 58679	9c3209ff7550