home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / main.bin / ObjectOutputStream.java < prev    next >
Text File  |  1998-01-23  |  41KB  |  1,213 lines
  1. /*
  2.  * @(#)ObjectOutputStream.java    1.30 97/10/01
  3.  * 
  4.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion 1.1_beta
  20.  */
  21.  
  22. package java.io;
  23.  
  24. import java.util.Stack;
  25.  
  26. /**
  27.  * An ObjectOutputStream writes primitive data types and graphs of
  28.  * Java objects to an OutputStream.  The objects can be read
  29.  * (reconstituted) using an ObjectInputStream.
  30.  * Persistent storage of objects can be accomplished by using a file for
  31.  * the stream.
  32.  * If the stream is a network socket stream, the objects can be reconsituted
  33.  * on another host or in another process. <p>
  34.  *
  35.  * Only objects that support the java.io.Serializable interface can be
  36.  * written to streams.
  37.  *
  38.  * The class of each serializable object is encoded including the class
  39.  * name and signature of the class, the values of the
  40.  * object's fields and arrays, and the closure of any other objects
  41.  * referenced from the initial objects. <p>
  42.  * 
  43.  * The method <STRONG>writeObject</STRONG> is used to write an object
  44.  * to the stream.  Any object, including Strings and arrays, is
  45.  * written with writeObject. Multiple objects or primitives can be
  46.  * written to the stream.  The objects must be read back from the
  47.  * corresponding ObjectInputstream with the same types and in the same
  48.  * order as they were written.<p>
  49.  *
  50.  * Primitive data types can also be written to the stream using the
  51.  * appropriate methods from DataOutput. Strings can also be written
  52.  * using the writeUTF method.<p>
  53.  *
  54.  * The default serialization mechanism for an object writes the class
  55.  * of the object, the class signature, and the values of all
  56.  * non-transient and non-static fields.  References to other objects
  57.  * (except in transient or static fields) cause those objects to be
  58.  * written also. Multiple references to a single object are encoded
  59.  * using a reference sharing mechanism so that graphs of objects can
  60.  * be restored to the same shape as when the original was written. <p>
  61.  *
  62.  * For example to write an object that can be read by the example in ObjectInputStream: <br>
  63.  * <PRE>
  64.  *    FileOutputStream ostream = new FileOutputStream("t.tmp");
  65.  *    ObjectOutputStream p = new ObjectOutputStream(ostream);
  66.  *
  67.  *    p.writeInt(12345);
  68.  *    p.writeObject("Today");
  69.  *    p.writeObject(new Date());
  70.  *
  71.  *    p.flush();
  72.  *    ostream.close();
  73.  *
  74.  * </PRE>
  75.  *
  76.  * Classes that require special handling during the serialization and deserialization
  77.  * process must implement special methods with these exact signatures: <p>
  78.  *
  79.  * <PRE>
  80.  * private void readObject(java.io.ObjectInputStream stream)
  81.  *     throws IOException, ClassNotFoundException; 
  82.  * private void writeObject(java.io.ObjectOutputStream stream)
  83.  *     throws IOException
  84.  * </PRE><p>
  85.  * The writeObject method is responsible for writing the state of
  86.  * the object for its particular class so that the corresponding
  87.  * readObject method can restore it.
  88.  * The method does not need to concern itself with the
  89.  * state belonging to the object's superclasses or subclasses.
  90.  * State is saved by writing the individual fields to the ObjectOutputStream
  91.  * using the writeObject method or by using the methods for
  92.  * primitive data types supported by DataOutput. <p>
  93.  *
  94.  * Serialization does not write out the fields of any object that does
  95.  * not implement the java.io.Serializable interface.  Subclasses of
  96.  * Objects that are not serializable can be serializable. In this case
  97.  * the non-serializable class must have a no-arg constructor to allow
  98.  * its fields to be initialized.  In this case it is the
  99.  * responsibility of the subclass to save and restore the state of the
  100.  * non-serializable class. It is frequently the case that the fields
  101.  * of that class are accessible (public, package, or protected) or
  102.  * that there are get and set methods that can be used to restore the
  103.  * state. <p>
  104.  *
  105.  * Serialization of an object can be prevented by implementing writeObject
  106.  * and readObject methods that throw the NotSerializableException.
  107.  * The exception will be caught by the ObjectOutputStream and abort the
  108.  * serialization process.
  109.  *
  110.  * Implementing the Externalizable interface allows the object to
  111.  * assume complete control over the contents and format of the object's
  112.  * serialized form.  The methods of the Externalizable interface,
  113.  * writeExternal and readExternal, are called to save and restore the
  114.  * objects state.  When implemented by a class they can write and read
  115.  * their own state using all of the methods of ObjectOutput and
  116.  * ObjectInput.  It is the responsibility of the objects to handle any
  117.  * versioning that occurs.
  118.  *
  119.  * @author    Roger Riggs
  120.  * @version     1.30, 10/01/97
  121.  * @see java.io.DataOutput
  122.  * @see java.io.ObjectInputStream
  123.  * @see java.io.Serializable
  124.  * @see java.io.Externalizable
  125.  * @since       JDK1.1
  126.  */
  127. public class ObjectOutputStream
  128.     extends OutputStream
  129.     implements ObjectOutput, ObjectStreamConstants
  130.             
  131. { 
  132.     /** 
  133.      * Creates an ObjectOutputStream that writes to the specified OutputStream.
  134.      * The stream header is written to the stream. The caller may want to call
  135.      * flush immediately so that the corresponding ObjectInputStream can read
  136.      * the header immediately.
  137.      * @exception IOException Any exception thrown by the underlying OutputStream.
  138.      * @since     JDK1.1
  139.      */
  140.     public ObjectOutputStream(OutputStream out) throws IOException {
  141.     this.out = out;
  142.     dos = new DataOutputStream(this);
  143.     buf = new byte[1024];    // allocate buffer
  144.     writeStreamHeader();
  145.     resetStream();
  146.     }
  147.  
  148.     /**
  149.      * Write the specified object to the ObjectOutputStream.
  150.      * The class of the object, the signature of the class, and the values
  151.      * of the non-transient and non-static fields of the class and all
  152.      * of its supertypes are written.  Default serialization for a class can be
  153.      * overridden using the writeObject and the readObject methods. 
  154.      * Objects referenced by this object are written transitively so
  155.      * that a complete equivalent graph of objects can be
  156.      * reconstructed by an ObjectInputStream.  <p>
  157.      *
  158.      * Exceptions are thrown for
  159.      * problems with the OutputStream and for classes that should not be
  160.      * serialized.  All exceptions are fatal to the OutputStream, which
  161.      * is left in an indeterminate state, and it is up to the caller
  162.      * to ignore or recover the stream state.
  163.      * @exception InvalidClassException Something is wrong with a class used by
  164.      *       serialization.
  165.      * @exception NotSerializableException Some object to be serialized does not
  166.      *      implement the java.io.Serializable interface.
  167.      * @exception IOException Any exception thrown by the underlying OutputStream.
  168.      * @since     JDK1.1
  169.      */
  170.     public final void writeObject(Object obj)
  171.     throws IOException
  172.     {
  173.     Object prevObject = currentObject;
  174.     ObjectStreamClass prevClassDesc = currentClassDesc;
  175.     boolean oldBlockDataMode = setBlockData(false);
  176.     recursionDepth++;
  177.  
  178.     try {
  179.         if (serializeNullAndRepeat(obj))
  180.         return;
  181.  
  182.         if (checkSpecialClasses(obj))
  183.         return;
  184.  
  185.  
  186.         /* If the replacment is enabled, give subclasses one chance
  187.          * to substitute a new object. If one is substituted,
  188.          * recheck for null, repeated refs, and special cased classes
  189.          */
  190.         if (enableReplace) {
  191.         Object altobj = replaceObject(obj);
  192.         if (obj != altobj) {
  193.  
  194.             if (altobj != null && !(altobj instanceof Serializable)) {
  195.             String clname = altobj.getClass().getName();
  196.             throw new NotSerializableException(clname);
  197.             }
  198.             
  199.             // If the alternate object is already
  200.             // serialized just remember the replacement
  201.             if (serializeNullAndRepeat(altobj)) {
  202.             addReplacement(obj, altobj);
  203.             return;
  204.             }
  205.  
  206.             /* Add this to the set of replaced objects.
  207.              * This must be done before the object is
  208.              * serialized so that if the object indirectly
  209.              * refers to the original it will be redirected to
  210.              * the replacement.
  211.              *
  212.              * NB: checkSpecialClasses should only call
  213.              * serializeNullandRepeat for objects that will not
  214.              * recurse.
  215.              */
  216.             addReplacement(obj, altobj);
  217.  
  218.             if (checkSpecialClasses(altobj))
  219.             return;
  220.  
  221.             obj = altobj;
  222.         }
  223.         }
  224.         /* Write out the object as itself */
  225.         outputObject(obj);
  226.     } catch (ObjectStreamException ee) {
  227.         if (abortIOException == null) {
  228.         try {
  229.             /* Prepare to write the exception to the stream.
  230.              * End blockdatamode in case it's set
  231.              * Write the exception code
  232.              * reset the stream to forget all previous objects
  233.              * write the exception that occurred
  234.              * reset the stream again so subsequent objects won't map to
  235.              * the exception or its args.
  236.              * Continue below to rethrow the exception.
  237.              */
  238.             setBlockData(false);
  239.  
  240.             writeCode(TC_EXCEPTION);
  241.             resetStream();
  242.             this.writeObject(ee);
  243.             resetStream();
  244.  
  245.             // Set the pending exception to be rethrown.
  246.             abortIOException = ee;
  247.         } catch (IOException fatal) {
  248.             /* An exception occurred while writing the original exception to
  249.              * the stream.  The original exception is not complete in
  250.              * the stream and recusion would be bad. Supercede the original
  251.              * Exception with a StreamCorruptedException using the message
  252.              * from this current exception.
  253.              */
  254.             abortIOException =
  255.             new StreamCorruptedException(fatal.getMessage());
  256.         }
  257.         }
  258.     } catch (IOException ee) {
  259.         // Don't supercede a pending exception, the original will be re-thrown.
  260.         if (abortIOException == null)
  261.         abortIOException = ee;
  262.         
  263.     } finally {
  264.         /* Restore state of previous call incase this is a nested call */
  265.         recursionDepth--;
  266.         currentObject = prevObject;
  267.         currentClassDesc = prevClassDesc;
  268.         setBlockData(oldBlockDataMode);
  269.     }
  270.     
  271.     /* If the recursion depth is 0, test for and clear the pending exception.
  272.      * If there is a pending exception throw it.
  273.      */
  274.     IOException pending = abortIOException;
  275.     if (recursionDepth == 0)
  276.         abortIOException = null;
  277.     if (pending != null) {
  278.         throw pending;
  279.     }
  280.     }
  281.     
  282.     /*
  283.      * Check for special cases of serializing objects.
  284.      */
  285.     private boolean checkSpecialClasses(Object obj) throws IOException {
  286.  
  287.     /*
  288.      * If this is a class, don't allow substitution
  289.      */
  290.     if (obj instanceof Class) {
  291.         outputClass((Class)obj);
  292.         return true;
  293.     }
  294.  
  295.     if (obj instanceof ObjectStreamClass) {
  296.         outputClassDescriptor((ObjectStreamClass)obj);
  297.         return true;
  298.     }
  299.  
  300.     if (obj instanceof String) {
  301.         outputString((String)obj);
  302.         return true;
  303.     }
  304.  
  305.     if (obj.getClass().isArray()) {
  306.         outputArray(obj);
  307.         return true;
  308.     }
  309.     return false;
  310.     }
  311.  
  312.     /**
  313.      * Write the non-static and non-transient fields of the current class
  314.      * to this stream.  This may only be called from the writeObject method
  315.      * of the class being serialized. It will throw the NotActiveException
  316.      * if it is called otherwise.
  317.      * @since     JDK1.1
  318.      */
  319.     public final void defaultWriteObject() throws IOException {
  320.     if (currentObject == null || currentClassDesc == null)
  321.         throw new NotActiveException("defaultWriteObject");
  322.     
  323.     if (currentClassDesc.getFieldSequence() != null) {
  324.         boolean prevmode = setBlockData(false);
  325.         outputClassFields(currentObject, currentClassDesc.forClass(),
  326.                   currentClassDesc.getFieldSequence());
  327.         setBlockData(prevmode);
  328.     }
  329.     }
  330.     
  331.     /**
  332.      * Reset will disregard the state of any objects already written
  333.      * to the stream.  The state is reset to be the same as a new
  334.      * ObjectOutputStream.  The current point in the stream is marked
  335.      * as reset so the corresponding ObjectInputStream will be reset
  336.      * at the same point.  Objects previously written to the stream
  337.      * will not be refered to as already being in the stream.  They
  338.      * will be written to the stream again.
  339.      * @since     JDK1.1
  340.      */
  341.     public void reset() throws IOException {
  342.     if (currentObject != null || currentClassDesc != null)
  343.         throw new IOException("Illegal call to reset");
  344.     
  345.     /* Write a reset to the stream. */        
  346.     setBlockData(false);
  347.     writeCode(TC_RESET);
  348.     
  349.     resetStream();            // re-init the stream
  350.     abortIOException = null;
  351.     }
  352.  
  353.     /*
  354.      * Internal reset function to reinitialize the state of the stream.
  355.      * Reset state of things changed by using the stream.
  356.      */
  357.     private void resetStream() throws IOException {
  358.     wireHandle2Object = new Object[100];
  359.     wireNextHandle = new int[100];
  360.     wireHash2Handle = new int[101];
  361.     for (int i = 0; i < wireHash2Handle.length; i++) {
  362.         wireHash2Handle[i] = -1;
  363.     }
  364.     classDescStack = new Stack();
  365.     nextWireOffset = 0;
  366.     replaceObjects = null;
  367.     nextReplaceOffset = 0;
  368.     setBlockData(true);        /* Re-enable buffering */
  369.     }
  370.     
  371.     /**
  372.      * Subclasses may implement this method to allow class data to be stored
  373.      * in the stream. By default this method does nothing.
  374.      * The corresponding method in ObjectInputStream is resolveClass.
  375.      * This method is called exactly once for each unique class in the stream.
  376.      * The class name and signature will have already been written to the stream.
  377.      * This method may make free use of the ObjectOutputStream to save
  378.      * any representation of the class it deems suitable (for example,
  379.      * the bytes of the class file).  The resolveClass method in the corresponding
  380.      * subclass of ObjectInputStream must read and use any data or objects
  381.      * written by annotateClass. 
  382.      * annotateClass is called only for normal classes.  Arrays are not normal classes.
  383.      * @exception IOException Any exception thrown by the underlying OutputStream.
  384.      * @since     JDK1.1
  385.      */
  386.     protected void annotateClass(Class cl)
  387.     throws IOException
  388.     {
  389.     }
  390.  
  391.     /** This method will allow trusted subclasses of ObjectOutputStream
  392.      * to substitute one object for another during
  393.      * serialization. Replacing objects is disabled until
  394.      * enableReplaceObject is called. The enableReplaceObject method
  395.      * checks that the stream requesting to do replacment can be
  396.      * trusted. Every reference to serializable objects is passed to
  397.      * replaceObject.  To insure that the private state of objects is
  398.      * not unintentionally exposed only trusted streams may use
  399.      * replaceObject. <p>
  400.      *
  401.      * When a subclass is replacing objects it must insure that either
  402.      * a complementary substitution must be made during
  403.      * deserialization or that the substituted object is compatible
  404.      * with every field where the reference will be stored.  Objects
  405.      * whose type is not a subclass of the type of the field or array
  406.      * element abort the serialization by raising an exception and the
  407.      * object is not be stored. <p>
  408.      *
  409.      * This method is called only once when each object is first encountered.
  410.      * All subsequent references to the object will be redirected to the
  411.      * new object. This method should return the object to be substituted or
  412.      * the original object. <P>
  413.      *
  414.      * Null can be returned as the object to be substituted, but may
  415.      * cause NullReferenceException in classes that contain references
  416.      * to the original object since they may be expecting an object
  417.      * instead of null.<p>
  418.      *
  419.      * @exception IOException Any exception thrown by the underlying
  420.      * OutputStream.
  421.      * @since     JDK1.1
  422.      */
  423.     protected Object replaceObject(Object obj)
  424.     throws IOException
  425.     {
  426.     return obj;
  427.     }
  428.  
  429.     /**
  430.      * Enable the stream to do replacement of objects in the stream.
  431.      * If the stream is a trusted class it is allowed to enable replacement.
  432.      * Trusted classes are those classes with a classLoader equals null. <p>
  433.      * 
  434.      * When enabled the replaceObject method is called for every object
  435.      * being serialized.
  436.      * 
  437.      * @exception SecurityException The classloader of this stream object is non-null.
  438.      * @since     JDK1.1
  439.      */
  440.     protected final boolean enableReplaceObject(boolean enable)
  441.     throws SecurityException
  442.     {
  443.     boolean previous = enableReplace;
  444.     if (enable) {
  445.         ClassLoader loader = this.getClass().getClassLoader();
  446.         if (loader == null) {
  447.         enableReplace = true;
  448.         return previous;
  449.         }
  450.         throw new SecurityException("Not trusted class");
  451.     } else {
  452.         enableReplace = false;
  453.     }
  454.     return previous;
  455.     }
  456.  
  457.     /**
  458.      * The writeStreamHeader method is provided so subclasses can
  459.      * append or prepend their own header to the stream.
  460.      * It writes the magic number and version to the stream.
  461.      * @since     JDK1.1
  462.      */
  463.     protected void writeStreamHeader() throws IOException {
  464.     writeShort(STREAM_MAGIC);
  465.     writeShort(STREAM_VERSION);
  466.     }
  467.  
  468.     /**
  469.      * Write a string to the stream.
  470.      * Note that since Strings are Objects, writeObject
  471.      * will behave identically.
  472.      */
  473.     private void outputString(String s) throws IOException {
  474.     /* Allocate a write handle but don't write it to the stream,
  475.      * Write out the code for a string,
  476.      * the read can regenerate the same sequence and it saves bytes.
  477.      */
  478.     assignWireOffset(s);
  479.     writeCode(TC_STRING);
  480.     writeUTF(s); 
  481.     }
  482.  
  483.  
  484.     /* Classes are special, they can not created during deserialization,
  485.      * but the appropriate class can be found. 
  486.      */
  487.     private void outputClass(Class aclass) throws IOException {
  488.  
  489.     writeCode(TC_CLASS);
  490.     /* Find the class descriptor and write it out */
  491.     ObjectStreamClass v = ObjectStreamClass.lookup(aclass);
  492.  
  493.     if (v == null)
  494.         throw new NotSerializableException(aclass.getName());
  495.  
  496.     outputClassDescriptor(v);
  497.  
  498.     assignWireOffset(aclass);
  499.     }
  500.   
  501.  
  502.     /* Write the class descriptor */
  503.     private void outputClassDescriptor(ObjectStreamClass classdesc) 
  504.     throws IOException
  505.     {
  506.     if (serializeNullAndRepeat(classdesc))
  507.         return;
  508.  
  509.     /* Write out the code for a class
  510.      * Write out the class name and its serialVersionUID
  511.      */
  512.     writeCode(TC_CLASSDESC);
  513.     String classname = classdesc.getName();
  514.  
  515.     writeUTF(classname);
  516.     writeLong(classdesc.getSerialVersionUID());
  517.  
  518.     /* This is done here to be symetric with the inputClass method
  519.      * Since the resolveClassName() method may use the stream.
  520.      * The assignments of wirehandles must be done in the same order
  521.      */
  522.     assignWireOffset(classdesc);
  523.  
  524.     /* Write the version description for this class */
  525.     classdesc.write(this);
  526.  
  527.     /* Give subclassers a chance to add the class implementation
  528.      * to the stream.  Set BlockData mode so any information they
  529.      * write can be skipped on reading.
  530.      */
  531.     boolean prevMode = setBlockData(true);
  532.     annotateClass(classdesc.forClass());
  533.     setBlockData(prevMode);
  534.     writeCode(TC_ENDBLOCKDATA);
  535.  
  536.     /*
  537.      * Write out the superclass descriptor of this descriptor
  538.      * only if it is for a java.io.Serializable class.
  539.      * else write null.
  540.      */
  541.     ObjectStreamClass superdesc = classdesc.getSuperclass();
  542.     outputClassDescriptor(superdesc);
  543.     }
  544.     
  545.     /**
  546.      * Write an array out. Note that since Arrays are Objects, writeObject(obj)
  547.      * will behave identically. <br><br>
  548.      * @param o can represent an array of any type/dimension.
  549.      */
  550.     private void outputArray(Object obj)
  551.     throws IOException
  552.     {
  553.     Class currclass = obj.getClass();
  554.  
  555.     ObjectStreamClass v = ObjectStreamClass.lookup(currclass);
  556.  
  557.     /* Write out the code for an array and the name of the class */
  558.     writeCode(TC_ARRAY);
  559.     outputClassDescriptor(v);
  560.  
  561.     /* Assign the wirehandle for this object and outputArrayValues
  562.      * writes the length and the array contents.
  563.      */
  564.     assignWireOffset(obj);
  565.  
  566.     int i, length;
  567.     Class type = currclass.getComponentType();
  568.  
  569.     if (type.isPrimitive()) {
  570.         /* Write arrays of primitive types using the DataOutput
  571.          * methods that convert each element into the output buffer.
  572.          * The data types are ordered by the frequency
  573.          * in which they are expected to occur.
  574.          */
  575.         if (type == Integer.TYPE) {
  576.         int[] array = (int[])obj;
  577.         length = array.length;
  578.         writeInt(length);
  579.         for (i = 0; i < length; i++) {
  580.             writeInt(array[i]);
  581.         }
  582.         } else if (type == Byte.TYPE) {
  583.         byte[] array = (byte[])obj;
  584.         length = array.length;
  585.         writeInt(length);
  586.         write(array, 0, length);
  587.         } else if (type == Long.TYPE) {
  588.         long[] array = (long[])obj;
  589.         length = array.length;
  590.         writeInt(length);
  591.         for (i = 0; i < length; i++) {
  592.             writeLong(array[i]);
  593.         }
  594.         } else if (type == Float.TYPE) {
  595.         float[] array = (float[])obj;
  596.         length = array.length;
  597.         writeInt(length);
  598.         for (i = 0; i < length; i++) {
  599.             writeFloat(array[i]);
  600.         }
  601.         } else if (type == Double.TYPE) {
  602.         double[] array = (double[])obj;
  603.         length = array.length;
  604.         writeInt(length);
  605.         for (i = 0; i < length; i++) {
  606.             writeDouble(array[i]);
  607.         }
  608.         } else if (type == Short.TYPE) {
  609.         short[] array = (short[])obj;
  610.         length = array.length;
  611.         writeInt(length);
  612.         for (i = 0; i < length; i++) {
  613.             writeShort(array[i]);
  614.         }
  615.         } else if (type == Character.TYPE) {
  616.         char[] array = (char[])obj;
  617.         length = array.length;
  618.         writeInt(length);
  619.         for (i = 0; i < length; i++) {
  620.             writeChar(array[i]);
  621.         }
  622.         } else if (type == Boolean.TYPE) {
  623.         boolean[] array = (boolean[])obj;
  624.         length = array.length;
  625.         writeInt(length);
  626.         for (i = 0; i < length; i++) {
  627.             writeBoolean(array[i]);
  628.         }
  629.         } else {
  630.         throw new InvalidClassException(currclass.getName());
  631.         }
  632.     } else {
  633.         Object[] array = (Object[])obj;
  634.         length = array.length;
  635.         writeInt(length);
  636.         for (i = 0; i < length; i++) {
  637.         writeObject(array[i]);
  638.         }
  639.     }
  640.     }
  641.  
  642.     /*
  643.      * Put the object into the stream The newObject code is written
  644.      * followed by the ObjectStreamClass for the object's class.  Each
  645.      * of the objects classes is written using the default
  646.      * serialization code and dispatching to Specials where
  647.      * appropriate.
  648.      */
  649.     private void outputObject(Object obj)
  650.     throws IOException
  651.     {
  652.     currentObject = obj;
  653.     Class currclass = obj.getClass();
  654.  
  655.     /* Get the Class descriptor for this class,
  656.      * Throw a NotSerializableException if there is none.
  657.      */
  658.     currentClassDesc = ObjectStreamClass.lookup(currclass);
  659.     if (currentClassDesc == null) {
  660.         throw new NotSerializableException(currclass.getName());
  661.     }
  662.  
  663.     /* Write the code to expect an instance and
  664.      * the class descriptor of the instance
  665.      */
  666.     writeCode(TC_OBJECT);
  667.     outputClassDescriptor(currentClassDesc);
  668.  
  669.     /* Assign the next wirehandle */
  670.     assignWireOffset(obj);
  671.  
  672.     /* If the object is externalizable,
  673.      * call writeExternal.
  674.      * else do Serializable processing.
  675.      */
  676.     if (currentClassDesc.isExternalizable()) {
  677.         Externalizable ext = (Externalizable)obj;
  678.         ext.writeExternal(this);
  679.     } else {
  680.  
  681.         /* The object's classes should be processed from supertype to subtype
  682.          * Push all the clases of the current object onto a stack.
  683.          * Remember the stack pointer where this set of classes is being pushed.
  684.          */
  685.         int stackMark = classDescStack.size();
  686.         try {
  687.         ObjectStreamClass next;
  688.         while ((next = currentClassDesc.getSuperclass()) != null) {
  689.             classDescStack.push(currentClassDesc);
  690.             currentClassDesc = next;
  691.         }
  692.  
  693.         /* 
  694.          * For currentClassDesc and all the pushed class descriptors
  695.          *    If the class is writing its own data
  696.          *          set blockData = true; call the class writeObject method
  697.          *    If not
  698.          *     invoke either the defaultWriteObject method.
  699.          */
  700.         do {
  701.             if (currentClassDesc.hasWriteObject()) {
  702.             setBlockData(true); /* Block any data the class writes */
  703.             invokeObjectWriter(obj, currentClassDesc.forClass());
  704.             setBlockData(false);
  705.             writeCode(TC_ENDBLOCKDATA);
  706.             } else {
  707.             defaultWriteObject();
  708.             }
  709.         } while (classDescStack.size() > stackMark &&
  710.              (currentClassDesc = (ObjectStreamClass)classDescStack.pop()) != null);
  711.         } finally {
  712.         classDescStack.setSize(stackMark);
  713.         }
  714.     }
  715.     }
  716.     
  717.     /* Serialize the reference if it is NULL or is for an object that
  718.      * was already replaced or already serialized.
  719.      * If the object was already replaced, look for the replacement
  720.      * object in the known objects and if found, write its handle
  721.      * Return True if the reference is either null or a repeat.
  722.      */
  723.     private boolean serializeNullAndRepeat(Object obj)
  724.     throws IOException
  725.     {
  726.         if (obj == null) {
  727.         writeCode(TC_NULL);
  728.         return true;
  729.     }
  730.     /* Look to see if this object has already been replaced.
  731.      * If so, proceed using the replacement object.
  732.      */
  733.     if (replaceObjects != null) {
  734.         for (int i = 0; i < nextReplaceOffset; i+= 2) {
  735.         if (replaceObjects[i] == obj) {
  736.             obj = replaceObjects[i+1];
  737.             break;
  738.         }
  739.         }
  740.     }
  741.  
  742.     int handle = findWireOffset(obj);
  743.     if (handle >= 0) {
  744.         /* Add a reference to the stream */
  745.         writeCode(TC_REFERENCE);
  746.         writeInt(handle + baseWireHandle);
  747.         return true;
  748.     }
  749.     return false;        // not serialized, its up to the caller
  750.     }
  751.  
  752.     /*
  753.      * Locate and return if found the handle for the specified object.
  754.      * -1 is returned if the object does not occur in the array of
  755.      * known objects. 
  756.      */
  757.     private int findWireOffset(Object obj) {
  758.     int hash = System.identityHashCode(obj);
  759.     int index = (hash & 0x7FFFFFFF) % wireHash2Handle.length;
  760.  
  761.     for (int handle = wireHash2Handle[index];
  762.          handle >= 0;
  763.          handle = wireNextHandle[handle]) {
  764.         
  765.         if (wireHandle2Object[handle] == obj)
  766.         return handle;
  767.     }
  768.     return -1;
  769.     }
  770.  
  771.     /* Allocate a handle for an object.
  772.      * The Vector is indexed by the wireHandleOffset
  773.      * and contains the object.
  774.      */
  775.     private void assignWireOffset(Object obj)
  776.     throws IOException
  777.     {
  778.     // Extend the array if there isn't room for this new element
  779.     if (nextWireOffset == wireHandle2Object.length) {
  780.         Object[] oldhandles = wireHandle2Object;
  781.         wireHandle2Object = new Object[nextWireOffset*2];
  782.         System.arraycopy(oldhandles, 0,
  783.                  wireHandle2Object, 0,
  784.                  nextWireOffset);
  785.         int[] oldnexthandles = wireNextHandle;
  786.         wireNextHandle = new int[nextWireOffset*2];
  787.         System.arraycopy(oldnexthandles, 0,
  788.                  wireNextHandle, 0,
  789.                  nextWireOffset);
  790.         // TBD: Rehash the hash array if necessary
  791.     }
  792.     wireHandle2Object[nextWireOffset] = obj;
  793.  
  794.     hashInsert(obj, nextWireOffset);
  795.  
  796.     nextWireOffset++;
  797.     return;
  798.     }
  799.  
  800.  
  801.     /*
  802.      * Insert the specified object into the hash array and link if
  803.      * necessary. Put the new object into the hash table and link the
  804.      * previous to it. Newer objects occur earlier in the list.
  805.      */
  806.     private void hashInsert(Object obj, int offset) {
  807.     int hash = System.identityHashCode(obj);
  808.     int index = (hash & 0x7FFFFFFF) % wireHash2Handle.length;
  809.     wireNextHandle[offset] = wireHash2Handle[index];
  810.     wireHash2Handle[index] = offset;
  811.     }
  812.  
  813.     /*
  814.      * Add a replacement object to the table.
  815.      * The even numbered indices are the original objects.
  816.      * The odd numbered indices are the replacement objects.
  817.      *
  818.      */
  819.     private void addReplacement(Object orig, Object replacement) {
  820.     // Extend the array if there isn't room for this new element
  821.  
  822.     if (replaceObjects == null) {
  823.         replaceObjects = new Object[10];
  824.     }
  825.     if (nextReplaceOffset == replaceObjects.length) {
  826.         Object[] oldhandles = replaceObjects;
  827.         replaceObjects = new Object[2+nextReplaceOffset*2];
  828.         System.arraycopy(oldhandles, 0,
  829.                  replaceObjects, 0,
  830.                  nextReplaceOffset);
  831.     }
  832.     replaceObjects[nextReplaceOffset++] = orig;
  833.     replaceObjects[nextReplaceOffset++] = replacement;
  834.     }
  835.  
  836.     /* Write out the code indicating the type what follows.
  837.      * See ObjectStreamConstants for definitions.
  838.      */
  839.     private void writeCode(int tag)
  840.     throws IOException
  841.     {
  842.     writeByte(tag);
  843.     }
  844.  
  845.     /*
  846.      * Implement the OutputStream methods.  The stream has
  847.      * two modes used internally to ObjectOutputStream.  When
  848.      * in BlockData mode, all writes are buffered and written
  849.      * to the underlying stream prefixed by a code and length.
  850.      * When not in BlockData mode (false), writes pass directly
  851.      * through to the underlying stream.
  852.      * The BlockData mode is used to encapsulate data written
  853.      * by class specific writeObject methods that is intended
  854.      * only to be read by corresponding readObject method of the 
  855.      * same class.  The blocking of data allows it to be skipped
  856.      * if necessary.
  857.      *
  858.      * The setBlockData method is used to switch buffering
  859.      * on and off.  When switching between on and off
  860.      * the buffer is drained.
  861.      *
  862.      * The actual buffering is very similar to that of
  863.      * BufferedOutputStream but BufferedOutputStream can
  864.      * write to the underlying stream without the headers.
  865.      */
  866.     private boolean blockDataMode;    /* true to buffer and block data */
  867.     private byte[] buf;        /* byte array of buffered data. */
  868.     private int count;        /* count of bytes in the buffer */
  869.     private OutputStream out;    /* Stream to write the data to */
  870.  
  871.     /**
  872.      * Writes a byte. This method will block until the byte is actually
  873.      * written.
  874.      * @param b    the byte
  875.      * @exception IOException If an I/O error has occurred.
  876.      * @since     JDK1.1
  877.      */
  878.     public void write(int data) throws IOException {
  879.     
  880.     if (count >= buf.length)
  881.         drain();        /* Drain, make room for more */
  882.     buf[count++] = (byte)data;
  883.     }
  884.  
  885.     /**
  886.      * Writes an array of bytes. This method will block until the bytes
  887.      * are actually written.
  888.      * @param b    the data to be written
  889.      * @exception IOException If an I/O error has occurred.
  890.      * @since     JDK1.1
  891.      */
  892.     public void write(byte b[]) throws IOException {
  893.     write(b, 0, b.length);
  894.     }
  895.  
  896.     /**
  897.      * Writes a sub array of bytes. 
  898.      * @param b    the data to be written
  899.      * @param off    the start offset in the data
  900.      * @param len    the number of bytes that are written
  901.      * @exception IOException If an I/O error has occurred.
  902.      * @since     JDK1.1
  903.      */
  904.     public void write(byte b[], int off, int len) throws IOException {
  905.     if (len < 0)
  906.         throw new IndexOutOfBoundsException();
  907.  
  908.     /*
  909.      * If array will fit in output buffer, copy it in there; otherwise,
  910.      * drain anything in the buffer and send it through to underlying
  911.      * output stream directly.
  912.      */
  913.     int avail = buf.length - count;
  914.     if (len <= avail) {
  915.         System.arraycopy(b, off, buf, count, len);
  916.         count += len;
  917.     } else {
  918.         drain();
  919.         if (blockDataMode) {
  920.         if (len <= 255) {
  921.             out.write(TC_BLOCKDATA);
  922.             out.write(len);
  923.         } else {
  924.             // use block data with int size if necessary
  925.             out.write(TC_BLOCKDATALONG);
  926.             // send 32 bit int directly to underlying stream
  927.             out.write((len >> 24) & 0xFF);
  928.             out.write((len >> 16) & 0xFF);
  929.             out.write((len >>  8) & 0xFF);
  930.             out.write(len & 0xFF);
  931.         }
  932.         }
  933.         out.write(b, off, len);
  934.     }
  935.     }
  936.  
  937.  
  938.     /**
  939.      * Flushes the stream. This will write any buffered
  940.      * output bytes and flush through to the underlying stream.
  941.      * @exception IOException If an I/O error has occurred.
  942.      * @since     JDK1.1
  943.      */
  944.     public void flush() throws IOException {
  945.     drain();
  946.     out.flush();
  947.     }
  948.  
  949.     /**
  950.      * Drain any buffered data in ObjectOutputStream.  Similar to flush
  951.      * but does not propagate the flush to the underlaying stream.
  952.      * @since     JDK1.1
  953.      */
  954.     protected void drain() throws IOException {
  955.     /*
  956.      * Drain the data buffer.
  957.      * If the blocking mode is on, prepend the buffer
  958.      * with the code for a blocked data and the length.
  959.      * The code is TC_BLOCKDATA and the length is < 255 so it fits
  960.      * in a byte. 
  961.      */
  962.     if (count == 0)
  963.         return;
  964.  
  965.     /* If in blockdata mode, write the header with the count.
  966.      * If the count is < 256, use the short header form.
  967.      * othewise use the long form.
  968.      */
  969.     if (blockDataMode) {
  970.         if (count <= 255) {
  971.         out.write(TC_BLOCKDATA);
  972.         out.write(count);
  973.         } else {
  974.         out.write(TC_BLOCKDATALONG);
  975.         out.write((count >> 24) & 0xFF);
  976.         out.write((count >> 16) & 0xFF);
  977.         out.write((count >>  8) & 0xFF);
  978.         out.write(count & 0xFF);
  979.         }
  980.     }
  981.     out.write(buf, 0, count);
  982.     count = 0;
  983.     }
  984.  
  985.     /**
  986.      * Closes the stream. This method must be called
  987.      * to release any resources associated with the
  988.      * stream.
  989.      * @exception IOException If an I/O error has occurred.
  990.      * @since     JDK1.1
  991.      */
  992.     public void close() throws IOException {
  993.     flush();        /* Make sure we're not holding any data */
  994.     out.close();
  995.     }
  996.  
  997.     /*
  998.      * Set the blockData mode,  if it turned from on to off
  999.      * the buffer is drained.  The previous mode is returned.
  1000.      */
  1001.     private boolean setBlockData(boolean mode) throws IOException {
  1002.     if (blockDataMode == mode)
  1003.         return mode;
  1004.     drain();
  1005.     blockDataMode = mode;
  1006.     return !mode;        /* previous value was the opposite */
  1007.     }
  1008.     
  1009.     /* -------------------------------------------------------------- */
  1010.     /*
  1011.      * Provide the methods to implement DataOutput.
  1012.      * These are copied from DataOutputStream to avoid the overhead
  1013.      * of multiple method calls and to buffer the data directly.
  1014.      */
  1015.     private DataOutputStream dos;
  1016.  
  1017.     /**
  1018.      * Writes a boolean.
  1019.      * @param data the boolean to be written
  1020.      * @since     JDK1.1
  1021.      */
  1022.     public void writeBoolean(boolean data) throws IOException {
  1023.     if (count >= buf.length)
  1024.         drain();
  1025.     buf[count++] = (byte)(data ? 1 : 0);
  1026.  
  1027.     }
  1028.  
  1029.     /**
  1030.      * Writes an 8 bit byte.
  1031.      * @param data the byte value to be written
  1032.      * @since     JDK1.1
  1033.      */
  1034.     public void writeByte(int data) throws IOException  {
  1035.     if (count >= buf.length)
  1036.         drain();
  1037.     buf[count++] = (byte)data;
  1038.     }
  1039.  
  1040.     /**
  1041.      * Writes a 16 bit short.
  1042.      * @param data the short value to be written
  1043.      * @since     JDK1.1
  1044.      */
  1045.     public void writeShort(int data)  throws IOException {
  1046.     if (count + 2 > buf.length)
  1047.         drain();
  1048.     buf[count++] = (byte)((data >>>  8));
  1049.     buf[count++] = (byte)((data >>>  0));
  1050.     }
  1051.  
  1052.     /**
  1053.      * Writes a 16 bit char.
  1054.      * @param data the char value to be written
  1055.      * @since     JDK1.1
  1056.      */
  1057.     public void writeChar(int data)  throws IOException {
  1058.     if (count + 2 > buf.length)
  1059.         drain();
  1060.     buf[count++] = (byte)((data >>>  8));
  1061.     buf[count++] = (byte)((data >>>  0));
  1062.     }
  1063.  
  1064.     /**
  1065.      * Writes a 32 bit int.
  1066.      * @param data the integer value to be written
  1067.      * @since     JDK1.1
  1068.      */
  1069.     public void writeInt(int data)  throws IOException {
  1070.     if (count + 4 > buf.length)
  1071.         drain();
  1072.     buf[count++] = (byte)((data >>> 24));
  1073.     buf[count++] = (byte)((data >>> 16));
  1074.     buf[count++] = (byte)((data >>>  8));
  1075.     buf[count++] = (byte)((data >>>  0));
  1076.     }
  1077.  
  1078.     /**
  1079.      * Writes a 64 bit long.
  1080.      * @param data the long value to be written
  1081.      * @since     JDK1.1
  1082.      */
  1083.     public void writeLong(long data)  throws IOException {
  1084.     if (count + 8 > buf.length)
  1085.         drain();
  1086.     buf[count++] = (byte)((int)(data >>> 56));
  1087.     buf[count++] = (byte)((int)(data >>> 48));
  1088.     buf[count++] = (byte)((int)(data >>> 40));
  1089.     buf[count++] = (byte)((int)(data >>> 32));
  1090.     buf[count++] = (byte)((data >>> 24));
  1091.     buf[count++] = (byte)((data >>> 16));
  1092.     buf[count++] = (byte)((data >>>  8));
  1093.     buf[count++] = (byte)((data >>>  0));
  1094.     }
  1095.  
  1096.     /**
  1097.      * Writes a 32 bit float.
  1098.      * @param data the float value to be written
  1099.      * @since     JDK1.1
  1100.      */
  1101.     public void writeFloat(float data) throws IOException {
  1102.     int value = Float.floatToIntBits(data);
  1103.     if (count + 4 > buf.length)
  1104.         drain();
  1105.     buf[count++] = (byte)((value >>> 24));
  1106.     buf[count++] = (byte)((value >>> 16));
  1107.     buf[count++] = (byte)((value >>>  8));
  1108.     buf[count++] = (byte)((value >>>  0));
  1109.     }
  1110.  
  1111.     /**
  1112.      * Writes a 64 bit double.
  1113.      * @param data the double value to be written
  1114.      * @since     JDK1.1
  1115.      */
  1116.     public void writeDouble(double data) throws IOException {
  1117.     long value = Double.doubleToLongBits(data);
  1118.     if (count + 8 > buf.length)
  1119.         drain();
  1120.     buf[count++] = (byte)((int)(value >>> 56));
  1121.     buf[count++] = (byte)((int)(value >>> 48));
  1122.     buf[count++] = (byte)((int)(value >>> 40));
  1123.     buf[count++] = (byte)((int)(value >>> 32));
  1124.     buf[count++] = (byte)((value >>> 24));
  1125.     buf[count++] = (byte)((value >>> 16));
  1126.     buf[count++] = (byte)((value >>>  8));
  1127.     buf[count++] = (byte)((value >>>  0));
  1128.     }
  1129.  
  1130.     /**
  1131.      * Writes a String as a sequence of bytes.
  1132.      * @param s the String of bytes to be written
  1133.      * @since     JDK1.1
  1134.      */
  1135.     public void writeBytes(String data) throws IOException {
  1136.     dos.writeBytes(data);
  1137.     }
  1138.  
  1139.     /**
  1140.      * Writes a String as a sequence of chars.
  1141.      * @param s the String of chars to be written
  1142.      * @since     JDK1.1
  1143.      */
  1144.     public void writeChars(String data) throws IOException {
  1145.     dos.writeChars(data);
  1146.     }
  1147.  
  1148.     /**
  1149.      * Writes a String in UTF format.
  1150.      * @param str the String in UTF format
  1151.      * @since     JDK1.1
  1152.      */
  1153.     public void writeUTF(String data) throws IOException {
  1154.     dos.writeUTF(data);
  1155.     }
  1156.     
  1157.     /*************************************************************/
  1158.     
  1159.     /* Remember the first exception that stopped this stream. */
  1160.     private IOException abortIOException = null;
  1161.     
  1162.     /* Write the fields of the specified class.
  1163.      * The native implemention sorts the field names to put them
  1164.      * in cononical order, ignores transient and static fields
  1165.      * and invokes the appropriate write* method on this class.
  1166.      */
  1167.     private native void outputClassFields(Object o, Class cl,
  1168.                       int[] fieldSequence)
  1169.     throws IOException, InvalidClassException;
  1170.  
  1171.     /* Test if Read/WriteObject methods are present, if so
  1172.      * invoke writer and return true.
  1173.      */
  1174.     private native boolean invokeObjectWriter(Object o, Class c)
  1175.     throws IOException;
  1176.  
  1177.     /* Object references are mapped to the wire handles through a hashtable
  1178.      * WireHandles are integers generated by the ObjectOutputStream,
  1179.      * they need only be unique within a stream.
  1180.      * Objects are assigned sequential handles and stored in wireHandle2Object.
  1181.      * The handle for an object is its index in wireHandle2Object.
  1182.      * Object with the "same" hashcode are chained using wireHash2Handle.
  1183.      * The hashcode of objects is used to index through the wireHash2Handle.
  1184.      * -1 is the marker for unused cells in wireNextHandle
  1185.      */
  1186.     private Object[] wireHandle2Object;
  1187.     private int[] wireNextHandle;
  1188.     private int[] wireHash2Handle;
  1189.     private int nextWireOffset;
  1190.  
  1191.     /* The object is the current object and ClassDescriptor is the current
  1192.      * subclass of the object being read. Nesting information is kept
  1193.      * on the stack.
  1194.      */
  1195.     private Object currentObject;
  1196.     private ObjectStreamClass currentClassDesc;
  1197.     private Stack classDescStack;
  1198.  
  1199.     /* 
  1200.      * Flag set to true to allow replaceObject to be called.
  1201.      * Set by enableReplaceObject.
  1202.      * The array of replaceObjects and the index of the next insertion.
  1203.      */
  1204.     private boolean enableReplace;
  1205.     private Object[] replaceObjects;
  1206.     private int nextReplaceOffset;
  1207.  
  1208.     /* Recursion level, starts at zero and is incremented for each entry
  1209.      * to writeObject.  Decremented before exit.
  1210.      */ 
  1211.     private int recursionDepth = 0;
  1212. }
  1213.