libjava/java/lang/reflect/Field.java

   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 }