libjava/java/io/ObjectStreamField.java

   1 /* ObjectStreamField.java -- Class used to store name and class of fields
   2    Copyright (C) 1998, 1999, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.io;
  40
  41 import java.lang.reflect.Field;
  42 import java.lang.reflect.Modifier;
  43 import gnu.java.lang.reflect.TypeSignature;
  44
  45 /**
  46  * This class intends to describe the field of a class for the serialization
  47  * subsystem. Serializable fields in a serializable class can be explicitly
  48  * exported using an array of ObjectStreamFields.
  49  */
  50 public class ObjectStreamField implements Comparable
  51 {
  52   private String name;
  53   private Class type;
  54   private String typename;
  55   private int offset = -1; // XXX make sure this is correct
  56   private boolean unshared;
  57   private boolean persistent = false;
  58   private boolean toset = true;
  59   private Field field;
  60
  61   ObjectStreamField (Field field)
  62   {
  63     this (field.getName(), field.getType());
  64     this.field = field;
  65     toset = !Modifier.isFinal(field.getModifiers());
  66   }
  67
  68   /**
  69    * This constructor creates an ObjectStreamField instance
  70    * which represents a field named <code>name</code> and is
  71    * of the type <code>type</code>.
  72    *
  73    * @param name Name of the field to export.
  74    * @param type Type of the field in the concerned class.
  75    */
  76   public ObjectStreamField (String name, Class type)
  77   {
  78     this (name, type, false);
  79   }
  80
  81   /**
  82    * This constructor creates an ObjectStreamField instance
  83    * which represents a field named <code>name</code> and is
  84    * of the type <code>type</code>.
  85    *
  86    * @param name Name of the field to export.
  87    * @param type Type of the field in the concerned class.
  88    */
  89   public ObjectStreamField (String name, Class type, boolean unshared)
  90   {
  91     if (name == null)
  92       throw new NullPointerException();
  93
  94     this.name = name;
  95     this.type = type;
  96     this.typename = TypeSignature.getEncodingOfClass(type);
  97     this.unshared = unshared;
  98   }
  99
 100   /**
 101    * There are many cases you can not get java.lang.Class from typename
 102    * if your context class loader cann not load it, then use typename to
 103    * construct the field.
 104    *
 105    * @param name Name of the field to export.
 106    * @param typename The coded name of the type for this field.
 107    */
 108   ObjectStreamField (String name, String typename)
 109   {
 110     this.name = name;
 111     this.typename = typename;
 112     try
 113       {
 114         type = TypeSignature.getClassForEncoding(typename);
 115       }
 116     catch(ClassNotFoundException e)
 117       {
 118       }
 119   }
 120
 121   /**
 122    * There are many cases you can not get java.lang.Class from typename
 123    * if your context class loader cann not load it, then use typename to
 124    * construct the field.
 125    *
 126    * @param name Name of the field to export.
 127    * @param typename The coded name of the type for this field.
 128    * @param loader The class loader to use to resolve class names.
 129    */
 130   ObjectStreamField (String name, String typename, ClassLoader loader)
 131   {
 132     this.name = name;
 133     this.typename = typename;
 134     try
 135       {
 136         type = TypeSignature.getClassForEncoding(typename, true, loader);
 137       }
 138     catch(ClassNotFoundException e)
 139       {
 140       }
 141   }
 142
 143   /**
 144    * This method returns the name of the field represented by the
 145    * ObjectStreamField instance.
 146    *
 147    * @return A string containing the name of the field.
 148    */
 149   public String getName ()
 150   {
 151     return name;
 152   }
 153
 154   /**
 155    * This method returns the class representing the type of the
 156    * field which is represented by this instance of ObjectStreamField.
 157    *
 158    * @return A class representing the type of the field.
 159    */
 160   public Class getType ()
 161   {
 162     return type;
 163   }
 164
 165   /**
 166    * This method returns the char encoded type of the field which
 167    * is represented by this instance of ObjectStreamField.
 168    *
 169    * @return A char representing the type of the field.
 170    */
 171   public char getTypeCode ()
 172   {
 173     return typename.charAt (0);
 174   }
 175
 176   /**
 177    * This method returns a more explicit type name than
 178    * {@link #getTypeCode()} in the case the type is a real
 179    * class (and not a primitive).
 180    *
 181    * @return The name of the type (class name) if it is not a
 182    * primitive, in the other case null is returned.
 183    */
 184   public String getTypeString ()
 185   {
 186     // use intern()
 187     if (isPrimitive())
 188       return null;
 189     return typename.intern();
 190   }
 191
 192   /**
 193    * This method returns the current offset of the field in
 194    * the serialization stream relatively to the other fields.
 195    * The offset is expressed in bytes.
 196    *
 197    * @return The offset of the field in bytes.
 198    * @see #setOffset(int)
 199    */
 200   public int getOffset ()
 201   {
 202     return offset;
 203   }
 204
 205   /**
 206    * This method sets the current offset of the field.
 207    *
 208    * @param off The offset of the field in bytes.
 209    * @see getOffset()
 210    */
 211   protected void setOffset (int off)
 212   {
 213     offset = off;
 214   }
 215
 216   /**
 217    * This method returns whether the field represented by this object is
 218    * unshared or not.
 219    *
 220    * @return Tells if this field is unshared or not.
 221    */
 222   public boolean isUnshared ()
 223   {
 224     return unshared;
 225   }
 226
 227   /**
 228    * This method returns true if the type of the field
 229    * represented by this instance is a primitive.
 230    *
 231    * @return true if the type is a primitive, false
 232    * in the other case.
 233    */
 234   public boolean isPrimitive ()
 235   {
 236     return typename.length() == 1;
 237   }
 238
 239   public int compareTo (Object o)
 240   {
 241     ObjectStreamField f = (ObjectStreamField)o;
 242     boolean this_is_primitive = isPrimitive ();
 243     boolean f_is_primitive = f.isPrimitive ();
 244
 245     if (this_is_primitive && !f_is_primitive)
 246       return -1;
 247
 248     if (!this_is_primitive && f_is_primitive)
 249       return 1;
 250
 251     return getName ().compareTo (f.getName ());
 252   }
 253
 254   /**
 255    * This method is specific to classpath's implementation and so has the default
 256    * access. It changes the state of this field to "persistent". It means that
 257    * the field should not be changed when the stream is read (if it is not
 258    * explicitly specified using serialPersistentFields).
 259    *
 260    * @param persistent True if the field is persistent, false in the
 261    * other cases.
 262    * @see #isPersistent()
 263    */
 264   void setPersistent(boolean persistent)
 265   {
 266     this.persistent = persistent;
 267   }
 268
 269   /**
 270    * This method returns true if the field is marked as persistent.
 271    *
 272    * @return True if persistent, false in the other cases.
 273    * @see #setPersistent(boolean)
 274    */
 275   boolean isPersistent()
 276   {
 277     return persistent;
 278   }
 279
 280   /**
 281    * This method is specific to classpath's implementation and so
 282    * has the default access. It changes the state of this field as
 283    * to be set by ObjectInputStream.
 284    *
 285    * @param toset True if this field should be set, false in the other
 286    * cases.
 287    * @see #isToSet()
 288    */
 289   void setToSet(boolean toset)
 290   {
 291     this.toset = toset;
 292   }
 293
 294   /**
 295    * This methods returns true if the field is marked as to be
 296    * set.
 297    *
 298    * @return True if it is to be set, false in the other cases.
 299    * @see #setToSet(boolean)
 300    */
 301   boolean isToSet()
 302   {
 303     return toset;
 304   }
 305
 306   public String toString ()
 307   {
 308     return "ObjectStreamField< " + type + " " + name + " >";
 309   }
 310
 311   final void setBooleanField(Object obj, boolean val)
 312   {
 313       try
 314       {
 315           field.setBoolean(obj, val);
 316       }
 317       catch(IllegalAccessException x)
 318       {
 319           throw new InternalError(x.getMessage());
 320       }
 321   }
 322
 323   final void setByteField(Object obj, byte val)
 324   {
 325       try
 326       {
 327           field.setByte(obj, val);
 328       }
 329       catch(IllegalAccessException x)
 330       {
 331           throw new InternalError(x.getMessage());
 332       }
 333   }
 334
 335   final void setCharField(Object obj, char val)
 336   {
 337       try
 338       {
 339           field.setChar(obj, val);
 340       }
 341       catch(IllegalAccessException x)
 342       {
 343           throw new InternalError(x.getMessage());
 344       }
 345   }
 346
 347   final void setShortField(Object obj, short val)
 348   {
 349       try
 350       {
 351           field.setShort(obj, val);
 352       }
 353       catch(IllegalAccessException x)
 354       {
 355           throw new InternalError(x.getMessage());
 356       }
 357   }
 358
 359   final void setIntField(Object obj, int val)
 360   {
 361       try
 362       {
 363           field.setInt(obj, val);
 364       }
 365       catch(IllegalAccessException x)
 366       {
 367           throw new InternalError(x.getMessage());
 368       }
 369   }
 370
 371   final void setLongField(Object obj, long val)
 372   {
 373       try
 374       {
 375           field.setLong(obj, val);
 376       }
 377       catch(IllegalAccessException x)
 378       {
 379           throw new InternalError(x.getMessage());
 380       }
 381   }
 382
 383   final void setFloatField(Object obj, float val)
 384   {
 385       try
 386       {
 387           field.setFloat(obj, val);
 388       }
 389       catch(IllegalAccessException x)
 390       {
 391           throw new InternalError(x.getMessage());
 392       }
 393   }
 394
 395   final void setDoubleField(Object obj, double val)
 396   {
 397       try
 398       {
 399           field.setDouble(obj, val);
 400       }
 401       catch(IllegalAccessException x)
 402       {
 403           throw new InternalError(x.getMessage());
 404       }
 405   }
 406
 407   final void setObjectField(Object obj, Object val)
 408   {
 409     try
 410       {
 411         field.set(obj, val);
 412       }
 413     catch(IllegalAccessException x)
 414       {
 415         throw new InternalError(x.getMessage());
 416       }
 417   }
 418 }