/*
 
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
 
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
*
 
* This code is free software; you can redistribute it and/or modify it
 
* under the terms of the GNU General Public License version 2 only, as
 
* published by the Free Software Foundation.
  
Oracle designates this
 
* particular file as subject to the "Classpath" exception as provided
 
* by Oracle in the LICENSE file that accompanied this code.
 
*
 
* This code is distributed in the hope that it will be useful, but WITHOUT
 
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
* FITNESS FOR A PARTICULAR PURPOSE.
  
See the GNU General Public License
 
* version 2 for more details (a copy is included in the LICENSE file that
 
* accompanied this code).
 
*
 
* You should have received a copy of the GNU General Public License version
 
* 2 along with this work; if not, write to the Free Software Foundation,
 
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 
*
 
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 
* or visit www.oracle.com if you need additional information or have any
 
* questions.
 
*/

package java.lang.reflect;

import sun.reflect.CallerSensitive;
import sun.reflect.FieldAccessor;
import sun.reflect.Reflection;
import sun.reflect.generics.repository.FieldRepository;
import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.scope.ClassScope;
import java.lang.annotation.Annotation;
import java.util.Map;
import java.util.Objects;
import sun.reflect.annotation.AnnotationParser;
import sun.reflect.annotation.AnnotationSupport;
import sun.reflect.annotation.TypeAnnotation;
import sun.reflect.annotation.TypeAnnotationParser;

/**
 
* A {@code Field} provides information about, and dynamic access to, a
 
* single field of a class or an interface.
  
The reflected field may
 
* be a class (static) field or an instance field.
 
*
 
* <p>A {@code Field} permits widening conversions to occur during a get or
 
* set access operation, but throws an {@code IllegalArgumentException} if a
 
* narrowing conversion would occur.
 
*
 
* @see Member
 
*
 
* @see java.lang.Class#getFields()
 
* @see java.lang.Class#getField(String)
 
* @see java.lang.Class#getDeclaredFields()
 
* @see java.lang.Class#getDeclaredField(String)
 
*
 
* @author Kenneth Russell
 
* @author Nakul Saraiya
 
*/

