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

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 * Machine.  Classes are loaded as required using the standard mechanisms.
 *
 * <p>Only objects that support the java.io.Serializable or
 * java.io.Externalizable interface can be read from streams.
 *
-* <p>The method <code>readObject</code> is used to read an object from the
+* <p>The method {@code readObject} is used to read an object from the
 * stream.  Java's safe casting should be used to get the desired type.  In
 * Java, strings and arrays are objects and are treated as objects during
 * serialization. When read they need to be cast to the expected type.
 *
 * <p>Primitive data types can be read from the stream using the appropriate
 * behave in the same manner--if the stream is already positioned at the end of
 * data written by the corresponding writeExternal method, object reads will
 * throw OptionalDataExceptions with eof set to true, bytewise reads will
 * return -1, and primitive reads will throw EOFExceptions.  Note that this
 * behavior does not hold for streams written with the old
-* <code>ObjectStreamConstants.PROTOCOL_VERSION_1</code> protocol, in which the
+* {@code ObjectStreamConstants.PROTOCOL_VERSION_1} protocol, in which the
 * end of data written by writeExternal methods is not demarcated, and hence
 * cannot be detected.
 *
 * <p>The readObjectNoData method is responsible for initializing the state of
 * the object for its particular class in the event that the serialization
 * <p>Enum constants are deserialized differently than ordinary serializable or
 * externalizable objects.  The serialized form of an enum constant consists
 * solely of its name; field values of the constant are not transmitted.  To
 * deserialize an enum constant, ObjectInputStream reads the constant name from
 * the stream; the deserialized constant is then obtained by calling the static
-* method <code>Enum.valueOf(Class, String)</code> with the enum constant's
+* method {@code Enum.valueOf(Class, String)} with the enum constant's
 * base type and the received constant name as arguments.  Like other
 * serializable or externalizable objects, enum constants can function as the
 * targets of back references appearing subsequently in the serialization
 * stream.  The process by which enum constants are deserialized cannot be
 * customized: any class-specific readObject, readObjectNoData, and readResolve
 * @param   in input stream to read from
 * @throws  StreamCorruptedException if the stream header is incorrect
 * @throws  IOException if an I/O error occurs while reading stream header
 * @throws  SecurityException if untrusted subclass illegally overrides
 *          security-sensitive methods
