diff options
Diffstat (limited to 'awt/java/beans/PropertyDescriptor.java')
| -rw-r--r-- | awt/java/beans/PropertyDescriptor.java | 300 |
1 files changed, 300 insertions, 0 deletions
diff --git a/awt/java/beans/PropertyDescriptor.java b/awt/java/beans/PropertyDescriptor.java new file mode 100644 index 0000000..9389152 --- /dev/null +++ b/awt/java/beans/PropertyDescriptor.java @@ -0,0 +1,300 @@ +/* + * 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. + */ + +package java.beans; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.Vector; +import org.apache.harmony.beans.internal.nls.Messages; + +public class PropertyDescriptor extends FeatureDescriptor { + private Method getter; + + private Method setter; + + private Class<?> propertyEditorClass; + + private boolean constrained; + + private boolean bound; + + public PropertyDescriptor(String propertyName, Class<?> beanClass, String getterName, + String setterName) throws IntrospectionException { + super(); + if (beanClass == null) { + throw new IntrospectionException(Messages.getString("beans.03")); //$NON-NLS-1$ + } + if (propertyName == null || propertyName.length() == 0) { + throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$ + } + this.setName(propertyName); + this.setDisplayName(propertyName); + if (setterName != null) { + if (hasMethod(beanClass, setterName)) { + setWriteMethod(beanClass, setterName); + } else { + throw new IntrospectionException(Messages.getString("beans.20")); //$NON-NLS-1$ + } + } + if (getterName != null) { + if (hasMethod(beanClass, getterName)) { + setReadMethod(beanClass, getterName); + } else { + throw new IntrospectionException(Messages.getString("beans.1F")); //$NON-NLS-1$ + } + } + } + + public PropertyDescriptor(String propertyName, Method getter, Method setter) + throws IntrospectionException { + super(); + if (propertyName == null || propertyName.length() == 0) { + throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$ + } + this.setName(propertyName); + this.setDisplayName(propertyName); + setWriteMethod(setter); + setReadMethod(getter); + } + + public PropertyDescriptor(String propertyName, Class<?> beanClass) + throws IntrospectionException { + String getterName; + String setterName; + if (beanClass == null) { + throw new IntrospectionException(Messages.getString("beans.03")); //$NON-NLS-1$ + } + if (propertyName == null || propertyName.length() == 0) { + throw new IntrospectionException(Messages.getString("beans.04")); //$NON-NLS-1$ + } + this.setName(propertyName); + this.setDisplayName(propertyName); + getterName = createDefaultMethodName(propertyName, "is"); //$NON-NLS-1$ + if (hasMethod(beanClass, getterName)) { + setReadMethod(beanClass, getterName); + } else { + getterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$ + if (hasMethod(beanClass, getterName)) { + setReadMethod(beanClass, getterName); + } + } + setterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$ + if (hasMethod(beanClass, setterName)) { + setWriteMethod(beanClass, setterName); + } + if (getter == null && setter == null) { + throw new IntrospectionException(Messages.getString("beans.01", propertyName)); //$NON-NLS-1$ + } + } + + public void setWriteMethod(Method setter) throws IntrospectionException { + if (setter != null) { + int modifiers = setter.getModifiers(); + if (!Modifier.isPublic(modifiers)) { + throw new IntrospectionException(Messages.getString("beans.05")); //$NON-NLS-1$ + } + Class<?>[] parameterTypes = setter.getParameterTypes(); + if (parameterTypes.length != 1) { + throw new IntrospectionException(Messages.getString("beans.06")); //$NON-NLS-1$ + } + Class<?> parameterType = parameterTypes[0]; + Class<?> propertyType = getPropertyType(); + if (propertyType != null && !propertyType.equals(parameterType)) { + throw new IntrospectionException(Messages.getString("beans.07")); //$NON-NLS-1$ + } + } + this.setter = setter; + } + + public void setReadMethod(Method getter) throws IntrospectionException { + if (getter != null) { + int modifiers = getter.getModifiers(); + if (!Modifier.isPublic(modifiers)) { + throw new IntrospectionException(Messages.getString("beans.0A")); //$NON-NLS-1$ + } + Class<?>[] parameterTypes = getter.getParameterTypes(); + if (parameterTypes.length != 0) { + throw new IntrospectionException(Messages.getString("beans.08")); //$NON-NLS-1$ + } + Class<?> returnType = getter.getReturnType(); + if (returnType.equals(Void.TYPE)) { + throw new IntrospectionException(Messages.getString("beans.33")); //$NON-NLS-1$ + } + Class<?> propertyType = getPropertyType(); + if ((propertyType != null) && !returnType.equals(propertyType)) { + throw new IntrospectionException(Messages.getString("beans.09")); //$NON-NLS-1$ + } + } + this.getter = getter; + } + + public Method getWriteMethod() { + return setter; + } + + public Method getReadMethod() { + return getter; + } + + @Override + public boolean equals(Object object) { + boolean result = (object != null && object instanceof PropertyDescriptor); + if (result) { + PropertyDescriptor pd = (PropertyDescriptor) object; + boolean gettersAreEqual = (this.getter == null) && (pd.getReadMethod() == null) + || (this.getter != null) && (this.getter.equals(pd.getReadMethod())); + boolean settersAreEqual = (this.setter == null) && (pd.getWriteMethod() == null) + || (this.setter != null) && (this.setter.equals(pd.getWriteMethod())); + boolean propertyTypesAreEqual = this.getPropertyType() == pd.getPropertyType(); + boolean propertyEditorClassesAreEqual = this.getPropertyEditorClass() == pd + .getPropertyEditorClass(); + boolean boundPropertyAreEqual = this.isBound() == pd.isBound(); + boolean constrainedPropertyAreEqual = this.isConstrained() == pd.isConstrained(); + result = gettersAreEqual && settersAreEqual && propertyTypesAreEqual + && propertyEditorClassesAreEqual && boundPropertyAreEqual + && constrainedPropertyAreEqual; + } + return result; + } + + public void setPropertyEditorClass(Class<?> propertyEditorClass) { + this.propertyEditorClass = propertyEditorClass; + } + + public Class<?> getPropertyType() { + Class<?> result = null; + if (getter != null) { + result = getter.getReturnType(); + } else if (setter != null) { + Class<?>[] parameterTypes = setter.getParameterTypes(); + result = parameterTypes[0]; + } + return result; + } + + public Class<?> getPropertyEditorClass() { + return propertyEditorClass; + } + + public void setConstrained(boolean constrained) { + this.constrained = constrained; + } + + public void setBound(boolean bound) { + this.bound = bound; + } + + public boolean isConstrained() { + return constrained; + } + + public boolean isBound() { + return bound; + } + + boolean hasMethod(Class<?> beanClass, String methodName) { + Method[] methods = findMethods(beanClass, methodName); + return (methods.length > 0); + } + + String createDefaultMethodName(String propertyName, String prefix) { + String result = null; + if (propertyName != null) { + String bos = propertyName.substring(0, 1).toUpperCase(); + String eos = propertyName.substring(1, propertyName.length()); + result = prefix + bos + eos; + } + return result; + } + + Method[] findMethods(Class<?> aClass, String methodName) { + Method[] allMethods = aClass.getMethods(); + Vector<Method> matchedMethods = new Vector<Method>(); + Method[] result; + for (Method method : allMethods) { + if (method.getName().equals(methodName)) { + matchedMethods.add(method); + } + } + result = new Method[matchedMethods.size()]; + for (int j = 0; j < matchedMethods.size(); ++j) { + result[j] = matchedMethods.elementAt(j); + } + return result; + } + + void setReadMethod(Class<?> beanClass, String getterName) { + boolean result = false; + Method[] getters = findMethods(beanClass, getterName); + for (Method element : getters) { + try { + setReadMethod(element); + result = true; + } catch (IntrospectionException ie) { + } + if (result) { + break; + } + } + } + + void setWriteMethod(Class<?> beanClass, String setterName) throws IntrospectionException { + boolean result = false; + Method[] setters = findMethods(beanClass, setterName); + for (Method element : setters) { + try { + setWriteMethod(element); + result = true; + } catch (IntrospectionException ie) { + } + if (result) { + break; + } + } + } + + public PropertyEditor createPropertyEditor(Object bean) { + PropertyEditor editor; + if (propertyEditorClass == null) { + return null; + } + if (!PropertyEditor.class.isAssignableFrom(propertyEditorClass)) { + // beans.48=Property editor is not assignable from the + // PropertyEditor interface + throw new ClassCastException(Messages.getString("beans.48")); //$NON-NLS-1$ + } + try { + Constructor<?> constr; + try { + // try to look for the constructor with single Object argument + constr = propertyEditorClass.getConstructor(Object.class); + editor = (PropertyEditor) constr.newInstance(bean); + } catch (NoSuchMethodException e) { + // try no-argument constructor + constr = propertyEditorClass.getConstructor(); + editor = (PropertyEditor) constr.newInstance(); + } + } catch (Exception e) { + // beans.47=Unable to instantiate property editor + RuntimeException re = new RuntimeException(Messages.getString("beans.47"), e); //$NON-NLS-1$ + throw re; + } + return editor; + } +} |