diff options
Diffstat (limited to 'java/io/ObjectInputStream.java')
| -rw-r--r-- | java/io/ObjectInputStream.java | 1232 |
1 files changed, 615 insertions, 617 deletions
diff --git a/java/io/ObjectInputStream.java b/java/io/ObjectInputStream.java index e4d514c8f..134e04e3b 100644 --- a/java/io/ObjectInputStream.java +++ b/java/io/ObjectInputStream.java @@ -1,21 +1,22 @@ -/************************************************************************* -/* ObjectInputStream.java -- Class used to read serialized objects /* -/* Copyright (c) 1998 by Free Software Foundation, Inc. -/* -/* This program is free software; you can redistribute it and/or modify -/* it under the terms of the GNU Library General Public License as published -/* by the Free Software Foundation, version 2. (see COPYING.LIB) -/* -/* This program 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 for more details. -/* -/* You should have received a copy of the GNU General Public License -/* along with this program; if not, write to the Free Software Foundation -/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA -/*************************************************************************/ + ObjectInputStream.java -- Class used to read serialized objects + + Copyright (c) 1998 by Free Software Foundation, Inc. + Written by Geoff Berry <gcb@gnu.org>. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Library General Public License as published + by the Free Software Foundation, version 2. (see COPYING.LIB) + + This program 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 for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation + Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA +*/ package java.io; @@ -29,7 +30,7 @@ import gnu.java.io.ObjectIdentityWrapper; import gnu.java.lang.reflect.TypeSignature; -/** +/** An <code>ObjectInputStream</code> can be used to read objects as well as primitive data in a platform-independent manner from an <code>InputStream</code>. @@ -37,7 +38,7 @@ import gnu.java.lang.reflect.TypeSignature; The data produced by an <code>ObjectOutputStream</code> can be read and reconstituted by an <code>ObjectInputStream</code>. - <code>readObject(Object)</code> is used to read Objects, the + <code>readObject (Object)</code> is used to read Objects, the <code>read<type></code> methods are used to read primitive data (as in <code>DataInputStream</code>). Strings can be read as objects or as primitive data, depending on how they were @@ -45,28 +46,28 @@ import gnu.java.lang.reflect.TypeSignature; Example usage: <pre> - Hashtable map = new Hashtable(); - map.put( "one", new Integer( 1 ) ); - map.put( "two", new Integer( 2 ) ); + Hashtable map = new Hashtable (); + map.put ("one", new Integer (1)); + map.put ("two", new Integer (2)); ObjectOutputStream oos = - new ObjectOutputStream( new FileOutputStream( "numbers" ) ); - oos.writeObject( map ); - oos.close(); + new ObjectOutputStream (new FileOutputStream ("numbers")); + oos.writeObject (map); + oos.close (); ObjectInputStream ois = - new ObjectInputStream( new FileInputStream( "numbers" ) ); - Hashtable newmap = (Hashtable)ois.readObject(); - - System.out.println( newmap ); + new ObjectInputStream (new FileInputStream ("numbers")); + Hashtable newmap = (Hashtable)ois.readObject (); + + System.out.println (newmap); </pre> The default deserialization can be overriden in two ways. By defining a method <code>private void - readObject(ObjectInputStream)</code>, a class can dictate exactly + readObject (ObjectInputStream)</code>, a class can dictate exactly how information about itself is reconstituted. - <code>defaultReadObject()</code> may be called from this method to + <code>defaultReadObject ()</code> may be called from this method to carry out default deserialization. This method is not responsible for dealing with fields of super-classes or subclasses. @@ -97,23 +98,23 @@ public class ObjectInputStream extends InputStream @exception StreamCorruptedException An invalid stream magic number or stream version was read from the stream. - @see readStreamHeader() + @see readStreamHeader () */ - public ObjectInputStream( InputStream in ) + public ObjectInputStream (InputStream in) throws IOException, StreamCorruptedException { this.resolveEnabled = false; this.isDeserializing = false; this.blockDataPosition = 0; this.blockDataBytes = 0; - this.blockData = new byte[ BUFFER_SIZE ]; - this.blockDataInput = new DataInputStream( this ); - this.realInputStream = new DataInputStream( in ); + this.blockData = new byte[BUFFER_SIZE]; + this.blockDataInput = new DataInputStream (this); + this.realInputStream = new DataInputStream (in); this.nextOID = baseWireHandle; - this.objectLookupTable = new Hashtable(); - this.validators = new Vector(); - setBlockDataMode( true ); - readStreamHeader(); + this.objectLookupTable = new Hashtable (); + this.validators = new Vector (); + setBlockDataMode (true); + readStreamHeader (); } @@ -121,7 +122,7 @@ public class ObjectInputStream extends InputStream Returns the next deserialized object read from the underlying stream. This method can be overriden by a class by implementing - <code>private void readObject(ObjectInputStream)</code>. + <code>private void readObject (ObjectInputStream)</code>. If an exception is thrown from this method, the stream is left in an undefined state. @@ -132,211 +133,210 @@ public class ObjectInputStream extends InputStream @exception IOException Exception from underlying <code>InputStream</code>. */ - public final Object readObject() throws ClassNotFoundException, IOException + public final Object readObject () throws ClassNotFoundException, IOException { - if( this.useSubclassMethod ) - return readObjectOverride(); - - boolean was_deserializing; + if (this.useSubclassMethod) + return readObjectOverride (); + + boolean was_deserializing; Object ret_val; was_deserializing = this.isDeserializing; - if( ! was_deserializing ) - setBlockDataMode( false ); + if (! was_deserializing) + setBlockDataMode (false); this.isDeserializing = true; - DEBUG( "MARKER " ); - byte marker = this.realInputStream.readByte(); +// DEBUG ("MARKER "); + byte marker = this.realInputStream.readByte (); switch (marker) { case TC_BLOCKDATA: case TC_BLOCKDATALONG: - readNextBlock( marker ); - throw new BlockDataException( this.blockDataBytes ); - + readNextBlock (marker); + throw new BlockDataException (this.blockDataBytes); + case TC_NULL: ret_val = null; break; case TC_REFERENCE: { - DEBUG( "REFERENCE " ); - Integer oid = new Integer( this.realInputStream.readInt() ); +// DEBUG ("REFERENCE "); + Integer oid = new Integer (this.realInputStream.readInt ()); ret_val = ((ObjectIdentityWrapper) - this.objectLookupTable.get(oid)).object; + this.objectLookupTable.get (oid)).object; break; } - + case TC_CLASS: { - ObjectStreamClass osc = (ObjectStreamClass)readObject(); - Class clazz = osc.forClass(); - assignNewHandle( clazz ); + ObjectStreamClass osc = (ObjectStreamClass)readObject (); + Class clazz = osc.forClass (); + assignNewHandle (clazz); ret_val = clazz; break; } - + case TC_CLASSDESC: { - DEBUG( "CLASSDESC NAME " ); - String name = this.realInputStream.readUTF(); - DEBUG( "UID " ); - long uid = this.realInputStream.readLong(); - DEBUG( "FLAGS " ); - byte flags = this.realInputStream.readByte(); - DEBUG( "FIELD COUNT " ); - short field_count = this.realInputStream.readShort(); - ObjectStreamField[] fields = new ObjectStreamField[ field_count ]; - - ObjectStreamClass osc = new ObjectStreamClass( name, uid, - flags, fields ); - assignNewHandle( osc ); - - for( int i=0; i < field_count; i++ ) +// DEBUG ("CLASSDESC NAME "); + String name = this.realInputStream.readUTF (); +// DEBUG ("UID "); + long uid = this.realInputStream.readLong (); +// DEBUG ("FLAGS "); + byte flags = this.realInputStream.readByte (); +// DEBUG ("FIELD COUNT "); + short field_count = this.realInputStream.readShort (); + ObjectStreamField[] fields = new ObjectStreamField[field_count]; + + ObjectStreamClass osc = new ObjectStreamClass (name, uid, + flags, fields); + assignNewHandle (osc); + + for (int i=0; i < field_count; i++) { - DEBUG( "TYPE CODE " ); - char type_code = (char)this.realInputStream.readByte(); - DEBUG( "FIELD NAME " ); - String field_name = this.realInputStream.readUTF(); +// DEBUG ("TYPE CODE "); + char type_code = (char)this.realInputStream.readByte (); +// DEBUG ("FIELD NAME "); + String field_name = this.realInputStream.readUTF (); String class_name; - if( type_code == 'L' || type_code == '[' ) - class_name = (String)readObject(); + if (type_code == 'L' || type_code == '[') + class_name = (String)readObject (); else - class_name = String.valueOf( type_code ); - + class_name = String.valueOf (type_code); + fields[i] = - new ObjectStreamField( field_name, + new ObjectStreamField (field_name, TypeSignature.getClassForEncoding - ( class_name ) ); + (class_name)); } - - setBlockDataMode( true ); - osc.setClass( resolveClass( osc ) ); - setBlockDataMode( false ); - - DEBUG( "ENDBLOCKDATA " ); - if( this.realInputStream.readByte() != TC_ENDBLOCKDATA ) - throw new IOException( "Data annotated to class was not consumed." ); - - osc.setSuperclass( (ObjectStreamClass)readObject() ); + + setBlockDataMode (true); + osc.setClass (resolveClass (osc)); + setBlockDataMode (false); + +// DEBUG ("ENDBLOCKDATA "); + if (this.realInputStream.readByte () != TC_ENDBLOCKDATA) + throw new IOException ("Data annotated to class was not consumed."); + + osc.setSuperclass ((ObjectStreamClass)readObject ()); ret_val = osc; break; } - + case TC_STRING: { - DEBUG( "STRING " ); - String s = this.realInputStream.readUTF(); - ret_val = processResoultion( s, assignNewHandle( s ) ); +// DEBUG ("STRING "); + String s = this.realInputStream.readUTF (); + ret_val = processResoultion (s, assignNewHandle (s)); break; } - + case TC_ARRAY: { - ObjectStreamClass osc = (ObjectStreamClass)readObject(); - Class componenetType = osc.forClass().getComponentType(); - DEBUG( "ARRAY LENGTH " ); - int length = this.realInputStream.readInt(); - Object array = Array.newInstance( componenetType, length ); - int handle = assignNewHandle( array ); - readArrayElements( array, componenetType ); - ret_val = processResoultion( array, handle ); + ObjectStreamClass osc = (ObjectStreamClass)readObject (); + Class componenetType = osc.forClass ().getComponentType (); +// DEBUG ("ARRAY LENGTH "); + int length = this.realInputStream.readInt (); + Object array = Array.newInstance (componenetType, length); + int handle = assignNewHandle (array); + readArrayElements (array, componenetType); + ret_val = processResoultion (array, handle); break; } - + case TC_OBJECT: { - ObjectStreamClass osc = (ObjectStreamClass)readObject(); - Class clazz = osc.forClass(); - - if( !Serializable.class.isAssignableFrom( clazz ) ) - throw new NotSerializableException( clazz + " is not Serializable, and thus cannot be deserialized." ); - - if( Externalizable.class.isAssignableFrom( clazz ) ) + ObjectStreamClass osc = (ObjectStreamClass)readObject (); + Class clazz = osc.forClass (); + + if (!Serializable.class.isAssignableFrom (clazz)) + throw new NotSerializableException (clazz + " is not Serializable, and thus cannot be deserialized."); + + if (Externalizable.class.isAssignableFrom (clazz)) { Externalizable obj = null; - + try { - obj = (Externalizable)clazz.newInstance(); + obj = (Externalizable)clazz.newInstance (); } - catch( InstantiationException e ) + catch (InstantiationException e) { - throw new ClassNotFoundException( "Instance of " + clazz - + " could not be created" ); + throw new ClassNotFoundException ("Instance of " + clazz + + " could not be created"); } - catch( IllegalAccessException e ) + catch (IllegalAccessException e) { - throw new ClassNotFoundException( "Instance of " + clazz - + " could not be created because class or zero-argument constructor is not accessible" ); + throw new ClassNotFoundException ("Instance of " + clazz + + " could not be created because class or zero-argument constructor is not accessible"); } - catch( NoSuchMethodError e ) + catch (NoSuchMethodError e) { - throw new ClassNotFoundException( "Instance of " + clazz - + " could not be created because zero-argument constructor is not defined" ); + throw new ClassNotFoundException ("Instance of " + clazz + + " could not be created because zero-argument constructor is not defined"); } - int handle = assignNewHandle( obj ); + int handle = assignNewHandle (obj); + + boolean read_from_blocks = ((osc.getFlags () & SC_BLOCK_DATA) != 0); - boolean read_from_blocks = ((osc.getFlags() & SC_BLOCK_DATA) != 0); - - if( read_from_blocks ) - setBlockDataMode( true ); + if (read_from_blocks) + setBlockDataMode (true); - obj.readExternal( this ); + obj.readExternal (this); - if( read_from_blocks ) - setBlockDataMode( false ); + if (read_from_blocks) + setBlockDataMode (false); - ret_val = processResoultion( obj, handle ); + ret_val = processResoultion (obj, handle); break; - } // end if( Externalizable.class.isAssignableFrom( clazz ) ) + } // end if (Externalizable.class.isAssignableFrom (clazz)) // find the first non-serializable, non-abstract // class in clazz's inheritance hierarchy - Class first_nonserial = clazz.getSuperclass(); - while( Serializable.class.isAssignableFrom( first_nonserial ) - || Modifier.isAbstract( first_nonserial.getModifiers() ) ) - first_nonserial = first_nonserial.getSuperclass(); - - DEBUGln( "Using " + first_nonserial - + " as starting point for constructing " + clazz ); + Class first_nonserial = clazz.getSuperclass (); + while (Serializable.class.isAssignableFrom (first_nonserial) + || Modifier.isAbstract (first_nonserial.getModifiers ())) + first_nonserial = first_nonserial.getSuperclass (); + +// DEBUGln ("Using " + first_nonserial +// + " as starting point for constructing " + clazz); Object obj = null; - obj = newObject( clazz, first_nonserial ); - - if( obj == null ) - throw new ClassNotFoundException( "Instance of " + clazz + - " could not be created" ); + obj = newObject (clazz, first_nonserial); + + if (obj == null) + throw new ClassNotFoundException ("Instance of " + clazz + + " could not be created"); - int handle = assignNewHandle( obj ); + int handle = assignNewHandle (obj); this.currentObject = obj; ObjectStreamClass[] hierarchy = - ObjectStreamClass.getObjectStreamClasses( clazz ); + ObjectStreamClass.getObjectStreamClasses (clazz); - DEBUGln( "Got class hierarchy of depth " + hierarchy.length ); +// DEBUGln ("Got class hierarchy of depth " + hierarchy.length); - // XXX: rewrite this loop natively? boolean has_read; - for( int i=0; i < hierarchy.length; i++ ) + for (int i=0; i < hierarchy.length; i++) { this.currentObjectStreamClass = hierarchy[i]; - DEBUGln( "Reading fields of " - + this.currentObjectStreamClass.getName() ); +// DEBUGln ("Reading fields of " +// + this.currentObjectStreamClass.getName ()); has_read = true; - + try { - this.currentObjectStreamClass.forClass(). - getDeclaredMethod( "readObject", ourReadObjectParams ); + this.currentObjectStreamClass.forClass (). + getDeclaredMethod ("readObject", readObjectParams); } - catch( NoSuchMethodException e ) + catch (NoSuchMethodException e) { has_read = false; } @@ -345,59 +345,59 @@ public class ObjectInputStream extends InputStream // that aren't in the stream // should skip over classes in the stream that aren't in the // real classes hierarchy - readFields( obj, this.currentObjectStreamClass.getFields(), - has_read, this.currentObjectStreamClass ); + readFields (obj, this.currentObjectStreamClass.fields, + has_read, this.currentObjectStreamClass); - if( has_read ) + if (has_read) { - DEBUG( "ENDBLOCKDATA? " ); - if( this.realInputStream.readByte() != TC_ENDBLOCKDATA ) - throw new IOException( "No end of block data seen for class with readObject(ObjectInputStream) method." ); +// DEBUG ("ENDBLOCKDATA? "); + if (this.realInputStream.readByte () != TC_ENDBLOCKDATA) + throw new IOException ("No end of block data seen for class with readObject (ObjectInputStream) method."); } } this.currentObject = null; this.currentObjectStreamClass = null; - ret_val = processResoultion( obj, handle ); + ret_val = processResoultion (obj, handle); break; } - + case TC_RESET: - clearHandles(); - ret_val = readObject(); + clearHandles (); + ret_val = readObject (); break; - + case TC_EXCEPTION: { - Exception e = (Exception)readObject(); - clearHandles(); - throw new WriteAbortedException( "Exception thrown during writing of stream", e ); + Exception e = (Exception)readObject (); + clearHandles (); + throw new WriteAbortedException ("Exception thrown during writing of stream", e); } - + default: - throw new IOException( "Unknown marker on stream" ); + throw new IOException ("Unknown marker on stream"); } - + this.isDeserializing = was_deserializing; - if( ! was_deserializing ) + if (! was_deserializing) { - setBlockDataMode( true ); + setBlockDataMode (true); - if( validators.size() > 0 ) - invokeValidators(); + if (validators.size () > 0) + invokeValidators (); } - + return ret_val; } - - /** + + /** Reads the current objects non-transient, non-static fields from the current class from the underlying output stream. This method is intended to be called from within a object's - <code>private void readObject(ObjectInputStream)</code> + <code>private void readObject (ObjectInputStream)</code> method. @exception ClassNotFoundException The class that an object being @@ -405,24 +405,24 @@ public class ObjectInputStream extends InputStream @exception NotActiveException This method was called from a context other than from the current object's and current class's - <code>private void readObject(ObjectInputStream)</code> + <code>private void readObject (ObjectInputStream)</code> method. @exception IOException Exception from underlying <code>OutputStream</code>. */ - public void defaultReadObject() + public void defaultReadObject () throws ClassNotFoundException, IOException, NotActiveException { - if( this.currentObject == null || this.currentObjectStreamClass == null ) - throw new NotActiveException( "defaultReadObject called by non-active class and/or object" ); - - if( fieldsAlreadyRead ) - throw new NotActiveException( "defaultReadObject called but fields already read from stream (by defaultReadObject or readFields)" ); + if (this.currentObject == null || this.currentObjectStreamClass == null) + throw new NotActiveException ("defaultReadObject called by non-active class and/or object"); + + if (fieldsAlreadyRead) + throw new NotActiveException ("defaultReadObject called but fields already read from stream (by defaultReadObject or readFields)"); - readFields( this.currentObject, - this.currentObjectStreamClass.getFields(), - false, this.currentObjectStreamClass ); + readFields (this.currentObject, + this.currentObjectStreamClass.fields, + false, this.currentObjectStreamClass); fieldsAlreadyRead = true; } @@ -431,7 +431,7 @@ public class ObjectInputStream extends InputStream /** Registers a <code>ObjectInputValidation</code> to be carried out on the object graph currently being deserialized before it is - returned to the original caller of <code>readObject()</code>. + returned to the original caller of <code>readObject ()</code>. The order of validation for multiple <code>ObjectInputValidation</code>s can be controled using <code>priority</code>. Validators with higher priorities are @@ -446,25 +446,25 @@ public class ObjectInputStream extends InputStream validator outside of the <code>readObject</code> method of the object currently being deserialized */ - public void registerValidation( ObjectInputValidation validator, - int priority ) + public void registerValidation (ObjectInputValidation validator, + int priority) throws InvalidObjectException, NotActiveException { - if( this.currentObject == null || this.currentObjectStreamClass == null ) - throw new NotActiveException( "registerValidation called by non-active class and/or object" ); - - if( validator == null ) - throw new InvalidObjectException( "attempt to add a null ObjectInputValidation object" ); - - this.validators.addElement( new ValidatorAndPriority( validator, - priority ) ); + if (this.currentObject == null || this.currentObjectStreamClass == null) + throw new NotActiveException ("registerValidation called by non-active class and/or object"); + + if (validator == null) + throw new InvalidObjectException ("attempt to add a null ObjectInputValidation object"); + + this.validators.addElement (new ValidatorAndPriority (validator, + priority)); } - - /** + + /** Called when a class is being deserialized. This is a hook to allow subclasses to read in information written by the - <code>annotateClass(Class)</code> method of an + <code>annotateClass (Class)</code> method of an <code>ObjectOutputStream</code>. This implementation looks up the active call stack for a @@ -475,29 +475,29 @@ public class ObjectInputStream extends InputStream @exception IOException Exception from underlying <code>OutputStream</code>. - @see java.io.ObjectOutputStream#annotateClass(java.lang.Class) + @see java.io.ObjectOutputStream#annotateClass (java.lang.Class) */ - protected Class resolveClass( ObjectStreamClass osc ) + protected Class resolveClass (ObjectStreamClass osc) throws ClassNotFoundException, IOException { - DEBUGln( "Resolving " + osc ); +// DEBUGln ("Resolving " + osc); - SecurityManager sm = System.getSecurityManager(); - - if( sm == null ) - sm = new SecurityManager() {}; - - ClassLoader cl = currentClassLoader( sm ); + SecurityManager sm = System.getSecurityManager (); - if( cl == null ) + if (sm == null) + sm = new SecurityManager () {}; + + ClassLoader cl = currentClassLoader (sm); + + if (cl == null) { - DEBUGln( "No class loader found" ); - return Class.forName( osc.getName() ); +// DEBUGln ("No class loader found"); + return Class.forName (osc.getName ()); } else { - DEBUGln( "Using " + cl ); - return cl.loadClass( osc.getName() ); +// DEBUGln ("Using " + cl); + return cl.loadClass (osc.getName ()); } } @@ -513,28 +513,28 @@ public class ObjectInputStream extends InputStream @exception IOException Exception from underlying <code>OutputStream</code>. - @see enableResolveObject(boolean) + @see enableResolveObject (boolean) */ - protected Object resolveObject( Object obj ) throws IOException + protected Object resolveObject (Object obj) throws IOException { return obj; } - + /** If <code>enable</code> is <code>true</code> and this object is - trusted, then <code>resolveObject(Object)</code> will be called - in subsequent calls to <code>readObject(Object)</code>. - Otherwise, <code>resolveObject(Object)</code> will not be called. + trusted, then <code>resolveObject (Object)</code> will be called + in subsequent calls to <code>readObject (Object)</code>. + Otherwise, <code>resolveObject (Object)</code> will not be called. @exception SecurityException This class is not trusted. */ - protected boolean enableResolveObject( boolean enable ) + protected boolean enableResolveObject (boolean enable) throws SecurityException { - if( enable ) - if( getClass().getClassLoader() != null ) - throw new SecurityException( "Untrusted ObjectInputStream subclass attempted to enable object resolution" ); + if (enable) + if (getClass ().getClassLoader () != null) + throw new SecurityException ("Untrusted ObjectInputStream subclass attempted to enable object resolution"); boolean old_val = this.resolveEnabled; this.resolveEnabled = enable; @@ -544,396 +544,398 @@ public class ObjectInputStream extends InputStream /** Reads stream magic and stream version information from the - underlying stream. + underlying stream. @exception IOException Exception from underlying stream. @exception StreamCorruptedException An invalid stream magic - number or stream version was read from the stream. + number or stream version was read from the stream. */ - protected void readStreamHeader() + protected void readStreamHeader () throws IOException, StreamCorruptedException { - DEBUG( "STREAM MAGIC " ); - if( this.realInputStream.readShort() != STREAM_MAGIC ) - throw new StreamCorruptedException( "Invalid stream magic number" ); - - DEBUG( "STREAM VERSION " ); - if( this.realInputStream.readShort() != STREAM_VERSION ) - throw new StreamCorruptedException( "Invalid stream version number" ); +// DEBUG ("STREAM MAGIC "); + if (this.realInputStream.readShort () != STREAM_MAGIC) + throw new StreamCorruptedException ("Invalid stream magic number"); + +// DEBUG ("STREAM VERSION "); + if (this.realInputStream.readShort () != STREAM_VERSION) + throw new StreamCorruptedException ("Invalid stream version number"); } - public int read() throws IOException + public int read () throws IOException { - if( this.readDataFromBlock ) + if (this.readDataFromBlock) { - if( this.blockDataPosition >= this.blockDataBytes ) - readNextBlock(); - return this.blockData[ this.blockDataPosition++ ]; + if (this.blockDataPosition >= this.blockDataBytes) + readNextBlock (); + return this.blockData[this.blockDataPosition++]; } else - return this.realInputStream.read(); + return this.realInputStream.read (); } - public int read( byte data[], int offset, int length ) throws IOException + public int read (byte data[], int offset, int length) throws IOException { - if( this.readDataFromBlock ) + if (this.readDataFromBlock) { - if( this.blockDataPosition + length >= this.blockDataBytes ) - readNextBlock(); + if (this.blockDataPosition + length >= this.blockDataBytes) + readNextBlock (); - System.arraycopy( this.blockData, this.blockDataPosition, - data, offset, length ); + System.arraycopy (this.blockData, this.blockDataPosition, + data, offset, length); return length; } else - return this.realInputStream.read( data, offset, length ); + return this.realInputStream.read (data, offset, length); } - public int available() throws IOException + public int available () throws IOException { - if( this.readDataFromBlock ) + if (this.readDataFromBlock) { - if( this.blockDataPosition >= this.blockDataBytes ) - readNextBlock(); - + if (this.blockDataPosition >= this.blockDataBytes) + readNextBlock (); + return this.blockDataBytes - this.blockDataPosition; } else - return this.realInputStream.available(); + return this.realInputStream.available (); } - public void close() throws IOException + public void close () throws IOException { - this.realInputStream.close(); + this.realInputStream.close (); } - public boolean readBoolean() throws IOException + public boolean readBoolean () throws IOException { - return this.dataInputStream.readBoolean(); + return this.dataInputStream.readBoolean (); } - public byte readByte() throws IOException + public byte readByte () throws IOException { - return this.dataInputStream.readByte(); + return this.dataInputStream.readByte (); } - public int readUnsignedByte() throws IOException + public int readUnsignedByte () throws IOException { - return this.dataInputStream.readUnsignedByte(); + return this.dataInputStream.readUnsignedByte (); } - - public short readShort() throws IOException + + public short readShort () throws IOException { - return this.dataInputStream.readShort(); + return this.dataInputStream.readShort (); } - public int readUnsignedShort() throws IOException + public int readUnsignedShort () throws IOException { - return this.dataInputStream.readUnsignedShort(); + return this.dataInputStream.readUnsignedShort (); } - public char readChar() throws IOException + public char readChar () throws IOException { - return this.dataInputStream.readChar(); + return this.dataInputStream.readChar (); } - public int readInt() throws IOException + public int readInt () throws IOException { - return this.dataInputStream.readInt(); + return this.dataInputStream.readInt (); } - public long readLong() throws IOException + public long readLong () throws IOException { - return this.dataInputStream.readLong(); + return this.dataInputStream.readLong (); } - public float readFloat() throws IOException + public float readFloat () throws IOException { - return this.dataInputStream.readFloat(); + return this.dataInputStream.readFloat (); } - public double readDouble() throws IOException + public double readDouble () throws IOException { - return this.dataInputStream.readDouble(); + return this.dataInputStream.readDouble (); } - public void readFully( byte data[] ) throws IOException + public void readFully (byte data[]) throws IOException { - this.dataInputStream.readFully( data ); + this.dataInputStream.readFully (data); } - public void readFully( byte data[], int offset, int size ) + public void readFully (byte data[], int offset, int size) throws IOException { - this.dataInputStream.readFully( data, offset, size ); + this.dataInputStream.readFully (data, offset, size); } - public int skipBytes( int len ) throws IOException + public int skipBytes (int len) throws IOException { - return this.dataInputStream.skipBytes( len ); + return this.dataInputStream.skipBytes (len); } /** @deprecated - @see java.io.DataInputStream#readLine() + @see java.io.DataInputStream#readLine () */ - public String readLine() throws IOException + public String readLine () throws IOException { - return this.dataInputStream.readLine(); + return this.dataInputStream.readLine (); } - public String readUTF() throws IOException + public String readUTF () throws IOException { - return this.dataInputStream.readUTF(); + return this.dataInputStream.readUTF (); } - + /** This class allows a class to specify exactly which fields should be read, and what values should be read for these fields. - + XXX: finish up comments */ public static abstract class GetField { - public abstract ObjectStreamClass getObjectStreamClass(); + public abstract ObjectStreamClass getObjectStreamClass (); - public abstract boolean defaulted( String name ) + public abstract boolean defaulted (String name) throws IOException, IllegalArgumentException; - public abstract boolean get( String name, boolean defvalue ) + public abstract boolean get (String name, boolean defvalue) throws IOException, IllegalArgumentException; - public abstract char get( String name, char defvalue) + public abstract char get (String name, char defvalue) throws IOException, IllegalArgumentException; - - public abstract byte get( String name, byte defvalue ) + + public abstract byte get (String name, byte defvalue) throws IOException, IllegalArgumentException; - public abstract short get( String name, short defvalue ) + public abstract short get (String name, short defvalue) throws IOException, IllegalArgumentException; - public abstract int get( String name, int defvalue ) + public abstract int get (String name, int defvalue) throws IOException, IllegalArgumentException; - public abstract long get( String name, long defvalue ) + public abstract long get (String name, long defvalue) throws IOException, IllegalArgumentException; - public abstract float get( String name, float defvalue ) + public abstract float get (String name, float defvalue) throws IOException, IllegalArgumentException; - public abstract double get( String name, double defvalue ) + public abstract double get (String name, double defvalue) throws IOException, IllegalArgumentException; - public abstract Object get( String name, Object defvalue) + public abstract Object get (String name, Object defvalue) throws IOException, IllegalArgumentException; } - public GetField readFields() + public GetField readFields () throws IOException, ClassNotFoundException, NotActiveException { - if( true ) - throw new RuntimeException( "putFields() not implemented!" ); + if (this.currentObject == null || this.currentObjectStreamClass == null) + throw new NotActiveException ("readFields called by non-active class and/or object"); + + if (fieldsAlreadyRead) + throw new NotActiveException ("readFields called but fields already read from stream (by defaultReadObject or readFields)"); - if( this.currentObject == null || this.currentObjectStreamClass == null ) - throw new NotActiveException( "readFields called by non-active class and/or object" ); + final ObjectStreamClass clazz = this.currentObjectStreamClass; + final byte[] prim_field_data = new byte[clazz.primFieldSize]; + final Object[] objs = new Object[clazz.objectFieldCount]; + readFully (prim_field_data); + for (int i = 0; i < objs.length; ++ i) + objs[i] = readObject (); - if( fieldsAlreadyRead ) - throw new NotActiveException( "readFields called but fields already read from stream (by defaultReadObject or readFields)" ); - - // XXX actually read the data - return new GetField() + return new GetField () { - public ObjectStreamClass getObjectStreamClass() + public ObjectStreamClass getObjectStreamClass () { - return currentObjectStreamClass; + return clazz; } - public boolean defaulted( String name ) + public boolean defaulted (String name) throws IOException, IllegalArgumentException { - return currentObjectStreamClass.getField( name ) == null; + return clazz.getField (name) == null; } - - public boolean get( String name, boolean defvalue ) + + public boolean get (String name, boolean defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Boolean.TYPE ); + ObjectStreamField field = getField (name, Boolean.TYPE); - if( field == null ) + if (field == null) return defvalue; - - return primFieldData[ field.getOffset() ] == 0 ? false : true; + + return prim_field_data[field.getOffset ()] == 0 ? false : true; } - - public char get( String name, char defvalue ) + + public char get (String name, char defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Character.TYPE ); + ObjectStreamField field = getField (name, Character.TYPE); - if( field == null ) + if (field == null) return defvalue; - - int off = field.getOffset(); - - return (char)(((primFieldData[off++] & 0xFF) << 8) - | (primFieldData[off] & 0xFF)); + + int off = field.getOffset (); + + return (char)(((prim_field_data[off++] & 0xFF) << 8) + | (prim_field_data[off] & 0xFF)); } - - public byte get( String name, byte defvalue ) + + public byte get (String name, byte defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Byte.TYPE ); + ObjectStreamField field = getField (name, Byte.TYPE); - if( field == null ) + if (field == null) return defvalue; - - return primFieldData[ field.getOffset() ]; + + return prim_field_data[field.getOffset ()]; } - - public short get( String name, short defvalue ) + + public short get (String name, short defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Short.TYPE ); + ObjectStreamField field = getField (name, Short.TYPE); - if( field == null ) + if (field == null) return defvalue; - - int off = field.getOffset(); - - return (short)(((primFieldData[off++] & 0xFF) << 8) - | (primFieldData[off] & 0xFF)); + + int off = field.getOffset (); + + return (short)(((prim_field_data[off++] & 0xFF) << 8) + | (prim_field_data[off] & 0xFF)); } - - public int get( String name, int defvalue ) + + public int get (String name, int defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Integer.TYPE ); + ObjectStreamField field = getField (name, Integer.TYPE); - if( field == null ) + if (field == null) return defvalue; - - int off = field.getOffset(); - - return ((primFieldData[off++] & 0xFF) << 24) - | ((primFieldData[off++] & 0xFF) << 16) - | ((primFieldData[off++] & 0xFF) << 8) - | (primFieldData[off] & 0xFF); + + int off = field.getOffset (); + + return ((prim_field_data[off++] & 0xFF) << 24) + | ((prim_field_data[off++] & 0xFF) << 16) + | ((prim_field_data[off++] & 0xFF) << 8) + | (prim_field_data[off] & 0xFF); } - - public long get( String name, long defvalue ) + + public long get (String name, long defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Long.TYPE ); + ObjectStreamField field = getField (name, Long.TYPE); - if( field == null ) + if (field == null) return defvalue; - - int off = field.getOffset(); - - return (long)(((primFieldData[off++] & 0xFF) << 56) - | ((primFieldData[off++] & 0xFF) << 48) - | ((primFieldData[off++] & 0xFF) << 40) - | ((primFieldData[off++] & 0xFF) << 32) - | ((primFieldData[off++] & 0xFF) << 24) - | ((primFieldData[off++] & 0xFF) << 16) - | ((primFieldData[off++] & 0xFF) << 8) - | (primFieldData[off] & 0xFF)); + + int off = field.getOffset (); + + return (long)(((prim_field_data[off++] & 0xFF) << 56) + | ((prim_field_data[off++] & 0xFF) << 48) + | ((prim_field_data[off++] & 0xFF) << 40) + | ((prim_field_data[off++] & 0xFF) << 32) + | ((prim_field_data[off++] & 0xFF) << 24) + | ((prim_field_data[off++] & 0xFF) << 16) + | ((prim_field_data[off++] & 0xFF) << 8) + | (prim_field_data[off] & 0xFF)); } - public float get( String name, float defvalue ) + public float get (String name, float defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Float.TYPE ); + ObjectStreamField field = getField (name, Float.TYPE); - if( field == null ) + if (field == null) return defvalue; - - int off = field.getOffset(); - - return Float.intBitsToFloat(((primFieldData[off++] & 0xFF) << 24) - | ((primFieldData[off++] & 0xFF) << 16) - | ((primFieldData[off++] & 0xFF) << 8) - | (primFieldData[off] & 0xFF)); + + int off = field.getOffset (); + + return Float.intBitsToFloat (((prim_field_data[off++] & 0xFF) << 24) + | ((prim_field_data[off++] & 0xFF) << 16) + | ((prim_field_data[off++] & 0xFF) << 8) + | (prim_field_data[off] & 0xFF)); } - public double get( String name, double defvalue ) + public double get (String name, double defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, Double.TYPE ); + ObjectStreamField field = getField (name, Double.TYPE); - if( field == null ) + if (field == null) return defvalue; - - int off = field.getOffset(); - - return Double.longBitsToDouble( - (long)(((primFieldData[off++] & 0xFF) << 56) - | ((primFieldData[off++] & 0xFF) << 48) - | ((primFieldData[off++] & 0xFF) << 40) - | ((primFieldData[off++] & 0xFF) << 32) - | ((primFieldData[off++] & 0xFF) << 24) - | ((primFieldData[off++] & 0xFF) << 16) - | ((primFieldData[off++] & 0xFF) << 8) - | (primFieldData[off] & 0xFF))); + + int off = field.getOffset (); + + return Double.longBitsToDouble ( + (long)(((prim_field_data[off++] & 0xFF) << 56) + | ((prim_field_data[off++] & 0xFF) << 48) + | ((prim_field_data[off++] & 0xFF) << 40) + | ((prim_field_data[off++] & 0xFF) << 32) + | ((prim_field_data[off++] & 0xFF) << 24) + | ((prim_field_data[off++] & 0xFF) << 16) + | ((prim_field_data[off++] & 0xFF) << 8) + | (prim_field_data[off] & 0xFF))); } - public Object get( String name, Object defvalue ) + public Object get (String name, Object defvalue) throws IOException, IllegalArgumentException { - ObjectStreamField field = getField( name, null ); + ObjectStreamField field = getField (name, null); - if( field == null ) + if (field == null) return defvalue; - - return objects[ field.getOffset() ]; + + return objs[field.getOffset ()]; } - private ObjectStreamField getField( String name, Class type ) + private ObjectStreamField getField (String name, Class type) throws IllegalArgumentException { - ObjectStreamField field = currentObjectStreamClass.getField( name ); + ObjectStreamField field = clazz.getField (name); - if( field == null ) + if (field == null) return null; - - Class field_type = field.getType(); - if( type == field_type || - ( type != null && field_type.isPrimitive() ) ) + Class field_type = field.getType (); + + if (type == field_type || + (type != null && field_type.isPrimitive ())) return field; - throw new IllegalArgumentException( "Field requested is of type " - + field_type.getName() + throw new IllegalArgumentException ("Field requested is of type " + + field_type.getName () + ", but requested type was " - + (type == null ? - "Object" : type.getName()) ); + + (type == null ? + "Object" : type.getName ())); } - - private byte[] primFieldData; - private Object[] objects; }; - + } /** Protected constructor that allows subclasses to override deserialization. This constructor should be called by subclasses - that wish to override <code>readObject(Object)</code>. This + that wish to override <code>readObject (Object)</code>. This method does a security check <i>NOTE: currently not implemented</i>, then sets a flag that informs - <code>readObject(Object)</code> to call the subclasses - <code>readObjectOverride(Object)</code> method. + <code>readObject (Object)</code> to call the subclasses + <code>readObjectOverride (Object)</code> method. - @see readObjectOverride(Object) + @see readObjectOverride (Object) */ - protected ObjectInputStream() - throws IOException, StreamCorruptedException + protected ObjectInputStream () + throws IOException, SecurityException { - //XXX: security check + SecurityManager sec_man = System.getSecurityManager (); + if (sec_man != null) + sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION); this.useSubclassMethod = true; } @@ -945,174 +947,174 @@ public class ObjectInputStream extends InputStream writing objects, subclasses must invoke the 0-argument constructor on this class from there constructor. - @see ObjectInputStream() + @see ObjectInputStream () */ - protected Object readObjectOverride() + protected Object readObjectOverride () throws ClassNotFoundException, IOException, OptionalDataException { - throw new IOException( "Subclass of ObjectInputStream must implement readObjectOverride" ); + throw new IOException ("Subclass of ObjectInputStream must implement readObjectOverride"); } - + // assigns the next availible handle to OBJ - private int assignNewHandle( Object obj ) + private int assignNewHandle (Object obj) { - this.objectLookupTable.put( new Integer( this.nextOID ), - new ObjectIdentityWrapper( obj ) ); + this.objectLookupTable.put (new Integer (this.nextOID), + new ObjectIdentityWrapper (obj)); - try - { - DEBUG( "Assigning handle " + this.nextOID ); - DEBUGln( " to " + obj ); - } - catch( Throwable t ) {} +// try +// { +// DEBUG ("Assigning handle " + this.nextOID); +// DEBUGln (" to " + obj); +// } +// catch (Throwable t) {} return this.nextOID++; } - private Object processResoultion( Object obj, int handle ) + private Object processResoultion (Object obj, int handle) throws IOException { - if( obj instanceof Resolvable ) - obj = ((Resolvable)obj).readResolve(); - - if( this.resolveEnabled ) - obj = resolveObject( obj ); - - this.objectLookupTable.put( new Integer( handle ), - new ObjectIdentityWrapper( obj ) ); + if (obj instanceof Resolvable) + obj = ((Resolvable)obj).readResolve (); + + if (this.resolveEnabled) + obj = resolveObject (obj); + + this.objectLookupTable.put (new Integer (handle), + new ObjectIdentityWrapper (obj)); return obj; } - - private void clearHandles() + + private void clearHandles () { - this.objectLookupTable.clear(); + this.objectLookupTable.clear (); this.nextOID = baseWireHandle; } - - private void readNextBlock() throws IOException + + private void readNextBlock () throws IOException { - DEBUG( "MARKER " ); - readNextBlock( this.realInputStream.readByte() ); +// DEBUG ("MARKER "); + readNextBlock (this.realInputStream.readByte ()); } - private void readNextBlock( byte marker ) throws IOException + private void readNextBlock (byte marker) throws IOException { - if( marker == TC_BLOCKDATA ) + if (marker == TC_BLOCKDATA) { - DEBUG( "BLOCK DATA SIZE " ); - this.blockDataBytes = this.realInputStream.readUnsignedByte(); +// DEBUG ("BLOCK DATA SIZE "); + this.blockDataBytes = this.realInputStream.readUnsignedByte (); } - else if( marker == TC_BLOCKDATALONG ) + else if (marker == TC_BLOCKDATALONG) { - DEBUG( "BLOCK DATA LONG SIZE " ); - this.blockDataBytes = this.realInputStream.readInt(); +// DEBUG ("BLOCK DATA LONG SIZE "); + this.blockDataBytes = this.realInputStream.readInt (); } else { - throw new EOFException( "Attempt to read primitive data, but no data block is active." ); + throw new EOFException ("Attempt to read primitive data, but no data block is active."); } - if( this.blockData.length < this.blockDataBytes ) - this.blockData = new byte[ this.blockDataBytes ]; - - this.realInputStream.readFully( this.blockData, 0, this.blockDataBytes ); + if (this.blockData.length < this.blockDataBytes) + this.blockData = new byte[this.blockDataBytes]; + + this.realInputStream.readFully (this.blockData, 0, this.blockDataBytes); this.blockDataPosition = 0; } - private void readArrayElements( Object array, Class clazz ) + private void readArrayElements (Object array, Class clazz) throws ClassNotFoundException, IOException { - if( clazz.isPrimitive() ) + if (clazz.isPrimitive ()) { - if( clazz == Boolean.TYPE ) + if (clazz == Boolean.TYPE) { boolean[] cast_array = (boolean[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readBoolean(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readBoolean (); return; } - if( clazz == Byte.TYPE ) + if (clazz == Byte.TYPE) { byte[] cast_array = (byte[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readByte(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readByte (); return; } - if( clazz == Character.TYPE ) + if (clazz == Character.TYPE) { char[] cast_array = (char[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readChar(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readChar (); return; } - if( clazz == Double.TYPE ) + if (clazz == Double.TYPE) { double[] cast_array = (double[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readDouble(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readDouble (); return; } - if( clazz == Float.TYPE ) + if (clazz == Float.TYPE) { float[] cast_array = (float[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readFloat(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readFloat (); return; } - if( clazz == Integer.TYPE ) + if (clazz == Integer.TYPE) { int[] cast_array = (int[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readInt(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readInt (); return; } - if( clazz == Long.TYPE ) + if (clazz == Long.TYPE) { long[] cast_array = (long[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readLong(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readLong (); return; } - if( clazz == Short.TYPE ) + if (clazz == Short.TYPE) { short[] cast_array = (short[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = this.realInputStream.readShort(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = this.realInputStream.readShort (); return; } } else { Object[] cast_array = (Object[])array; - for( int i=0; i < cast_array.length; i++ ) - cast_array[i] = readObject(); + for (int i=0; i < cast_array.length; i++) + cast_array[i] = readObject (); } } - - private void readFields( Object obj, ObjectStreamField[] stream_fields, + + private void readFields (Object obj, ObjectStreamField[] stream_fields, boolean call_read_method, - ObjectStreamClass stream_osc ) + ObjectStreamClass stream_osc) throws ClassNotFoundException, IOException { - if( call_read_method ) + if (call_read_method) { fieldsAlreadyRead = false; - setBlockDataMode( true ); - callReadMethod( obj, stream_osc.forClass() ); - setBlockDataMode( false ); + setBlockDataMode (true); + callReadMethod (obj, stream_osc.forClass ()); + setBlockDataMode (false); return; } ObjectStreamField[] real_fields = - ObjectStreamClass.lookup( stream_osc.forClass() ).getFields(); + ObjectStreamClass.lookup (stream_osc.forClass ()).fields; boolean default_initialize, set_value; String field_name = null; @@ -1122,40 +1124,40 @@ public class ObjectInputStream extends InputStream int stream_idx = 0; int real_idx = 0; - while( stream_idx < stream_fields.length - && real_idx < real_fields.length ) + while (stream_idx < stream_fields.length + && real_idx < real_fields.length) { default_initialize = false; set_value = true; - if( stream_idx == stream_fields.length ) + if (stream_idx == stream_fields.length) default_initialize = true; else { - stream_field = stream_fields[ stream_idx ]; - type = stream_field.getType(); + stream_field = stream_fields[stream_idx]; + type = stream_field.getType (); } - - if( real_idx == real_fields.length ) + + if (real_idx == real_fields.length) set_value = false; else { - real_field = real_fields[ real_idx ]; - type = real_field.getType(); - field_name = real_field.getName(); + real_field = real_fields[real_idx]; + type = real_field.getType (); + field_name = real_field.getName (); } - if( set_value && !default_initialize ) + if (set_value && !default_initialize) { int comp_val = - real_field.compareTo( stream_field ); + real_field.compareTo (stream_field); - if( comp_val < 0 ) + if (comp_val < 0) { default_initialize = true; real_idx++; } - else if( comp_val > 0 ) + else if (comp_val > 0) { set_value = false; stream_idx++; @@ -1167,159 +1169,159 @@ public class ObjectInputStream extends InputStream } } - if( type == Boolean.TYPE ) + if (type == Boolean.TYPE) { boolean value = - default_initialize ? false : this.realInputStream.readBoolean(); - if( set_value ) - setBooleanField( obj, field_name, value ); + default_initialize ? false : this.realInputStream.readBoolean (); + if (set_value) + setBooleanField (obj, field_name, value); } - else if( type == Byte.TYPE ) + else if (type == Byte.TYPE) { byte value = - default_initialize ? 0 : this.realInputStream.readByte(); - if( set_value ) - setByteField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readByte (); + if (set_value) + setByteField (obj, field_name, value); } - else if( type == Character.TYPE ) + else if (type == Character.TYPE) { char value = - default_initialize ? 0 : this.realInputStream.readChar(); - if( set_value ) - setCharField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readChar (); + if (set_value) + setCharField (obj, field_name, value); } - else if( type == Double.TYPE ) + else if (type == Double.TYPE) { double value = - default_initialize ? 0 : this.realInputStream.readDouble(); - if( set_value ) - setDoubleField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readDouble (); + if (set_value) + setDoubleField (obj, field_name, value); } - else if( type == Float.TYPE ) + else if (type == Float.TYPE) { float value = - default_initialize ? 0 : this.realInputStream.readFloat(); - if( set_value ) - setFloatField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readFloat (); + if (set_value) + setFloatField (obj, field_name, value); } - else if( type == Integer.TYPE ) + else if (type == Integer.TYPE) { int value = - default_initialize ? 0 : this.realInputStream.readInt(); - if( set_value ) - setIntField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readInt (); + if (set_value) + setIntField (obj, field_name, value); } - else if( type == Long.TYPE ) + else if (type == Long.TYPE) { long value = - default_initialize ? 0 : this.realInputStream.readLong(); - if( set_value ) - setLongField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readLong (); + if (set_value) + setLongField (obj, field_name, value); } - else if( type == Short.TYPE ) + else if (type == Short.TYPE) { short value = - default_initialize ? 0 : this.realInputStream.readShort(); - if( set_value ) - setShortField( obj, field_name, value ); + default_initialize ? 0 : this.realInputStream.readShort (); + if (set_value) + setShortField (obj, field_name, value); } else { Object value = - default_initialize ? null : readObject(); - if( set_value ) - setObjectField( obj, field_name, - real_field.getTypeString(), value ); + default_initialize ? null : readObject (); + if (set_value) + setObjectField (obj, field_name, + real_field.getTypeString (), value); } } } - + // Toggles writing primitive data to block-data buffer. - private void setBlockDataMode( boolean on ) + private void setBlockDataMode (boolean on) { - DEBUGln( "Setting block data mode to " + on ); +// DEBUGln ("Setting block data mode to " + on); this.readDataFromBlock = on; - if( on ) + if (on) this.dataInputStream = this.blockDataInput; else this.dataInputStream = this.realInputStream; } - + // returns a new instance of REAL_CLASS that has been constructed // only to th level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS) - private Object newObject( Class real_class, Class constructor_class ) + private Object newObject (Class real_class, Class constructor_class) { try { - Object obj = allocateObject( real_class ); - callConstructor( constructor_class, obj ); + Object obj = allocateObject (real_class); + callConstructor (constructor_class, obj); return obj; } - catch( InstantiationException e ) + catch (InstantiationException e) { return null; } } - + // runs all registered ObjectInputValidations in prioritized order // on OBJ - private void invokeValidators() throws InvalidObjectException + private void invokeValidators () throws InvalidObjectException { - Object[] validators = new Object[ this.validators.size() ]; - this.validators.copyInto( validators ); - Arrays.sort( validators ); - + Object[] validators = new Object[this.validators.size ()]; + this.validators.copyInto (validators); + Arrays.sort (validators); + try { - for( int i=0; i < validators.length; i++ ) - ((ObjectInputValidation)validators[i]).validateObject(); + for (int i=0; i < validators.length; i++) + ((ObjectInputValidation)validators[i]).validateObject (); } finally { - this.validators.removeAllElements(); + this.validators.removeAllElements (); } } - + // this native method is used to get access to the protected method // of the same name in SecurityManger - private static native ClassLoader currentClassLoader( SecurityManager sm ); + private static native ClassLoader currentClassLoader (SecurityManager sm); - private native void callReadMethod( Object obj, Class clazz ); + private native void callReadMethod (Object obj, Class clazz); - private native Object allocateObject( Class clazz ) + private native Object allocateObject (Class clazz) throws InstantiationException; - private native void callConstructor( Class clazz, Object obj ); - - private native void setBooleanField( Object obj, String field_name, - boolean val ); - private native void setByteField( Object obj, String field_name, - byte val ); - private native void setCharField( Object obj, String field_name, - char val ); - private native void setDoubleField( Object obj, String field_name, - double val ); - private native void setFloatField( Object obj, String field_name, - float val ); - private native void setIntField( Object obj, String field_name, - int val ); - private native void setLongField( Object obj, String field_name, - long val ); - private native void setShortField( Object obj, String field_name, - short val ); - private native void setObjectField( Object obj, String field_name, - String type_code, Object val ); + private native void callConstructor (Class clazz, Object obj); + + private native void setBooleanField (Object obj, String field_name, + boolean val); + private native void setByteField (Object obj, String field_name, + byte val); + private native void setCharField (Object obj, String field_name, + char val); + private native void setDoubleField (Object obj, String field_name, + double val); + private native void setFloatField (Object obj, String field_name, + float val); + private native void setIntField (Object obj, String field_name, + int val); + private native void setLongField (Object obj, String field_name, + long val); + private native void setShortField (Object obj, String field_name, + short val); + private native void setObjectField (Object obj, String field_name, + String type_code, Object val); private static final int BUFFER_SIZE = 1024; - private static final Class[] ourReadObjectParams = { ObjectInputStream.class }; - + private static final Class[] readObjectParams = { ObjectInputStream.class }; + private DataInputStream realInputStream; private DataInputStream dataInputStream; private DataInputStream blockDataInput; @@ -1339,25 +1341,21 @@ public class ObjectInputStream extends InputStream static { - //DEBUG - //System.out.println( "Using ObjectInputStream" ); - //eDEBUG - - System.loadLibrary( "javaio" ); + System.loadLibrary ("javaio"); } - private void DEBUG( String msg ) + private void DEBUG (String msg) { - System.out.print( msg ); + System.out.print (msg); } - - private void DEBUGln( String msg ) + + private void DEBUGln (String msg) { - System.out.println( msg ); + System.out.println (msg); } - + } @@ -1367,13 +1365,13 @@ class ValidatorAndPriority implements Comparable int priority; ObjectInputValidation validator; - ValidatorAndPriority( ObjectInputValidation validator, int priority ) + ValidatorAndPriority (ObjectInputValidation validator, int priority) { this.priority = priority; this.validator = validator; } - public int compareTo( Object o ) + public int compareTo (Object o) { ValidatorAndPriority vap = (ValidatorAndPriority)o; return this.priority - vap.priority; |