-* @throws  NullPointerException if <code>in</code> is <code>null</code>
+* @throws  NullPointerException if {@code in} is {@code null}
 * @see     ObjectInputStream#ObjectInputStream()
 * @see     ObjectInputStream#readFields()
 * @see     ObjectOutputStream#ObjectOutputStream(OutputStream)
 */
 public ObjectInputStream(InputStream in) throws IOException {
 *
 * <p>The serialization filter is initialized to the value of
 * {@linkplain ObjectInputFilter.Config#getSerialFilter() the system-wide filter}.
 *
 * <p>If there is a security manager installed, this method first calls the
-* security manager's <code>checkPermission</code> method with the
+* security manager's {@code checkPermission} method with the
-* <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
 */
 }
 }
 }
 /**
-* This method is called by trusted subclasses of ObjectOutputStream that
+* This method is called by trusted subclasses of ObjectInputStream that
-* constructed ObjectOutputStream using the protected no-arg constructor.
++ constructed ObjectInputStream using the protected no-arg constructor.
 * The subclass is expected to provide an override method with the modifier
 * "final".
 *
 * @return  the Object read from the stream.
 * @throws  ClassNotFoundException Class definition of a serialized object
 /**
 * Reads the persistent fields from the stream and makes them available by
 * name.
 *
-* @return  the <code>GetField</code> object representing the persistent
+* @return  the {@code GetField} object representing the persistent
 *          fields of the object being deserialized
 * @throws  ClassNotFoundException if the class of a serialized object
 *          could not be found.
 * @throws  IOException if an I/O error occurs.
 * @throws  NotActiveException if the stream is not currently reading
 /**
 * Load the local class equivalent of the specified stream class
 * description.  Subclasses may implement this method to allow classes to
 * be fetched from an alternate source.
 *
-* <p>The corresponding method in <code>ObjectOutputStream</code> is
+* <p>The corresponding method in {@code ObjectOutputStream} is
-* <code>annotateClass</code>.  This method will be invoked only once for
+* {@code annotateClass}.  This method will be invoked only once for
 * each unique class in the stream.  This method can be implemented by
 * subclasses to use an alternate loading mechanism but must return a
-* <code>Class</code> object. Once returned, if the class is not an array
+* {@code Class} object. Once returned, if the class is not an array
 * class, its serialVersionUID is compared to the serialVersionUID of the
 * serialized class, and if there is a mismatch, the deserialization fails
 * and an {@link InvalidClassException} is thrown.
 *
 * <p>The default implementation of this method in
-* <code>ObjectInputStream</code> returns the result of calling
+* {@code ObjectInputStream} returns the result of calling
 * <pre>
 *     Class.forName(desc.getName(), false, loader)
 * </pre>
-* where <code>loader</code> is the first class loader on the current
+* where {@code loader} is the first class loader on the current
 * thread's stack (starting from the currently executing method) that is
 * neither the {@linkplain ClassLoader#getPlatformClassLoader() platform
-* class loader} nor its ancestor; otherwise, <code>loader</code> is the
+* class loader} nor its ancestor; otherwise, {@code loader} is the
 * <em>platform class loader</em>. If this call results in a
-* <code>ClassNotFoundException</code> and the name of the passed
+* {@code ClassNotFoundException} and the name of the passed
-* <code>ObjectStreamClass</code> instance is the Java language keyword
+* {@code ObjectStreamClass} instance is the Java language keyword
-* for a primitive type or void, then the <code>Class</code> object
+* for a primitive type or void, then the {@code Class} object
 * representing that primitive type or void will be returned
-* (e.g., an <code>ObjectStreamClass</code> with the name
+* (e.g., an {@code ObjectStreamClass} with the name
-* <code>"int"</code> will be resolved to <code>Integer.TYPE</code>).
+* {@code "int"} will be resolved to {@code Integer.TYPE}).
-* Otherwise, the <code>ClassNotFoundException</code> will be thrown to
+* Otherwise, the {@code ClassNotFoundException} will be thrown to
 * the caller of this method.
 *
-* @param   desc an instance of class <code>ObjectStreamClass</code>
+* @param   desc an instance of class {@code ObjectStreamClass}
-* @return  a <code>Class</code> object corresponding to <code>desc</code>
+* @return  a {@code Class} object corresponding to {@code desc}
 * @throws  IOException any of the usual Input/Output exceptions.
 * @throws  ClassNotFoundException if class of a serialized object cannot
 *          be found.
 */
 protected Class<?> resolveClass(ObjectStreamClass desc)
 * interfaces and the proxy class.
 *
 * <p>This method is called exactly once for each unique proxy class
 * descriptor in the stream.
 *
-* <p>The corresponding method in <code>ObjectOutputStream</code> is
+* <p>The corresponding method in {@code ObjectOutputStream} is
-* <code>annotateProxyClass</code>.  For a given subclass of
+* {@code annotateProxyClass}.  For a given subclass of
-* <code>ObjectInputStream</code> that overrides this method, the
+* {@code ObjectInputStream} that overrides this method, the
-* <code>annotateProxyClass</code> method in the corresponding subclass of
+* {@code annotateProxyClass} method in the corresponding subclass of
-* <code>ObjectOutputStream</code> must write any data or objects read by
+* {@code ObjectOutputStream} must write any data or objects read by
 * this method.
 *
 * <p>The default implementation of this method in
-* <code>ObjectInputStream</code> returns the result of calling
+* {@code ObjectInputStream} returns the result of calling
-* <code>Proxy.getProxyClass</code> with the list of <code>Class</code>
+* {@code Proxy.getProxyClass} with the list of {@code Class}
-* objects for the interfaces that are named in the <code>interfaces</code>
+* objects for the interfaces that are named in the {@code interfaces}
-* parameter.  The <code>Class</code> object for each interface name
+* parameter.  The {@code Class} object for each interface name
-* <code>i</code> is the value returned by calling
+* {@code i} is the value returned by calling
 * <pre>
 *     Class.forName(i, false, loader)
 * </pre>
-* where <code>loader</code> is the first class loader on the current
+* where {@code loader} is the first class loader on the current
 * thread's stack (starting from the currently executing method) that is
 * neither the {@linkplain ClassLoader#getPlatformClassLoader() platform
-* class loader} nor its ancestor; otherwise, <code>loader</code> is the
+* class loader} nor its ancestor; otherwise, {@code loader} is the
 * <em>platform class loader</em>.
 * Unless any of the resolved interfaces are non-public, this same value
