Source for java.lang.reflect.Field

   1: /* java.lang.reflect.Field - reflection of Java fields
   2:    Copyright (C) 1998, 2001, 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 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.lang.reflect;
  40: 
  41: import gnu.java.lang.ClassHelper;
  42: 
  43: import gnu.java.lang.reflect.FieldSignatureParser;
  44: import java.lang.annotation.Annotation;
  45: 
  46: /**
  47:  * The Field class represents a member variable of a class. It also allows
  48:  * dynamic access to a member, via reflection. This works for both
  49:  * static and instance fields. Operations on Field objects know how to
  50:  * do widening conversions, but throw {@link IllegalArgumentException} if
  51:  * a narrowing conversion would be necessary. You can query for information
  52:  * on this Field regardless of location, but get and set access may be limited
  53:  * by Java language access controls. If you can't do it in the compiler, you
  54:  * can't normally do it here either.<p>
  55:  *
  56:  * <B>Note:</B> This class returns and accepts types as Classes, even
  57:  * primitive types; there are Class types defined that represent each
  58:  * different primitive type.  They are <code>java.lang.Boolean.TYPE,
  59:  * java.lang.Byte.TYPE,</code>, also available as <code>boolean.class,
  60:  * byte.class</code>, etc.  These are not to be confused with the
  61:  * classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are
  62:  * real classes.<p>
  63:  *
  64:  * Also note that this is not a serializable class.  It is entirely feasible
  65:  * to make it serializable using the Externalizable interface, but this is
  66:  * on Sun, not me.
  67:  *
  68:  * @author John Keiser
  69:  * @author Eric Blake <ebb9@email.byu.edu>
  70:  * @author Per Bothner <bothner@cygnus.com>
  71:  * @see Member
  72:  * @see Class
  73:  * @see Class#getField(String)
  74:  * @see Class#getDeclaredField(String)
  75:  * @see Class#getFields()
  76:  * @see Class#getDeclaredFields()
  77:  * @since 1.1
  78:  * @status updated to 1.4
  79:  */
  80: public final class Field
  81:   extends AccessibleObject implements Member
  82: {
  83:   private Class declaringClass;
  84:   private String name;
  85: 
  86:   // Offset in bytes from the start of declaringClass's fields array.
  87:   private int offset;
  88: 
  89:   // The Class (or primitive TYPE) of this field.
  90:   private Class type;
  91: 
  92:   static final int FIELD_MODIFIERS
  93:     = Modifier.FINAL | Modifier.PRIVATE | Modifier.PROTECTED
  94:       | Modifier.PUBLIC | Modifier.STATIC | Modifier.TRANSIENT
  95:       | Modifier.VOLATILE;
  96: 
  97:   // This is instantiated by Class sometimes, but it uses C++ and
  98:   // avoids the Java protection check.
  99:   Field ()
 100:   {
 101:   }
 102: 
 103:   /**
 104:    * Gets the class that declared this field, or the class where this field
 105:    * is a non-inherited member.
 106:    * @return the class that declared this member
 107:    */
 108:   public Class<?> getDeclaringClass()
 109:   {
 110:     return declaringClass;
 111:   }
 112: 
 113:   /**
 114:    * Gets the name of this field.
 115:    * @return the name of this field
 116:    */
 117:   public native String getName();
 118: 
 119:   /**
 120:    * Return the raw modifiers for this field.
 121:    * @return the field's modifiers
 122:    */
 123:   private native int getModifiersInternal();
 124: 
 125:   /**
 126:    * Gets the modifiers this field uses.  Use the <code>Modifier</code>
 127:    * class to interpret the values.  A field can only have a subset of the
 128:    * following modifiers: public, private, protected, static, final,
 129:    * transient, and volatile.
 130:    *
 131:    * @return an integer representing the modifiers to this Member
 132:    * @see Modifier
 133:    */
 134:   public int getModifiers()
 135:   {
 136:     return getModifiersInternal() & FIELD_MODIFIERS;
 137:   }
 138: 
 139:   /**
 140:    * Return true if this field is synthetic, false otherwise.
 141:    * @since 1.5
 142:    */
 143:   public boolean isSynthetic()
 144:   {
 145:     return (getModifiersInternal() & Modifier.SYNTHETIC) != 0;
 146:   }
 147: 
 148:   /**
 149:    * Return true if this field represents an enum constant,
 150:    * false otherwise.
 151:    * @since 1.5
 152:    */
 153:   public boolean isEnumConstant()
 154:   {
 155:     return (getModifiersInternal() & Modifier.ENUM) != 0;
 156:   }
 157: 
 158:   /**
 159:    * Gets the type of this field.
 160:    * @return the type of this field
 161:    */
 162:   public native Class<?> getType();
 163: 
 164:   /**
 165:    * Compare two objects to see if they are semantically equivalent.
 166:    * Two Fields are semantically equivalent if they have the same declaring
 167:    * class, name, and type. Since you can't creat a Field except through
 168:    * the VM, this is just the == relation.
 169:    *
 170:    * @param o the object to compare to
 171:    * @return <code>true</code> if they are equal; <code>false</code> if not
 172:    */
 173:   public boolean equals (Object fld)
 174:   {
 175:     if (! (fld instanceof Field))
 176:       return false;
 177:     Field f = (Field) fld;
 178:     return declaringClass == f.declaringClass && offset == f.offset;
 179:   }
 180: 
 181:   /**
 182:    * Get the hash code for the Field. The Field hash code is the hash code
 183:    * of its name XOR'd with the hash code of its class name.
 184:    *
 185:    * @return the hash code for the object.
 186:    */
 187:   public int hashCode()
 188:   {
 189:     return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
 190:   }
 191: 
 192:   /**
 193:    * Get a String representation of the Field. A Field's String
 194:    * representation is "&lt;modifiers&gt; &lt;type&gt;
 195:    * &lt;class&gt;.&lt;fieldname&gt;".<br> Example:
 196:    * <code>public transient boolean gnu.parse.Parser.parseComplete</code>
 197:    *
 198:    * @return the String representation of the Field
 199:    */
 200:   public String toString ()
 201:   {
 202:     StringBuffer sbuf = new StringBuffer ();
 203:     int mods = getModifiers();
 204:     if (mods != 0)
 205:       {
 206:     Modifier.toString(mods, sbuf);
 207:     sbuf.append(' ');
 208:       }
 209:     Method.appendClassName (sbuf, getType ());
 210:     sbuf.append(' ');
 211:     Method.appendClassName (sbuf, getDeclaringClass());
 212:     sbuf.append('.');
 213:     sbuf.append(getName());
 214:     return sbuf.toString();
 215:   }
 216: 
 217:   public String toGenericString()
 218:   {
 219:     StringBuilder sb = new StringBuilder(64);
 220:     Modifier.toString(getModifiers(), sb).append(' ');
 221:     sb.append(getGenericType()).append(' ');
 222:     sb.append(getDeclaringClass().getName()).append('.');
 223:     sb.append(getName());
 224:     return sb.toString();
 225:   }
 226: 
 227:   /**
 228:    * Get the value of this Field.  If it is primitive, it will be wrapped
 229:    * in the appropriate wrapper type (boolean = java.lang.Boolean).<p>
 230:    *
 231:    * If the field is static, <code>o</code> will be ignored. Otherwise, if
 232:    * <code>o</code> is null, you get a <code>NullPointerException</code>,
 233:    * and if it is incompatible with the declaring class of the field, you
 234:    * get an <code>IllegalArgumentException</code>.<p>
 235:    *
 236:    * Next, if this Field enforces access control, your runtime context is
 237:    * evaluated, and you may have an <code>IllegalAccessException</code> if
 238:    * you could not access this field in similar compiled code. If the field
 239:    * is static, and its class is uninitialized, you trigger class
 240:    * initialization, which may end in a
 241:    * <code>ExceptionInInitializerError</code>.<p>
 242:    *
 243:    * Finally, the field is accessed, and primitives are wrapped (but not
 244:    * necessarily in new objects). This method accesses the field of the
 245:    * declaring class, even if the instance passed in belongs to a subclass
 246:    * which declares another field to hide this one.
 247:    *
 248:    * @param o the object to get the value of this Field from
 249:    * @return the value of the Field
 250:    * @throws IllegalAccessException if you could not normally access this field
 251:    *         (i.e. it is not public)
 252:    * @throws IllegalArgumentException if <code>o</code> is not an instance of
 253:    *         the class or interface declaring this field
 254:    * @throws NullPointerException if <code>o</code> is null and this field
 255:    *         requires an instance
 256:    * @throws ExceptionInInitializerError if accessing a static field triggered
 257:    *         class initialization, which then failed
 258:    * @see #getBoolean(Object)
 259:    * @see #getByte(Object)
 260:    * @see #getChar(Object)
 261:    * @see #getShort(Object)
 262:    * @see #getInt(Object)
 263:    * @see #getLong(Object)
 264:    * @see #getFloat(Object)
 265:    * @see #getDouble(Object)
 266:    */
 267:   public Object get(Object obj)
 268:     throws IllegalAccessException
 269:   {
 270:     return get(null, obj);
 271:   }
 272: 
 273:   /**
 274:    * Get the value of this boolean Field. If the field is static,
 275:    * <code>o</code> will be ignored.
 276:    *
 277:    * @param o the object to get the value of this Field from
 278:    * @return the value of the Field
 279:    * @throws IllegalAccessException if you could not normally access this field
 280:    *         (i.e. it is not public)
 281:    * @throws IllegalArgumentException if this is not a boolean field of
 282:    *         <code>o</code>, or if <code>o</code> is not an instance of the
 283:    *         declaring class of this field
 284:    * @throws NullPointerException if <code>o</code> is null and this field
 285:    *         requires an instance
 286:    * @throws ExceptionInInitializerError if accessing a static field triggered
 287:    *         class initialization, which then failed
 288:    * @see #get(Object)
 289:    */
 290:   public boolean getBoolean(Object obj)
 291:     throws IllegalAccessException
 292:   {
 293:     return getBoolean(null, obj);
 294:   }
 295: 
 296:   /**
 297:    * Get the value of this byte Field. If the field is static,
 298:    * <code>o</code> will be ignored.
 299:    *
 300:    * @param o the object to get the value of this Field from
 301:    * @return the value of the Field
 302:    * @throws IllegalAccessException if you could not normally access this field
 303:    *         (i.e. it is not public)
 304:    * @throws IllegalArgumentException if this is not a byte field of
 305:    *         <code>o</code>, or if <code>o</code> is not an instance of the
 306:    *         declaring class of this field
 307:    * @throws NullPointerException if <code>o</code> is null and this field
 308:    *         requires an instance
 309:    * @throws ExceptionInInitializerError if accessing a static field triggered
 310:    *         class initialization, which then failed
 311:    * @see #get(Object)
 312:    */
 313:   public byte getByte(Object obj)
 314:     throws IllegalAccessException
 315:   {
 316:     return getByte(null, obj);
 317:   }
 318: 
 319:   /**
 320:    * Get the value of this Field as a char. If the field is static,
 321:    * <code>o</code> will be ignored.
 322:    *
 323:    * @throws IllegalAccessException if you could not normally access this field
 324:    *         (i.e. it is not public)
 325:    * @throws IllegalArgumentException if this is not a char field of
 326:    *         <code>o</code>, or if <code>o</code> is not an instance
 327:    *         of the declaring class of this field
 328:    * @throws NullPointerException if <code>o</code> is null and this field
 329:    *         requires an instance
 330:    * @throws ExceptionInInitializerError if accessing a static field triggered
 331:    *         class initialization, which then failed
 332:    * @see #get(Object)
 333:    */
 334:   public char getChar(Object obj)
 335:     throws IllegalAccessException
 336:   {
 337:     return getChar(null, obj);
 338:   }
 339: 
 340:   /**
 341:    * Get the value of this Field as a short. If the field is static,
 342:    * <code>o</code> will be ignored.
 343:    *
 344:    * @param o the object to get the value of this Field from
 345:    * @return the value of the Field
 346:    * @throws IllegalAccessException if you could not normally access this field
 347:    *         (i.e. it is not public)
 348:    * @throws IllegalArgumentException if this is not a byte or short
 349:    *         field of <code>o</code>, or if <code>o</code> is not an instance
 350:    *         of the declaring class of this field
 351:    * @throws NullPointerException if <code>o</code> is null and this field
 352:    *         requires an instance
 353:    * @throws ExceptionInInitializerError if accessing a static field triggered
 354:    *         class initialization, which then failed
 355:    * @see #get(Object)
 356:    */
 357:   public short getShort(Object obj)
 358:     throws IllegalAccessException
 359:   {
 360:     return getShort(null, obj);
 361:   }
 362: 
 363:   /**
 364:    * Get the value of this Field as an int. If the field is static,
 365:    * <code>o</code> will be ignored.
 366:    *
 367:    * @param o the object to get the value of this Field from
 368:    * @return the value of the Field
 369:    * @throws IllegalAccessException if you could not normally access this field
 370:    *         (i.e. it is not public)
 371:    * @throws IllegalArgumentException if this is not a byte, short, char, or
 372:    *         int field of <code>o</code>, or if <code>o</code> is not an
 373:    *         instance of the declaring class of this field
 374:    * @throws NullPointerException if <code>o</code> is null and this field
 375:    *         requires an instance
 376:    * @throws ExceptionInInitializerError if accessing a static field triggered
 377:    *         class initialization, which then failed
 378:    * @see #get(Object)
 379:    */
 380:   public int getInt(Object obj)
 381:     throws IllegalAccessException
 382:   {
 383:     return getInt(null, obj);
 384:   }
 385: 
 386:   /**
 387:    * Get the value of this Field as a long. If the field is static,
 388:    * <code>o</code> will be ignored.
 389:    *
 390:    * @param o the object to get the value of this Field from
 391:    * @return the value of the Field
 392:    * @throws IllegalAccessException if you could not normally access this field
 393:    *         (i.e. it is not public)
 394:    * @throws IllegalArgumentException if this is not a byte, short, char, int,
 395:    *         or long field of <code>o</code>, or if <code>o</code> is not an
 396:    *         instance of the declaring class of this field
 397:    * @throws NullPointerException if <code>o</code> is null and this field
 398:    *         requires an instance
 399:    * @throws ExceptionInInitializerError if accessing a static field triggered
 400:    *         class initialization, which then failed
 401:    * @see #get(Object)
 402:    */
 403:   public long getLong(Object obj)
 404:     throws IllegalAccessException
 405:   {
 406:     return getLong(null, obj);
 407:   }
 408: 
 409:   /**
 410:    * Get the value of this Field as a float. If the field is static,
 411:    * <code>o</code> will be ignored.
 412:    *
 413:    * @param o the object to get the value of this Field from
 414:    * @return the value of the Field
 415:    * @throws IllegalAccessException if you could not normally access this field
 416:    *         (i.e. it is not public)
 417:    * @throws IllegalArgumentException if this is not a byte, short, char, int,
 418:    *         long, or float field of <code>o</code>, or if <code>o</code> is
 419:    *         not an instance of the declaring class of this field
 420:    * @throws NullPointerException if <code>o</code> is null and this field
 421:    *         requires an instance
 422:    * @throws ExceptionInInitializerError if accessing a static field triggered
 423:    *         class initialization, which then failed
 424:    * @see #get(Object)
 425:    */
 426:   public float getFloat(Object obj)
 427:     throws IllegalAccessException
 428:   {
 429:     return getFloat(null, obj);
 430:   }
 431: 
 432:   /**
 433:    * Get the value of this Field as a double. If the field is static,
 434:    * <code>o</code> will be ignored.
 435:    *
 436:    * @param o the object to get the value of this Field from
 437:    * @return the value of the Field
 438:    * @throws IllegalAccessException if you could not normally access this field
 439:    *         (i.e. it is not public)
 440:    * @throws IllegalArgumentException if this is not a byte, short, char, int,
 441:    *         long, float, or double field of <code>o</code>, or if
 442:    *         <code>o</code> is not an instance of the declaring class of this
 443:    *         field
 444:    * @throws NullPointerException if <code>o</code> is null and this field
 445:    *         requires an instance
 446:    * @throws ExceptionInInitializerError if accessing a static field triggered
 447:    *         class initialization, which then failed
 448:    * @see #get(Object)
 449:    */
 450:   public double getDouble(Object obj)
 451:     throws IllegalAccessException
 452:   {
 453:     return getDouble(null, obj);
 454:   }
 455: 
 456:   private native boolean getBoolean (Class caller, Object obj)
 457:     throws IllegalArgumentException, IllegalAccessException;
 458: 
 459:   private native char getChar (Class caller, Object obj)
 460:     throws IllegalArgumentException, IllegalAccessException;
 461: 
 462:   private native byte getByte (Class caller, Object obj)
 463:     throws IllegalArgumentException, IllegalAccessException;
 464: 
 465:   private native short getShort (Class caller, Object obj)
 466:     throws IllegalArgumentException, IllegalAccessException;
 467: 
 468:   private native int getInt (Class caller, Object obj)
 469:     throws IllegalArgumentException, IllegalAccessException;
 470: 
 471:   private native long getLong (Class caller, Object obj)
 472:     throws IllegalArgumentException, IllegalAccessException;
 473: 
 474:   private native float getFloat (Class caller, Object obj)
 475:     throws IllegalArgumentException, IllegalAccessException;
 476: 
 477:   private native double getDouble (Class caller, Object obj)
 478:     throws IllegalArgumentException, IllegalAccessException;
 479: 
 480:   private native Object get (Class caller, Object obj)
 481:     throws IllegalArgumentException, IllegalAccessException;
 482: 
 483:   /**
 484:    * Set the value of this Field.  If it is a primitive field, the value
 485:    * will be unwrapped from the passed object (boolean = java.lang.Boolean).<p>
 486:    *
 487:    * If the field is static, <code>o</code> will be ignored. Otherwise, if
 488:    * <code>o</code> is null, you get a <code>NullPointerException</code>,
 489:    * and if it is incompatible with the declaring class of the field, you
 490:    * get an <code>IllegalArgumentException</code>.<p>
 491:    *
 492:    * Next, if this Field enforces access control, your runtime context is
 493:    * evaluated, and you may have an <code>IllegalAccessException</code> if
 494:    * you could not access this field in similar compiled code. This also
 495:    * occurs whether or not there is access control if the field is final.
 496:    * If the field is primitive, and unwrapping your argument fails, you will
 497:    * get an <code>IllegalArgumentException</code>; likewise, this error
 498:    * happens if <code>value</code> cannot be cast to the correct object type.
 499:    * If the field is static, and its class is uninitialized, you trigger class
 500:    * initialization, which may end in a
 501:    * <code>ExceptionInInitializerError</code>.<p>
 502:    *
 503:    * Finally, the field is set with the widened value. This method accesses
 504:    * the field of the declaring class, even if the instance passed in belongs
 505:    * to a subclass which declares another field to hide this one.
 506:    *
 507:    * @param o the object to set this Field on
 508:    * @param value the value to set this Field to
 509:    * @throws IllegalAccessException if you could not normally access this field
 510:    *         (i.e. it is not public)
 511:    * @throws IllegalArgumentException if <code>value</code> cannot be
 512:    *         converted by a widening conversion to the underlying type of
 513:    *         the Field, or if <code>o</code> is not an instance of the class
 514:    *         declaring this field
 515:    * @throws NullPointerException if <code>o</code> is null and this field
 516:    *         requires an instance
 517:    * @throws ExceptionInInitializerError if accessing a static field triggered
 518:    *         class initialization, which then failed
 519:    * @see #setBoolean(Object, boolean)
 520:    * @see #setByte(Object, byte)
 521:    * @see #setChar(Object, char)
 522:    * @see #setShort(Object, short)
 523:    * @see #setInt(Object, int)
 524:    * @see #setLong(Object, long)
 525:    * @see #setFloat(Object, float)
 526:    * @see #setDouble(Object, double)
 527:    */
 528:   public void set(Object object, Object value)
 529:     throws IllegalAccessException
 530:   {
 531:     set(null, object, value);
 532:   }
 533: 
 534:   /**
 535:    * Set this boolean Field. If the field is static, <code>o</code> will be
 536:    * ignored.
 537:    *
 538:    * @param o the object to set this Field on
 539:    * @param value the value to set this Field to
 540:    * @throws IllegalAccessException if you could not normally access this field
 541:    *         (i.e. it is not public)
 542:    * @throws IllegalArgumentException if this is not a boolean field, or if
 543:    *         <code>o</code> is not an instance of the class declaring this
 544:    *         field
 545:    * @throws NullPointerException if <code>o</code> is null and this field
 546:    *         requires an instance
 547:    * @throws ExceptionInInitializerError if accessing a static field triggered
 548:    *         class initialization, which then failed
 549:    * @see #set(Object, Object)
 550:    */
 551:   public void setBoolean(Object obj, boolean b)
 552:     throws IllegalAccessException
 553:   {
 554:     setBoolean(null, obj, b, true);
 555:   }
 556: 
 557:   /**
 558:    * Set this byte Field. If the field is static, <code>o</code> will be
 559:    * ignored.
 560:    *
 561:    * @param o the object to set this Field on
 562:    * @param value the value to set this Field to
 563:    * @throws IllegalAccessException if you could not normally access this field
 564:    *         (i.e. it is not public)
 565:    * @throws IllegalArgumentException if this is not a byte, short, int, long,
 566:    *         float, or double field, or if <code>o</code> is not an instance
 567:    *         of the class declaring this field
 568:    * @throws NullPointerException if <code>o</code> is null and this field
 569:    *         requires an instance
 570:    * @throws ExceptionInInitializerError if accessing a static field triggered
 571:    *         class initialization, which then failed
 572:    * @see #set(Object, Object)
 573:    */
 574:   public void setByte(Object obj, byte b)
 575:     throws IllegalAccessException
 576:   {
 577:     setByte(null, obj, b, true);
 578:   }
 579: 
 580:   /**
 581:    * Set this char Field. If the field is static, <code>o</code> will be
 582:    * ignored.
 583:    *
 584:    * @param o the object to set this Field on
 585:    * @param value the value to set this Field to
 586:    * @throws IllegalAccessException if you could not normally access this field
 587:    *         (i.e. it is not public)
 588:    * @throws IllegalArgumentException if this is not a char, int, long,
 589:    *         float, or double field, or if <code>o</code> is not an instance
 590:    *         of the class declaring this field
 591:    * @throws NullPointerException if <code>o</code> is null and this field
 592:    *         requires an instance
 593:    * @throws ExceptionInInitializerError if accessing a static field triggered
 594:    *         class initialization, which then failed
 595:    * @see #set(Object, Object)
 596:    */
 597:   public void setChar(Object obj, char c)
 598:     throws IllegalAccessException
 599:   {
 600:     setChar(null, obj, c, true);
 601:   }
 602: 
 603:   /**
 604:    * Set this short Field. If the field is static, <code>o</code> will be
 605:    * ignored.
 606:    *
 607:    * @param o the object to set this Field on
 608:    * @param value the value to set this Field to
 609:    * @throws IllegalAccessException if you could not normally access this field
 610:    *         (i.e. it is not public)
 611:    * @throws IllegalArgumentException if this is not a short, int, long,
 612:    *         float, or double field, or if <code>o</code> is not an instance
 613:    *         of the class declaring this field
 614:    * @throws NullPointerException if <code>o</code> is null and this field
 615:    *         requires an instance
 616:    * @throws ExceptionInInitializerError if accessing a static field triggered
 617:    *         class initialization, which then failed
 618:    * @see #set(Object, Object)
 619:    */
 620:   public void setShort(Object obj,  short s)
 621:     throws IllegalAccessException
 622:   {
 623:     setShort(null, obj, s, true);
 624:   }
 625: 
 626:   /**
 627:    * Set this int Field. If the field is static, <code>o</code> will be
 628:    * ignored.
 629:    *
 630:    * @param o the object to set this Field on
 631:    * @param value the value to set this Field to
 632:    * @throws IllegalAccessException if you could not normally access this field
 633:    *         (i.e. it is not public)
 634:    * @throws IllegalArgumentException if this is not an int, long, float, or
 635:    *         double field, or if <code>o</code> is not an instance of the
 636:    *         class declaring this field
 637:    * @throws NullPointerException if <code>o</code> is null and this field
 638:    *         requires an instance
 639:    * @throws ExceptionInInitializerError if accessing a static field triggered
 640:    *         class initialization, which then failed
 641:    * @see #set(Object, Object)
 642:    */
 643:   public void setInt(Object obj, int i)
 644:     throws IllegalAccessException
 645:   {
 646:     setInt(null, obj, i, true);
 647:   }
 648: 
 649:   /**
 650:    * Set this long Field. If the field is static, <code>o</code> will be
 651:    * ignored.
 652:    *
 653:    * @param o the object to set this Field on
 654:    * @param value the value to set this Field to
 655:    * @throws IllegalAccessException if you could not normally access this field
 656:    *         (i.e. it is not public)
 657:    * @throws IllegalArgumentException if this is not a long, float, or double
 658:    *         field, or if <code>o</code> is not an instance of the class
 659:    *         declaring this field
 660:    * @throws NullPointerException if <code>o</code> is null and this field
 661:    *         requires an instance
 662:    * @throws ExceptionInInitializerError if accessing a static field triggered
 663:    *         class initialization, which then failed
 664:    * @see #set(Object, Object)
 665:    */
 666:   public void setLong(Object obj, long l)
 667:     throws IllegalArgumentException, IllegalAccessException
 668:   {
 669:     setLong(null, obj, l, true);
 670:   }
 671: 
 672:   /**
 673:    * Set this float Field. If the field is static, <code>o</code> will be
 674:    * ignored.
 675:    *
 676:    * @param o the object to set this Field on
 677:    * @param value the value to set this Field to
 678:    * @throws IllegalAccessException if you could not normally access this field
 679:    *         (i.e. it is not public)
 680:    * @throws IllegalArgumentException if this is not a float or long field, or
 681:    *         if <code>o</code> is not an instance of the class declaring this
 682:    *         field
 683:    * @throws NullPointerException if <code>o</code> is null and this field
 684:    *         requires an instance
 685:    * @throws ExceptionInInitializerError if accessing a static field triggered
 686:    *         class initialization, which then failed
 687:    * @see #set(Object, Object)
 688:    */
 689:   public void setFloat(Object obj, float f)
 690:     throws IllegalAccessException
 691:   {
 692:     setFloat(null, obj, f, true);
 693:   }
 694: 
 695:   /**
 696:    * Set this double Field. If the field is static, <code>o</code> will be
 697:    * ignored.
 698:    *
 699:    * @param o the object to set this Field on
 700:    * @param value the value to set this Field to
 701:    * @throws IllegalAccessException if you could not normally access this field
 702:    *         (i.e. it is not public)
 703:    * @throws IllegalArgumentException if this is not a double field, or if
 704:    *         <code>o</code> is not an instance of the class declaring this
 705:    *         field
 706:    * @throws NullPointerException if <code>o</code> is null and this field
 707:    *         requires an instance
 708:    * @throws ExceptionInInitializerError if accessing a static field triggered
 709:    *         class initialization, which then failed
 710:    * @see #set(Object, Object)
 711:    */
 712:   public void setDouble(Object obj, double d)
 713:     throws IllegalAccessException
 714:   {
 715:     setDouble(null, obj, d, true);
 716:   }
 717: 
 718:   /**
 719:    * Return the generic type of the field. If the field type is not a generic
 720:    * type, the method returns the same as <code>getType()</code>.
 721:    *
 722:    * @throws GenericSignatureFormatError if the generic signature does
 723:    *         not conform to the format specified in the Virtual Machine
 724:    *         specification, version 3.
 725:    * @since 1.5
 726:    */
 727:   public Type getGenericType()
 728:   {
 729:     String signature = getSignature();
 730:     if (signature == null)
 731:       return getType();
 732:     FieldSignatureParser p = new FieldSignatureParser(getDeclaringClass(),
 733:                                                       signature);
 734:     return p.getFieldType();
 735:   }
 736: 
 737:   public <T extends Annotation> T getAnnotation(Class<T> annoClass)
 738:   {
 739:     Annotation[] annos = getDeclaredAnnotations();
 740:     for (int i = 0; i < annos.length; ++i)
 741:       if (annos[i].annotationType() == annoClass)
 742:     return (T) annos[i];
 743:     return null;
 744:   }
 745: 
 746:   public Annotation[] getDeclaredAnnotations()
 747:   {
 748:     Annotation[] result = getDeclaredAnnotationsInternal();
 749:     if (result == null)
 750:       result = new Annotation[0];
 751:     return result;
 752:   }
 753: 
 754:   private native Annotation[] getDeclaredAnnotationsInternal();
 755: 
 756:   /**
 757:    * Return the String in the Signature attribute for this field. If there
 758:    * is no Signature attribute, return null.
 759:    */
 760:   private native String getSignature();
 761: 
 762:   native void setByte (Class caller, Object obj, byte b, boolean checkFinal)
 763:     throws IllegalArgumentException, IllegalAccessException;
 764: 
 765:   native void setShort (Class caller, Object obj, short s, boolean checkFinal)
 766:     throws IllegalArgumentException, IllegalAccessException;
 767: 
 768:   native void setInt (Class caller, Object obj, int i, boolean checkFinal)  
 769:     throws IllegalArgumentException, IllegalAccessException;
 770: 
 771:   native void setLong (Class caller, Object obj, long l, boolean checkFinal)
 772:     throws IllegalArgumentException, IllegalAccessException;
 773: 
 774:   native void setFloat (Class caller, Object obj, float f, boolean checkFinal)
 775:     throws IllegalArgumentException, IllegalAccessException;
 776: 
 777:   native void setDouble (Class caller, Object obj, double d,
 778:              boolean checkFinal)
 779:     throws IllegalArgumentException, IllegalAccessException;
 780: 
 781:   native void setChar (Class caller, Object obj, char c, boolean checkFinal)
 782:     throws IllegalArgumentException, IllegalAccessException;
 783: 
 784:   native void setBoolean (Class caller, Object obj, boolean b,
 785:               boolean checkFinal)
 786:     throws IllegalArgumentException, IllegalAccessException;
 787: 
 788:   native void set (Class caller, Object obj, Object val, Class type, 
 789:            boolean checkFinal)
 790:     throws IllegalArgumentException, IllegalAccessException;
 791: 
 792:   private void set (Class caller, Object object, Object value)
 793:     throws IllegalArgumentException, IllegalAccessException
 794:   {
 795:     Class type = getType();
 796:     if (! type.isPrimitive())
 797:       set(caller, object, value, type, true);
 798:     else if (value instanceof Byte)
 799:       setByte(caller, object, ((Byte) value).byteValue(), true);
 800:     else if (value instanceof Short)
 801:       setShort (caller, object, ((Short) value).shortValue(), true);
 802:     else if (value instanceof Integer)
 803:       setInt(caller, object, ((Integer) value).intValue(), true);
 804:     else if (value instanceof Long)
 805:       setLong(caller, object, ((Long) value).longValue(), true);
 806:     else if (value instanceof Float)
 807:       setFloat(caller, object, ((Float) value).floatValue(), true);
 808:     else if (value instanceof Double)
 809:       setDouble(caller, object, ((Double) value).doubleValue(), true);
 810:     else if (value instanceof Character)
 811:       setChar(caller, object, ((Character) value).charValue(), true);
 812:     else if (value instanceof Boolean)
 813:       setBoolean(caller, object, ((Boolean) value).booleanValue(), true);
 814:     else
 815:       throw new IllegalArgumentException();
 816:   }
 817: }