public final
class
Field extends AccessibleObject implements Member {

    
private Class<?>
            
clazz;
    
private int
                 
slot;
    
// This is guaranteed to be interned by the VM in the 1.4
    
// reflection implementation
    
private String
              
name
;
    
private Class<?>
            
type;
    
private int
                 
modifiers;
    
// Generics and annotations support
    
private transient String
    
signature
;
    
// generic info repository; lazily initialized
    
private transient FieldRepository genericInfo;
    
private byte[]
              
annotations;
    
// Cached field accessor created without override
    
private FieldAccessor fieldAccessor;
    
// Cached field accessor created with override
    
private FieldAccessor overrideFieldAccessor;
    
// For sharing of FieldAccessors. This branching structure is
    
// currently only two levels deep (i.e., one root Field and
    
// potentially many Field objects pointing to it.)
    
//
    
// If this branching structure would ever contain cycles, deadlocks can
    
// occur in annotation code.
    
private Field
               
root
;

    
// Generics infrastructure

    
private String getGenericSignature() {return signature;}

    
// Accessor for factory
    
private GenericsFactory getFactory() {
        
Class<?> c = getDeclaringClass();
        
// create scope and factory
        
return CoreReflectionFactory.make(c, ClassScope.make(c));
    
}

    
// Accessor for generic info repository
    
private FieldRepository getGenericInfo() {
        
// lazily initialize repository if necessary
        
if (genericInfo == null) {
            
// create and cache generic info repository
            
genericInfo = FieldRepository.make(getGenericSignature(),
                                               
getFactory());
        
}
        
return genericInfo; //return cached repository
    
}


    
/**
     
* Package-private constructor used by ReflectAccess to enable
     
* instantiation of these objects in Java code from the java.lang
     
* package via sun.reflect.LangReflectAccess.
     
*/

    
Field(Class<?> declaringClass,
          
String name,
          
Class<?> type,
          
int modifiers,
          
int slot,
          
String signature,
          
byte[] annotations)
    
{
        
this.clazz = declaringClass;
        
this.name = name;
        
this.type = type;
        
this.modifiers = modifiers;
        
this.slot = slot;
        
this.signature = signature;
        
this.annotations = annotations;
    
}

    
/**
     
* Package-private routine (exposed to java.lang.Class via
     
* ReflectAccess) which returns a copy of this Field. The copy's
     
* "root" field points to this Field.
     
*/

    
Field copy() {
        
// This routine enables sharing of FieldAccessor objects
        
// among Field objects which refer to the same underlying
        
// method in the VM. (All of this contortion is only necessary
        
// because of the "accessibility" bit in AccessibleObject,
        
// which implicitly requires that new java.lang.reflect
        
// objects be fabricated for each reflective call on Class
        
// objects.)
        
if (this.root != null)
            
throw new IllegalArgumentException("Can not copy a non-root Field");

        
Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
        
res.root = this;
        
// Might as well eagerly propagate this if already present
        
res.fieldAccessor = fieldAccessor;
        
res.overrideFieldAccessor = overrideFieldAccessor;

        
return res;
    
}

    
/**
     
* Returns the {@code Class} object representing the class or interface
     
* that declares the field represented by this {@code Field} object.
     
*/

    
public Class<?> getDeclaringClass() {
        
return clazz;
    
}

    
/**
     
* Returns the name of the field represented by this {@code Field} object.
     
*/

    
public String getName() {
        
return name;
    
}

    
/**
     
* Returns the Java language modifiers for the field represented
     
* by this {@code Field} object, as an integer. The {@code Modifier} class should
     
* be used to decode the modifiers.
     
*
     
* @see Modifier
     
*/

    
public int getModifiers() {
        
return modifiers;
    
}

    
/**
     
* Returns {@code true} if this field represents an element of
     
* an enumerated type; returns {@code false} otherwise.
     
*
     
* @return {@code true} if and only if this field represents an element of
     
* an enumerated type.
     
* @since 1.5
     
*/

    
public boolean isEnumConstant() {
        
return (getModifiers() & Modifier.ENUM) != 0;
    
}

    
/**
     
* Returns {@code true} if this field is a synthetic
     
* field; returns {@code false} otherwise.
     
*
     
* @return true if and only if this field is a synthetic
     
* field as defined by the Java Language Specification.
     
* @since 1.5
     
*/

    
public boolean isSynthetic() {
        
return Modifier.isSynthetic(getModifiers());
    
}

    
/**
     
* Returns a {@code Class} object that identifies the
     
* declared type for the field represented by this
     
* {@code Field} object.
     
*
     
* @return a {@code Class} object identifying the declared
     
* type of the field represented by this object
     
*/

    
public Class<?> getType() {
        
return type;
    
}

    
/**
     
* Returns a {@code Type} object that represents the declared type for
     
* the field represented by this {@code Field} object.
     
*
     
* <p>If the {@code Type} is a parameterized type, the
     
* {@code Type} object returned must accurately reflect the
     
* actual type parameters used in the source code.
     
*
     
* <p>If the type of the underlying field is a type variable or a
     
* parameterized type, it is created. Otherwise, it is resolved.
     
*
     
* @return a {@code Type} object that represents the declared type for
     
*the field represented by this {@code Field} object
     
* @throws GenericSignatureFormatError if the generic field
     
*signature does not conform to the format specified in
     
*<cite>The Java&trade; Virtual Machine Specification</cite>
     
* @throws TypeNotPresentException if the generic type
     
*signature of the underlying field refers to a non-existent
     
*type declaration
     
* @throws MalformedParameterizedTypeException if the generic
     
*signature of the underlying field refers to a parameterized type
     
*that cannot be instantiated for any reason
     
* @since 1.5
     
*/

    
public Type getGenericType() {
        
if (getGenericSignature() != null)
            
return getGenericInfo().getGenericType();
        
else
            
return
getType();
    
}


    
/**
     
* Compares this {@code Field} against the specified object.
  
Returns
     
* true if the objects are the same.
  
Two {@code Field} objects are the same if
     
* they were declared by the same class and have the same name
     
* and type.
     
*/

    
public boolean equals(Object obj) {
        
if (obj != null && obj instanceof Field) {
            
Field other = (Field)obj;
            
return (getDeclaringClass() == other.getDeclaringClass())
                
&& (getName() == other.getName())
                
&& (getType() == other.getType());
        
}
        
return false;
    
}

    
/**
     
* Returns a hashcode for this {@code Field}.
  
This is computed as the
     
* exclusive-or of the hashcodes for the underlying field's
     
* declaring class name and its name.
     
*/

    
public int hashCode() {
        
return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
    
}

    
/**
     
* Returns a string describing this {@code Field}.
  
The format is
     
* the access modifiers for the field, if any, followed
     
* by the field type, followed by a space, followed by
     
* the fully-qualified name of the class declaring the field,
     
* followed by a period, followed by the name of the field.
     
* For example:
     
* <pre>
     
*
    
public static final int java.lang.Thread.MIN_PRIORITY
     
*
    
private int java.io.FileDescriptor.fd
     
* </pre>
     
*
     
* <p>The modifiers are placed in canonical order as specified by
     
* "The Java Language Specification".
  
This is {@code public},
     
* {@code protected} or {@code private} first, and then other
     
* modifiers in the following order: {@code static}, {@code final},
     
* {@code transient}, {@code volatile}.
     
*
     
* @return a string describing this {@code Field}
     
* @jls 8.3.1 Field Modifiers
     
*/

    
public String toString() {
        
int mod = getModifiers();
        
return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            
+ getType().getTypeName() + " "
            
+ getDeclaringClass().getTypeName() + "."
            
+ getName());
    
}

    
/**
     
* Returns a string describing this {@code Field}, including
     
* its generic type.
  
The format is the access modifiers for the
     
* field, if any, followed by the generic field type, followed by
     
* a space, followed by the fully-qualified name of the class
     
* declaring the field, followed by a period, followed by the name
     
* of the field.
     
*
     
* <p>The modifiers are placed in canonical order as specified by
     
* "The Java Language Specification".
  
This is {@code public},
     
* {@code protected} or {@code private} first, and then other
     
* modifiers in the following order: {@code static}, {@code final},
     
* {@code transient}, {@code volatile}.
     
*
     
* @return a string describing this {@code Field}, including
     
* its generic type
     
*
     
* @since 1.5
     
* @jls 8.3.1 Field Modifiers
     
*/

    
public String toGenericString() {
        
int mod = getModifiers();
        
Type fieldType = getGenericType();
        
return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
            
+ fieldType.getTypeName() + " "
            
+ getDeclaringClass().getTypeName() + "."
            
+ getName());
    
}

    
/**
     
* Returns the value of the field represented by this {@code Field}, on
     
* the specified object. The value is automatically wrapped in an
     
* object if it has a primitive type.
     
*
     
* <p>The underlying field's value is obtained as follows:
     
*
     
* <p>If the underlying field is a static field, the {@code obj} argument
     
* is ignored; it may be null.
     
*
     
* <p>Otherwise, the underlying field is an instance field.
  
If the
     
* specified {@code obj} argument is null, the method throws a
     
* {@code NullPointerException}. If the specified object is not an
     
* instance of the class or interface declaring the underlying
     
* field, the method throws an {@code IllegalArgumentException}.
     
*
     
* <p>If this {@code Field} object is enforcing Java language access control, and
     
* the underlying field is inaccessible, the method throws an
     
* {@code IllegalAccessException}.
     
* If the underlying field is static, the class that declared the
     
* field is initialized if it has not already been initialized.
     
*
     
* <p>Otherwise, the value is retrieved from the underlying instance
     
* or static field.
  
If the field has a primitive type, the value
     
* is wrapped in an object before being returned, otherwise it is
     
* returned as is.
     
*
     
* <p>If the field is hidden in the type of {@code obj},
     
* the field's value is obtained according to the preceding rules.
     
*
     
* @param obj object from which the represented field's value is
     
* to be extracted
     
* @return the value of the represented field in object
     
* {@code obj}; primitive values are wrapped in an appropriate
     
* object before being returned
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof).
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
*/

    
@CallerSensitive
    
