| /* |
| * 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 dalvik.system.VMStack; |
| import java.lang.annotation.Annotation; |
| 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 { |
| |
| private Class<?> declaringClass; |
| |
| private Class<?> type; |
| |
| private Type genericType; |
| |
| private volatile boolean genericTypesAreInitialized = false; |
| |
| private String name; |
| |
| private int slot; |
| |
| private static final int TYPE_BOOLEAN = 1; |
| |
| private static final int TYPE_BYTE = 2; |
| |
| private static final int TYPE_CHAR = 3; |
| |
| private static final int TYPE_SHORT = 4; |
| |
| private static final int TYPE_INTEGER = 5; |
| |
| private static final int TYPE_FLOAT = 6; |
| |
| private static final int TYPE_LONG = 7; |
| |
| private static final int TYPE_DOUBLE = 8; |
| |
| /** |
| * 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); |
| } |
| |
| native private Annotation[] getDeclaredAnnotations(Class declaringClass, int slot); |
| |
| /** |
| * 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 wrapped. |
| * <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. |
| * <p> |
| * |
| * @param object |
| * the object to access |
| * @return the field value, possibly wrapped |
| * @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() { |
| // BEGIN android-changed |
| return name.hashCode() ^ getDeclaringClass().getName().hashCode(); |
| // END android-changed |
| } |
| |
| /** |
| * 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 |
| * unwrapped. If the unwrap 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(' '); |
| } |
| result.append(type.getName()); |
| 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, int type_no) throws IllegalAccessException; |
| |
| private native int getIField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) throws IllegalAccessException; |
| |
| private native long getJField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) throws IllegalAccessException; |
| |
| private native boolean getZField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) throws IllegalAccessException; |
| |
| private native float getFField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) throws IllegalAccessException; |
| |
| private native char getCField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) throws IllegalAccessException; |
| |
| private native short getSField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) throws IllegalAccessException; |
| |
| private native byte getBField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no) 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, int type_no, double v) throws IllegalAccessException; |
| |
| private native void setIField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, int i) throws IllegalAccessException; |
| |
| private native void setJField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, long j) throws IllegalAccessException; |
| |
| private native void setZField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, boolean z) throws IllegalAccessException; |
| |
| private native void setFField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, float f) throws IllegalAccessException; |
| |
| private native void setCField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, char c) throws IllegalAccessException; |
| |
| private native void setSField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, short s) throws IllegalAccessException; |
| |
| private native void setBField(Object o, Class<?> declaringClass, Class<?> type, int slot, |
| boolean noAccessCheck, int type_no, byte b) throws IllegalAccessException; |
| |
| } |
