objectoutputstream.java

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

	  checkType (field, 'I');
	  int off = field.getOffset ();
	  prim_field_data[off++] = (byte)(value >>> 24);
	  prim_field_data[off++] = (byte)(value >>> 16);
	  prim_field_data[off++] = (byte)(value >>> 8);
	  prim_field_data[off] = (byte)value;
	}

	public void put (String name, long value)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field
	    = currentObjectStreamClass.getField (name);
	  checkType (field, 'J');
	  int off = field.getOffset ();
	  prim_field_data[off++] = (byte)(value >>> 52);
	  prim_field_data[off++] = (byte)(value >>> 48);
	  prim_field_data[off++] = (byte)(value >>> 40);
	  prim_field_data[off++] = (byte)(value >>> 32);
	  prim_field_data[off++] = (byte)(value >>> 24);
	  prim_field_data[off++] = (byte)(value >>> 16);
	  prim_field_data[off++] = (byte)(value >>> 8);
	  prim_field_data[off] = (byte)value;
	}

	public void put (String name, short value)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field
	    = currentObjectStreamClass.getField (name);
	  checkType (field, 'S');
	  int off = field.getOffset ();
	  prim_field_data[off++] = (byte)(value >>> 8);
	  prim_field_data[off] = (byte)value;
	}

	public void put (String name, Object value)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field
	    = currentObjectStreamClass.getField (name);
	  if (field == null)
	    throw new IllegalArgumentException ();
	  if (value != null &&
	      ! field.getType ().isAssignableFrom (value.getClass ()))
	    throw new IllegalArgumentException ();
	  objs[field.getOffset ()] = value;
	}

	public void write (ObjectOutput out) throws IOException
	{
	  // Apparently Block data is not used with PutField as per
	  // empirical evidence against JDK 1.2.  Also see Mauve test
	  // java.io.ObjectInputOutput.Test.GetPutField.
	  boolean oldmode = setBlockDataMode (false);
	  out.write (prim_field_data);
	  for (int i = 0; i < objs.length; ++ i)
	    out.writeObject (objs[i]);
	  setBlockDataMode (oldmode);
	}

	private void checkType (ObjectStreamField field, char type)
	  throws IllegalArgumentException
	{
	  if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0) != type)
	    throw new IllegalArgumentException ();
	}
      };
    // end PutFieldImpl

    return currentPutField;
  }


  public void writeFields () throws IOException
  {
    if (currentPutField == null)
      throw new NotActiveException ("writeFields can only be called after putFields has been called");

    currentPutField.write (this);
  }


  // write out the block-data buffer, picking the correct header
  // depending on the size of the buffer
  private void writeBlockDataHeader (int size) throws IOException
  {
    if (size < 256)
      {
	realOutput.writeByte (TC_BLOCKDATA);
	realOutput.write (size);
      }
    else
      {
	realOutput.writeByte (TC_BLOCKDATALONG);
	realOutput.writeInt (size);
      }
  }


  // lookup the handle for OBJ, return null if OBJ doesn't have a
  // handle yet
  private Integer findHandle (Object obj)
  {
    return (Integer)OIDLookupTable.get (new ObjectIdentityWrapper (obj));
  }


  // assigns the next availible handle to OBJ
  private int assignNewHandle (Object obj)
  {
    OIDLookupTable.put (new ObjectIdentityWrapper (obj),
			new Integer (nextOID));
    return nextOID++;
  }


  // resets mapping from objects to handles
  private void clearHandles ()
  {
    nextOID = baseWireHandle;
    OIDLookupTable.clear ();
  }


  // write out array size followed by each element of the array
  private void writeArraySizeAndElements (Object array, Class clazz)
    throws IOException
  {
    int length = Array.getLength (array);

    if (clazz.isPrimitive ())
      {
	if (clazz == Boolean.TYPE)
	  {
	    boolean[] cast_array = (boolean[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeBoolean (cast_array[i]);
	    return;
	  }
	if (clazz == Byte.TYPE)
	  {
	    byte[] cast_array = (byte[])array;
	    realOutput.writeInt (length);
	    realOutput.write(cast_array, 0, length);
	    return;
	  }
	if (clazz == Character.TYPE)
	  {
	    char[] cast_array = (char[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeChar (cast_array[i]);
	    return;
	  }
	if (clazz == Double.TYPE)
	  {
	    double[] cast_array = (double[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeDouble (cast_array[i]);
	    return;
	  }
	if (clazz == Float.TYPE)
	  {
	    float[] cast_array = (float[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeFloat (cast_array[i]);
	    return;
	  }
	if (clazz == Integer.TYPE)
	  {
	    int[] cast_array = (int[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeInt (cast_array[i]);
	    return;
	  }
	if (clazz == Long.TYPE)
	  {
	    long[] cast_array = (long[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeLong (cast_array[i]);
	    return;
	  }
	if (clazz == Short.TYPE)
	  {
	    short[] cast_array = (short[])array;
	    realOutput.writeInt (length);
	    for (int i=0; i < length; i++)
	      realOutput.writeShort (cast_array[i]);
	    return;
	  }
      }
    else
      {
	Object[] cast_array = (Object[])array;
	realOutput.writeInt (length);
	for (int i=0; i < length; i++)
	  writeObject (cast_array[i]);
      }
  }


  // writes out FIELDS of OBJECT for the specified ObjectStreamClass.
  // FIELDS are already in canonical order.
  private void writeFields (Object obj, ObjectStreamClass osc)
    throws IOException
  {
    ObjectStreamField[] fields = osc.fields;
    boolean oldmode = setBlockDataMode (false);
    String field_name;
    Class type;
    for (int i=0; i < fields.length; i++)
      {
	field_name = fields[i].getName ();
	type = fields[i].getType ();

	if (type == Boolean.TYPE)
	  realOutput.writeBoolean (getBooleanField (obj, osc.forClass(), field_name));
	else if (type == Byte.TYPE)
	  realOutput.writeByte (getByteField (obj, osc.forClass(), field_name));
	else if (type == Character.TYPE)
	  realOutput.writeChar (getCharField (obj, osc.forClass(), field_name));
	else if (type == Double.TYPE)
	  realOutput.writeDouble (getDoubleField (obj, osc.forClass(), field_name));
	else if (type == Float.TYPE)
	  realOutput.writeFloat (getFloatField (obj, osc.forClass(), field_name));
	else if (type == Integer.TYPE)
	  realOutput.writeInt (getIntField (obj, osc.forClass(), field_name));
	else if (type == Long.TYPE)
	  realOutput.writeLong (getLongField (obj, osc.forClass(), field_name));
	else if (type == Short.TYPE)
	  realOutput.writeShort (getShortField (obj, osc.forClass(), field_name));
	else
	  writeObject (getObjectField (obj, osc.forClass(), field_name,
				       fields[i].getTypeString ()));
      }
    setBlockDataMode (oldmode);
  }


  // Toggles writing primitive data to block-data buffer.
  private boolean setBlockDataMode (boolean on) throws IOException
  {
    if (on == writeDataAsBlocks)
      return on;

    drain();
    boolean oldmode = writeDataAsBlocks;
    writeDataAsBlocks = on;

    if (on)
      dataOutput = blockDataOutput;
    else
      dataOutput = realOutput;

    return oldmode;
  }


  private void callWriteMethod (Object obj, ObjectStreamClass osc) throws IOException
  {
    Class klass = osc.forClass();
    try
      {
	Class classArgs[] = {ObjectOutputStream.class};
	Method m = getMethod (klass, "writeObject", classArgs);
	if (m == null)
	  return;
	Object args[] = {this};
	m.invoke (obj, args);	
      }
    catch (InvocationTargetException x)
      {
        /* Rethrow if possible. */
	Throwable exception = x.getTargetException();
	if (exception instanceof RuntimeException)
	  throw (RuntimeException) exception;
	if (exception instanceof IOException)
	  throw (IOException) exception;

	throw new IOException ("Exception thrown from writeObject() on " +
			       klass + ": " + exception.getClass().getName());
      }
    catch (Exception x)
      {
	throw new IOException ("Failure invoking writeObject() on " +
			       klass + ": " + x.getClass().getName());
      }
  }

  private boolean getBooleanField (Object obj, Class klass, String field_name)
    throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	boolean b = f.getBoolean (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private byte getByteField (Object obj, Class klass, String field_name) throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	byte b = f.getByte (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private char getCharField (Object obj, Class klass, String field_name) throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	char b = f.getChar (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private double getDoubleField (Object obj, Class klass, String field_name)
    throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	double b = f.getDouble (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private float getFloatField (Object obj, Class klass, String field_name)
    throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	float b = f.getFloat (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private int getIntField (Object obj, Class klass, String field_name) throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	int b = f.getInt (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private long getLongField (Object obj, Class klass, String field_name) throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	long b = f.getLong (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private short getShortField (Object obj, Class klass, String field_name)
    throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	short b = f.getShort (obj);
	return b;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private Object getObjectField (Object obj, Class klass, String field_name,
				 String type_code) throws IOException
  {
    try
      {
	Field f = getField (klass, field_name);
	Object o = f.get (obj);
	// FIXME: We should check the type_code here
	return o;
      }
    catch (Exception _)
      {
	throw new IOException ();
      }    
  }

  private static Field getField (Class klass, String name)
    throws java.lang.NoSuchFieldException
  {
    return klass.getDeclaredField(name);
  }

  private static Method getMethod (Class klass, String name, Class[] args)
    throws java.lang.NoSuchMethodException
  {
    return klass.getDeclaredMethod(name, args);
  }

  // this value comes from 1.2 spec, but is used in 1.1 as well
  private final static int BUFFER_SIZE = 1024;

  private static int defaultProtocolVersion = PROTOCOL_VERSION_2;

  private DataOutputStream dataOutput;
  private boolean writeDataAsBlocks;
  private DataOutputStream realOutput;
  private DataOutputStream blockDataOutput;
  private byte[] blockData;
  private int blockDataCount;
  private Object currentObject;
  private ObjectStreamClass currentObjectStreamClass;
  private PutField currentPutField;
  private boolean fieldsAlreadyWritten;
  private boolean replacementEnabled;
  private boolean isSerializing;
  private int nextOID;
  private Hashtable OIDLookupTable;
  private int protocolVersion;
  private boolean useSubclassMethod;

  static
  {
    if (Configuration.INIT_LOAD_LIBRARY)
      {
        System.loadLibrary ("javaio");
      }
  }
}