-* of <code>loader</code> is also the class loader passed to
+* of {@code loader} is also the class loader passed to
-* <code>Proxy.getProxyClass</code>; if non-public interfaces are present,
+* {@code Proxy.getProxyClass}; if non-public interfaces are present,
 * their class loader is passed instead (if more than one non-public
 * interface class loader is encountered, an
-* <code>IllegalAccessError</code> is thrown).
+* {@code IllegalAccessError} is thrown).
-* If <code>Proxy.getProxyClass</code> throws an
+* If {@code Proxy.getProxyClass} throws an
-* <code>IllegalArgumentException</code>, <code>resolveProxyClass</code>
+* {@code IllegalArgumentException}, {@code resolveProxyClass}
-* will throw a <code>ClassNotFoundException</code> containing the
+* will throw a {@code ClassNotFoundException} containing the
-* <code>IllegalArgumentException</code>.
+* {@code IllegalArgumentException}.
 *
 * @param interfaces the list of interface names that were
 *                deserialized in the proxy class descriptor
 * @return  a proxy class for the specified interfaces
 * @throws        IOException any exception thrown by the underlying
-*                <code>InputStream</code>
+*                {@code InputStream}
 * @throws        ClassNotFoundException if the proxy class or any of the
 *                named interfaces could not be found
 * @see ObjectOutputStream#annotateProxyClass(Class)
 * @since 1.3
 */
 * The readStreamHeader method is provided to allow subclasses to read and
 * verify their own stream headers. It reads and verifies the magic number
 * and version number.
 *
 * @throws  IOException if there are I/O errors while reading from the
-*          underlying <code>InputStream</code>
+*          underlying {@code InputStream}
 * @throws  StreamCorruptedException if control information in the stream
 *          is inconsistent
 */
 protected void readStreamHeader()
 throws IOException, StreamCorruptedException
 * Read a class descriptor from the serialization stream.  This method is
 * called when the ObjectInputStream expects a class descriptor as the next
 * item in the serialization stream.  Subclasses of ObjectInputStream may
 * override this method to read in class descriptors that have been written
 * in non-standard formats (by subclasses of ObjectOutputStream which have
-* overridden the <code>writeClassDescriptor</code> method).  By default,
+* overridden the {@code writeClassDescriptor} method).  By default,
 * this method reads class descriptors according to the format defined in
 * the Object Serialization specification.
 *
 * @return  the class descriptor read
 * @throws  IOException If an I/O error has occurred.
 /**
 * Returns the number of bytes that can be read without blocking.
 *
 * @return  the number of available bytes.
 * @throws  IOException if there are I/O errors while reading from the
-*          underlying <code>InputStream</code>
+*          underlying {@code InputStream}
 */
 public int available() throws IOException {
 return bin.available();
 }
 /**
 * Reads in a line that has been terminated by a \n, \r, \r\n or EOF.
 *
 * @return  a String copy of the line.
 * @throws  IOException if there are I/O errors while reading from the
-*          underlying <code>InputStream</code>
+*          underlying {@code InputStream}
 * @deprecated This method does not properly convert bytes to characters.
 *          see DataInputStream for the details and alternatives.
 */
 @Deprecated
 public String readLine() throws IOException {
 * <a href="DataInput.html#modified-utf-8">modified UTF-8</a>
 * format.
 *
 * @return  the String.
 * @throws  IOException if there are I/O errors while reading from the
-*          underlying <code>InputStream</code>
+*          underlying {@code InputStream}
 * @throws  UTFDataFormatException if read bytes do not represent a valid
 *          modified UTF-8 encoding of a string
 */
 public String readUTF() throws IOException {
 return bin.readUTF();
 /**
 * Provide access to the persistent fields read from the input stream.
 */
 public abstract static class GetField {
+/**
+* Constructor for subclasses to call.
+*/
+public GetField() {}
 /**
 * Get the ObjectStreamClass that describes the fields in the stream.
 *
 * @return  the descriptor class that describes the serializable fields
 * stream.
 *
 * @param  name the name of the field
 * @return true, if and only if the named field is defaulted
 * @throws IOException if there are I/O errors while reading from
-*         the underlying <code>InputStream</code>
+*         the underlying {@code InputStream}
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 *         correspond to a serializable field
 */
 public abstract boolean defaulted(String name) throws IOException;
 /**
 * Get the value of the named boolean field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>boolean</code> field
+* @return the value of the named {@code boolean} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract boolean get(String name, boolean val)
 throws IOException;
 /**
 * Get the value of the named byte field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>byte</code> field
+* @return the value of the named {@code byte} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract byte get(String name, byte val) throws IOException;
 /**
 * Get the value of the named char field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>char</code> field
+* @return the value of the named {@code char} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract char get(String name, char val) throws IOException;
 /**
 * Get the value of the named short field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>short</code> field
+* @return the value of the named {@code short} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract short get(String name, short val) throws IOException;
 /**
 * Get the value of the named int field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>int</code> field
+* @return the value of the named {@code int} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract int get(String name, int val) throws IOException;
 /**
 * Get the value of the named long field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>long</code> field
+* @return the value of the named {@code long} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract long get(String name, long val) throws IOException;
 /**
 * Get the value of the named float field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>float</code> field
+* @return the value of the named {@code float} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract float get(String name, float val) throws IOException;
 /**
 * Get the value of the named double field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>double</code> field
+* @return the value of the named {@code double} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract double get(String name, double val) throws IOException;
 /**
 * Get the value of the named Object field from the persistent field.
 *
 * @param  name the name of the field
-* @param  val the default value to use if <code>name</code> does not
+* @param  val the default value to use if {@code name} does not
 *         have a value
-* @return the value of the named <code>Object</code> field
+* @return the value of the named {@code Object} field
 * @throws IOException if there are I/O errors while reading from the
-*         underlying <code>InputStream</code>
+*         underlying {@code InputStream}
-* @throws IllegalArgumentException if type of <code>name</code> is
+* @throws IllegalArgumentException if type of {@code name} is
 *         not serializable or if the field type is incorrect
 */
 public abstract Object get(String name, Object val) throws IOException;
 }
 throw new StreamCorruptedException(
 "unexpected reset; recursion depth: " + depth);
 }
 clear();
 }
