/[classpath]/classpath/java/io/ObjectInputStream.java
ViewVC logotype

Diff of /classpath/java/io/ObjectInputStream.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.27 by mark, Sun Mar 2 00:00:19 2003 UTC revision 1.28 by mark, Fri Mar 14 12:45:53 2003 UTC
# Line 368  public class ObjectInputStream extends I Line 368  public class ObjectInputStream extends I
368                ObjectStreamClass[] hierarchy =                ObjectStreamClass[] hierarchy =
369                  ObjectStreamClass.getObjectStreamClasses (clazz);                  ObjectStreamClass.getObjectStreamClasses (clazz);
370                                
               boolean has_read;  
371                for (int i=0; i < hierarchy.length; i++)                for (int i=0; i < hierarchy.length; i++)
372                  {                  {
373                    this.currentObjectStreamClass = hierarchy[i];                    this.currentObjectStreamClass = hierarchy[i];
374                                        
375                    dumpElementln ("Reading fields of "                    dumpElementln ("Reading fields of "
376                                   + this.currentObjectStreamClass.getName ());                                   + this.currentObjectStreamClass.getName ());
                     
                   has_read = true;  
                     
                   try  
                     {  
                       this.currentObjectStreamClass.forClass ().  
                         getDeclaredMethod ("readObject", readObjectParams);  
                     }  
                   catch (NoSuchMethodException e)  
                     {  
                       has_read = false;  
                     }  
377    
378                    // XXX: should initialize fields in classes in the hierarchy                    // XXX: should initialize fields in classes in the hierarchy
379                    // that aren't in the stream                    // that aren't in the stream
380                    // should skip over classes in the stream that aren't in the                    // should skip over classes in the stream that aren't in the
381                    // real classes hierarchy                    // real classes hierarchy
382                    readFields (obj, this.currentObjectStreamClass.fields,                    
383                                has_read, this.currentObjectStreamClass);                    if (this.currentObjectStreamClass.hasReadMethod())
   
                   if (has_read)  
384                      {                      {
385                          fieldsAlreadyRead = false;
386                          boolean oldmode = setBlockDataMode (true);
387                          callReadMethod (obj, this.currentObjectStreamClass);
388                          setBlockDataMode (oldmode);
389                        dumpElement ("ENDBLOCKDATA? ");                        dumpElement ("ENDBLOCKDATA? ");
390                        try                        try
391                          {                          {
# Line 415  public class ObjectInputStream extends I Line 404  public class ObjectInputStream extends I
404                            dumpElementln ("no, got IOException");                            dumpElementln ("no, got IOException");
405                          }                          }
406                      }                      }
407                      else
408                        {
409                          readFields (obj, currentObjectStreamClass);
410                        }
411                  }                  }
412    
413                this.currentObject = null;                this.currentObject = null;
# Line 487  public class ObjectInputStream extends I Line 480  public class ObjectInputStream extends I
480        throw new NotActiveException ("defaultReadObject called but fields already read from stream (by defaultReadObject or readFields)");        throw new NotActiveException ("defaultReadObject called but fields already read from stream (by defaultReadObject or readFields)");
481    
482      boolean oldmode = setBlockDataMode(false);      boolean oldmode = setBlockDataMode(false);
483      readFields (this.currentObject,      readFields (this.currentObject, this.currentObjectStreamClass);
                 this.currentObjectStreamClass.fields,  
                 false, this.currentObjectStreamClass);  
484      setBlockDataMode(oldmode);      setBlockDataMode(oldmode);
485    
486      fieldsAlreadyRead = true;      fieldsAlreadyRead = true;
# Line 1307  public class ObjectInputStream extends I Line 1298  public class ObjectInputStream extends I
1298    }    }
1299    
1300    
1301    private void readFields (Object obj, ObjectStreamField[] stream_fields,    private void readFields (Object obj, ObjectStreamClass stream_osc)
                            boolean call_read_method,  
                            ObjectStreamClass stream_osc)  
