rev 55117 : 8223350: [lworld] Use inline classes instead of value classes

   1 /*
   2  * Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.lang.reflect;
  27 
  28 import jdk.internal.access.SharedSecrets;
  29 import jdk.internal.reflect.CallerSensitive;
  30 import jdk.internal.reflect.FieldAccessor;
  31 import jdk.internal.reflect.Reflection;
  32 import jdk.internal.vm.annotation.ForceInline;
  33 import sun.reflect.generics.repository.FieldRepository;
  34 import sun.reflect.generics.factory.CoreReflectionFactory;
  35 import sun.reflect.generics.factory.GenericsFactory;
  36 import sun.reflect.generics.scope.ClassScope;
  37 import java.lang.annotation.Annotation;
  38 import java.util.Map;
  39 import java.util.Objects;
  40 import sun.reflect.annotation.AnnotationParser;
  41 import sun.reflect.annotation.AnnotationSupport;
  42 import sun.reflect.annotation.TypeAnnotation;
  43 import sun.reflect.annotation.TypeAnnotationParser;
  44 
  45 /**
  46  * A {@code Field} provides information about, and dynamic access to, a
  47  * single field of a class or an interface.  The reflected field may
  48  * be a class (static) field or an instance field.
  49  *
  50  * <p>A {@code Field} permits widening conversions to occur during a get or
  51  * set access operation, but throws an {@code IllegalArgumentException} if a
  52  * narrowing conversion would occur.
  53  *
  54  * @see Member
  55  * @see java.lang.Class
  56  * @see java.lang.Class#getFields()
  57  * @see java.lang.Class#getField(String)
  58  * @see java.lang.Class#getDeclaredFields()
  59  * @see java.lang.Class#getDeclaredField(String)
  60  *
  61  * @author Kenneth Russell
  62  * @author Nakul Saraiya
  63  * @since 1.1
  64  */
  65 public final
  66 class Field extends AccessibleObject implements Member {
  67 
  68     private Class<?>            clazz;
  69     private int                 slot;
  70     // This is guaranteed to be interned by the VM in the 1.4
  71     // reflection implementation
  72     private String              name;
  73     private Class<?>            type;
  74     private int                 modifiers;
  75     // Generics and annotations support
  76     private transient String    signature;
  77     // generic info repository; lazily initialized
  78     private transient FieldRepository genericInfo;
  79     private byte[]              annotations;
  80     // Cached field accessor created without override
  81     private FieldAccessor fieldAccessor;
  82     // Cached field accessor created with override
  83     private FieldAccessor overrideFieldAccessor;
  84     // For sharing of FieldAccessors. This branching structure is
  85     // currently only two levels deep (i.e., one root Field and
  86     // potentially many Field objects pointing to it.)
  87     //
  88     // If this branching structure would ever contain cycles, deadlocks can
  89     // occur in annotation code.
  90     private Field               root;
  91 
  92     // Generics infrastructure
  93 
  94     private String getGenericSignature() {return signature;}
  95 
  96     // Accessor for factory
  97     private GenericsFactory getFactory() {
  98         Class<?> c = getDeclaringClass();
  99         // create scope and factory
 100         return CoreReflectionFactory.make(c, ClassScope.make(c));
 101     }
 102 
 103     // Accessor for generic info repository
 104     private FieldRepository getGenericInfo() {
 105         // lazily initialize repository if necessary
 106         if (genericInfo == null) {
 107             // create and cache generic info repository
 108             genericInfo = FieldRepository.make(getGenericSignature(),
 109                                                getFactory());
 110         }
 111         return genericInfo; //return cached repository
 112     }
 113 
 114 
 115     /**
 116      * Package-private constructor used by ReflectAccess to enable
 117      * instantiation of these objects in Java code from the java.lang
 118      * package via sun.reflect.LangReflectAccess.
 119      */
 120     Field(Class<?> declaringClass,
 121           String name,
 122           Class<?> type,
 123           int modifiers,
 124           int slot,
 125           String signature,
 126           byte[] annotations)
 127     {
 128         this.clazz = declaringClass;
 129         this.name = name;
 130         this.type = type;
 131         this.modifiers = modifiers;
 132         this.slot = slot;
 133         this.signature = signature;
 134         this.annotations = annotations;
 135     }
 136 
 137     /**
 138      * Package-private routine (exposed to java.lang.Class via
 139      * ReflectAccess) which returns a copy of this Field. The copy's
 140      * "root" field points to this Field.
 141      */
 142     Field copy() {
 143         // This routine enables sharing of FieldAccessor objects
 144         // among Field objects which refer to the same underlying
 145         // method in the VM. (All of this contortion is only necessary
 146         // because of the "accessibility" bit in AccessibleObject,
 147         // which implicitly requires that new java.lang.reflect
 148         // objects be fabricated for each reflective call on Class
 149         // objects.)
 150         if (this.root != null)
 151             throw new IllegalArgumentException("Can not copy a non-root Field");
 152 
 153         Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
 154         res.root = this;
 155         // Might as well eagerly propagate this if already present
 156         res.fieldAccessor = fieldAccessor;
 157         res.overrideFieldAccessor = overrideFieldAccessor;
 158 
 159         return res;
 160     }
 161 
 162     /**
 163      * @throws InaccessibleObjectException {@inheritDoc}
 164      * @throws SecurityException {@inheritDoc}
 165      */
 166     @Override
 167     @CallerSensitive
 168     public void setAccessible(boolean flag) {
 169         AccessibleObject.checkPermission();
 170 
 171         if (flag) {
 172             if (clazz.isValue()) {
 173                 throw new InaccessibleObjectException(
 174                     "Unable to make a value class field \"" + this + "\" accessible");
 175             }
 176 
 177             checkCanSetAccessible(Reflection.getCallerClass());
 178         }
 179         setAccessible0(flag);
 180     }
 181 
 182     @Override
 183     void checkCanSetAccessible(Class<?> caller) {
 184         checkCanSetAccessible(caller, clazz);
 185     }
 186 
 187     /**
 188      * Returns the {@code Class} object representing
 189      * {@linkplain Class#asBoxType() the box type} of the class or interface
 190      * that declares the field represented by this {@code Field} object.
 191      */
 192     @Override
 193     public Class<?> getDeclaringClass() {
 194         return clazz;
 195     }
 196 
 197     /**
 198      * Returns the name of the field represented by this {@code Field} object.
 199      */
 200     public String getName() {
 201         return name;
 202     }
 203 
 204     /**
 205      * Returns the Java language modifiers for the field represented
 206      * by this {@code Field} object, as an integer. The {@code Modifier} class should
 207      * be used to decode the modifiers.
 208      *
 209      * @see Modifier
 210      */
 211     public int getModifiers() {
 212         return modifiers;
 213     }
 214 
 215     /**
 216      * Returns {@code true} if this field represents an element of
 217      * an enumerated type; returns {@code false} otherwise.
 218      *
 219      * @return {@code true} if and only if this field represents an element of
 220      * an enumerated type.
 221      * @since 1.5
 222      */
 223     public boolean isEnumConstant() {
 224         return (getModifiers() & Modifier.ENUM) != 0;
 225     }
 226 
 227     /**
 228      * Returns {@code true} if this field is a synthetic
 229      * field; returns {@code false} otherwise.
 230      *
 231      * @return true if and only if this field is a synthetic
 232      * field as defined by the Java Language Specification.
 233      * @since 1.5
 234      */
 235     public boolean isSynthetic() {
 236         return Modifier.isSynthetic(getModifiers());
 237     }
 238 
 239     /**
 240      * Returns a {@code Class} object that identifies the
 241      * declared type for the field represented by this
 242      * {@code Field} object.
 243      *
 244      * @return a {@code Class} object identifying the declared
 245      * type of the field represented by this object
 246      */
 247     public Class<?> getType() {
 248         return type;
 249     }
 250 
 251     /**
 252      * Returns a {@code Type} object that represents the declared type for
 253      * the field represented by this {@code Field} object.
 254      *
 255      * <p>If the {@code Type} is a parameterized type, the
 256      * {@code Type} object returned must accurately reflect the
 257      * actual type parameters used in the source code.
 258      *
 259      * <p>If the type of the underlying field is a type variable or a
 260      * parameterized type, it is created. Otherwise, it is resolved.
 261      *
 262      * @return a {@code Type} object that represents the declared type for
 263      *     the field represented by this {@code Field} object
 264      * @throws GenericSignatureFormatError if the generic field
 265      *     signature does not conform to the format specified in
 266      *     <cite>The Java&trade; Virtual Machine Specification</cite>
 267      * @throws TypeNotPresentException if the generic type
 268      *     signature of the underlying field refers to a non-existent
 269      *     type declaration
 270      * @throws MalformedParameterizedTypeException if the generic
 271      *     signature of the underlying field refers to a parameterized type
 272      *     that cannot be instantiated for any reason
 273      * @since 1.5
 274      */
 275     public Type getGenericType() {
 276         if (getGenericSignature() != null)
 277             return getGenericInfo().getGenericType();
 278         else
 279             return getType();
 280     }
 281 
 282 
 283     /**
 284      * Compares this {@code Field} against the specified object.  Returns
 285      * true if the objects are the same.  Two {@code Field} objects are the same if
 286      * they were declared by the same class and have the same name
 287      * and type.
 288      */
 289     public boolean equals(Object obj) {
 290         if (obj != null && obj instanceof Field) {
 291             Field other = (Field)obj;
 292             return (getDeclaringClass() == other.getDeclaringClass())
 293                 && (getName() == other.getName())
 294                 && (getType() == other.getType());
 295         }
 296         return false;
 297     }
 298 
 299     /**
 300      * Returns a hashcode for this {@code Field}.  This is computed as the
 301      * exclusive-or of the hashcodes for the underlying field's
 302      * declaring class name and its name.
 303      */
 304     public int hashCode() {
 305         return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
 306     }
 307 
 308     /**
 309      * Returns a string describing this {@code Field}.  The format is
 310      * the access modifiers for the field, if any, followed
 311      * by the field type, followed by a space, followed by
 312      * the fully-qualified name of the class declaring the field,
 313      * followed by a period, followed by the name of the field.
 314      * For example:
 315      * <pre>
 316      *    public static final int java.lang.Thread.MIN_PRIORITY
 317      *    private int java.io.FileDescriptor.fd
 318      * </pre>
 319      *
 320      * <p>The modifiers are placed in canonical order as specified by
 321      * "The Java Language Specification".  This is {@code public},
 322      * {@code protected} or {@code private} first, and then other
 323      * modifiers in the following order: {@code static}, {@code final},
 324      * {@code transient}, {@code volatile}.
 325      *
 326      * @return a string describing this {@code Field}
 327      * @jls 8.3.1 Field Modifiers
 328      */
 329     public String toString() {
 330         int mod = getModifiers();
 331         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
 332             + getType().getTypeName() + " "
 333             + getDeclaringClass().getTypeName() + "."
 334             + getName());
 335     }
 336 
 337     @Override
 338     String toShortString() {
 339         return "field " + getDeclaringClass().getTypeName() + "." + getName();
 340     }
 341 
 342     /**
 343      * Returns a string describing this {@code Field}, including
 344      * its generic type.  The format is the access modifiers for the
 345      * field, if any, followed by the generic field type, followed by
 346      * a space, followed by the fully-qualified name of the class
 347      * declaring the field, followed by a period, followed by the name
 348      * of the field.
 349      *
 350      * <p>The modifiers are placed in canonical order as specified by
 351      * "The Java Language Specification".  This is {@code public},
 352      * {@code protected} or {@code private} first, and then other
 353      * modifiers in the following order: {@code static}, {@code final},
 354      * {@code transient}, {@code volatile}.
 355      *
 356      * @return a string describing this {@code Field}, including
 357      * its generic type
 358      *
 359      * @since 1.5
 360      * @jls 8.3.1 Field Modifiers
 361      */
 362     public String toGenericString() {
 363         int mod = getModifiers();
 364         Type fieldType = getGenericType();
 365         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
 366             + fieldType.getTypeName() + " "
 367             + getDeclaringClass().getTypeName() + "."
 368             + getName());
 369     }
 370 
 371     /**
 372      * Returns the value of the field represented by this {@code Field}, on
 373      * the specified object. The value is automatically wrapped in an
 374      * object if it has a primitive type.
 375      *
 376      * <p>The underlying field's value is obtained as follows:
 377      *
 378      * <p>If the underlying field is a static field, the {@code obj} argument
 379      * is ignored; it may be null.
 380      *
 381      * <p>Otherwise, the underlying field is an instance field.  If the
 382      * specified {@code obj} argument is null, the method throws a
 383      * {@code NullPointerException}. If the specified object is not an
 384      * instance of the class or interface declaring the underlying
 385      * field, the method throws an {@code IllegalArgumentException}.
 386      *
 387      * <p>If this {@code Field} object is enforcing Java language access control, and
 388      * the underlying field is inaccessible, the method throws an
 389      * {@code IllegalAccessException}.
 390      * If the underlying field is static, the class that declared the
 391      * field is initialized if it has not already been initialized.
 392      *
 393      * <p>Otherwise, the value is retrieved from the underlying instance
 394      * or static field.  If the field has a primitive type, the value
 395      * is wrapped in an object before being returned, otherwise it is
 396      * returned as is.
 397      *
 398      * <p>If the field is hidden in the type of {@code obj},
 399      * the field's value is obtained according to the preceding rules.
 400      *
 401      * @param obj object from which the represented field's value is
 402      * to be extracted
 403      * @return the value of the represented field in object
 404      * {@code obj}; primitive values are wrapped in an appropriate
 405      * object before being returned
 406      *
 407      * @exception IllegalAccessException    if this {@code Field} object
 408      *              is enforcing Java language access control and the underlying
 409      *              field is inaccessible.
 410      * @exception IllegalArgumentException  if the specified object is not an
 411      *              instance of the class or interface declaring the underlying
 412      *              field (or a subclass or implementor thereof).
 413      * @exception NullPointerException      if the specified object is null
 414      *              and the field is an instance field.
 415      * @exception ExceptionInInitializerError if the initialization provoked
 416      *              by this method fails.
 417      */
 418     @CallerSensitive
 419     @ForceInline // to ensure Reflection.getCallerClass optimization
 420     public Object get(Object obj)
 421         throws IllegalArgumentException, IllegalAccessException
 422     {
 423         if (!override) {
 424             Class<?> caller = Reflection.getCallerClass();
 425             checkAccess(caller, obj);
 426         }
 427         return getFieldAccessor(obj).get(obj);
 428     }
 429 
 430     /**
 431      * Gets the value of a static or instance {@code boolean} field.
 432      *
 433      * @param obj the object to extract the {@code boolean} value
 434      * from
 435      * @return the value of the {@code boolean} field
 436      *
 437      * @exception IllegalAccessException    if this {@code Field} object
 438      *              is enforcing Java language access control and the underlying
 439      *              field is inaccessible.
 440      * @exception IllegalArgumentException  if the specified object is not
 441      *              an instance of the class or interface declaring the
 442      *              underlying field (or a subclass or implementor
 443      *              thereof), or if the field value cannot be
 444      *              converted to the type {@code boolean} by a
 445      *              widening conversion.
 446      * @exception NullPointerException      if the specified object is null
 447      *              and the field is an instance field.
 448      * @exception ExceptionInInitializerError if the initialization provoked
 449      *              by this method fails.
 450      * @see       Field#get
 451      */
 452     @CallerSensitive
 453     @ForceInline // to ensure Reflection.getCallerClass optimization
 454     public boolean getBoolean(Object obj)
 455         throws IllegalArgumentException, IllegalAccessException
 456     {
 457         if (!override) {
 458             Class<?> caller = Reflection.getCallerClass();
 459             checkAccess(caller, obj);
 460         }
 461         return getFieldAccessor(obj).getBoolean(obj);
 462     }
 463 
 464     /**
 465      * Gets the value of a static or instance {@code byte} field.
 466      *
 467      * @param obj the object to extract the {@code byte} value
 468      * from
 469      * @return the value of the {@code byte} field
 470      *
 471      * @exception IllegalAccessException    if this {@code Field} object
 472      *              is enforcing Java language access control and the underlying
 473      *              field is inaccessible.
 474      * @exception IllegalArgumentException  if the specified object is not
 475      *              an instance of the class or interface declaring the
 476      *              underlying field (or a subclass or implementor
 477      *              thereof), or if the field value cannot be
 478      *              converted to the type {@code byte} by a
 479      *              widening conversion.
 480      * @exception NullPointerException      if the specified object is null
 481      *              and the field is an instance field.
 482      * @exception ExceptionInInitializerError if the initialization provoked
 483      *              by this method fails.
 484      * @see       Field#get
 485      */
 486     @CallerSensitive
 487     @ForceInline // to ensure Reflection.getCallerClass optimization
 488     public byte getByte(Object obj)
 489         throws IllegalArgumentException, IllegalAccessException
 490     {
 491         if (!override) {
 492             Class<?> caller = Reflection.getCallerClass();
 493             checkAccess(caller, obj);
 494         }
 495         return getFieldAccessor(obj).getByte(obj);
 496     }
 497 
 498     /**
 499      * Gets the value of a static or instance field of type
 500      * {@code char} or of another primitive type convertible to
 501      * type {@code char} via a widening conversion.
 502      *
 503      * @param obj the object to extract the {@code char} value
 504      * from
 505      * @return the value of the field converted to type {@code char}
 506      *
 507      * @exception IllegalAccessException    if this {@code Field} object
 508      *              is enforcing Java language access control and the underlying
 509      *              field is inaccessible.
 510      * @exception IllegalArgumentException  if the specified object is not
 511      *              an instance of the class or interface declaring the
 512      *              underlying field (or a subclass or implementor
 513      *              thereof), or if the field value cannot be
 514      *              converted to the type {@code char} by a
 515      *              widening conversion.
 516      * @exception NullPointerException      if the specified object is null
 517      *              and the field is an instance field.
 518      * @exception ExceptionInInitializerError if the initialization provoked
 519      *              by this method fails.
 520      * @see Field#get
 521      */
 522     @CallerSensitive
 523     @ForceInline // to ensure Reflection.getCallerClass optimization
 524     public char getChar(Object obj)
 525         throws IllegalArgumentException, IllegalAccessException
 526     {
 527         if (!override) {
 528             Class<?> caller = Reflection.getCallerClass();
 529             checkAccess(caller, obj);
 530         }
 531         return getFieldAccessor(obj).getChar(obj);
 532     }
 533 
 534     /**
 535      * Gets the value of a static or instance field of type
 536      * {@code short} or of another primitive type convertible to
 537      * type {@code short} via a widening conversion.
 538      *
 539      * @param obj the object to extract the {@code short} value
 540      * from
 541      * @return the value of the field converted to type {@code short}
 542      *
 543      * @exception IllegalAccessException    if this {@code Field} object
 544      *              is enforcing Java language access control and the underlying
 545      *              field is inaccessible.
 546      * @exception IllegalArgumentException  if the specified object is not
 547      *              an instance of the class or interface declaring the
 548      *              underlying field (or a subclass or implementor
 549      *              thereof), or if the field value cannot be
 550      *              converted to the type {@code short} by a
 551      *              widening conversion.
 552      * @exception NullPointerException      if the specified object is null
 553      *              and the field is an instance field.
 554      * @exception ExceptionInInitializerError if the initialization provoked
 555      *              by this method fails.
 556      * @see       Field#get
 557      */
 558     @CallerSensitive
 559     @ForceInline // to ensure Reflection.getCallerClass optimization
 560     public short getShort(Object obj)
 561         throws IllegalArgumentException, IllegalAccessException
 562     {
 563         if (!override) {
 564             Class<?> caller = Reflection.getCallerClass();
 565             checkAccess(caller, obj);
 566         }
 567         return getFieldAccessor(obj).getShort(obj);
 568     }
 569 
 570     /**
 571      * Gets the value of a static or instance field of type
 572      * {@code int} or of another primitive type convertible to
 573      * type {@code int} via a widening conversion.
 574      *
 575      * @param obj the object to extract the {@code int} value
 576      * from
 577      * @return the value of the field converted to type {@code int}
 578      *
 579      * @exception IllegalAccessException    if this {@code Field} object
 580      *              is enforcing Java language access control and the underlying
 581      *              field is inaccessible.
 582      * @exception IllegalArgumentException  if the specified object is not
 583      *              an instance of the class or interface declaring the
 584      *              underlying field (or a subclass or implementor
 585      *              thereof), or if the field value cannot be
 586      *              converted to the type {@code int} by a
 587      *              widening conversion.
 588      * @exception NullPointerException      if the specified object is null
 589      *              and the field is an instance field.
 590      * @exception ExceptionInInitializerError if the initialization provoked
 591      *              by this method fails.
 592      * @see       Field#get
 593      */
 594     @CallerSensitive
 595     @ForceInline // to ensure Reflection.getCallerClass optimization
 596     public int getInt(Object obj)
 597         throws IllegalArgumentException, IllegalAccessException
 598     {
 599         if (!override) {
 600             Class<?> caller = Reflection.getCallerClass();
 601             checkAccess(caller, obj);
 602         }
 603         return getFieldAccessor(obj).getInt(obj);
 604     }
 605 
 606     /**
 607      * Gets the value of a static or instance field of type
 608      * {@code long} or of another primitive type convertible to
 609      * type {@code long} via a widening conversion.
 610      *
 611      * @param obj the object to extract the {@code long} value
 612      * from
 613      * @return the value of the field converted to type {@code long}
 614      *
 615      * @exception IllegalAccessException    if this {@code Field} object
 616      *              is enforcing Java language access control and the underlying
 617      *              field is inaccessible.
 618      * @exception IllegalArgumentException  if the specified object is not
 619      *              an instance of the class or interface declaring the
 620      *              underlying field (or a subclass or implementor
 621      *              thereof), or if the field value cannot be
 622      *              converted to the type {@code long} by a
 623      *              widening conversion.
 624      * @exception NullPointerException      if the specified object is null
 625      *              and the field is an instance field.
 626      * @exception ExceptionInInitializerError if the initialization provoked
 627      *              by this method fails.
 628      * @see       Field#get
 629      */
 630     @CallerSensitive
 631     @ForceInline // to ensure Reflection.getCallerClass optimization
 632     public long getLong(Object obj)
 633         throws IllegalArgumentException, IllegalAccessException
 634     {
 635         if (!override) {
 636             Class<?> caller = Reflection.getCallerClass();
 637             checkAccess(caller, obj);
 638         }
 639         return getFieldAccessor(obj).getLong(obj);
 640     }
 641 
 642     /**
 643      * Gets the value of a static or instance field of type
 644      * {@code float} or of another primitive type convertible to
 645      * type {@code float} via a widening conversion.
 646      *
 647      * @param obj the object to extract the {@code float} value
 648      * from
 649      * @return the value of the field converted to type {@code float}
 650      *
 651      * @exception IllegalAccessException    if this {@code Field} object
 652      *              is enforcing Java language access control and the underlying
 653      *              field is inaccessible.
 654      * @exception IllegalArgumentException  if the specified object is not
 655      *              an instance of the class or interface declaring the
 656      *              underlying field (or a subclass or implementor
 657      *              thereof), or if the field value cannot be
 658      *              converted to the type {@code float} by a
 659      *              widening conversion.
 660      * @exception NullPointerException      if the specified object is null
 661      *              and the field is an instance field.
 662      * @exception ExceptionInInitializerError if the initialization provoked
 663      *              by this method fails.
 664      * @see Field#get
 665      */
 666     @CallerSensitive
 667     @ForceInline // to ensure Reflection.getCallerClass optimization
 668     public float getFloat(Object obj)
 669         throws IllegalArgumentException, IllegalAccessException
 670     {
 671         if (!override) {
 672             Class<?> caller = Reflection.getCallerClass();
 673             checkAccess(caller, obj);
 674         }
 675         return getFieldAccessor(obj).getFloat(obj);
 676     }
 677 
 678     /**
 679      * Gets the value of a static or instance field of type
 680      * {@code double} or of another primitive type convertible to
 681      * type {@code double} via a widening conversion.
 682      *
 683      * @param obj the object to extract the {@code double} value
 684      * from
 685      * @return the value of the field converted to type {@code double}
 686      *
 687      * @exception IllegalAccessException    if this {@code Field} object
 688      *              is enforcing Java language access control and the underlying
 689      *              field is inaccessible.
 690      * @exception IllegalArgumentException  if the specified object is not
 691      *              an instance of the class or interface declaring the
 692      *              underlying field (or a subclass or implementor
 693      *              thereof), or if the field value cannot be
 694      *              converted to the type {@code double} by a
 695      *              widening conversion.
 696      * @exception NullPointerException      if the specified object is null
 697      *              and the field is an instance field.
 698      * @exception ExceptionInInitializerError if the initialization provoked
 699      *              by this method fails.
 700      * @see       Field#get
 701      */
 702     @CallerSensitive
 703     @ForceInline // to ensure Reflection.getCallerClass optimization
 704     public double getDouble(Object obj)
 705         throws IllegalArgumentException, IllegalAccessException
 706     {
 707         if (!override) {
 708             Class<?> caller = Reflection.getCallerClass();
 709             checkAccess(caller, obj);
 710         }
 711         return getFieldAccessor(obj).getDouble(obj);
 712     }
 713 
 714     /**
 715      * Sets the field represented by this {@code Field} object on the
 716      * specified object argument to the specified new value. The new
 717      * value is automatically unwrapped if the underlying field has a
 718      * primitive type.
 719      *
 720      * <p>The operation proceeds as follows:
 721      *
 722      * <p>If the underlying field is static, the {@code obj} argument is
 723      * ignored; it may be null.
 724      *
 725      * <p>Otherwise the underlying field is an instance field.  If the
 726      * specified object argument is null, the method throws a
 727      * {@code NullPointerException}.  If the specified object argument is not
 728      * an instance of the class or interface declaring the underlying
 729      * field, the method throws an {@code IllegalArgumentException}.
 730      *
 731      * <p>If this {@code Field} object is enforcing Java language access control, and
 732      * the underlying field is inaccessible, the method throws an
 733      * {@code IllegalAccessException}.
 734      *
 735      * <p>If the underlying field is final, the method throws an
 736      * {@code IllegalAccessException} unless {@code setAccessible(true)}
 737      * has succeeded for this {@code Field} object
 738      * and the field is non-static. Setting a final field in this way
 739      * is meaningful only during deserialization or reconstruction of
 740      * instances of classes with blank final fields, before they are
 741      * made available for access by other parts of a program. Use in
 742      * any other context may have unpredictable effects, including cases
 743      * in which other parts of a program continue to use the original
 744      * value of this field.
 745      *
 746      * <p>If the underlying field is of a primitive type, an unwrapping
 747      * conversion is attempted to convert the new value to a value of
 748      * a primitive type.  If this attempt fails, the method throws an
 749      * {@code IllegalArgumentException}.
 750      *
 751      * <p>If, after possible unwrapping, the new value cannot be
 752      * converted to the type of the underlying field by an identity or
 753      * widening conversion, the method throws an
 754      * {@code IllegalArgumentException}.
 755      *
 756      * <p>If the underlying field is static, the class that declared the
 757      * field is initialized if it has not already been initialized.
 758      *
 759      * <p>The field is set to the possibly unwrapped and widened new value.
 760      *
 761      * <p>If the field is hidden in the type of {@code obj},
 762      * the field's value is set according to the preceding rules.
 763      *
 764      * @param obj the object whose field should be modified
 765      * @param value the new value for the field of {@code obj}
 766      * being modified
 767      *
 768      * @exception IllegalAccessException    if this {@code Field} object
 769      *              is enforcing Java language access control and the underlying
 770      *              field is either inaccessible or final.
 771      * @exception IllegalArgumentException  if the specified object is not an
 772      *              instance of the class or interface declaring the underlying
 773      *              field (or a subclass or implementor thereof),
 774      *              or if an unwrapping conversion fails.
 775      * @exception NullPointerException      if the specified object is null
 776      *              and the field is an instance field.
 777      * @exception ExceptionInInitializerError if the initialization provoked
 778      *              by this method fails.
 779      */
 780     @CallerSensitive
 781     @ForceInline // to ensure Reflection.getCallerClass optimization
 782     public void set(Object obj, Object value)
 783         throws IllegalArgumentException, IllegalAccessException
 784     {
 785         ensureNotValueClass();
 786 
 787         if (!override) {
 788             Class<?> caller = Reflection.getCallerClass();
 789             checkAccess(caller, obj);
 790         }
 791         getFieldAccessor(obj).set(obj, value);
 792     }
 793 
 794     /**
 795      * Sets the value of a field as a {@code boolean} on the specified object.
 796      * This method is equivalent to
 797      * {@code set(obj, zObj)},
 798      * where {@code zObj} is a {@code Boolean} object and
 799      * {@code zObj.booleanValue() == z}.
 800      *
 801      * @param obj the object whose field should be modified
 802      * @param z   the new value for the field of {@code obj}
 803      * being modified
 804      *
 805      * @exception IllegalAccessException    if this {@code Field} object
 806      *              is enforcing Java language access control and the underlying
 807      *              field is either inaccessible or final.
 808      * @exception IllegalArgumentException  if the specified object is not an
 809      *              instance of the class or interface declaring the underlying
 810      *              field (or a subclass or implementor thereof),
 811      *              or if an unwrapping conversion fails.
 812      * @exception NullPointerException      if the specified object is null
 813      *              and the field is an instance field.
 814      * @exception ExceptionInInitializerError if the initialization provoked
 815      *              by this method fails.
 816      * @see       Field#set
 817      */
 818     @CallerSensitive
 819     @ForceInline // to ensure Reflection.getCallerClass optimization
 820     public void setBoolean(Object obj, boolean z)
 821         throws IllegalArgumentException, IllegalAccessException
 822     {
 823         ensureNotValueClass();
 824 
 825         if (!override) {
 826             Class<?> caller = Reflection.getCallerClass();
 827             checkAccess(caller, obj);
 828         }
 829         getFieldAccessor(obj).setBoolean(obj, z);
 830     }
 831 
 832     /**
 833      * Sets the value of a field as a {@code byte} on the specified object.
 834      * This method is equivalent to
 835      * {@code set(obj, bObj)},
 836      * where {@code bObj} is a {@code Byte} object and
 837      * {@code bObj.byteValue() == b}.
 838      *
 839      * @param obj the object whose field should be modified
 840      * @param b   the new value for the field of {@code obj}
 841      * being modified
 842      *
 843      * @exception IllegalAccessException    if this {@code Field} object
 844      *              is enforcing Java language access control and the underlying
 845      *              field is either inaccessible or final.
 846      * @exception IllegalArgumentException  if the specified object is not an
 847      *              instance of the class or interface declaring the underlying
 848      *              field (or a subclass or implementor thereof),
 849      *              or if an unwrapping conversion fails.
 850      * @exception NullPointerException      if the specified object is null
 851      *              and the field is an instance field.
 852      * @exception ExceptionInInitializerError if the initialization provoked
 853      *              by this method fails.
 854      * @see       Field#set
 855      */
 856     @CallerSensitive
 857     @ForceInline // to ensure Reflection.getCallerClass optimization
 858     public void setByte(Object obj, byte b)
 859         throws IllegalArgumentException, IllegalAccessException
 860     {
 861         ensureNotValueClass();
 862 
 863         if (!override) {
 864             Class<?> caller = Reflection.getCallerClass();
 865             checkAccess(caller, obj);
 866         }
 867         getFieldAccessor(obj).setByte(obj, b);
 868     }
 869 
 870     /**
 871      * Sets the value of a field as a {@code char} on the specified object.
 872      * This method is equivalent to
 873      * {@code set(obj, cObj)},
 874      * where {@code cObj} is a {@code Character} object and
 875      * {@code cObj.charValue() == c}.
 876      *
 877      * @param obj the object whose field should be modified
 878      * @param c   the new value for the field of {@code obj}
 879      * being modified
 880      *
 881      * @exception IllegalAccessException    if this {@code Field} object
 882      *              is enforcing Java language access control and the underlying
 883      *              field is either inaccessible or final.
 884      * @exception IllegalArgumentException  if the specified object is not an
 885      *              instance of the class or interface declaring the underlying
 886      *              field (or a subclass or implementor thereof),
 887      *              or if an unwrapping conversion fails.
 888      * @exception NullPointerException      if the specified object is null
 889      *              and the field is an instance field.
 890      * @exception ExceptionInInitializerError if the initialization provoked
 891      *              by this method fails.
 892      * @see       Field#set
 893      */
 894     @CallerSensitive
 895     @ForceInline // to ensure Reflection.getCallerClass optimization
 896     public void setChar(Object obj, char c)
 897         throws IllegalArgumentException, IllegalAccessException
 898     {
 899         ensureNotValueClass();
 900 
 901         if (!override) {
 902             Class<?> caller = Reflection.getCallerClass();
 903             checkAccess(caller, obj);
 904         }
 905         getFieldAccessor(obj).setChar(obj, c);
 906     }
 907 
 908     /**
 909      * Sets the value of a field as a {@code short} on the specified object.
 910      * This method is equivalent to
 911      * {@code set(obj, sObj)},
 912      * where {@code sObj} is a {@code Short} object and
 913      * {@code sObj.shortValue() == s}.
 914      *
 915      * @param obj the object whose field should be modified
 916      * @param s   the new value for the field of {@code obj}
 917      * being modified
 918      *
 919      * @exception IllegalAccessException    if this {@code Field} object
 920      *              is enforcing Java language access control and the underlying
 921      *              field is either inaccessible or final.
 922      * @exception IllegalArgumentException  if the specified object is not an
 923      *              instance of the class or interface declaring the underlying
 924      *              field (or a subclass or implementor thereof),
 925      *              or if an unwrapping conversion fails.
 926      * @exception NullPointerException      if the specified object is null
 927      *              and the field is an instance field.
 928      * @exception ExceptionInInitializerError if the initialization provoked
 929      *              by this method fails.
 930      * @see       Field#set
 931      */
 932     @CallerSensitive
 933     @ForceInline // to ensure Reflection.getCallerClass optimization
 934     public void setShort(Object obj, short s)
 935         throws IllegalArgumentException, IllegalAccessException
 936     {
 937         ensureNotValueClass();
 938 
 939         if (!override) {
 940             Class<?> caller = Reflection.getCallerClass();
 941             checkAccess(caller, obj);
 942         }
 943         getFieldAccessor(obj).setShort(obj, s);
 944     }
 945 
 946     /**
 947      * Sets the value of a field as an {@code int} on the specified object.
 948      * This method is equivalent to
 949      * {@code set(obj, iObj)},
 950      * where {@code iObj} is an {@code Integer} object and
 951      * {@code iObj.intValue() == i}.
 952      *
 953      * @param obj the object whose field should be modified
 954      * @param i   the new value for the field of {@code obj}
 955      * being modified
 956      *
 957      * @exception IllegalAccessException    if this {@code Field} object
 958      *              is enforcing Java language access control and the underlying
 959      *              field is either inaccessible or final.
 960      * @exception IllegalArgumentException  if the specified object is not an
 961      *              instance of the class or interface declaring the underlying
 962      *              field (or a subclass or implementor thereof),
 963      *              or if an unwrapping conversion fails.
 964      * @exception NullPointerException      if the specified object is null
 965      *              and the field is an instance field.
 966      * @exception ExceptionInInitializerError if the initialization provoked
 967      *              by this method fails.
 968      * @see       Field#set
 969      */
 970     @CallerSensitive
 971     @ForceInline // to ensure Reflection.getCallerClass optimization
 972     public void setInt(Object obj, int i)
 973         throws IllegalArgumentException, IllegalAccessException
 974     {
 975         ensureNotValueClass();
 976 
 977         if (!override) {
 978             Class<?> caller = Reflection.getCallerClass();
 979             checkAccess(caller, obj);
 980         }
 981         getFieldAccessor(obj).setInt(obj, i);
 982     }
 983 
 984     /**
 985      * Sets the value of a field as a {@code long} on the specified object.
 986      * This method is equivalent to
 987      * {@code set(obj, lObj)},
 988      * where {@code lObj} is a {@code Long} object and
 989      * {@code lObj.longValue() == l}.
 990      *
 991      * @param obj the object whose field should be modified
 992      * @param l   the new value for the field of {@code obj}
 993      * being modified
 994      *
 995      * @exception IllegalAccessException    if this {@code Field} object
 996      *              is enforcing Java language access control and the underlying
 997      *              field is either inaccessible or final.
 998      * @exception IllegalArgumentException  if the specified object is not an
 999      *              instance of the class or interface declaring the underlying
1000      *              field (or a subclass or implementor thereof),
1001      *              or if an unwrapping conversion fails.
1002      * @exception NullPointerException      if the specified object is null
1003      *              and the field is an instance field.
1004      * @exception ExceptionInInitializerError if the initialization provoked
1005      *              by this method fails.
1006      * @see       Field#set
1007      */
1008     @CallerSensitive
1009     @ForceInline // to ensure Reflection.getCallerClass optimization
1010     public void setLong(Object obj, long l)
1011         throws IllegalArgumentException, IllegalAccessException
1012     {
1013         ensureNotValueClass();
1014 
1015         if (!override) {
1016             Class<?> caller = Reflection.getCallerClass();
1017             checkAccess(caller, obj);
1018         }
1019         getFieldAccessor(obj).setLong(obj, l);
1020     }
1021 
1022     /**
1023      * Sets the value of a field as a {@code float} on the specified object.
1024      * This method is equivalent to
1025      * {@code set(obj, fObj)},
1026      * where {@code fObj} is a {@code Float} object and
1027      * {@code fObj.floatValue() == f}.
1028      *
1029      * @param obj the object whose field should be modified
1030      * @param f   the new value for the field of {@code obj}
1031      * being modified
1032      *
1033      * @exception IllegalAccessException    if this {@code Field} object
1034      *              is enforcing Java language access control and the underlying
1035      *              field is either inaccessible or final.
1036      * @exception IllegalArgumentException  if the specified object is not an
1037      *              instance of the class or interface declaring the underlying
1038      *              field (or a subclass or implementor thereof),
1039      *              or if an unwrapping conversion fails.
1040      * @exception NullPointerException      if the specified object is null
1041      *              and the field is an instance field.
1042      * @exception ExceptionInInitializerError if the initialization provoked
1043      *              by this method fails.
1044      * @see       Field#set
1045      */
1046     @CallerSensitive
1047     @ForceInline // to ensure Reflection.getCallerClass optimization
1048     public void setFloat(Object obj, float f)
1049         throws IllegalArgumentException, IllegalAccessException
1050     {
1051         ensureNotValueClass();
1052 
1053         if (!override) {
1054             Class<?> caller = Reflection.getCallerClass();
1055             checkAccess(caller, obj);
1056         }
1057         getFieldAccessor(obj).setFloat(obj, f);
1058     }
1059 
1060     /**
1061      * Sets the value of a field as a {@code double} on the specified object.
1062      * This method is equivalent to
1063      * {@code set(obj, dObj)},
1064      * where {@code dObj} is a {@code Double} object and
1065      * {@code dObj.doubleValue() == d}.
1066      *
1067      * @param obj the object whose field should be modified
1068      * @param d   the new value for the field of {@code obj}
1069      * being modified
1070      *
1071      * @exception IllegalAccessException    if this {@code Field} object
1072      *              is enforcing Java language access control and the underlying
1073      *              field is either inaccessible or final.
1074      * @exception IllegalArgumentException  if the specified object is not an
1075      *              instance of the class or interface declaring the underlying
1076      *              field (or a subclass or implementor thereof),
1077      *              or if an unwrapping conversion fails.
1078      * @exception NullPointerException      if the specified object is null
1079      *              and the field is an instance field.
1080      * @exception ExceptionInInitializerError if the initialization provoked
1081      *              by this method fails.
1082      * @see       Field#set
1083      */
1084     @CallerSensitive
1085     @ForceInline // to ensure Reflection.getCallerClass optimization
1086     public void setDouble(Object obj, double d)
1087         throws IllegalArgumentException, IllegalAccessException
1088     {
1089         ensureNotValueClass();
1090 
1091         if (!override) {
1092             Class<?> caller = Reflection.getCallerClass();
1093             checkAccess(caller, obj);
1094         }
1095         getFieldAccessor(obj).setDouble(obj, d);
1096     }
1097 
1098     // check access to field
1099     private void checkAccess(Class<?> caller, Object obj)
1100         throws IllegalAccessException
1101     {
1102         checkAccess(caller, clazz,
1103                     Modifier.isStatic(modifiers) ? null : obj.getClass(),
1104                     modifiers);
1105     }
1106 
1107     /*
1108      * Ensure the declaring class is not a value class.
1109      */
1110     private void ensureNotValueClass() throws IllegalAccessException {
1111         if (clazz.isValue()) {
1112             throw new IllegalAccessException("cannot set this field of a value class "
1113                 + clazz.getName());
1114         }
1115     }
1116 
1117     // security check is done before calling this method
1118     private FieldAccessor getFieldAccessor(Object obj)
1119         throws IllegalAccessException
1120     {
1121         boolean ov = override;
1122         FieldAccessor a = (ov) ? overrideFieldAccessor : fieldAccessor;
1123         return (a != null) ? a : acquireFieldAccessor(ov);
1124     }
1125 
1126     // NOTE that there is no synchronization used here. It is correct
1127     // (though not efficient) to generate more than one FieldAccessor
1128     // for a given Field. However, avoiding synchronization will
1129     // probably make the implementation more scalable.
1130     private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
1131         // First check to see if one has been created yet, and take it
1132         // if so
1133         FieldAccessor tmp = null;
1134         if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
1135         if (tmp != null) {
1136             if (overrideFinalCheck)
1137                 overrideFieldAccessor = tmp;
1138             else
1139                 fieldAccessor = tmp;
1140         } else {
1141             // Otherwise fabricate one and propagate it up to the root
1142             tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
1143             setFieldAccessor(tmp, overrideFinalCheck);
1144         }
1145 
1146         return tmp;
1147     }
1148 
1149     // Returns FieldAccessor for this Field object, not looking up
1150     // the chain to the root
1151     private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
1152         return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
1153     }
1154 
1155     // Sets the FieldAccessor for this Field object and
1156     // (recursively) its root
1157     private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
1158         if (overrideFinalCheck)
1159             overrideFieldAccessor = accessor;
1160         else
1161             fieldAccessor = accessor;
1162         // Propagate up
1163         if (root != null) {
1164             root.setFieldAccessor(accessor, overrideFinalCheck);
1165         }
1166     }
1167 
1168     @Override
1169     Field getRoot() {
1170         return root;
1171     }
1172 
1173     /**
1174      * @throws NullPointerException {@inheritDoc}
1175      * @since 1.5
1176      */
1177     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
1178         Objects.requireNonNull(annotationClass);
1179         return annotationClass.cast(declaredAnnotations().get(annotationClass));
1180     }
1181 
1182     /**
1183      * {@inheritDoc}
1184      * @throws NullPointerException {@inheritDoc}
1185      * @since 1.8
1186      */
1187     @Override
1188     public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
1189         Objects.requireNonNull(annotationClass);
1190 
1191         return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
1192     }
1193 
1194     /**
1195      * {@inheritDoc}
1196      */
1197     public Annotation[] getDeclaredAnnotations()  {
1198         return AnnotationParser.toArray(declaredAnnotations());
1199     }
1200 
1201     private transient volatile Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
1202 
1203     private Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
1204         Map<Class<? extends Annotation>, Annotation> declAnnos;
1205         if ((declAnnos = declaredAnnotations) == null) {
1206             synchronized (this) {
1207                 if ((declAnnos = declaredAnnotations) == null) {
1208                     Field root = this.root;
1209                     if (root != null) {
1210                         declAnnos = root.declaredAnnotations();
1211                     } else {
1212                         declAnnos = AnnotationParser.parseAnnotations(
1213                                 annotations,
1214                                 SharedSecrets.getJavaLangAccess()
1215                                         .getConstantPool(getDeclaringClass()),
1216                                 getDeclaringClass());
1217                     }
1218                     declaredAnnotations = declAnnos;
1219                 }
1220             }
1221         }
1222         return declAnnos;
1223     }
1224 
1225     private native byte[] getTypeAnnotationBytes0();
1226 
1227     /**
1228      * Returns an AnnotatedType object that represents the use of a type to specify
1229      * the declared type of the field represented by this Field.
1230      * @return an object representing the declared type of the field
1231      * represented by this Field
1232      *
1233      * @since 1.8
1234      */
1235     public AnnotatedType getAnnotatedType() {
1236         return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
1237                                                        SharedSecrets.getJavaLangAccess().
1238                                                            getConstantPool(getDeclaringClass()),
1239                                                        this,
1240                                                        getDeclaringClass(),
1241                                                        getGenericType(),
1242                                                        TypeAnnotation.TypeAnnotationTarget.FIELD);
1243 }
1244 }
--- EOF ---