An IndexedPropertyDescriptor describes a property that acts like an
array and has an indexed read and/or indexed write method to access
specific elements of the array.
An indexed property may also provide simple non-indexed read and write
methods. If these are present, they read and write arrays of the type
returned by the indexed read method.
| Constructor: |
|---|
 IndexedPropertyDescriptor(IndexedPropertyDescriptor old) {
super(old);
indexedReadMethodRef = old.indexedReadMethodRef;
indexedWriteMethodRef = old.indexedWriteMethodRef;
indexedPropertyTypeRef = old.indexedPropertyTypeRef;
indexedWriteMethodName = old.indexedWriteMethodName;
indexedReadMethodName = old.indexedReadMethodName;
}
|
public IndexedPropertyDescriptor(String propertyName,
Class<?> beanClass) throws IntrospectionException {
this(propertyName, beanClass,
Introspector.GET_PREFIX + NameGenerator.capitalize(propertyName),
Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName),
Introspector.GET_PREFIX + NameGenerator.capitalize(propertyName),
Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName));
} This constructor constructs an IndexedPropertyDescriptor for a property
that follows the standard Java conventions by having getFoo and setFoo
accessor methods, for both indexed access and array access.
Thus if the argument name is "fred", it will assume that there
is an indexed reader method "getFred", a non-indexed (array) reader
method also called "getFred", an indexed writer method "setFred",
and finally a non-indexed writer method "setFred". Parameters:
propertyName - The programmatic name of the property.
beanClass - The Class object for the target bean.
IntrospectionException - if an exception occurs during
introspection.
- exception:
IntrospectionException - if an exception occurs during
introspection.
|
IndexedPropertyDescriptor(PropertyDescriptor x,
PropertyDescriptor y) {
super(x,y);
if (x instanceof IndexedPropertyDescriptor) {
IndexedPropertyDescriptor ix = (IndexedPropertyDescriptor)x;
try {
Method xr = ix.getIndexedReadMethod();
if (xr != null) {
setIndexedReadMethod(xr);
}
Method xw = ix.getIndexedWriteMethod();
if (xw != null) {
setIndexedWriteMethod(xw);
}
} catch (IntrospectionException ex) {
// Should not happen
throw new AssertionError(ex);
}
}
if (y instanceof IndexedPropertyDescriptor) {
IndexedPropertyDescriptor iy = (IndexedPropertyDescriptor)y;
try {
Method yr = iy.getIndexedReadMethod();
if (yr != null && yr.getDeclaringClass() == getClass0()) {
setIndexedReadMethod(yr);
}
Method yw = iy.getIndexedWriteMethod();
if (yw != null && yw.getDeclaringClass() == getClass0()) {
setIndexedWriteMethod(yw);
}
} catch (IntrospectionException ex) {
// Should not happen
throw new AssertionError(ex);
}
}
} Package-private constructor.
Merge two property descriptors. Where they conflict, give the
second argument (y) priority over the first argumnnt (x). Parameters:
x - The first (lower priority) PropertyDescriptor
y - The second (higher priority) PropertyDescriptor
|
public IndexedPropertyDescriptor(String propertyName,
Method readMethod,
Method writeMethod,
Method indexedReadMethod,
Method indexedWriteMethod) throws IntrospectionException {
super(propertyName, readMethod, writeMethod);
setIndexedReadMethod0(indexedReadMethod);
setIndexedWriteMethod0(indexedWriteMethod);
// Type checking
setIndexedPropertyType(findIndexedPropertyType(indexedReadMethod, indexedWriteMethod));
} This constructor takes the name of a simple property, and Method
objects for reading and writing the property. Parameters:
propertyName - The programmatic name of the property.
readMethod - The method used for reading the property values as an array.
May be null if the property is write-only or must be indexed.
writeMethod - The method used for writing the property values as an array.
May be null if the property is read-only or must be indexed.
indexedReadMethod - The method used for reading an indexed property value.
May be null if the property is write-only.
indexedWriteMethod - The method used for writing an indexed property value.
May be null if the property is read-only.
IntrospectionException - if an exception occurs during
introspection.
- exception:
IntrospectionException - if an exception occurs during
introspection.
|
public IndexedPropertyDescriptor(String propertyName,
Class<?> beanClass,
String readMethodName,
String writeMethodName,
String indexedReadMethodName,
String indexedWriteMethodName) throws IntrospectionException {
super(propertyName, beanClass, readMethodName, writeMethodName);
this.indexedReadMethodName = indexedReadMethodName;
if (indexedReadMethodName != null && getIndexedReadMethod() == null) {
throw new IntrospectionException("Method not found: " + indexedReadMethodName);
}
this.indexedWriteMethodName = indexedWriteMethodName;
if (indexedWriteMethodName != null && getIndexedWriteMethod() == null) {
throw new IntrospectionException("Method not found: " + indexedWriteMethodName);
}
// Implemented only for type checking.
findIndexedPropertyType(getIndexedReadMethod(), getIndexedWriteMethod());
} This constructor takes the name of a simple property, and method
names for reading and writing the property, both indexed
and non-indexed. Parameters:
propertyName - The programmatic name of the property.
beanClass - The Class object for the target bean.
readMethodName - The name of the method used for reading the property
values as an array. May be null if the property is write-only
or must be indexed.
writeMethodName - The name of the method used for writing the property
values as an array. May be null if the property is read-only
or must be indexed.
indexedReadMethodName - The name of the method used for reading
an indexed property value.
May be null if the property is write-only.
indexedWriteMethodName - The name of the method used for writing
an indexed property value.
May be null if the property is read-only.
IntrospectionException - if an exception occurs during
introspection.
- exception:
IntrospectionException - if an exception occurs during
introspection.
|
IndexedPropertyDescriptor(Class<?> bean,
String base,
Method read,
Method write,
Method readIndexed,
Method writeIndexed) throws IntrospectionException {
super(bean, base, read, write);
setIndexedReadMethod0(readIndexed);
setIndexedWriteMethod0(writeIndexed);
// Type checking
setIndexedPropertyType(findIndexedPropertyType(readIndexed, writeIndexed));
} Creates PropertyDescriptor for the specified bean
with the specified name and methods to read/write the property value. Parameters:
bean - the type of the target bean
base - the base name of the property (the rest of the method name)
read - the method used for reading the property value
write - the method used for writing the property value
readIndexed - the method used for reading an indexed property value
writeIndexed - the method used for writing an indexed property value
IntrospectionException - if an exception occurs during introspection
- exception:
IntrospectionException - if an exception occurs during introspection
- since:
1.7 -
|
| Method from java.beans.IndexedPropertyDescriptor Detail: |
|---|
void appendTo(StringBuilder sb) {
super.appendTo(sb);
appendTo(sb, "indexedPropertyType", this.indexedPropertyTypeRef);
appendTo(sb, "indexedReadMethod", this.indexedReadMethodRef);
appendTo(sb, "indexedWriteMethod", this.indexedWriteMethodRef);
} |
public boolean equals(Object obj) {
// Note: This would be identical to PropertyDescriptor but they don't
// share the same fields.
if (this == obj) {
return true;
}
if (obj != null && obj instanceof IndexedPropertyDescriptor) {
IndexedPropertyDescriptor other = (IndexedPropertyDescriptor)obj;
Method otherIndexedReadMethod = other.getIndexedReadMethod();
Method otherIndexedWriteMethod = other.getIndexedWriteMethod();
if (!compareMethods(getIndexedReadMethod(), otherIndexedReadMethod)) {
return false;
}
if (!compareMethods(getIndexedWriteMethod(), otherIndexedWriteMethod)) {
return false;
}
if (getIndexedPropertyType() != other.getIndexedPropertyType()) {
return false;
}
return super.equals(obj);
}
return false;
} Compares this PropertyDescriptor against the specified object.
Returns true if the objects are the same. Two PropertyDescriptors
are the same if the read, write, property types, property editor and
flags are equivalent. |
public synchronized Class<?> getIndexedPropertyType() {
Class type = getIndexedPropertyType0();
if (type == null) {
try {
type = findIndexedPropertyType(getIndexedReadMethod(),
getIndexedWriteMethod());
setIndexedPropertyType(type);
} catch (IntrospectionException ex) {
// fall
}
}
return type;
} Returns the Java type info for the indexed property.
Note that the {@code Class} object may describe
primitive Java types such as {@code int}.
This type is returned by the indexed read method
or is used as the parameter type of the indexed write method. |
public synchronized Method getIndexedReadMethod() {
Method indexedReadMethod = getIndexedReadMethod0();
if (indexedReadMethod == null) {
Class cls = getClass0();
if (cls == null ||
(indexedReadMethodName == null && indexedReadMethodRef == null)) {
// the Indexed readMethod was explicitly set to null.
return null;
}
if (indexedReadMethodName == null) {
Class type = getIndexedPropertyType0();
if (type == boolean.class || type == null) {
indexedReadMethodName = Introspector.IS_PREFIX + getBaseName();
} else {
indexedReadMethodName = Introspector.GET_PREFIX + getBaseName();
}
}
Class[] args = { int.class };
indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
if (indexedReadMethod == null) {
// no "is" method, so look for a "get" method.
indexedReadMethodName = Introspector.GET_PREFIX + getBaseName();
indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
}
setIndexedReadMethod0(indexedReadMethod);
}
return indexedReadMethod;
} Gets the method that should be used to read an indexed
property value. |
public synchronized Method getIndexedWriteMethod() {
Method indexedWriteMethod = getIndexedWriteMethod0();
if (indexedWriteMethod == null) {
Class cls = getClass0();
if (cls == null ||
(indexedWriteMethodName == null && indexedWriteMethodRef == null)) {
// the Indexed writeMethod was explicitly set to null.
return null;
}
// We need the indexed type to ensure that we get the correct method.
// Cannot use the getIndexedPropertyType method since that could
// result in an infinite loop.
Class type = getIndexedPropertyType0();
if (type == null) {
try {
type = findIndexedPropertyType(getIndexedReadMethod(), null);
setIndexedPropertyType(type);
} catch (IntrospectionException ex) {
// Set iprop type to be the classic type
Class propType = getPropertyType();
if (propType.isArray()) {
type = propType.getComponentType();
}
}
}
if (indexedWriteMethodName == null) {
indexedWriteMethodName = Introspector.SET_PREFIX + getBaseName();
}
Class[] args = (type == null) ? null : new Class[] { int.class, type };
indexedWriteMethod = Introspector.findMethod(cls, indexedWriteMethodName, 2, args);
if (indexedWriteMethod != null) {
if (!indexedWriteMethod.getReturnType().equals(void.class)) {
indexedWriteMethod = null;
}
}
setIndexedWriteMethod0(indexedWriteMethod);
}
return indexedWriteMethod;
} Gets the method that should be used to write an indexed property value. |
public int hashCode() {
int result = super.hashCode();
result = 37 * result + ((indexedWriteMethodName == null) ? 0 :
indexedWriteMethodName.hashCode());
result = 37 * result + ((indexedReadMethodName == null) ? 0 :
indexedReadMethodName.hashCode());
result = 37 * result + ((getIndexedPropertyType() == null) ? 0 :
getIndexedPropertyType().hashCode());
return result;
} |
public synchronized void setIndexedReadMethod(Method readMethod) throws IntrospectionException {
// the indexed property type is set by the reader.
setIndexedPropertyType(findIndexedPropertyType(readMethod,
getIndexedWriteMethod0()));
setIndexedReadMethod0(readMethod);
} Sets the method that should be used to read an indexed property value. |
public synchronized void setIndexedWriteMethod(Method writeMethod) throws IntrospectionException {
// If the indexed property type has not been set, then set it.
Class type = findIndexedPropertyType(getIndexedReadMethod(),
writeMethod);
setIndexedPropertyType(type);
setIndexedWriteMethod0(writeMethod);
} Sets the method that should be used to write an indexed property value. |
java.beans.FeatureDescriptor