001    /* java.lang.reflect.Field - reflection of Java fields
002       Copyright (C) 1998, 2001, 2005, 2006 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.lang.reflect;
040    
041    import gnu.java.lang.ClassHelper;
042    
043    import gnu.java.lang.reflect.FieldSignatureParser;
044    import java.lang.annotation.Annotation;
045    
046    /**
047     * The Field class represents a member variable of a class. It also allows
048     * dynamic access to a member, via reflection. This works for both
049     * static and instance fields. Operations on Field objects know how to
050     * do widening conversions, but throw {@link IllegalArgumentException} if
051     * a narrowing conversion would be necessary. You can query for information
052     * on this Field regardless of location, but get and set access may be limited
053     * by Java language access controls. If you can't do it in the compiler, you
054     * can't normally do it here either.<p>
055     *
056     * <B>Note:</B> This class returns and accepts types as Classes, even
057     * primitive types; there are Class types defined that represent each
058     * different primitive type.  They are <code>java.lang.Boolean.TYPE,
059     * java.lang.Byte.TYPE,</code>, also available as <code>boolean.class,
060     * byte.class</code>, etc.  These are not to be confused with the
061     * classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are
062     * real classes.<p>
063     *
064     * Also note that this is not a serializable class.  It is entirely feasible
065     * to make it serializable using the Externalizable interface, but this is
066     * on Sun, not me.
067     *
068     * @author John Keiser
069     * @author Eric Blake <ebb9@email.byu.edu>
070     * @author Per Bothner <bothner@cygnus.com>
071     * @see Member
072     * @see Class
073     * @see Class#getField(String)
074     * @see Class#getDeclaredField(String)
075     * @see Class#getFields()
076     * @see Class#getDeclaredFields()
077     * @since 1.1
078     * @status updated to 1.4
079     */
080    public final class Field
081      extends AccessibleObject implements Member
082    {
083      private Class declaringClass;
084      private String name;
085    
086      // Offset in bytes from the start of declaringClass's fields array.
087      private int offset;
088    
089      // The Class (or primitive TYPE) of this field.
090      private Class type;
091    
092      static final int FIELD_MODIFIERS
093        = Modifier.FINAL | Modifier.PRIVATE | Modifier.PROTECTED
094          | Modifier.PUBLIC | Modifier.STATIC | Modifier.TRANSIENT
095          | Modifier.VOLATILE;
096    
097      // This is instantiated by Class sometimes, but it uses C++ and
098      // avoids the Java protection check.
099      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    }