public Object get(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).get(obj);
    
}

    
/**
     
* Gets the value of a static or instance {@code boolean} field.
     
*
     
* @param obj the object to extract the {@code boolean} value
     
* from
     
* @return the value of the {@code boolean} field
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code boolean} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#get
     
*/

    
@CallerSensitive
    
public boolean getBoolean(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getBoolean(obj);
    
}

    
/**
     
* Gets the value of a static or instance {@code byte} field.
     
*
     
* @param obj the object to extract the {@code byte} value
     
* from
     
* @return the value of the {@code byte} field
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code byte} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#get
     
*/

    
@CallerSensitive
    
public byte getByte(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getByte(obj);
    
}

    
/**
     
* Gets the value of a static or instance field of type
     
* {@code char} or of another primitive type convertible to
     
* type {@code char} via a widening conversion.
     
*
     
* @param obj the object to extract the {@code char} value
     
* from
     
* @return the value of the field converted to type {@code char}
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code char} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see Field#get
     
*/

    
@CallerSensitive
    
public char getChar(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getChar(obj);
    
}

    
/**
     
* Gets the value of a static or instance field of type
     
* {@code short} or of another primitive type convertible to
     
* type {@code short} via a widening conversion.
     
*
     
* @param obj the object to extract the {@code short} value
     
* from
     
* @return the value of the field converted to type {@code short}
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code short} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#get
     
*/

    
@CallerSensitive
    
