diff options
Diffstat (limited to 'awt/java/beans/IndexedPropertyDescriptor.java')
| -rw-r--r-- | awt/java/beans/IndexedPropertyDescriptor.java | 227 |
1 files changed, 227 insertions, 0 deletions
diff --git a/awt/java/beans/IndexedPropertyDescriptor.java b/awt/java/beans/IndexedPropertyDescriptor.java new file mode 100644 index 0000000..25667d9 --- /dev/null +++ b/awt/java/beans/IndexedPropertyDescriptor.java @@ -0,0 +1,227 @@ +/* + * 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.Method; +import java.lang.reflect.Modifier; +import org.apache.harmony.beans.internal.nls.Messages; + +public class IndexedPropertyDescriptor extends PropertyDescriptor { + private Method indexedGetter; + + private Method indexedSetter; + + public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass, + String getterName, String setterName, String indexedGetterName, + String indexedSetterName) throws IntrospectionException { + super(propertyName, beanClass, getterName, setterName); + + // RI behaves like this + if (indexedGetterName == null && indexedSetterName == null && + (getterName != null || setterName != null)) { + throw new IntrospectionException(Messages.getString("beans.50")); + } + setIndexedReadMethod(beanClass, indexedGetterName); + setIndexedWriteMethod(beanClass, indexedSetterName); + } + + public IndexedPropertyDescriptor(String propertyName, Method getter, Method setter, + Method indexedGetter, Method indexedSetter) throws IntrospectionException { + super(propertyName, getter, setter); + + // we need this in order to be compatible with RI + if (indexedGetter == null && indexedSetter == null && + (getter != null || setter != null)) { + throw new IntrospectionException(Messages.getString("beans.50")); + } + setIndexedReadMethod(indexedGetter); + setIndexedWriteMethod(indexedSetter); + } + + public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass) + throws IntrospectionException { + super(propertyName, beanClass, null, null); + String getterName; + String setterName; + String indexedGetterName; + String indexedSetterName; + + // array getter + getterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$ + if (hasMethod(beanClass, getterName)) { + setReadMethod(beanClass, getterName); + } + // array setter + setterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$ + if (hasMethod(beanClass, setterName)) { + setWriteMethod(beanClass, setterName); + } + // indexed getter + indexedGetterName = createDefaultMethodName(propertyName, "get"); //$NON-NLS-1$ + if (hasMethod(beanClass, indexedGetterName)) { + setIndexedReadMethod(beanClass, indexedGetterName); + } + // indexed setter + indexedSetterName = createDefaultMethodName(propertyName, "set"); //$NON-NLS-1$ + if (hasMethod(beanClass, indexedSetterName)) { + setIndexedWriteMethod(beanClass, indexedSetterName); + } + // RI seems to behave a bit differently + if (indexedGetter == null && indexedSetter == null && + getReadMethod() == null && getWriteMethod() == null) { + throw new IntrospectionException( + Messages.getString("beans.01", propertyName)); //$NON-NLS-1$ + } + if (indexedGetter == null && indexedSetter == null) { + // not an indexed property indeed + throw new IntrospectionException(Messages.getString("beans.50")); + } + } + + public void setIndexedReadMethod(Method indexedGetter) throws IntrospectionException { + if (indexedGetter != null) { + int modifiers = indexedGetter.getModifiers(); + Class<?>[] parameterTypes; + Class<?> returnType; + Class<?> indexedPropertyType; + + if (!Modifier.isPublic(modifiers)) { + throw new IntrospectionException(Messages.getString("beans.21")); //$NON-NLS-1$ + } + parameterTypes = indexedGetter.getParameterTypes(); + if (parameterTypes.length != 1) { + throw new IntrospectionException(Messages.getString("beans.22")); //$NON-NLS-1$ + } + if (!parameterTypes[0].equals(int.class)) { + throw new IntrospectionException(Messages.getString("beans.23")); //$NON-NLS-1$ + } + returnType = indexedGetter.getReturnType(); + indexedPropertyType = getIndexedPropertyType(); + if ((indexedPropertyType != null) && !returnType.equals(indexedPropertyType)) { + throw new IntrospectionException(Messages.getString("beans.24")); //$NON-NLS-1$ + } + } + this.indexedGetter = indexedGetter; + } + + public void setIndexedWriteMethod(Method indexedSetter) throws IntrospectionException { + if (indexedSetter != null) { + int modifiers = indexedSetter.getModifiers(); + Class<?>[] parameterTypes; + Class<?> firstParameterType; + Class<?> secondParameterType; + Class<?> propType; + + if (!Modifier.isPublic(modifiers)) { + throw new IntrospectionException(Messages.getString("beans.25")); //$NON-NLS-1$ + } + parameterTypes = indexedSetter.getParameterTypes(); + if (parameterTypes.length != 2) { + throw new IntrospectionException(Messages.getString("beans.26")); //$NON-NLS-1$ + } + firstParameterType = parameterTypes[0]; + if (!firstParameterType.equals(int.class)) { + throw new IntrospectionException(Messages.getString("beans.27")); //$NON-NLS-1$ + } + secondParameterType = parameterTypes[1]; + propType = getIndexedPropertyType(); + if (propType != null && !secondParameterType.equals(propType)) { + throw new IntrospectionException(Messages.getString("beans.28")); //$NON-NLS-1$ + } + } + this.indexedSetter = indexedSetter; + } + + public Method getIndexedWriteMethod() { + return indexedSetter; + } + + public Method getIndexedReadMethod() { + return indexedGetter; + } + + @Override + public boolean equals(Object obj) { + boolean result = super.equals(obj); + + if (result) { + IndexedPropertyDescriptor pd = (IndexedPropertyDescriptor) obj; + + if (indexedGetter != null) { + result = indexedGetter.equals(pd.getIndexedReadMethod()); + } else if (result && indexedGetter == null) { + result = pd.getIndexedReadMethod() == null; + } + + if (result) { + if (indexedSetter != null) { + result = indexedSetter.equals(pd.getIndexedWriteMethod()); + } else if (indexedSetter == null) { + result = pd.getIndexedWriteMethod() == null; + } + } + } + + return result; + } + + public Class<?> getIndexedPropertyType() { + Class<?> result = null; + + if (indexedGetter != null) { + result = indexedGetter.getReturnType(); + } else if (indexedSetter != null) { + Class<?>[] parameterTypes = indexedSetter.getParameterTypes(); + + result = parameterTypes[1]; + } + return result; + } + + private void setIndexedReadMethod(Class<?> beanClass, String indexedGetterName) { + Method[] getters = findMethods(beanClass, indexedGetterName); + boolean result = false; + + for (Method element : getters) { + try { + setIndexedReadMethod(element); + result = true; + } catch (IntrospectionException ie) {} + + if (result) { + break; + } + } + } + + private void setIndexedWriteMethod(Class<?> beanClass, String indexedSetterName) { + Method[] setters = findMethods(beanClass, indexedSetterName); + boolean result = false; + + for (Method element : setters) { + try { + setIndexedWriteMethod(element); + result = true; + } catch (IntrospectionException ie) {} + + if (result) { + break; + } + } + } +} |