| Methods Summary |
|---|
| private sun.reflect.FieldAccessor | acquireFieldAccessor(boolean overrideFinalCheck)
// First check to see if one has been created yet, and take it
// if so
FieldAccessor tmp = null;
if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
if (tmp != null) {
if (overrideFinalCheck)
overrideFieldAccessor = tmp;
else
fieldAccessor = tmp;
} else {
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
setFieldAccessor(tmp, overrideFinalCheck);
}
return tmp;
|
| java.lang.reflect.Field | copy()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.
// 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.)
Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
res.root = this;
// Might as well eagerly propagate this if already present
res.fieldAccessor = fieldAccessor;
res.overrideFieldAccessor = overrideFieldAccessor;
return res;
|
| private synchronized java.util.Map | declaredAnnotations()
if (declaredAnnotations == null) {
declaredAnnotations = AnnotationParser.parseAnnotations(
annotations, sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
}
return declaredAnnotations;
|
| private void | doSecurityCheck(java.lang.Object obj)
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class caller = Reflection.getCallerClass(4);
Class targetClass = ((obj == null || !Modifier.isProtected(modifiers))
? clazz
: obj.getClass());
synchronized (this) {
if ((securityCheckCache == caller)
&& (securityCheckTargetClassCache == targetClass)) {
return;
}
}
Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
synchronized (this) {
securityCheckCache = caller;
securityCheckTargetClassCache = targetClass;
}
}
}
|
| public boolean | equals(java.lang.Object obj)Compares this Field against the specified object. Returns
true if the objects are the same. Two Field objects are the same if
they were declared by the same class and have the same name
and type.
if (obj != null && obj instanceof Field) {
Field other = (Field)obj;
return (getDeclaringClass() == other.getDeclaringClass())
&& (getName() == other.getName())
&& (getType() == other.getType());
}
return false;
|
| public java.lang.Object | get(java.lang.Object obj)Returns the value of the field represented by this 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 obj argument
is ignored; it may be null.
Otherwise, the underlying field is an instance field. If the
specified obj argument is null, the method throws a
NullPointerException. If the specified object is not an
instance of the class or interface declaring the underlying
field, the method throws an IllegalArgumentException.
If this Field object enforces Java language access control, and
the underlying field is inaccessible, the method throws an
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 obj,
the field's value is obtained according to the preceding rules.
return getFieldAccessor(obj).get(obj);
|
| public T | getAnnotation(java.lang.Class annotationClass)
if (annotationClass == null)
throw new NullPointerException();
return (T) declaredAnnotations().get(annotationClass);
|
| public boolean | getBoolean(java.lang.Object obj)Gets the value of a static or instance boolean field.
return getFieldAccessor(obj).getBoolean(obj);
|
| public byte | getByte(java.lang.Object obj)Gets the value of a static or instance byte field.
return getFieldAccessor(obj).getByte(obj);
|
| public char | getChar(java.lang.Object obj)Gets the value of a static or instance field of type
char or of another primitive type convertible to
type char via a widening conversion.
return getFieldAccessor(obj).getChar(obj);
|
| public java.lang.annotation.Annotation[] | getDeclaredAnnotations()
return declaredAnnotations().values().toArray(EMPTY_ANNOTATION_ARRAY);
|
| public java.lang.Class | getDeclaringClass()Returns the Class object representing the class or interface
that declares the field represented by this Field object.
return clazz;
|
| public double | getDouble(java.lang.Object obj)Gets the value of a static or instance field of type
double or of another primitive type convertible to
type double via a widening conversion.
return getFieldAccessor(obj).getDouble(obj);
|
| private sun.reflect.generics.factory.GenericsFactory | getFactory()
Class<?> c = getDeclaringClass();
// create scope and factory
return CoreReflectionFactory.make(c, ClassScope.make(c));
|
| private sun.reflect.FieldAccessor | getFieldAccessor(java.lang.Object obj)
doSecurityCheck(obj);
boolean ov = override;
FieldAccessor a = (ov)? overrideFieldAccessor : fieldAccessor;
return (a != null)? a : acquireFieldAccessor(ov);
|
| private sun.reflect.FieldAccessor | getFieldAccessor(boolean overrideFinalCheck)
return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
|
| public float | getFloat(java.lang.Object obj)Gets the value of a static or instance field of type
float or of another primitive type convertible to
type float via a widening conversion.
return getFieldAccessor(obj).getFloat(obj);
|
| private sun.reflect.generics.repository.FieldRepository | getGenericInfo()
// lazily initialize repository if necessary
if (genericInfo == null) {
// create and cache generic info repository
genericInfo = FieldRepository.make(getGenericSignature(),
getFactory());
}
return genericInfo; //return cached repository
|
| private java.lang.String | getGenericSignature()return signature;
|
| public java.lang.reflect.Type | getGenericType()Returns a Type object that represents the declared type for
the field represented by this Field object.
If the Type is a parameterized type, the
Type object returned must accurately reflect the
actual type parameters 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.
if (getGenericSignature() != null)
return getGenericInfo().getGenericType();
else
return getType();
|
| public int | getInt(java.lang.Object obj)Gets the value of a static or instance field of type
int or of another primitive type convertible to
type int via a widening conversion.
return getFieldAccessor(obj).getInt(obj);
|
| public long | getLong(java.lang.Object obj)Gets the value of a static or instance field of type
long or of another primitive type convertible to
type long via a widening conversion.
return getFieldAccessor(obj).getLong(obj);
|
| public int | getModifiers()Returns the Java language modifiers for the field represented
by this Field object, as an integer. The Modifier class should
be used to decode the modifiers.
return modifiers;
|
| public java.lang.String | getName()Returns the name of the field represented by this Field object.
return name;
|
| public short | getShort(java.lang.Object obj)Gets the value of a static or instance field of type
short or of another primitive type convertible to
type short via a widening conversion.
return getFieldAccessor(obj).getShort(obj);
|
| public java.lang.Class | getType()Returns a Class object that identifies the
declared type for the field represented by this
Field object.
return type;
|
| static java.lang.String | getTypeName(java.lang.Class type)
if (type.isArray()) {
try {
Class cl = type;
int dimensions = 0;
while (cl.isArray()) {
dimensions++;
cl = cl.getComponentType();
}
StringBuffer sb = new StringBuffer();
sb.append(cl.getName());
for (int i = 0; i < dimensions; i++) {
sb.append("[]");
}
return sb.toString();
} catch (Throwable e) { /*FALLTHRU*/ }
}
return type.getName();
|
| public int | hashCode()Returns a hashcode for this Field. This is computed as the
exclusive-or of the hashcodes for the underlying field's
declaring class name and its name.
return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
|
| public boolean | isEnumConstant()Returns true if this field represents an element of
an enumerated type; returns false otherwise.
return (getModifiers() & Modifier.ENUM) != 0;
|
| public boolean | isSynthetic()Returns true if this field is a synthetic
field; returns false otherwise.
return Modifier.isSynthetic(getModifiers());
|
| public void | set(java.lang.Object obj, java.lang.Object value)Sets the field represented by this 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 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
NullPointerException. If the specified object argument is not
an instance of the class or interface declaring the underlying
field, the method throws an IllegalArgumentException.
If this Field object enforces Java language access control, and
the underlying field is inaccessible, the method throws an
IllegalAccessException.
If the underlying field is final, the method throws an
IllegalAccessException unless
setAccessible(true) has succeeded for this field
and this field is non-static. Setting a final field in this way
is meaningful only during deserialization or reconstruction of
instances of classes with blank final fields, before they are
made available for access by other parts of a program. Use in
any other context may have unpredictable effects, including cases
in which other parts of a program continue to use the original
value of this field.
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
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
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 obj,
the field's value is set according to the preceding rules.
getFieldAccessor(obj).set(obj, value);
|
| public void | setBoolean(java.lang.Object obj, boolean z)Sets the value of a field as a boolean on the specified object.
This method is equivalent to
set(obj, zObj),
where zObj is a Boolean object and
zObj.booleanValue() == z.
getFieldAccessor(obj).setBoolean(obj, z);
|
| public void | setByte(java.lang.Object obj, byte b)Sets the value of a field as a byte on the specified object.
This method is equivalent to
set(obj, bObj),
where bObj is a Byte object and
bObj.byteValue() == b.
getFieldAccessor(obj).setByte(obj, b);
|
| public void | setChar(java.lang.Object obj, char c)Sets the value of a field as a char on the specified object.
This method is equivalent to
set(obj, cObj),
where cObj is a Character object and
cObj.charValue() == c.
getFieldAccessor(obj).setChar(obj, c);
|
| public void | setDouble(java.lang.Object obj, double d)Sets the value of a field as a double on the specified object.
This method is equivalent to
set(obj, dObj),
where dObj is a Double object and
dObj.doubleValue() == d.
getFieldAccessor(obj).setDouble(obj, d);
|
| private void | setFieldAccessor(sun.reflect.FieldAccessor accessor, boolean overrideFinalCheck)
if (overrideFinalCheck)
overrideFieldAccessor = accessor;
else
fieldAccessor = accessor;
// Propagate up
if (root != null) {
root.setFieldAccessor(accessor, overrideFinalCheck);
}
|
| public void | setFloat(java.lang.Object obj, float f)Sets the value of a field as a float on the specified object.
This method is equivalent to
set(obj, fObj),
where fObj is a Float object and
fObj.floatValue() == f.
getFieldAccessor(obj).setFloat(obj, f);
|
| public void | setInt(java.lang.Object obj, int i)Sets the value of a field as an int on the specified object.
This method is equivalent to
set(obj, iObj),
where iObj is a Integer object and
iObj.intValue() == i.
getFieldAccessor(obj).setInt(obj, i);
|
| public void | setLong(java.lang.Object obj, long l)Sets the value of a field as a long on the specified object.
This method is equivalent to
set(obj, lObj),
where lObj is a Long object and
lObj.longValue() == l.
getFieldAccessor(obj).setLong(obj, l);
|
| public void | setShort(java.lang.Object obj, short s)Sets the value of a field as a short on the specified object.
This method is equivalent to
set(obj, sObj),
where sObj is a Short object and
sObj.shortValue() == s.
getFieldAccessor(obj).setShort(obj, s);
|
| public java.lang.String | toGenericString()Returns a string describing this 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 public,
protected or private first, and then other
modifiers in the following order: static, final,
transient, volatile.
int mod = getModifiers();
Type fieldType = getGenericType();
return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
+ ((fieldType instanceof Class) ?
getTypeName((Class)fieldType): fieldType.toString())+ " "
+ getTypeName(getDeclaringClass()) + "."
+ getName());
|
| public java.lang.String | toString()Returns a string describing this 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:
public static final int java.lang.Thread.MIN_PRIORITY
private int java.io.FileDescriptor.fd
The modifiers are placed in canonical order as specified by
"The Java Language Specification". This is public,
protected or private first, and then other
modifiers in the following order: static, final,
transient, volatile.
int mod = getModifiers();
return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
+ getTypeName(getType()) + " "
+ getTypeName(getDeclaringClass()) + "."
+ getName());
|