public short getShort(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getShort(obj);
    
}

    
/**
     
* Gets the value of a static or instance field of type
     
* {@code int} or of another primitive type convertible to
     
* type {@code int} via a widening conversion.
     
*
     
* @param obj the object to extract the {@code int} value
     
* from
     
* @return the value of the field converted to type {@code int}
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code int} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#get
     
*/

    
@CallerSensitive
    
public int getInt(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getInt(obj);
    
}

    
/**
     
* Gets the value of a static or instance field of type
     
* {@code long} or of another primitive type convertible to
     
* type {@code long} via a widening conversion.
     
*
     
* @param obj the object to extract the {@code long} value
     
* from
     
* @return the value of the field converted to type {@code long}
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code long} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#get
     
*/

    
@CallerSensitive
    
public long getLong(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getLong(obj);
    
}

    
/**
     
* Gets the value of a static or instance field of type
     
* {@code float} or of another primitive type convertible to
     
* type {@code float} via a widening conversion.
     
*
     
* @param obj the object to extract the {@code float} value
     
* from
     
* @return the value of the field converted to type {@code float}
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code float} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see Field#get
     
*/

    
@CallerSensitive
    
public float getFloat(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getFloat(obj);
    
}

    
/**
     
* Gets the value of a static or instance field of type
     
* {@code double} or of another primitive type convertible to
     
* type {@code double} via a widening conversion.
     
*
     
* @param obj the object to extract the {@code double} value
     
* from
     
* @return the value of the field converted to type {@code double}
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is inaccessible.
     
* @exception IllegalArgumentException
  
if the specified object is not
     
*
              
an instance of the class or interface declaring the
     
*
              
underlying field (or a subclass or implementor
     
*
              
thereof), or if the field value cannot be
     
*
              
converted to the type {@code double} by a
     
*
              
widening conversion.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#get
     
*/

    
@CallerSensitive
    
