001/* ObjectStreamField.java -- Class used to store name and class of fields
002   Copyright (C) 1998, 1999, 2003, 2004, 2005  Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010 
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package java.io;
040
041import gnu.java.lang.reflect.TypeSignature;
042
043import java.lang.reflect.Field;
044import java.security.AccessController;
045import java.security.PrivilegedAction;
046
047/**
048 * This class intends to describe the field of a class for the serialization
049 * subsystem. Serializable fields in a serializable class can be explicitly
050 * exported using an array of ObjectStreamFields.
051 *
052 * @author Tom Tromey (tromey@redhat.com)
053 * @author Jeroen Frijters (jeroen@frijters.net)
054 * @author Guilhem Lavaux (guilhem@kaffe.org)
055 * @author Michael Koch (konqueror@gmx.de)
056 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
057 */
058public class ObjectStreamField 
059  implements Comparable<Object>
060{
061  private String name;
062  private Class<?> type;
063  private String typename;
064  private int offset = -1; // XXX make sure this is correct
065  private boolean unshared;
066  private boolean persistent = false;
067  private boolean toset = true;
068  Field field;
069
070  ObjectStreamField (Field field)
071  {
072    this (field.getName(), field.getType());
073    this.field = field;
074  }
075
076  /**
077   * This constructor creates an ObjectStreamField instance 
078   * which represents a field named <code>name</code> and is
079   * of the type <code>type</code>.
080   *
081   * @param name Name of the field to export.
082   * @param type Type of the field in the concerned class.
083   */
084  public ObjectStreamField (String name, Class<?> type)
085  {
086    this (name, type, false);
087  }
088
089  /**
090   * This constructor creates an ObjectStreamField instance 
091   * which represents a field named <code>name</code> and is
092   * of the type <code>type</code>.
093   *
094   * @param name Name of the field to export.
095   * @param type Type of the field in the concerned class.
096   * @param unshared true if field will be unshared, false otherwise.
097   */
098  public ObjectStreamField (String name, Class<?> type, boolean unshared)
099  {
100    if (name == null)
101      throw new NullPointerException();
102
103    this.name = name;
104    this.type = type;
105    this.typename = TypeSignature.getEncodingOfClass(type);
106    this.unshared = unshared;
107  }
108 
109  /**
110   * There are many cases you can not get java.lang.Class from typename 
111   * if your context class loader cannot load it, then use typename to
112   * construct the field.
113   *
114   * @param name Name of the field to export.
115   * @param typename The coded name of the type for this field.
116   */
117  ObjectStreamField (String name, String typename)
118  {
119    this.name = name;
120    this.typename = typename;
121  }
122
123  void resolveType(ClassLoader loader)
124  {
125    try
126      {
127        type = TypeSignature.getClassForEncoding(typename, true, loader);
128      }
129    catch(ClassNotFoundException e)
130      {
131      }
132  }
133  
134  /**
135   * This method returns the name of the field represented by the
136   * ObjectStreamField instance.
137   *
138   * @return A string containing the name of the field.
139   */
140  public String getName ()
141  {
142    return name;
143  }
144
145  /**
146   * This method returns the class representing the type of the
147   * field which is represented by this instance of ObjectStreamField.
148   *
149   * @return A class representing the type of the field.
150   */
151  public Class<?> getType ()
152  {
153    return type;
154  }
155
156  /**
157   * This method returns the char encoded type of the field which
158   * is represented by this instance of ObjectStreamField.
159   *
160   * @return A char representing the type of the field.
161   */
162  public char getTypeCode ()
163  {
164    return typename.charAt (0);
165  }
166
167  /**
168   * This method returns a more explicit type name than
169   * {@link #getTypeCode()} in the case the type is a real
170   * class (and not a primitive).
171   *
172   * @return The name of the type (class name) if it is not a 
173   * primitive, in the other case null is returned.
174   */
175  public String getTypeString ()
176  {
177    // use intern()
178    if (isPrimitive())
179      return null;
180    return typename.intern();
181  }
182
183  /**
184   * This method returns the current offset of the field in
185   * the serialization stream relatively to the other fields.
186   * The offset is expressed in bytes.
187   *
188   * @return The offset of the field in bytes.
189   * @see #setOffset(int)
190   */
191  public int getOffset ()
192  {
193    return offset;
194  }
195
196  /**
197   * This method sets the current offset of the field.
198   * 
199   * @param off The offset of the field in bytes.
200   * @see #getOffset()
201   */
202  protected void setOffset (int off)
203  {
204    offset = off;
205  }
206
207  /**
208   * This method returns whether the field represented by this object is
209   * unshared or not.
210   *
211   * @return Tells if this field is unshared or not.
212   */
213  public boolean isUnshared ()
214  {
215    return unshared;
216  }
217
218  /**
219   * This method returns true if the type of the field
220   * represented by this instance is a primitive.
221   *
222   * @return true if the type is a primitive, false
223   * in the other case.
224   */
225  public boolean isPrimitive ()
226  {
227    return typename.length() == 1;
228  }
229
230  /**
231   * Compares this object to the given object.
232   *
233   * @param obj the object to compare to.
234   *
235   * @return -1, 0 or 1.
236   */
237  public int compareTo (Object obj)
238  {
239    ObjectStreamField f = (ObjectStreamField) obj;
240    boolean this_is_primitive = isPrimitive ();
241    boolean f_is_primitive = f.isPrimitive ();
242
243    if (this_is_primitive && !f_is_primitive)
244      return -1;
245
246    if (!this_is_primitive && f_is_primitive)
247      return 1;
248
249    return getName ().compareTo (f.getName ());
250  }
251
252  /**
253   * This method is specific to classpath's implementation and so has the default
254   * access. It changes the state of this field to "persistent". It means that
255   * the field should not be changed when the stream is read (if it is not
256   * explicitly specified using serialPersistentFields).
257   *
258   * @param persistent True if the field is persistent, false in the 
259   * other cases.
260   * @see #isPersistent()
261   */
262  void setPersistent(boolean persistent)
263  {
264    this.persistent = persistent;
265  }
266
267  /**
268   * This method returns true if the field is marked as persistent.
269   *
270   * @return True if persistent, false in the other cases.
271   * @see #setPersistent(boolean)
272   */
273  boolean isPersistent()
274  {
275    return persistent;
276  }
277
278  /**
279   * This method is specific to classpath's implementation and so 
280   * has the default access. It changes the state of this field as
281   * to be set by ObjectInputStream.
282   *
283   * @param toset True if this field should be set, false in the other
284   * cases.
285   * @see #isToSet()
286   */
287  void setToSet(boolean toset)
288  {
289    this.toset = toset;
290  }
291
292  /**
293   * This method returns true if the field is marked as to be
294   * set.
295   *
296   * @return True if it is to be set, false in the other cases.
297   * @see #setToSet(boolean)
298   */
299  boolean isToSet()
300  {
301    return toset;
302  }
303
304  /**
305   * This method searches for its field reference in the specified class
306   * object. It requests privileges. If an error occurs the internal field
307   * reference is not modified.
308   *
309   * @throws NoSuchFieldException if the field name does not exist in this class.
310   * @throws SecurityException if there was an error requesting the privileges.
311   */
312  void lookupField(Class clazz) throws NoSuchFieldException, SecurityException
313  {
314    final Field f = clazz.getDeclaredField(name);
315    
316    AccessController.doPrivileged(new PrivilegedAction()
317      {
318        public Object run()
319        {
320          f.setAccessible(true);
321          return null;
322        }
323      });
324    
325    this.field = f;
326  }
327
328  /**
329   * This method check whether the field described by this
330   * instance of ObjectStreamField is compatible with the
331   * actual implementation of this field.
332   *
333   * @throws NullPointerException if this field does not exist
334   * in the real class.
335   * @throws InvalidClassException if the types are incompatible.
336   */
337  void checkFieldType() throws InvalidClassException
338  {
339    Class<?> ftype = field.getType();
340
341    if (!ftype.isAssignableFrom(type))
342      throw new InvalidClassException
343        ("invalid field type for " + name +
344         " in class " + field.getDeclaringClass());
345  }
346
347  /**
348   * Returns a string representing this object.
349   *
350   * @return the string.
351   */
352  public String toString ()
353  {
354    return "ObjectStreamField< " + type + " " + name + " >";
355  }
356
357  final void setBooleanField(Object obj, boolean val)
358  {
359    VMObjectStreamClass.setBooleanNative(field, obj, val);  
360  }
361
362  final void setByteField(Object obj, byte val)
363  {
364    VMObjectStreamClass.setByteNative(field, obj, val);
365  }
366  
367  final void setCharField(Object obj, char val)
368  {
369    VMObjectStreamClass.setCharNative(field, obj, val);
370  }
371  
372  final void setShortField(Object obj, short val)
373  {
374    VMObjectStreamClass.setShortNative(field, obj, val);
375  }
376
377  final void setIntField(Object obj, int val)
378  {
379    VMObjectStreamClass.setIntNative(field, obj, val);
380  }
381  
382  final void setLongField(Object obj, long val)
383  {
384    VMObjectStreamClass.setLongNative(field, obj, val);
385  }
386  
387  final void setFloatField(Object obj, float val)
388  {
389    VMObjectStreamClass.setFloatNative(field, obj, val);
390  }
391  
392  final void setDoubleField(Object obj, double val)
393  {
394    VMObjectStreamClass.setDoubleNative(field, obj, val);
395  }
396  
397  final void setObjectField(Object obj, Object val)
398  { 
399    VMObjectStreamClass.setObjectNative(field, obj, val);
400  }
401}