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 }