public double getDouble(Object obj)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
return getFieldAccessor(obj).getDouble(obj);
    
}

    
/**
     
* Sets the field represented by this {@code Field} object on the
     
* specified object argument to the specified new value. The new
     
* value is automatically unwrapped if the underlying field has a
     
* primitive type.
     
*
     
* <p>The operation proceeds as follows:
     
*
     
* <p>If the underlying field is static, the {@code obj} argument is
     
* ignored; it may be null.
     
*
     
* <p>Otherwise the underlying field is an instance field.
  
If the
     
* specified object argument is null, the method throws a
     
* {@code NullPointerException}.
  
If the specified object argument is not
     
* an instance of the class or interface declaring the underlying
     
* field, the method throws an {@code IllegalArgumentException}.
     
*
     
* <p>If this {@code Field} object is enforcing Java language access control, and
     
* the underlying field is inaccessible, the method throws an
     
* {@code IllegalAccessException}.
     
*
     
* <p>If the underlying field is final, the method throws an
     
* {@code IllegalAccessException} unless {@code setAccessible(true)}
     
* has succeeded for this {@code Field} object
     
* and the field is non-static. Setting a final field in this way
     
* is meaningful only during deserialization or reconstruction of
     
* instances of classes with blank final fields, before they are
     
* made available for access by other parts of a program. Use in
     
* any other context may have unpredictable effects, including cases
     
* in which other parts of a program continue to use the original
     
* value of this field.
     
*
     
* <p>If the underlying field is of a primitive type, an unwrapping
     
* conversion is attempted to convert the new value to a value of
     
* a primitive type.
  
If this attempt fails, the method throws an
     
* {@code IllegalArgumentException}.
     
*
     
* <p>If, after possible unwrapping, the new value cannot be
     
* converted to the type of the underlying field by an identity or
     
* widening conversion, the method throws an
     
* {@code IllegalArgumentException}.
     
*
     
* <p>If the underlying field is static, the class that declared the
     
* field is initialized if it has not already been initialized.
     
*
     
* <p>The field is set to the possibly unwrapped and widened new value.
     
*
     
* <p>If the field is hidden in the type of {@code obj},
     
* the field's value is set according to the preceding rules.
     
*
     
* @param obj the object whose field should be modified
     
* @param value the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
*/

    
@CallerSensitive
    
public void set(Object obj, Object value)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).set(obj, value);
    
}

    
/**
     
* Sets the value of a field as a {@code boolean} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, zObj)},
     
* where {@code zObj} is a {@code Boolean} object and
     
* {@code zObj.booleanValue() == z}.
     
*
     
* @param obj the object whose field should be modified
     
* @param z
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setBoolean(Object obj, boolean z)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setBoolean(obj, z);
    
}

    
/**
     
* Sets the value of a field as a {@code byte} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, bObj)},
     
* where {@code bObj} is a {@code Byte} object and
     
* {@code bObj.byteValue() == b}.
     
*
     
* @param obj the object whose field should be modified
     
* @param b
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setByte(Object obj, byte b)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setByte(obj, b);
    
}

    
/**
     
* Sets the value of a field as a {@code char} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, cObj)},
     
* where {@code cObj} is a {@code Character} object and
     
* {@code cObj.charValue() == c}.
     
*
     
* @param obj the object whose field should be modified
     
* @param c
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setChar(Object obj, char c)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setChar(obj, c);
    
}

    
/**
     
* Sets the value of a field as a {@code short} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, sObj)},
     
* where {@code sObj} is a {@code Short} object and
     
* {@code sObj.shortValue() == s}.
     
*
     
* @param obj the object whose field should be modified
     
* @param s
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setShort(Object obj, short s)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setShort(obj, s);
    
}

    
/**
     
* Sets the value of a field as an {@code int} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, iObj)},
     
* where {@code iObj} is a {@code Integer} object and
     
* {@code iObj.intValue() == i}.
     
*
     
* @param obj the object whose field should be modified
     
* @param i
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setInt(Object obj, int i)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setInt(obj, i);
    
}

    
/**
     
* Sets the value of a field as a {@code long} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, lObj)},
     
* where {@code lObj} is a {@code Long} object and
     
* {@code lObj.longValue() == l}.
     
*
     
* @param obj the object whose field should be modified
     
* @param l
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setLong(Object obj, long l)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setLong(obj, l);
    
}

    
/**
     
* Sets the value of a field as a {@code float} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, fObj)},
     
* where {@code fObj} is a {@code Float} object and
     
* {@code fObj.floatValue() == f}.
     
*
     
* @param obj the object whose field should be modified
     
* @param f
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setFloat(Object obj, float f)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setFloat(obj, f);
    
}

    
/**
     
* Sets the value of a field as a {@code double} on the specified object.
     
* This method is equivalent to
     
* {@code set(obj, dObj)},
     
* where {@code dObj} is a {@code Double} object and
     
* {@code dObj.doubleValue() == d}.
     
*
     
* @param obj the object whose field should be modified
     
* @param d
   
the new value for the field of {@code obj}
     
* being modified
     
*
     
* @exception IllegalAccessException
    
if this {@code Field} object
     
*
              
is enforcing Java language access control and the underlying
     
*
              
field is either inaccessible or final.
     
* @exception IllegalArgumentException
  
if the specified object is not an
     
*
              
instance of the class or interface declaring the underlying
     
*
              
field (or a subclass or implementor thereof),
     
*
              
or if an unwrapping conversion fails.
     
* @exception NullPointerException
      
if the specified object is null
     
*
              
and the field is an instance field.
     
* @exception ExceptionInInitializerError if the initialization provoked
     
*
              
by this method fails.
     
* @see
       
Field#set
     
*/

    
@CallerSensitive
    
