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 * @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 * @since 1.1 */ public final class Field extends AccessibleObject implements Member { private final Class clazz; private final int slot; // This is guaranteed to be interned by the VM in the 1.4 // reflection implementation private final String name; private final Class type; private final int modifiers; private final boolean trustedFinal; // Generics and annotations support private final transient String signature; private final byte[] annotations; /** * Fields are mutable due to {@link AccessibleObject#setAccessible(boolean)}. * Thus, we return a new copy of a root each time a field is returned. * Some lazily initialized immutable states can be stored on root and shared to the copies. */ private Field root; private transient volatile FieldRepository genericInfo; private @Stable FieldAccessor fieldAccessor; // access control enabled private @Stable FieldAccessor overrideFieldAccessor; // access control suppressed // End shared states // 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() { var genericInfo = this.genericInfo; if (genericInfo == null) { var root = this.root; if (root != null) { genericInfo = root.getGenericInfo(); } else { genericInfo = FieldRepository.make(getGenericSignature(), getFactory()); } this.genericInfo = genericInfo; } return genericInfo; } /** * Package-private constructor */ @SuppressWarnings("deprecation") Field(Class declaringClass, String name, Class type, int modifiers, boolean trustedFinal, int slot, String signature, byte[] annotations) { this.clazz = declaringClass; this.name = name; this.type = type; this.modifiers = modifiers; this.trustedFinal = trustedFinal; 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, trustedFinal, slot, signature, annotations); res.root = this; // Might as well eagerly propagate this if already present res.fieldAccessor = fieldAccessor; res.overrideFieldAccessor = overrideFieldAccessor; res.genericInfo = genericInfo; return res; } /** * {@inheritDoc} * *
If this reflected object represents a non-final field, and this method is * used to enable access, then both {@linkplain #get(Object) read} * and {@linkplain #set(Object, Object) write} access to the field * are enabled. * *
If this reflected object represents a non-modifiable final field * then enabling access only enables read access. Any attempt to {@linkplain * #set(Object, Object) set} the field value throws an {@code * IllegalAccessException}. The following fields are non-modifiable: *
If this reflected object represents a non-static final field in a class that
* is not a record class or hidden class, then enabling access will enable read
* access. Whether write access is allowed or not is checked when attempting to
* {@linkplain #set(Object, Object) set} the field value.
*
* @throws InaccessibleObjectException {@inheritDoc}
*/
@Override
@CallerSensitive
public void setAccessible(boolean flag) {
if (flag) checkCanSetAccessible(Reflection.getCallerClass());
setAccessible0(flag);
}
@Override
void checkCanSetAccessible(Class caller) {
checkCanSetAccessible(caller, clazz);
}
/**
* Returns the {@code Class} object representing the class or interface
* that declares the field represented by this {@code Field} object.
*/
@Override
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
* @see #accessFlags()
* @jls 8.3 Field Declarations
* @jls 9.3 Field (Constant) Declarations
*/
public int getModifiers() {
return modifiers;
}
/**
* {@return an unmodifiable set of the {@linkplain AccessFlag
* access flags} for this field, possibly empty}
* @see #getModifiers()
* @jvms 4.5 Fields
* @since 20
*/
@Override
public Set If the declared type of the field is a parameterized type,
* the {@code Type} object returned must accurately reflect the
* actual type arguments used in the source code.
*
* 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
* The Java Virtual Machine Specification
* @throws TypeNotPresentException if the generic type
* signature of the underlying field refers to a non-existent
* class or interface 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 instanceof Field other) {
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:
* 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() {
return modifierPrefix()
+ getType().getTypeName() + " "
+ getDeclaringClass().getTypeName() + "."
+ getName();
}
private String modifierPrefix() {
StringBuilder sb = new StringBuilder();
Reflection.appendAccessControlModifiers(sb, modifiers);
if (Modifier.isStatic(modifiers))
sb.append("static ");
if (Modifier.isFinal(modifiers))
sb.append("final ");
if (Modifier.isTransient(modifiers))
sb.append("transient ");
if (Modifier.isVolatile(modifiers))
sb.append("volatile ");
return sb.toString();
}
@Override
String toShortString() {
return "field " + 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.
*
* 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() {
Type fieldType = getGenericType();
return modifierPrefix()
+ 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.
*
* The underlying field's value is obtained as follows:
*
* If the underlying field is a static field, the {@code obj} argument
* is ignored; it may be null.
*
* 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}.
*
* 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.
*
* 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.
*
* 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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof).
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public Object get(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().get(obj);
} else {
return getOverrideFieldAccessor().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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public boolean getBoolean(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getBoolean(obj);
} else {
return getOverrideFieldAccessor().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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public byte getByte(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getByte(obj);
} else {
return getOverrideFieldAccessor().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}
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public char getChar(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getChar(obj);
} else {
return getOverrideFieldAccessor().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}
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public short getShort(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getShort(obj);
} else {
return getOverrideFieldAccessor().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}
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public int getInt(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getInt(obj);
} else {
return getOverrideFieldAccessor().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}
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public long getLong(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getLong(obj);
} else {
return getOverrideFieldAccessor().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}
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public float getFloat(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getFloat(obj);
} else {
return getOverrideFieldAccessor().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}
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public double getDouble(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
return getFieldAccessor().getDouble(obj);
} else {
return getOverrideFieldAccessor().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.
*
* The operation proceeds as follows:
*
* If the underlying field is static, the {@code obj} argument is
* ignored; it may be null.
*
* 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}.
*
* 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 final, this {@code Field} object has write
* access if and only if all of the following conditions are true, where {@code D} is
* the field's {@linkplain #getDeclaringClass() declaring class}:
*
* If any of the above conditions is not met, this method throws an
* {@code IllegalAccessException}.
*
* These conditions are more restrictive than the conditions specified by {@link
* #setAccessible(boolean)} to suppress access checks. In particular, updating a
* module to export or open a package cannot be used to allow write access
* to final fields with the {@code set} methods defined by {@code Field}.
* Condition (b) is not met if the module containing {@code D} has been updated with
* {@linkplain Module#addExports(String, Module) addExports} to export the package to
* the caller's module. Condition (c) is not met if the module containing {@code D}
* has been updated with {@linkplain Module#addOpens(String, Module) addOpens} to open
* the package to the caller's module.
*
* This method may be called by
* JNI code with no caller class on the stack. In that case, and when the
* underlying field is final, this {@code Field} object has write access
* if and only if all of the following conditions are true, where {@code D} is the
* field's {@linkplain #getDeclaringClass() declaring class}:
*
* If any of the above conditions is not met, this method throws an
* {@code IllegalAccessException}.
*
* 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.
*
* 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}.
*
* 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}.
*
* If the underlying field is static, the class that declared the
* field is initialized if it has not already been initialized.
*
* The field is set to the possibly unwrapped and widened new value.
*
* 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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
*
* @see Mutation methods
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void set(Object obj, Object value)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().set(obj, value);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.set(obj, value);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setBoolean(Object obj, boolean z)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setBoolean(obj, z);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setBoolean(obj, z);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setByte(Object obj, byte b)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setByte(obj, b);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setByte(obj, b);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setChar(Object obj, char c)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setChar(obj, c);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setChar(obj, c);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setShort(Object obj, short s)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setShort(obj, s);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setShort(obj, s);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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 an {@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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setInt(Object obj, int i)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setInt(obj, i);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setInt(obj, i);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setLong(Object obj, long l)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setLong(obj, l);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setLong(obj, l);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setFloat(Object obj, float f)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setFloat(obj, f);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setFloat(obj, f);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.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
*
* @throws IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final;
* or if this {@code Field} object has no write access.
* @throws 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.
* @throws NullPointerException if the specified object is null
* and the field is an instance field.
* @throws ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*/
@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
public void setDouble(Object obj, double d)
throws IllegalArgumentException, IllegalAccessException
{
if (!override) {
Class caller = Reflection.getCallerClass();
checkAccess(caller, obj);
getFieldAccessor().setDouble(obj, d);
return;
}
FieldAccessor fa = getOverrideFieldAccessor();
if (!Modifier.isFinal(modifiers)) {
fa.setDouble(obj, d);
} else {
setFinal(Reflection.getCallerClass(), obj, () -> fa.setDouble(obj, d));
}
}
// check access to field
private void checkAccess(Class caller, Object obj)
throws IllegalAccessException
{
checkAccess(caller, clazz,
Modifier.isStatic(modifiers) ? null : obj.getClass(),
modifiers);
}
private FieldAccessor getFieldAccessor() {
FieldAccessor a = fieldAccessor;
return (a != null) ? a : acquireFieldAccessor();
}
private FieldAccessor getOverrideFieldAccessor() {
FieldAccessor a = overrideFieldAccessor;
return (a != null) ? a : acquireOverrideFieldAccessor();
}
// 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() {
// First check to see if one has been created yet, and take it
// if so
Field root = this.root;
FieldAccessor tmp = root == null ? null : root.fieldAccessor;
if (tmp != null) {
fieldAccessor = tmp;
} else {
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newFieldAccessor(this, false);
setFieldAccessor(tmp);
}
return tmp;
}
private FieldAccessor acquireOverrideFieldAccessor() {
// First check to see if one has been created yet, and take it
// if so
Field root = this.root;
FieldAccessor tmp = root == null ? null : root.overrideFieldAccessor;
if (tmp != null) {
overrideFieldAccessor = tmp;
} else {
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newFieldAccessor(this, true);
setOverrideFieldAccessor(tmp);
}
return tmp;
}
// Sets the fieldAccessor for this Field object and
// (recursively) its root
private void setFieldAccessor(FieldAccessor accessor) {
fieldAccessor = accessor;
// Propagate up
Field root = this.root;
if (root != null) {
root.setFieldAccessor(accessor);
}
}
// Sets the overrideFieldAccessor for this Field object and
// (recursively) its root
private void setOverrideFieldAccessor(FieldAccessor accessor) {
overrideFieldAccessor = accessor;
// Propagate up
Field root = this.root;
if (root != null) {
root.setOverrideFieldAccessor(accessor);
}
}
@Override
/* package-private */ Field getRoot() {
return root;
}
/* package-private */ boolean isTrustedFinal() {
return trustedFinal;
}
/**
* {@inheritDoc}
*
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*/
@Override
public
* public static final int java.lang.Thread.MIN_PRIORITY
* private int java.io.FileDescriptor.fd
*
*
*
*
*
*
*
*
*
*
*