-/**
-* Converts specified span of bytes into float values.
-*/
-// REMIND: remove once hotspot inlines Float.intBitsToFloat
-private static native void bytesToFloats(byte[] src, int srcpos,
-float[] dst, int dstpos,
-int nfloats);
-/**
-* Converts specified span of bytes into double values.
-*/
-// REMIND: remove once hotspot inlines Double.longBitsToDouble
-private static native void bytesToDoubles(byte[] src, int srcpos,
-double[] dst, int dstpos,
-int ndoubles);
 /**
 * Returns the first non-null and non-platform class loader (not counting
 * class loaders of generated reflection implementation classes) up the
 * execution stack, or the platform class loader if only code from the
 }
 }
 }
 void readFloats(float[] v, int off, int len) throws IOException {
-int span, endoff = off + len;
+int stop, endoff = off + len;
 while (off < endoff) {
 if (!blkmode) {
-span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
+int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
 in.readFully(buf, 0, span << 2);
+stop = off + span;
 pos = 0;
 } else if (end - pos < 4) {
 v[off++] = din.readFloat();
 continue;
 } else {
-span = Math.min(endoff - off, ((end - pos) >> 2));
+stop = Math.min(endoff, ((end - pos) >> 2));
 }
-bytesToFloats(buf, pos, v, off, span);
+while (off < stop) {
-off += span;
+v[off++] = Bits.getFloat(buf, pos);
-pos += span << 2;
+pos += 4;
+}
 }
 }
 void readLongs(long[] v, int off, int len) throws IOException {
 int stop, endoff = off + len;
 }
 }
 }
 void readDoubles(double[] v, int off, int len) throws IOException {
-int span, endoff = off + len;
+int stop, endoff = off + len;
 while (off < endoff) {
 if (!blkmode) {
-span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
+int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
 in.readFully(buf, 0, span << 3);
+stop = off + span;
 pos = 0;
 } else if (end - pos < 8) {
 v[off++] = din.readDouble();
 continue;
 } else {
-span = Math.min(endoff - off, ((end - pos) >> 3));
+stop = Math.min(endoff - off, ((end - pos) >> 3));
 }
-bytesToDoubles(buf, pos, v, off, span);
+while (off < stop) {
-off += span;
+v[off++] = Bits.getDouble(buf, pos);
-pos += span << 3;
+pos += 8;
+}
 }
 }
 /**
 * Reads in string written in "long" UTF format.  "Long" UTF format is

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 53304	9e968a576dd2
child 58679	9c3209ff7550