public void setDouble(Object obj, double d)
        
throws IllegalArgumentException, IllegalAccessException
    
{
        
if (!override) {
            
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                
Class<?> caller = Reflection.getCallerClass();
                
checkAccess(caller, clazz, obj, modifiers);
            
}
        
}
        
getFieldAccessor(obj).setDouble(obj, d);
    
}

    
// security check is done before calling this method
    
private FieldAccessor getFieldAccessor(Object obj)
        
throws IllegalAccessException
    
{
        
boolean ov = override;
        
FieldAccessor a = (ov) ? overrideFieldAccessor : fieldAccessor;
        
return (a != null) ? a : acquireFieldAccessor(ov);
    
}

    
// NOTE that there is no synchronization used here. It is correct
    
// (though not efficient) to generate more than one FieldAccessor
    
// for a given Field. However, avoiding synchronization will
    
// probably make the implementation more scalable.
    
private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
        
// First check to see if one has been created yet, and take it
        
// if so
        
FieldAccessor tmp = null;
        
if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
        
if (tmp != null) {
            
if (overrideFinalCheck)
                
overrideFieldAccessor = tmp;
            
else
                
fieldAccessor = tmp;
        
} else {
            
// Otherwise fabricate one and propagate it up to the root
            
tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
            
setFieldAccessor(tmp, overrideFinalCheck);
        
}

        
return tmp;
    
}

    
// Returns FieldAccessor for this Field object, not looking up
    
// the chain to the root
    
private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
        
return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
    
}

    
// Sets the FieldAccessor for this Field object and
    
// (recursively) its root
    
private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
        
if (overrideFinalCheck)
            
overrideFieldAccessor = accessor;
        
else
            
fieldAccessor = accessor;
        
// Propagate up
        
if (root != null) {
            
root.setFieldAccessor(accessor, overrideFinalCheck);
        
}
    
}

    
/**
     
* @throws NullPointerException {@inheritDoc}
     
* @since 1.5
     
*/
    
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
        
Objects.requireNonNull(annotationClass);
        
return annotationClass.cast(declaredAnnotations().get(annotationClass));
    
}

    
/**
     
* {@inheritDoc}
     
* @throws NullPointerException {@inheritDoc}
     
* @since 1.8
     
*/

    
@Override
    
public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
        
Objects.requireNonNull(annotationClass);

        
return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
    
}

    
/**
     
* {@inheritDoc}
     
*/
    
public Annotation[] getDeclaredAnnotations()
  
{
        
return AnnotationParser.toArray(declaredAnnotations());
    
}

    
private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;

    
private synchronized
  
Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
        
if (declaredAnnotations == null) {
            
Field root = this.root;
            
if (root != null) {
                
declaredAnnotations = root.declaredAnnotations();
            
} else {
                
declaredAnnotations = AnnotationParser.parseAnnotations(
                        
annotations,
                        
sun.misc.SharedSecrets.getJavaLangAccess().getConstantPool(getDeclaringClass()),
                        
getDeclaringClass());
            
}
        
}
        
return declaredAnnotations;
    
}

    
private native byte[] getTypeAnnotationBytes0();

    
/**
     
* Returns an AnnotatedType object that represents the use of a type to specify
     
* the declared type of the field represented by this Field.
     
* @return an object representing the declared type of the field
     
* represented by this Field
     
*
     
* @since 1.8
     
*/

    
public AnnotatedType getAnnotatedType() {
        
return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
                                                       
sun.misc.SharedSecrets.getJavaLangAccess().
                                                           
getConstantPool(getDeclaringClass()),
                                                       
this,
                                                       
getDeclaringClass(),
                                                       
getGenericType(),
                                                       
TypeAnnotation.TypeAnnotationTarget.FIELD);
}
}