/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.lang.reflect;
import java.lang.annotation.Annotation;
import java.util.Comparator;
import org.apache.harmony.kernel.vm.StringUtils;
import org.apache.harmony.luni.lang.reflect.GenericSignatureParser;
import org.apache.harmony.luni.lang.reflect.Types;
/**
* This class represents a field. Information about the field can be accessed,
* and the field's value can be accessed dynamically.
*/
public final class Field extends AccessibleObject implements Member {
/**
* Orders fields by their name and declaring class.
*
* @hide
*/
public static final Comparator<Field> ORDER_BY_NAME_AND_DECLARING_CLASS
= new Comparator<Field>() {
@Override public int compare(Field a, Field b) {
int comparison = a.name.compareTo(b.name);
if (comparison != 0) {
return comparison;
}
return a.getDeclaringClass().getName().compareTo(b.getDeclaringClass().getName());
}
};
private Class<?> declaringClass;
private Class<?> type;
private Type genericType;
private volatile boolean genericTypesAreInitialized = false;
private String name;
private int slot;
private static final char TYPE_BOOLEAN = 'Z';
private static final char TYPE_BYTE = 'B';
private static final char TYPE_CHAR = 'C';
private static final char TYPE_SHORT = 'S';
private static final char TYPE_INTEGER = 'I';
private static final char TYPE_FLOAT = 'F';
private static final char TYPE_LONG = 'J';
private static final char TYPE_DOUBLE = 'D';
/**
* Construct a clone of the given instance.
*
* @param orig non-null; the original instance to clone
*/
/*package*/ Field(Field orig) {
this(orig.declaringClass, orig.type, orig.name, orig.slot);
// Copy the accessible flag.
if (orig.flag) {
this.flag = true;
}
}
private Field(Class<?> declaringClass, Class<?> type, String name, int slot) {
this.declaringClass = declaringClass;
this.type = type;
this.name = name;
this.slot = slot;
}
private synchronized void initGenericType() {
if (!genericTypesAreInitialized) {
String signatureAttribute = getSignatureAttribute();
GenericSignatureParser parser = new GenericSignatureParser(
declaringClass.getClassLoader());
parser.parseForField(this.declaringClass, signatureAttribute);
genericType = parser.fieldType;
if (genericType == null) {
genericType = getType();
}
genericTypesAreInitialized = true;
}
}
/** {@inheritDoc} */
@Override
/* package */String getSignatureAttribute() {
Object[] annotation = getSignatureAnnotation(declaringClass, slot);
if (annotation == null) {
return null;
}
return StringUtils.combineStrings(annotation);
}
/**
* Get the Signature annotation for this field. Returns null if not found.
*/
native private Object[] getSignatureAnnotation(Class declaringClass, int slot);
/**
* Indicates whether or not this field is synthetic.
*
* @return {@code true} if this field is synthetic, {@code false} otherwise
*/
public boolean isSynthetic() {
int flags = getFieldModifiers(declaringClass, slot);
return (flags & Modifier.SYNTHETIC) != 0;
}
/**
* Returns the string representation of this field, including the field's
* generic type.
*
* @return the string representation of this field
*/
public String toGenericString() {
StringBuilder sb = new StringBuilder(80);
// append modifiers if any
int modifier = getModifiers();
if (modifier != 0) {
sb.append(Modifier.toString(modifier)).append(' ');
}
// append generic type
appendGenericType(sb, getGenericType());
sb.append(' ');
// append full field name
sb.append(getDeclaringClass().getName()).append('.').append(getName());
return sb.toString();
}
/**
* Indicates whether or not this field is an enumeration constant.
*
* @return {@code true} if this field is an enumeration constant, {@code
* false} otherwise
*/
public boolean isEnumConstant() {
int flags = getFieldModifiers(declaringClass, slot);
return (flags & Modifier.ENUM) != 0;
}
/**
* Returns the generic type of this field.
*
* @return the generic type
* @throws GenericSignatureFormatError
* if the generic field signature is invalid
* @throws TypeNotPresentException
* if the generic type points to a missing type
* @throws MalformedParameterizedTypeException
* if the generic type points to a type that cannot be
* instantiated for some reason
*/
public Type getGenericType() {
initGenericType();
return Types.getType(genericType);
}
@Override public Annotation[] getDeclaredAnnotations() {
return getDeclaredAnnotations(declaringClass, slot);
}
private static native Annotation[] getDeclaredAnnotations(Class declaringClass, int slot);
@Override public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
if (annotationType == null) {
throw new NullPointerException("annotationType == null");
}
return getAnnotation(declaringClass, slot, annotationType);
}
private static native <A extends Annotation> A getAnnotation(
Class<?> declaringClass, int slot, Class<A> annotationType);
@Override public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
if (annotationType == null) {
throw new NullPointerException("annotationType == null");
}
return isAnnotationPresent(declaringClass, slot, annotationType);
}
private static native boolean isAnnotationPresent(
Class<?> declaringClass, int slot, Class<? extends Annotation> annotationType);
/**
* Indicates whether or not the specified {@code object} is equal to this
* field. To be equal, the specified object must be an instance of
* {@code Field} with the same declaring class, type and name as this field.
*
* @param object
* the object to compare
* @return {@code true} if the specified object is equal to this method,
* {@code false} otherwise
* @see #hashCode
*/
@Override
public boolean equals(Object object) {
return object instanceof Field && toString().equals(object.toString());
}
/**
* Returns the value of the field in the specified object. This reproduces
* the effect of {@code object.fieldName}
*
* <p>If the type of this field is a primitive type, the field value is
* automatically boxed.
*
* <p>If this field is static, the object argument is ignored.
* Otherwise, if the object is null, a NullPointerException is thrown. If
* the object is not an instance of the declaring class of the method, an
* IllegalArgumentException is thrown.
*
* <p>If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value, possibly boxed
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public Object get(Object object) throws IllegalAccessException, IllegalArgumentException {
return getField(object, declaringClass, type, slot, flag);
}
/**
* Returns the value of the field in the specified object as a {@code
* boolean}. This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public boolean getBoolean(Object object) throws IllegalAccessException,
IllegalArgumentException {
return getZField(object, declaringClass, type, slot, flag, TYPE_BOOLEAN);
}
/**
* Returns the value of the field in the specified object as a {@code byte}.
* This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public byte getByte(Object object) throws IllegalAccessException, IllegalArgumentException {
return getBField(object, declaringClass, type, slot, flag, TYPE_BYTE);
}
/**
* Returns the value of the field in the specified object as a {@code char}.
* This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public char getChar(Object object) throws IllegalAccessException, IllegalArgumentException {
return getCField(object, declaringClass, type, slot, flag, TYPE_CHAR);
}
/**
* Returns the class that declares this field.
*
* @return the declaring class
*/
public Class<?> getDeclaringClass() {
return declaringClass;
}
/**
* Returns the value of the field in the specified object as a {@code
* double}. This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public double getDouble(Object object) throws IllegalAccessException, IllegalArgumentException {
return getDField(object, declaringClass, type, slot, flag, TYPE_DOUBLE);
}
/**
* Returns the value of the field in the specified object as a {@code float}
* . This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public float getFloat(Object object) throws IllegalAccessException, IllegalArgumentException {
return getFField(object, declaringClass, type, slot, flag, TYPE_FLOAT);
}
/**
* Returns the value of the field in the specified object as an {@code int}.
* This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public int getInt(Object object) throws IllegalAccessException, IllegalArgumentException {
return getIField(object, declaringClass, type, slot, flag, TYPE_INTEGER);
}
/**
* Returns the value of the field in the specified object as a {@code long}.
* This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public long getLong(Object object) throws IllegalAccessException, IllegalArgumentException {
return getJField(object, declaringClass, type, slot, flag, TYPE_LONG);
}
/**
* Returns the modifiers for this field. The {@link Modifier} class should
* be used to decode the result.
*
* @return the modifiers for this field
* @see Modifier
*/
public int getModifiers() {
return getFieldModifiers(declaringClass, slot);
}
private native int getFieldModifiers(Class<?> declaringClass, int slot);
/**
* Returns the name of this field.
*
* @return the name of this field
*/
public String getName() {
return name;
}
/**
* Returns the value of the field in the specified object as a {@code short}
* . This reproduces the effect of {@code object.fieldName}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* @param object
* the object to access
* @return the field value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public short getShort(Object object) throws IllegalAccessException, IllegalArgumentException {
return getSField(object, declaringClass, type, slot, flag, TYPE_SHORT);
}
/**
* Returns the constructor's signature in non-printable form. This is called
* (only) from IO native code and needed for deriving the serialVersionUID
* of the class
*
* @return the constructor's signature.
*/
@SuppressWarnings("unused")
private String getSignature() {
return getSignature(type);
}
/**
* Return the {@link Class} associated with the type of this field.
*
* @return the type of this field
*/
public Class<?> getType() {
return type;
}
/**
* Returns an integer hash code for this field. Objects which are equal
* return the same value for this method.
* <p>
* The hash code for a Field is the exclusive-or combination of the hash
* code of the field's name and the hash code of the name of its declaring
* class.
*
* @return the hash code for this field
* @see #equals
*/
@Override
public int hashCode() {
return name.hashCode() ^ getDeclaringClass().getName().hashCode();
}
/**
* Sets the value of the field in the specified object to the value. This
* reproduces the effect of {@code object.fieldName = value}
*
* <p>If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
*
* <p>If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
*
* <p>If the field type is a primitive type, the value is automatically
* unboxed. If the unboxing fails, an IllegalArgumentException is thrown. If
* the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void set(Object object, Object value) throws IllegalAccessException,
IllegalArgumentException {
setField(object, declaringClass, type, slot, flag, value);
}
/**
* Sets the value of the field in the specified object to the {@code
* boolean} value. This reproduces the effect of {@code object.fieldName =
* value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setBoolean(Object object, boolean value) throws IllegalAccessException,
IllegalArgumentException {
setZField(object, declaringClass, type, slot, flag, TYPE_BOOLEAN, value);
}
/**
* Sets the value of the field in the specified object to the {@code byte}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setByte(Object object, byte value) throws IllegalAccessException,
IllegalArgumentException {
setBField(object, declaringClass, type, slot, flag, TYPE_BYTE, value);
}
/**
* Sets the value of the field in the specified object to the {@code char}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setChar(Object object, char value) throws IllegalAccessException,
IllegalArgumentException {
setCField(object, declaringClass, type, slot, flag, TYPE_CHAR, value);
}
/**
* Sets the value of the field in the specified object to the {@code double}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setDouble(Object object, double value) throws IllegalAccessException,
IllegalArgumentException {
setDField(object, declaringClass, type, slot, flag, TYPE_DOUBLE, value);
}
/**
* Sets the value of the field in the specified object to the {@code float}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setFloat(Object object, float value) throws IllegalAccessException,
IllegalArgumentException {
setFField(object, declaringClass, type, slot, flag, TYPE_FLOAT, value);
}
/**
* Set the value of the field in the specified object to the {@code int}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setInt(Object object, int value) throws IllegalAccessException,
IllegalArgumentException {
setIField(object, declaringClass, type, slot, flag, TYPE_INTEGER, value);
}
/**
* Sets the value of the field in the specified object to the {@code long}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setLong(Object object, long value) throws IllegalAccessException,
IllegalArgumentException {
setJField(object, declaringClass, type, slot, flag, TYPE_LONG, value);
}
/**
* Sets the value of the field in the specified object to the {@code short}
* value. This reproduces the effect of {@code object.fieldName = value}
* <p>
* If this field is static, the object argument is ignored.
* Otherwise, if the object is {@code null}, a NullPointerException is
* thrown. If the object is not an instance of the declaring class of the
* method, an IllegalArgumentException is thrown.
* <p>
* If this Field object is enforcing access control (see AccessibleObject)
* and this field is not accessible from the current context, an
* IllegalAccessException is thrown.
* <p>
* If the value cannot be converted to the field type via a widening
* conversion, an IllegalArgumentException is thrown.
*
* @param object
* the object to access
* @param value
* the new value
* @throws NullPointerException
* if the object is {@code null} and the field is non-static
* @throws IllegalArgumentException
* if the object is not compatible with the declaring class
* @throws IllegalAccessException
* if this field is not accessible
*/
public void setShort(Object object, short value) throws IllegalAccessException,
IllegalArgumentException {
setSField(object, declaringClass, type, slot, flag, TYPE_SHORT, value);
}
/**
* Returns a string containing a concise, human-readable description of this
* field.
* <p>
* The format of the string is:
* <ol>
* <li>modifiers (if any)
* <li>type
* <li>declaring class name
* <li>'.'
* <li>field name
* </ol>
* <p>
* For example: {@code public static java.io.InputStream
* java.lang.System.in}
*
* @return a printable representation for this field
*/
@Override
public String toString() {
StringBuilder result = new StringBuilder(Modifier.toString(getModifiers()));
if (result.length() != 0) {
result.append(' ');
}
appendArrayType(result, type);
result.append(' ');
result.append(declaringClass.getName());
result.append('.');
result.append(name);
return result.toString();
}
private native Object getField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck) throws IllegalAccessException;
private native double getDField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native int getIField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native long getJField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native boolean getZField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native float getFField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native char getCField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native short getSField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native byte getBField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor) throws IllegalAccessException;
private native void setField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, Object value) throws IllegalAccessException;
private native void setDField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, double v) throws IllegalAccessException;
private native void setIField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, int i) throws IllegalAccessException;
private native void setJField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, long j) throws IllegalAccessException;
private native void setZField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, boolean z) throws IllegalAccessException;
private native void setFField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, float f) throws IllegalAccessException;
private native void setCField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, char c) throws IllegalAccessException;
private native void setSField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, short s) throws IllegalAccessException;
private native void setBField(Object o, Class<?> declaringClass, Class<?> type, int slot,
boolean noAccessCheck, char descriptor, byte b) throws IllegalAccessException;
}