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
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038
039 package java.io;
040
041 import gnu.java.lang.reflect.TypeSignature;
042
043 import java.lang.reflect.Field;
044 import java.security.AccessController;
045 import 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 */
058 public 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 }