1302      throws ClassNotFoundException, IOException      throws ClassNotFoundException, IOException
1303    {    {
1304      if (call_read_method)      ObjectStreamField[] stream_fields = stream_osc.fields;
       {  
         fieldsAlreadyRead = false;  
         boolean oldmode = setBlockDataMode (true);  
         callReadMethod (obj, stream_osc.forClass ());  
         setBlockDataMode (oldmode);  
         return;  
       }  
   
1305      ObjectStreamField[] real_fields =      ObjectStreamField[] real_fields =
1306        ObjectStreamClass.lookup (stream_osc.forClass ()).fields;        ObjectStreamClass.lookup (stream_osc.forClass ()).fields;
1307    
# Line 1386  public class ObjectInputStream extends I Line 1367  public class ObjectInputStream extends I
1367                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1368                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1369                  if (set_value)                  if (set_value)
1370                    setBooleanField (obj, field_name, value);                    setBooleanField (obj, stream_osc.forClass (), field_name, value);
1371                }                }
1372              else if (type == Byte.TYPE)              else if (type == Byte.TYPE)
1373                {                {
# Line 1395  public class ObjectInputStream extends I Line 1376  public class ObjectInputStream extends I
1376                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1377                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1378                  if (set_value)                  if (set_value)
1379                    setByteField (obj, field_name, value);                    setByteField (obj, stream_osc.forClass (), field_name, value);
1380                }                }
1381              else if (type == Character.TYPE)              else if (type == Character.TYPE)
1382                {                {
# Line 1404  public class ObjectInputStream extends I Line 1385  public class ObjectInputStream extends I
1385                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1386                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1387                  if (set_value)                  if (set_value)
1388                    setCharField (obj, field_name, value);                    setCharField (obj, stream_osc.forClass (), field_name, value);
1389                }                }
1390              else if (type == Double.TYPE)              else if (type == Double.TYPE)
1391                {                {
# Line 1413  public class ObjectInputStream extends I Line 1394  public class ObjectInputStream extends I
1394                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1395                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1396                  if (set_value)                  if (set_value)
1397                    setDoubleField (obj, field_name, value);                    setDoubleField (obj, stream_osc.forClass (), field_name, value);
1398                }                }
1399              else if (type == Float.TYPE)              else if (type == Float.TYPE)
1400                {                {
# Line 1422  public class ObjectInputStream extends I Line 1403  public class ObjectInputStream extends I
1403                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1404                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1405                  if (set_value)                  if (set_value)
1406                    setFloatField (obj, field_name, value);                    setFloatField (obj, stream_osc.forClass (), field_name, value);
1407                }                }
1408              else if (type == Integer.TYPE)              else if (type == Integer.TYPE)
1409                {                {
# Line 1431  public class ObjectInputStream extends I Line 1412  public class ObjectInputStream extends I
1412                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1413                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1414                  if (set_value)                  if (set_value)
1415                    setIntField (obj, field_name, value);                    setIntField (obj, stream_osc.forClass (), field_name, value);
1416                }                }
1417              else if (type == Long.TYPE)              else if (type == Long.TYPE)
1418                {                {
# Line 1440  public class ObjectInputStream extends I Line 1421  public class ObjectInputStream extends I
1421                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1422                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1423                  if (set_value)                  if (set_value)
1424                    setLongField (obj, field_name, value);                    setLongField (obj, stream_osc.forClass (), field_name, value);
1425                }                }
1426              else if (type == Short.TYPE)              else if (type == Short.TYPE)
1427                {                {
# Line 1449  public class ObjectInputStream extends I Line 1430  public class ObjectInputStream extends I
1430                  if (!default_initialize && set_value)                  if (!default_initialize && set_value)
1431                    dumpElementln ("  " + field_name + ": " + value);                    dumpElementln ("  " + field_name + ": " + value);
1432                  if (set_value)                  if (set_value)
1433                    setShortField (obj, field_name, value);                    setShortField (obj, stream_osc.forClass (), field_name, value);
1434                }                }
1435              else              else
1436                {                {
1437                  Object value =                  Object value =
1438                    default_initialize ? null : readObject ();                    default_initialize ? null : readObject ();
1439                  if (set_value)                  if (set_value)
1440                    setObjectField (obj, field_name,                    setObjectField (obj, stream_osc.forClass (), field_name,
1441                                    real_field.getTypeString (), value);                                    real_field.getTypeString (), value);
1442                }                }
1443            }            }
# Line 1534  public class ObjectInputStream extends I Line 1515  public class ObjectInputStream extends I
1515      return klass.getDeclaredMethod(name, args);      return klass.getDeclaredMethod(name, args);
1516    }    }
1517    
1518    private void callReadMethod (Object obj, Class klass) throws IOException    private void callReadMethod (Object obj, ObjectStreamClass osc) throws IOException
1519    {    {
1520        Class klass = osc.forClass();
1521      try      try
1522        {        {
1523          Class classArgs[] = {ObjectInputStream.class};          Class classArgs[] = {ObjectInputStream.class};
# Line 1569  public class ObjectInputStream extends I Line 1551  public class ObjectInputStream extends I
1551    
1552    private native void callConstructor (Class clazz, Object obj);    private native void callConstructor (Class clazz, Object obj);
1553    
1554    private void setBooleanField (Object obj, String field_name,    private void setBooleanField (Object obj, Class klass, String field_name,
1555                                  boolean val)                                  boolean val)
1556    {    {
1557      try      try
1558        {        {
         Class klass = obj.getClass ();  
1559          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1560          f.setAccessible(true);          f.setAccessible(true);
1561          f.setBoolean (obj, val);          f.setBoolean (obj, val);
# Line 1584  public class ObjectInputStream extends I Line 1565  public class ObjectInputStream extends I
1565        }            }    
1566    }    }
1567    
1568    private void setByteField (Object obj, String field_name,    private void setByteField (Object obj, Class klass, String field_name,
1569                               byte val)                               byte val)
1570    {    {
1571      try      try
1572        {        {
         Class klass = obj.getClass ();  
1573          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1574          f.setAccessible(true);          f.setAccessible(true);
1575          f.setByte (obj, val);          f.setByte (obj, val);
# Line 1599  public class ObjectInputStream extends I Line 1579  public class ObjectInputStream extends I
1579        }            }    
1580    }    }
1581    
1582    private void setCharField (Object obj, String field_name,    private void setCharField (Object obj, Class klass, String field_name,
1583                               char val)                               char val)
1584    {    {
1585      try      try
1586        {        {
         Class klass = obj.getClass ();  
1587          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1588          f.setAccessible(true);          f.setAccessible(true);
1589          f.setChar (obj, val);          f.setChar (obj, val);
# Line 1614  public class ObjectInputStream extends I Line 1593  public class ObjectInputStream extends I
1593        }            }    
1594    }    }
1595    
1596    private void setDoubleField (Object obj, String field_name,    private void setDoubleField (Object obj, Class klass, String field_name,
1597                                 double val)                                 double val)
1598    {    {
1599      try      try
1600        {        {
         Class klass = obj.getClass ();  
1601          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1602          f.setAccessible(true);          f.setAccessible(true);
1603          f.setDouble (obj, val);          f.setDouble (obj, val);
# Line 1629  public class ObjectInputStream extends I Line 1607  public class ObjectInputStream extends I
1607        }            }    
1608    }    }
1609    
1610    private void setFloatField (Object obj, String field_name,    private void setFloatField (Object obj, Class klass, String field_name,
1611                                float val)                                float val)
1612    {    {
1613      try      try
1614        {        {
         Class klass = obj.getClass ();  
1615          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1616          f.setAccessible(true);          f.setAccessible(true);
1617          f.setFloat (obj, val);          f.setFloat (obj, val);
# Line 1644  public class ObjectInputStream extends I Line 1621  public class ObjectInputStream extends I
1621        }            }    
1622    }    }
1623    
1624    private void setIntField (Object obj, String field_name,    private void setIntField (Object obj, Class klass, String field_name,
1625                              int val)                              int val)
1626    {    {
1627      try      try
1628        {        {
         Class klass = obj.getClass ();  
1629          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1630          f.setAccessible(true);          f.setAccessible(true);
1631          f.setInt (obj, val);          f.setInt (obj, val);
# Line 1660  public class ObjectInputStream extends I Line 1636  public class ObjectInputStream extends I
1636    }    }
1637    
1638    
1639    private void setLongField (Object obj, String field_name,    private void setLongField (Object obj, Class klass, String field_name,
1640                               long val)                               long val)
1641    {    {
1642      try      try
1643        {        {
         Class klass = obj.getClass ();  
1644          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1645          f.setAccessible(true);          f.setAccessible(true);
1646          f.setLong (obj, val);          f.setLong (obj, val);
# Line 1676  public class ObjectInputStream extends I Line 1651  public class ObjectInputStream extends I
1651    }    }
1652    
1653    
1654    private void setShortField (Object obj, String field_name,    private void setShortField (Object obj, Class klass, String field_name,
1655                                short val)                                short val)
1656    {    {
1657      try      try
1658        {        {
         Class klass = obj.getClass ();  
1659          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1660          f.setAccessible(true);          f.setAccessible(true);
1661          f.setShort (obj, val);          f.setShort (obj, val);
# Line 1692  public class ObjectInputStream extends I Line 1666  public class ObjectInputStream extends I
1666    }    }
1667    
1668    
1669    private void setObjectField (Object obj, String field_name, String type_code,    private void setObjectField (Object obj, Class klass, String field_name, String type_code,
1670                                 Object val)                                 Object val)
1671    {    {
1672      try      try
1673        {        {
         Class klass = obj.getClass ();  
1674          Field f = getField (klass, field_name);          Field f = getField (klass, field_name);
1675          f.setAccessible(true);          f.setAccessible(true);
1676          // FIXME: We should check the type_code here          // FIXME: We should check the type_code here

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.28

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26