void updateGenericsFor(Class<?> type) {
setClass0(type);
try {
setPropertyType(findPropertyType(this.readMethodRef.get(), this.writeMethodRef.get()));
} catch (IntrospectionException exception) {
setPropertyType(null);
}
}
/**
* Gets the Class object for the property.
*
* @return The Java type info for the property. Note that the "Class" object may describe a
* built-in Java type such as "int". The result may be "null" if this is an indexed property
* that does not support non-indexed access.
* <p>This is the type that will be returned by the ReadMethod.
*/
public synchronized Class<?> getPropertyType() {
Class type = getPropertyType0();
if (type == null) {
try {
type = findPropertyType(getReadMethod(), getWriteMethod());
setPropertyType(type);
} catch (IntrospectionException ex) {
// Fall
}
}
return type;
}
/**
* Sets the method that should be used to write the property value.
*
* @param writeMethod The new write method.
*/
public synchronized void setWriteMethod(Method writeMethod) throws IntrospectionException {
if (writeMethod == null) {
writeMethodName = null;
writeMethodRef = null;
return;
}
// Set the property type - which validates the method
setPropertyType(findPropertyType(getReadMethod(), writeMethod));
setClass0(writeMethod.getDeclaringClass());
writeMethodName = writeMethod.getName();
writeMethodRef = createReference(writeMethod, true);
}
/**
* Sets the method that should be used to read the property value.
*
* @param readMethod The new read method.
*/
public synchronized void setReadMethod(Method readMethod) throws IntrospectionException {
if (readMethod == null) {
readMethodName = null;
readMethodRef = null;
return;
}
// The property type is determined by the read method.
setPropertyType(findPropertyType(readMethod, getWriteMethod0()));
setClass0(readMethod.getDeclaringClass());
readMethodName = readMethod.getName();
readMethodRef = createReference(readMethod, true);
}
/**
* Sets the method that should be used to write the property value.
*
* @param writeMethod The new write method.
* @throws IntrospectionException if the write method is invalid
*/
public synchronized void setWriteMethod(@Nullable Method writeMethod)
throws IntrospectionException {
this.writeMethodRef.set(writeMethod);
if (writeMethod == null) {
writeMethodName = null;
return;
}
// Set the property type - which validates the method
setPropertyType(findPropertyType(getReadMethod(), writeMethod));
setClass0(writeMethod.getDeclaringClass());
writeMethodName = writeMethod.getName();
setTransient(writeMethod.getAnnotation(Transient.class));
}
/**
* Sets the method that should be used to read the property value.
*
* @param readMethod The new read method.
* @throws IntrospectionException if the read method is invalid
*/
public synchronized void setReadMethod(@Nullable Method readMethod)
throws IntrospectionException {
this.readMethodRef.set(readMethod);
if (readMethod == null) {
readMethodName = null;
return;
}
// The property type is determined by the read method.
setPropertyType(findPropertyType(readMethod, this.writeMethodRef.get()));
setClass0(readMethod.getDeclaringClass());
readMethodName = readMethod.getName();
setTransient(readMethod.getAnnotation(Transient.class));
}
/**
* Gets the method that should be used to write the property value.
*
* @return The method that should be used to write the property value. May return null if the
* property can't be written.
*/
@Pure
public synchronized @Nullable Method getWriteMethod() {
Method writeMethod = this.writeMethodRef.get();
if (writeMethod == null) {
Class<?> cls = getClass0();
if (cls == null || (writeMethodName == null && !this.writeMethodRef.isSet())) {
// The write method was explicitly set to null.
return null;
}
// We need the type to fetch the correct method.
Class<?> type = getPropertyType0();
if (type == null) {
try {
// Can't use getPropertyType since it will lead to recursive loop.
type = findPropertyType(getReadMethod(), null);
setPropertyType(type);
} catch (IntrospectionException ex) {
// Without the correct property type we can't be guaranteed
// to find the correct method.
return null;
}
}
if (writeMethodName == null) {
writeMethodName = Introspector.SET_PREFIX + getBaseName();
}
Class<?>[] args = (type == null) ? null : new Class<?>[] {type};
writeMethod = Introspector.findMethod(cls, writeMethodName, 1, args);
if (writeMethod != null) {
if (!writeMethod.getReturnType().equals(void.class)) {
writeMethod = null;
}
}
try {
setWriteMethod(writeMethod);
} catch (IntrospectionException ex) {
// fall through
}
}
return writeMethod;
}
/**
* Gets the method that should be used to write the property value.
*
* @return The method that should be used to write the property value. May return null if the
* property can't be written.
*/
public synchronized Method getWriteMethod() {
Method writeMethod = getWriteMethod0();
if (writeMethod == null) {
Class cls = getClass0();
if (cls == null || (writeMethodName == null && writeMethodRef == null)) {
// The write method was explicitly set to null.
return null;
}
// We need the type to fetch the correct method.
Class type = getPropertyType0();
if (type == null) {
try {
// Can't use getPropertyType since it will lead to recursive loop.
type = findPropertyType(getReadMethod(), null);
setPropertyType(type);
} catch (IntrospectionException ex) {
// Without the correct property type we can't be guaranteed
// to find the correct method.
return null;
}
}
if (writeMethodName == null) {
writeMethodName = "set" + getBaseName();
}
writeMethod =
Introspector.findMethod(
cls, writeMethodName, 1, (type == null) ? null : new Class[] {type});
try {
setWriteMethod(writeMethod);
} catch (IntrospectionException ex) {
// fall through
}
}
return writeMethod;
}
/**
* Creates {@code PropertyDescriptor} from the specified property info.
*
* @param entry the pair of values, where the {@code key} is the base name of the property (the
* rest of the method name) and the {@code value} is the automatically generated property info
* @param bound the flag indicating whether it is possible to treat this property as a bound
* property
* @since 9
*/
PropertyDescriptor(Entry<String, PropertyInfo> entry, boolean bound) {
String base = entry.getKey();
PropertyInfo info = entry.getValue();
setName(Introspector.decapitalize(base));
setReadMethod0(info.getReadMethod());
setWriteMethod0(info.getWriteMethod());
setPropertyType(info.getPropertyType());
setConstrained(info.isConstrained());
setBound(bound && info.is(PropertyInfo.Name.bound));
boolean isExpert = info.is(PropertyInfo.Name.expert);
setValue(PropertyInfo.Name.expert.name(), isExpert); // compatibility
setExpert(isExpert);
boolean isHidden = info.is(PropertyInfo.Name.hidden);
setValue(PropertyInfo.Name.hidden.name(), isHidden); // compatibility
setHidden(isHidden);
setPreferred(info.is(PropertyInfo.Name.preferred));
boolean isRequired = info.is(PropertyInfo.Name.required);
setValue(PropertyInfo.Name.required.name(), isRequired);
boolean visual = info.is(PropertyInfo.Name.visualUpdate);
setValue(PropertyInfo.Name.visualUpdate.name(), visual);
Object description = info.get(PropertyInfo.Name.description);
if (description != null) {
setShortDescription(description.toString());
}
Object values = info.get(PropertyInfo.Name.enumerationValues);
if (values != null) {
setValue(PropertyInfo.Name.enumerationValues.name(), values);
}
this.baseName = base;
}
/**
* Sets the method that should be used to write the property value.
*
* @param writeMethod The new write method.
* @throws IntrospectionException if the write method is invalid
* @since 1.2
*/
public synchronized void setWriteMethod(Method writeMethod) throws IntrospectionException {
// Set the property type - which validates the method
setPropertyType(findPropertyType(getReadMethod(), writeMethod));
setWriteMethod0(writeMethod);
}
/**
* Sets the method that should be used to read the property value.
*
* @param readMethod The new read method.
* @throws IntrospectionException if the read method is invalid
* @since 1.2
*/
public synchronized void setReadMethod(Method readMethod) throws IntrospectionException {
// The property type is determined by the read method.
setPropertyType(findPropertyType(readMethod, this.writeMethodRef.get()));
setReadMethod0(readMethod);
}