harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r387239 [4/21] - in /incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math: ./ Harmony/ doc/ doc/images/ make/ src/ src/common/ src/common/javasrc/ src/common/javasrc/java/ src/common/javasrc/java/applet/ src/common/javasrc/jav...
Date Mon, 20 Mar 2006 16:31:33 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/Introspector.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/Introspector.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/Introspector.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/Introspector.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,1066 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.23.6.3 $
+ */
+package java.beans;
+
+import java.awt.Image;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Vector;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.23.6.3 $
+ */
+
+public class Introspector {
+
+    public static final int USE_ALL_BEANINFO = 1;
+
+    public static final int IGNORE_IMMEDIATE_BEANINFO = 2;
+
+    public static final int IGNORE_ALL_BEANINFO = 3;
+    
+    private Introspector() {}
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static String decapitalize(String name) {
+        if((name != null) && (name.length() > 0)) {
+            // first two letters are capital
+            if((name.length() > 1) && name.substring(0,2).equals(
+                    name.substring(0,2).toUpperCase())) {
+                return name;
+            }
+            String result = name.substring(0,1).toLowerCase();
+            if(name.length() > 1) {
+                result += name.substring(1);
+            }
+            return result;
+           }
+        return name;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static BeanInfo getBeanInfo(Class beanClass, int flags)
+        throws IntrospectionException 
+    {
+        BeanInfo result = null;
+        if (flags == USE_ALL_BEANINFO) {
+            result = getBeanInfo(beanClass, null, false, false);    
+        } else if (flags == IGNORE_IMMEDIATE_BEANINFO) {
+            result = getBeanInfo(beanClass, null, true, false);    
+        } else if (flags == IGNORE_ALL_BEANINFO) {
+            result = getBeanInfo(beanClass, null, true, true);    
+        }
+        return result;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static BeanInfo getBeanInfo(Class beanClass)
+            throws IntrospectionException {
+        return getBeanInfo(beanClass, null, false, false);    
+    }
+    
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static BeanInfo getBeanInfo(Class beanClass, Class stopClass)
+       throws IntrospectionException
+    {
+        return getBeanInfo(beanClass, stopClass, false, false);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static synchronized void setBeanInfoSearchPath(String[] searchPath) {
+        if (searchPath != null) {
+            SecurityManager sm = System.getSecurityManager();
+            if (sm != null) {
+                sm.checkPropertiesAccess();
+            }
+            path = searchPath;
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static synchronized String[] getBeanInfoSearchPath() {
+        return path;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static void flushFromCaches(Class clz) {
+        removeBeanInfoClassFromCache(clz);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static void flushCaches() {
+        removeAllBeanInfoClassesFromCache();
+    }
+
+    // private methods
+
+    private static BeanInfoWrapper getBeanInfo(Class beanClass, Class stopClass,
+        boolean ignoreBeanClassBeanInfo, boolean ignoreSuperClassBeanInfo)
+    {
+        if (beanClass == null) {
+            return null;
+        }
+
+        BeanInfoWrapper beanInfoWrapper = findBeanInfoClassInCache(beanClass,
+                stopClass, ignoreBeanClassBeanInfo, ignoreSuperClassBeanInfo);
+
+        if (beanInfoWrapper != null) {
+            return beanInfoWrapper;
+        }
+
+        // find bean info as a separate class
+        
+        BeanInfo beanInfo = null;
+        if (!ignoreBeanClassBeanInfo) {
+            try {
+                Class beanInfoClass = findBeanInfoClass(beanClass);
+                if(beanInfoClass != null) {
+                    beanInfo = (BeanInfo) beanInfoClass.newInstance();
+                }
+            } catch (Exception e) {
+            }
+        }
+        
+        //...
+        
+        // generate bean info automatically
+        
+        BeanInfoImpl beanInfoImpl = new BeanInfoImpl(beanClass);
+        
+        //...
+        
+        BeanInfoWrapper wrapper = new BeanInfoWrapper(beanInfo, beanInfoImpl);
+    
+        Class parent = beanClass.getSuperclass();
+        if ((parent != null) && (parent != stopClass)) {
+            BeanInfoWrapper parentBeanInfo = getBeanInfo(parent, stopClass,
+                ignoreSuperClassBeanInfo, ignoreSuperClassBeanInfo);
+            
+            wrapper.merge(parentBeanInfo);
+        }
+        
+        //...
+        
+        storeBeanInfoClassInCache(wrapper, beanClass, stopClass,
+            ignoreBeanClassBeanInfo, ignoreSuperClassBeanInfo);
+        
+        return wrapper;
+    }
+
+    private static Class findBeanInfoClass(Class beanClass) {
+        Object result = null;
+
+        String beanClassName = beanClass.getName();
+        int idx = beanClassName.lastIndexOf(".");
+        String shortBeanInfoClassName = beanClassName.substring(idx + 1,
+            beanClassName.length()) + "BeanInfo";
+        String fullBeanInfoClassName = beanClassName + "BeanInfo";
+
+        Class beanInfoClass = null;
+        try {
+            beanInfoClass = Class.forName(
+                fullBeanInfoClassName, true, beanClass.getClassLoader());
+            
+        } catch (ClassNotFoundException cnfe) {
+            for (int i = 0; i < path.length; ++i) {
+                try {
+                    fullBeanInfoClassName = path[i] + "."
+                            + shortBeanInfoClassName;
+                    beanInfoClass = Class.forName(fullBeanInfoClassName, true,
+                            beanClass.getClassLoader());
+                    break;
+                } catch (ClassNotFoundException cnfe2) {
+                }
+            }
+        }
+        
+        return beanInfoClass;
+    }
+
+    private static BeanInfoWrapper findBeanInfoClassInCache(
+            Class beanClass,
+            Class stopClass,
+            boolean ignoreBeanClassBeanInfo,
+            boolean ignoreSuperClassBeanInfo) {
+        BeanInfoWrapper result = null;
+        ArrayList beanInfoDatas = (ArrayList) beanInfos.get(
+                beanClass.getName());
+        if (beanInfoDatas != null) {
+            Iterator iterator = beanInfoDatas.iterator();
+            while(iterator.hasNext()) {
+                BeanInfoData beanInfoData = (BeanInfoData) iterator.next();
+                if ((beanInfoData.getStopClass() == stopClass) &&
+                    (beanInfoData.getIgnoreBeanClassBeanInfo()
+                            ==  ignoreBeanClassBeanInfo)
+                    && (beanInfoData.getIgnoreSuperClassBeanInfo()
+                            ==  ignoreSuperClassBeanInfo))
+                {
+                    result = beanInfoData.getBeanInfoWrapper();
+                }
+                if (result != null) break;
+            }
+        }
+        return result;
+    }
+    
+    private static void storeBeanInfoClassInCache(
+            BeanInfoWrapper beanInfoWrapper,
+            Class beanClass,
+            Class stopClass,
+            boolean ignoreBeanClassBeanInfo,
+            boolean ignoreSuperClassBeanInfo) {
+        ArrayList beanInfoDatas = (ArrayList) beanInfos.get(
+                beanClass.getName());
+        if(beanInfoDatas == null) {
+            beanInfoDatas = new ArrayList();
+            beanInfos.put(beanClass.getName(), beanInfoDatas);
+        }
+        beanInfoDatas.add(new BeanInfoData(stopClass, ignoreBeanClassBeanInfo,
+            ignoreSuperClassBeanInfo, beanInfoWrapper));
+    }
+
+    private static void removeBeanInfoClassFromCache(Class beanClass) {
+        beanInfos.remove(beanClass.getName());
+    }
+
+    private static void removeAllBeanInfoClassesFromCache() {
+        beanInfos.clear();
+    }
+
+    // private fields
+
+    private static String[] path = {"sun.beans.infos"};
+    private static HashMap beanInfos = new HashMap();
+
+}
+
+class BeanInfoData {
+
+    private Class stopClass;
+    private boolean ignoreBeanClassBeanInfo;
+    private boolean ignoreSuperClassBeanInfo;
+    private BeanInfoWrapper beanInfoWrapper;
+
+    public BeanInfoData(BeanInfoWrapper beanInfo) {
+        this.stopClass = null;
+        this.ignoreBeanClassBeanInfo = false;
+        this.ignoreSuperClassBeanInfo = false;
+        this.beanInfoWrapper = beanInfo;
+    }
+
+    public BeanInfoData(Class stopClass, boolean ignoreBeanClassBeanInfo,
+        boolean ignoreSuperClassBeanInfo, BeanInfoWrapper beanInfoWrapper)
+    {
+        this.stopClass = stopClass;
+        this.ignoreBeanClassBeanInfo = ignoreBeanClassBeanInfo;
+        this.ignoreSuperClassBeanInfo = ignoreSuperClassBeanInfo;
+        this.beanInfoWrapper = beanInfoWrapper;
+    }
+
+    public Class getStopClass() {
+        return stopClass;
+    }
+
+    public boolean getIgnoreBeanClassBeanInfo() {
+        return ignoreBeanClassBeanInfo;
+    }
+
+    public boolean getIgnoreSuperClassBeanInfo() {
+        return ignoreSuperClassBeanInfo;
+    }
+
+    public BeanInfoWrapper getBeanInfoWrapper() {
+        return beanInfoWrapper;
+    }
+}
+
+class BeanInfoImpl implements BeanInfo {
+
+    private static int MT_OTHER = 0;
+    private static int MT_SETTER = 1;
+    private static int MT_GETTER = 2;
+    private static int MT_BOOLEAN_GETTER = 3;
+    private static int MT_INDEXED_SETTER = 4;
+    private static int MT_INDEXED_GETTER = 5;
+
+    public BeanInfoImpl(Class beanClass) {
+        this.beanClass = beanClass;
+    }
+
+    public PropertyDescriptor[] getPropertyDescriptors() {
+        if (propertyDescriptors == null) {
+            HashMap result = new HashMap();
+            
+            if (beanClass != null) {
+                ArrayList beanClassMethodsArrayList = getPublicMethods(
+                        beanClass);
+                
+                ArrayList setters = new ArrayList();
+                ArrayList getters = new ArrayList();
+                ArrayList booleanGetters = new ArrayList();
+                ArrayList indexedSetters = new ArrayList();
+                ArrayList indexedGetters = new ArrayList();
+                
+                Iterator iterator = beanClassMethodsArrayList.iterator();
+                while (iterator.hasNext()) {
+                    Method method = (Method) iterator.next();
+                    
+                    int methodType = getMethodType(method);
+                    if (methodType == MT_SETTER) {
+                        setters.add(method);
+                    } else if (methodType == MT_GETTER) {
+                        getters.add(method);
+                    } else if (methodType == MT_BOOLEAN_GETTER) {
+                        booleanGetters.add(method);
+                    } else if (methodType == MT_INDEXED_SETTER) {
+                        indexedSetters.add(method);
+                    } else if (methodType == MT_INDEXED_GETTER) {
+                        indexedGetters.add(method);
+                    }
+                }
+                try {
+                    addIndexedPropertyDescriptorsFromMethodList(result,
+                            indexedGetters, false);
+                    addIndexedPropertyDescriptorsFromMethodList(result,
+                            indexedSetters, true);
+                    addPropertyDescriptorsFromMethodList(result, booleanGetters,
+                            false);
+                    addPropertyDescriptorsFromMethodList(result, setters, true);
+                    addPropertyDescriptorsFromMethodList(result, getters, true);
+                } catch (Exception e) {
+                }
+                
+                Object[] values = result.values().toArray();
+                propertyDescriptors = new PropertyDescriptor[values.length];
+                for(int k = 0; k < propertyDescriptors.length; ++k) {
+                    propertyDescriptors[k] = (PropertyDescriptor) values[k];
+                }
+            }
+        }
+        
+        return propertyDescriptors;
+    }
+
+    public MethodDescriptor[] getMethodDescriptors() {
+        if(methodDescriptors == null) {
+            ArrayList result = new ArrayList();
+            ArrayList beanClassMethodsArrayList = getPublicMethods(beanClass);
+            
+            Iterator iterator = beanClassMethodsArrayList.iterator();
+            while (iterator.hasNext()) {
+                Method method = (Method) iterator.next();
+                result.add(new MethodDescriptor(method));
+            }
+            
+            methodDescriptors = new MethodDescriptor[result.size()];
+            for(int i = 0; i < methodDescriptors.length; ++i) {
+                methodDescriptors[i] = (MethodDescriptor) result.get(i);
+            }
+            
+        }
+        
+        return methodDescriptors;
+    }
+
+    public EventSetDescriptor[] getEventSetDescriptors() {
+        if(eventSetDescriptors == null) {
+            HashMap result = new HashMap();
+            ArrayList beanClassMethodsArrayList = getPublicMethods(beanClass);
+            
+            Iterator iterator = beanClassMethodsArrayList.iterator();
+            while(iterator.hasNext()) {
+                Method method = (Method) iterator.next();
+                String methodName = method.getName();
+                
+                String listenerName = null;
+                if(methodName.endsWith("Listener")) {
+                    listenerName = methodName.substring(0,
+                            methodName.lastIndexOf("Listener"));
+                    
+                    if(methodName.startsWith("add")) {
+                        listenerName = listenerName.substring(3);
+                    } else if(methodName.startsWith("remove")) {
+                        listenerName = listenerName.substring(6);
+                    } else {
+                        continue;
+                    }
+                    
+                    if(result.get(listenerName) == null) {
+                        Class[] parameterTypes = method.getParameterTypes();
+                        
+                        if(parameterTypes.length == 1) {
+                            Class listenerType = parameterTypes[0];
+                            
+                            // full and short names of classes
+                            String listenerTypeName = listenerType.getName();
+
+                            // check if the listener name extracted from param name and
+                            // listener name extracted from registration method are the same
+                            String listenerNameFromParam =
+                                listenerTypeName.substring(
+                                        listenerTypeName.lastIndexOf(".") + 1);
+                            
+                            String listenerNameFromMethod = listenerName
+                                    + "Listener";
+                            if(!listenerNameFromParam.equals(
+                                    listenerNameFromMethod)) {
+                                continue;
+                            }
+                            
+                            String eventTypeName = listenerTypeName.substring(0,
+                                    listenerTypeName.lastIndexOf(".") + 1)
+                                    + listenerName + "Event";
+                            
+                            // classes generated from classes names
+                            Class eventType = null;
+                            try {
+                                eventType = Class.forName(eventTypeName, true,
+                                        beanClass.getClassLoader());
+                            } catch (ClassNotFoundException cnfe) {
+                                System.out.println("Event type with name "
+                                        + eventTypeName + " is not found.");
+                            } finally {
+                                if(eventType == null) {
+                                    continue;
+                                }
+                            }
+                            
+                            Method[] methods = listenerType.getMethods();
+                            Vector listenerMethodsVec = new Vector();
+                            for(int i = 0; i < methods.length; ++i) {
+                                Class[] listenerMethodParams =
+                                    methods[i].getParameterTypes();
+                                if(listenerMethodParams.length == 1
+                                        && listenerMethodParams[0] == eventType) {
+                                    listenerMethodsVec.add(methods[i]);
+                                }
+                            }
+                            
+                            Method[] listenerMethods =
+                                    new Method[listenerMethodsVec.size()];
+                            Iterator iter = listenerMethodsVec.iterator();
+                            int idx2 = 0;
+                            while(iter.hasNext()) {
+                                listenerMethods[idx2] = (Method) iter.next();
+                                idx2++;
+                            }
+                            
+                            Method addListenerMethod = null;
+                            String addListenerMethodName = "add" + listenerName
+                                    + "Listener";
+                            try {
+                                addListenerMethod = beanClass.getMethod(
+                                    addListenerMethodName,
+                                    new Class[] { listenerType });
+                            } catch (NoSuchMethodException nsme) {
+                                // no adder found
+                                continue;
+                            }
+                            
+                            Method removeListenerMethod = null;
+                            String removeListenerMethodName = "remove"
+                                    + listenerName + "Listener";
+                            try {
+                                removeListenerMethod = beanClass.getMethod(
+                                    removeListenerMethodName,
+                                    new Class[] { listenerType });
+                            } catch (NoSuchMethodException nsme) {
+                                // no remover found
+                                continue;
+                            }
+                            
+                            Method getListenerMethod = null;
+                            String getListenerMethodName = "get" + listenerName
+                                    + "Listeners";
+                            try {
+                                getListenerMethod = beanClass.getMethod(
+                                    getListenerMethodName, new Class[] {});
+                            } catch (NoSuchMethodException nsme) {
+                                // no action - getter is not a mandatory method in event set descriptor pattern
+                            }
+
+                            try {
+                                listenerName = Introspector.decapitalize(
+                                        listenerName);
+                                EventSetDescriptor esd = new EventSetDescriptor(
+                                        listenerName,
+                                        listenerType,
+                                        listenerMethods,
+                                        addListenerMethod,
+                                        removeListenerMethod,
+                                        getListenerMethod);
+                                result.put(listenerName, esd);
+                            } catch (IntrospectionException ie) {
+                                System.out.println(
+                                        "Cannot generate event set descriptor "
+                                        + "for name" + listenerName + ".");
+                            }
+                            
+                        }
+                    }
+                }
+            }
+            
+            String[] eventSetDescriptorNames =
+                    new String[result.keySet().size()];
+            Iterator i = result.keySet().iterator();
+            int idx = 0;
+            while(i.hasNext()) {
+                eventSetDescriptorNames[idx++] =
+                    ((EventSetDescriptor) result.get(
+                            (String) i.next())).getName();
+            }
+            
+            Arrays.sort(eventSetDescriptorNames);
+
+            eventSetDescriptors =
+                    new EventSetDescriptor[eventSetDescriptorNames.length];
+            for(int j = 0; j < eventSetDescriptors.length; ++j) {
+                eventSetDescriptors[j] = (EventSetDescriptor) result.get(
+                        eventSetDescriptorNames[j]);
+            }
+            
+        }
+        return eventSetDescriptors;
+    }
+
+    public BeanInfo[] getAdditionalBeanInfo() {
+        // no info is obtained thru automatic introspection
+        return null;
+    }
+
+    public BeanDescriptor getBeanDescriptor() {
+        return new BeanDescriptor(beanClass, null);
+    }
+
+    public Image getIcon(int iconKind) {
+        // no info is obtained thru automatic introspection
+        return null;
+    }
+
+    public int getDefaultPropertyIndex() {
+        return defaultPropertyIndex;
+    }
+
+    public int getDefaultEventIndex() {
+        return defaultEventIndex;
+    }
+
+    private static int getMethodType(Method method) {
+        String name = method.getName();
+        int result = MT_OTHER;
+        try {
+            int modifiers = method.getModifiers();
+            
+            if(Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers)) {
+                Class[] parameterTypes = method.getParameterTypes();
+                Class returnType = method.getReturnType();
+
+                if(name.startsWith("get") && (parameterTypes.length == 0)
+                        && (returnType != void.class) && (name.length() > 3)) {
+                    result = MT_GETTER;
+                } else if(name.startsWith("is") && (parameterTypes.length == 0)
+                        && (returnType == boolean.class)
+                        && (name.length() > 2)) {
+                    result = MT_BOOLEAN_GETTER;
+                } else if(name.startsWith("get") && (parameterTypes.length == 1)
+                        && (returnType != void.class)
+                        && (parameterTypes[0] == int.class)
+                        && (name.length() > 3)) {
+                    result = MT_INDEXED_GETTER;
+                } else if(name.startsWith("set") && (parameterTypes.length == 1)
+                        && (returnType == void.class) && (name.length() > 3)) {
+                    result = MT_SETTER;
+                } else if(name.startsWith("set") && (parameterTypes.length == 2)
+                        && (returnType == void.class)
+                        && (parameterTypes[0] == int.class)
+                        && (name.length() > 3)) {
+                    result = MT_INDEXED_SETTER;
+                }
+            }
+        } catch (Exception e) {
+            result = MT_OTHER;
+        }
+        
+        return result;
+    }
+
+    private static String extractPropertyName(String methodName)
+            throws Exception {
+        String result = null;
+        
+        if ( methodName.startsWith("set") || methodName.startsWith("get") ) {
+            result = methodName.substring(3);
+            result = Introspector.decapitalize(result);
+        } else if (methodName.startsWith("is")) {
+            result = methodName.substring(2);
+            result = Introspector.decapitalize(result);
+        }
+        
+        return result;
+    }
+
+    private static ArrayList getPublicMethods(Class theClass) {
+        ArrayList result = new ArrayList();
+
+        Method[] beanClassMethods = theClass.getDeclaredMethods();
+        for (int i = 0; i < beanClassMethods.length; ++i) {
+            if(Modifier.isPublic(beanClassMethods[i].getModifiers())) {
+                result.add(beanClassMethods[i]);
+            }
+        }
+        
+        return result;
+    }
+    
+    private void addPropertyDescriptorsFromMethodList(
+            HashMap hmPropertyDescriptors,
+            ArrayList methods,
+            boolean checkExisting) throws Exception
+    {
+        Iterator iterator = methods.iterator();
+        while(iterator.hasNext()) {
+            Method method = (Method) iterator.next();
+            String methodName = method.getName();
+            String propertyName = extractPropertyName(methodName);
+            if ((!checkExisting) || (checkExisting && (hmPropertyDescriptors.get(propertyName) == null))) {
+                PropertyDescriptor propertyDescriptor = null;
+                try {
+                    propertyDescriptor = new PropertyDescriptor(propertyName, beanClass);
+                    hmPropertyDescriptors.put(propertyName, propertyDescriptor);
+                } catch (IntrospectionException ie) {
+                    System.out.println(ie.getClass() + ": " + ie.getMessage());
+                }
+            }
+        }
+    }
+    
+    private void addIndexedPropertyDescriptorsFromMethodList(
+            HashMap hmPropertyDescriptors,
+            ArrayList methods,
+            boolean checkExisting) throws Exception
+    {
+        Iterator iterator = methods.iterator();
+        while(iterator.hasNext()) {
+            Method method = (Method) iterator.next();
+            String methodName = method.getName();
+            String propertyName = extractPropertyName(methodName);
+            if ((!checkExisting) || (checkExisting
+                    && (hmPropertyDescriptors.get(propertyName) == null))) {
+                IndexedPropertyDescriptor indexedPropertyDescriptor = null;
+                try {
+                    indexedPropertyDescriptor = new IndexedPropertyDescriptor(
+                            propertyName, beanClass);
+                    hmPropertyDescriptors.put(propertyName,
+                            indexedPropertyDescriptor);
+                } catch (IntrospectionException ie) {
+                    System.out.println(ie.getClass() + ": " + ie.getMessage());
+                }
+            }
+        }
+    }
+    
+    private void clear() {
+        propertyDescriptors = null; 
+        methodDescriptors = null;
+        eventSetDescriptors = null;
+        defaultPropertyIndex = -1;
+        defaultEventIndex = -1;
+    }
+
+    private Class beanClass = null;
+    private PropertyDescriptor[] propertyDescriptors = null; 
+    private MethodDescriptor[] methodDescriptors = null;
+    private EventSetDescriptor[] eventSetDescriptors = null;
+    private int defaultPropertyIndex = -1;
+    private int defaultEventIndex = -1;
+    
+}
+
+class BeanInfoWrapper implements BeanInfo {
+    
+    private BeanInfo info;
+    private BeanInfoImpl impl;
+    private BeanInfoWrapper parentBeanInfoWrapper;
+    
+    public BeanInfoWrapper(BeanInfo info, BeanInfoImpl impl) {
+        this.info = info;
+        this.impl = impl;
+    }
+    
+    public PropertyDescriptor[] getPropertyDescriptors() {
+        PropertyDescriptor[] result = null;
+        PropertyDescriptor[] infoResult = null;
+        
+        if(info != null) {
+            infoResult = info.getPropertyDescriptors();
+            
+            BeanInfo[] infos = info.getAdditionalBeanInfo();
+            if(infos != null) {
+                for(int i = 0; i < infos.length; ++i) {
+                    BeanInfo additionalInfo = infos[i];
+                    
+                    if(infoResult == null) {
+                        infoResult = additionalInfo.getPropertyDescriptors();
+                    } else {
+                        infoResult = concatArraysToOneArray(infoResult,
+                                additionalInfo.getPropertyDescriptors());
+                    }
+                }
+            }
+        }
+        
+        if(info == null || infoResult == null) {
+            PropertyDescriptor[] implResult = impl.getPropertyDescriptors();
+            
+            // merge with parent info
+            if(parentBeanInfoWrapper != null) {
+                PropertyDescriptor[] parentResult =
+                        parentBeanInfoWrapper.getPropertyDescriptors();
+                HashMap hm = concatArraysUniqueByName(implResult, parentResult);
+                
+                Collection values = hm.values();
+                
+                result = new PropertyDescriptor[values.size()];
+                int idx = 0;
+                Iterator iterator = values.iterator();
+                while(iterator.hasNext()) {
+                    result[idx++] = (PropertyDescriptor) iterator.next();
+                }
+                
+                Arrays.sort(result, new Comparator() {
+                    public int compare(Object o1, Object o2) {
+                        PropertyDescriptor pd1 = (PropertyDescriptor) o1;
+                        PropertyDescriptor pd2 = (PropertyDescriptor) o2;
+                        return pd1.getName().compareTo(pd2.getName());
+                    }
+                    public boolean equals(Object o) {
+                        return false;
+                    }
+                });
+            } else {
+                result = implResult;
+            }
+        } else {
+            result = infoResult;
+        }
+        
+        return result;
+    }
+
+    public MethodDescriptor[] getMethodDescriptors() {
+        MethodDescriptor[] result = null;
+        MethodDescriptor[] infoResult = null;
+        
+        if(info != null) {
+            infoResult = info.getMethodDescriptors();
+            
+            BeanInfo[] infos = info.getAdditionalBeanInfo();
+            if(infos != null) {
+                for(int i = 0; i < infos.length; ++i) {
+                    BeanInfo additionalInfo = infos[i];
+                    
+                    if(infoResult == null) {
+                        infoResult = additionalInfo.getMethodDescriptors();
+                    } else {
+                        infoResult = concatArraysToOneArray(infoResult,
+                                additionalInfo.getMethodDescriptors());
+                    }
+                }
+            }
+        }
+        
+        if(info == null || infoResult == null) {
+            MethodDescriptor[] implResult = impl.getMethodDescriptors();
+            
+            // merge with parent info
+            if(parentBeanInfoWrapper != null) {
+                MethodDescriptor[] parentResult =
+                        parentBeanInfoWrapper.getMethodDescriptors();
+                result = concatArraysToOneArray(implResult, parentResult);
+            } else {
+                result = implResult;
+            }
+        } else {
+            result = infoResult;
+        }
+
+        if(result != null) {
+            Arrays.sort(result, new Comparator() {
+                public int compare(Object o1, Object o2) {
+                    MethodDescriptor md1 = (MethodDescriptor) o1;
+                    MethodDescriptor md2 = (MethodDescriptor) o2;
+                    return md1.getName().compareTo(md2.getName());
+                }
+                public boolean equals(Object o) {
+                    return false;
+                }
+            });
+        }
+        
+        return result;
+    }
+
+    public EventSetDescriptor[] getEventSetDescriptors() {
+        EventSetDescriptor[] result = null;
+        EventSetDescriptor[] infoResult = null;
+        
+        if(info != null) {
+            infoResult = info.getEventSetDescriptors();
+            
+            BeanInfo[] infos = info.getAdditionalBeanInfo();
+            if(infos != null) {
+                for(int i = 0; i < infos.length; ++i) {
+                    BeanInfo additionalInfo = infos[i];
+                    
+                    if(infoResult == null) {
+                        infoResult = additionalInfo.getEventSetDescriptors();
+                    } else {
+                        infoResult = concatArraysToOneArray(infoResult,
+                                additionalInfo.getEventSetDescriptors());
+                    }
+                }
+            }
+        }
+        
+        if(info == null || infoResult == null) {
+            EventSetDescriptor[] implResult = impl.getEventSetDescriptors();
+            
+            // merge with parent info
+            if(parentBeanInfoWrapper != null) {
+                EventSetDescriptor[] parentResult =
+                        parentBeanInfoWrapper.getEventSetDescriptors();
+                HashMap hm = concatArraysUniqueByName(implResult, parentResult);
+                
+                Collection values = hm.values();
+                
+                result = new EventSetDescriptor[values.size()];
+                int idx = 0;
+                Iterator iterator = values.iterator();
+                while(iterator.hasNext()) {
+                    result[idx++] = (EventSetDescriptor) iterator.next();
+                }
+                
+                Arrays.sort(result, new Comparator() {
+                    public int compare(Object o1, Object o2) {
+                        EventSetDescriptor esd1 = (EventSetDescriptor) o1;
+                        EventSetDescriptor esd2 = (EventSetDescriptor) o2;
+                        return esd1.getName().compareTo(esd2.getName());
+                    }
+                    public boolean equals(Object o) {
+                        return false;
+                    }
+                });
+            } else {
+                result = implResult;
+            }
+        } else {
+            result = infoResult;
+        }
+        
+        return result;
+    }
+
+    public BeanInfo[] getAdditionalBeanInfo() {
+        BeanInfo[] result = null;
+        
+        if(info != null) {
+            result = info.getAdditionalBeanInfo();
+        }
+        
+        return result;
+    }
+
+    public BeanDescriptor getBeanDescriptor() {
+        BeanDescriptor result = null;
+        
+        if(info != null) {
+            result = info.getBeanDescriptor();
+        }
+        
+        if(info == null || result == null) {
+            result = impl.getBeanDescriptor();
+        }
+        
+        return result;
+    }
+
+    public Image getIcon(int iconKind) {
+        Image result = null;
+        
+        if(info != null) {
+            result = info.getIcon(iconKind);
+        }
+        
+        return result;
+    }
+
+    public int getDefaultPropertyIndex() {
+        int result = -1;
+        
+        if(info != null) {
+            result = info.getDefaultPropertyIndex();
+        }
+        
+        if(info == null || result == -1) {
+            result = impl.getDefaultPropertyIndex();
+        }
+        
+        return result;
+    }
+
+    public int getDefaultEventIndex() {
+        int result = -1;
+        
+        if(info != null) {
+            result = info.getDefaultEventIndex();
+        }
+        
+        if(info == null || result == -1) {
+            result = impl.getDefaultEventIndex();
+        }
+        
+        return result;
+    }
+    
+    void merge(BeanInfoWrapper parentBeanInfoWrapper) {
+        this.parentBeanInfoWrapper = parentBeanInfoWrapper;
+    }
+    
+    private static HashMap concatArraysUniqueByName(FeatureDescriptor[] childs,
+            FeatureDescriptor[] parents) {
+        HashMap result = new HashMap();
+        
+        if(childs != null) {
+            for(int i = 0; i < childs.length; ++i) {
+                result.put(childs[i].getName(), childs[i]);
+            }
+        }
+        
+        if(parents != null) {
+            for(int j = 0; j < parents.length; ++j) {
+                if(result.get(parents[j].getName()) == null) {
+                    result.put(parents[j].getName(), parents[j]);
+                }
+            }
+        }
+        
+        return result;
+    }
+    
+    private static PropertyDescriptor[] concatArraysToOneArray(
+            PropertyDescriptor[] childs, PropertyDescriptor[] parents) {
+        if(childs != null || parents != null) {
+            HashMap hm = concatArraysUniqueByName(childs, parents);
+            PropertyDescriptor[] result = new PropertyDescriptor[hm.size()];
+            
+            Iterator iterator = hm.keySet().iterator();
+            int idx = 0;
+            
+            while(iterator.hasNext()) {
+                String name = (String) iterator.next();
+                result[idx++] = (PropertyDescriptor) hm.get(name);
+            }
+            
+            return result;
+        } else {
+            return null;
+        }
+    }
+    
+    private static MethodDescriptor[] concatArraysToOneArray(
+            MethodDescriptor[] childs, MethodDescriptor[] parents) {
+        MethodDescriptor[] result = null;
+        
+        if(childs != null || parents != null) {
+            int resultLength = 0;
+            
+            if(childs != null) {
+                resultLength = childs.length; 
+            }
+            
+            if(parents != null) {
+                resultLength += parents.length;
+            }
+            
+            result = new MethodDescriptor[resultLength];
+
+            if(childs != null) {
+                for(int i = 0; i < childs.length; ++i) {
+                    result[i] = childs[i];
+                }
+            }
+            
+            if(parents != null) {
+                int shift = (childs == null) ? 0 : childs.length; 
+                for(int i = 0; i < parents.length; ++i) {
+                    result[shift + i] = parents[i];
+                }
+            }
+            
+        }
+        
+        return result;
+    }
+    
+    private static EventSetDescriptor[] concatArraysToOneArray(
+            EventSetDescriptor[] childs, EventSetDescriptor[] parents) {
+        if(childs != null || parents != null) {
+            HashMap hm = concatArraysUniqueByName(childs, parents);
+            EventSetDescriptor[] result = new EventSetDescriptor[hm.size()];
+            
+            Iterator iterator = hm.keySet().iterator();
+            int idx = 0;
+            
+            while(iterator.hasNext()) {
+                String name = (String) iterator.next();
+                result[idx++] = (EventSetDescriptor) hm.get(name);
+            }
+            
+            return result;
+        } else {
+            return null;
+        }
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/MethodDescriptor.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/MethodDescriptor.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/MethodDescriptor.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/MethodDescriptor.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,77 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.5.4.3 $
+ */
+package java.beans;
+
+import java.lang.reflect.Method;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.5.4.3 $
+ */
+
+public class MethodDescriptor extends FeatureDescriptor {
+    
+    private Method method = null;
+    private ParameterDescriptor[] parameterDescriptors = {};
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public MethodDescriptor(Method method,
+            ParameterDescriptor[] parameterDescriptors) {
+        super();
+        
+        this.method = method;
+        this.parameterDescriptors = parameterDescriptors;
+        
+        if(method != null) {
+            setName(method.getName());
+            setDisplayName(method.getName());
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public MethodDescriptor(Method method) {
+        super();
+        
+        this.method = method;
+        if(method != null) {
+            setName(method.getName());
+            setDisplayName(method.getName());
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Method getMethod() {
+        return method;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public ParameterDescriptor[] getParameterDescriptors() {
+        return parameterDescriptors;
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/ParameterDescriptor.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/ParameterDescriptor.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/ParameterDescriptor.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/ParameterDescriptor.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.2.6.3 $
+ */
+package java.beans;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.2.6.3 $
+ */
+
+public class ParameterDescriptor extends FeatureDescriptor {
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public ParameterDescriptor() {
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PersistenceDelegate.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PersistenceDelegate.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PersistenceDelegate.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PersistenceDelegate.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,98 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.10.6.3 $
+ */
+package java.beans;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.10.6.3 $
+ */
+
+public abstract class PersistenceDelegate {
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PersistenceDelegate() {
+    }
+    
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    protected void initialize(
+            Class type, Object oldInstance, Object newInstance, Encoder out) {
+        if((out != null) && (type != null)) {
+            PersistenceDelegate pd = out.getPersistenceDelegate(
+                    type.getSuperclass());
+            if(pd != null) {
+                pd.initialize(type, oldInstance, newInstance, out);
+            }
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    protected abstract Expression instantiate(Object oldInstance, Encoder out);
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    protected boolean mutatesTo(Object oldInstance, Object newInstance) {
+        boolean bothInstancesAreNull = (oldInstance == null)
+                && (newInstance == null);
+        
+        if(bothInstancesAreNull) {
+            return true;
+        } else {
+            return (oldInstance != null) && (newInstance != null) ? 
+                oldInstance.getClass() == newInstance.getClass() : false;
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void writeObject(Object oldInstance, Encoder out) {
+        Object newInstance = (oldInstance != null) ? out.get(oldInstance)
+                : null;
+        
+       if(mutatesTo(oldInstance, newInstance)) {
+           if(oldInstance != null) {
+               initialize(oldInstance.getClass(), oldInstance, newInstance,
+                       out);
+           } else {
+               out.writeExpression(instantiate(oldInstance, out));
+           }
+       } else {
+           if(newInstance != null) {
+               out.remove(newInstance);
+           }
+           
+           out.writeExpression(instantiate(oldInstance, out));
+           
+           if(oldInstance != null) {
+            newInstance = out.get(oldInstance);
+               initialize(oldInstance.getClass(), oldInstance, newInstance,
+                       out);
+           }
+       }
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeEvent.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeEvent.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeEvent.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeEvent.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,83 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.4.6.3 $
+ */
+package java.beans;
+
+import java.util.EventObject;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.4.6.3 $
+ */
+
+public class PropertyChangeEvent extends EventObject {
+    
+    String propertyName;
+    Object oldValue;
+    Object newValue;
+    Object propagationId;
+    
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PropertyChangeEvent(Object source, String propertyName,
+            Object oldValue, Object newValue) {
+        super(source);
+        
+        this.propertyName = propertyName;
+        this.oldValue = oldValue;
+        this.newValue = newValue;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public String getPropertyName() {
+        return propertyName;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setPropagationId(Object propagationId) {
+        this.propagationId = propagationId;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Object getPropagationId() {
+        return propagationId;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Object getOldValue() {
+        return oldValue;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Object getNewValue() {
+        return newValue;
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListener.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListener.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListener.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListener.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,36 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.2.6.3 $
+ */
+package java.beans;
+
+import java.util.EventListener;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.2.6.3 $
+ */
+
+public interface PropertyChangeListener extends EventListener {
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void propertyChange(PropertyChangeEvent event);
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListenerProxy.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListenerProxy.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListenerProxy.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeListenerProxy.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.3.6.3 $
+ */
+package java.beans;
+
+import java.util.EventListenerProxy;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.3.6.3 $
+ */
+
+public class PropertyChangeListenerProxy extends EventListenerProxy
+        implements PropertyChangeListener {
+    
+    String propertyName;
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PropertyChangeListenerProxy(String propertyName,
+            PropertyChangeListener listener) {
+        super(listener);
+        this.propertyName = propertyName;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public String getPropertyName() {
+        return propertyName;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void propertyChange(PropertyChangeEvent event) {
+        PropertyChangeListener listener =
+            (PropertyChangeListener) getListener();
+        if (listener != null) {
+            listener.propertyChange(event);
+        }
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeSupport.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeSupport.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeSupport.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyChangeSupport.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,348 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.13.2.4 $
+ */
+package java.beans;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.13.2.4 $
+ */
+
+public class PropertyChangeSupport implements Serializable {
+    
+    private static final long serialVersionUID = 6401253773779951803l; 
+    
+    private transient Object sourceBean;
+    private transient ArrayList allPropertiesChangeListeners = new ArrayList();
+    private transient HashMap selectedPropertiesChangeListeners = new HashMap();
+
+    // fields for serialization compatibility
+    private Hashtable children;
+    private Object source;
+    private int propertyChangeSupportSerializedDataVersion = 1; 
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PropertyChangeSupport(Object sourceBean) {
+        this.sourceBean = sourceBean;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void firePropertyChange(
+            String propertyName, Object oldValue, Object newValue) {
+        PropertyChangeEvent event = createPropertyChangeEvent(propertyName,
+                oldValue, newValue);
+        doFirePropertyChange(event);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized void removePropertyChangeListener(
+            String propertyName, PropertyChangeListener listener) {
+        if ( (propertyName != null) && (listener != null) ) {
+            ArrayList listeners =
+                (ArrayList) selectedPropertiesChangeListeners.get(propertyName);
+            
+            if(listeners != null) {
+                listeners.remove(listener);    
+            }
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized void addPropertyChangeListener(
+            String propertyName, PropertyChangeListener listener) {
+        if(propertyName == null) {
+            throw new NullPointerException("propertyName is null");
+        } else if(listener != null) {
+            ArrayList listeners =
+                (ArrayList) selectedPropertiesChangeListeners.get(propertyName);
+            
+            if (listeners == null) {
+                listeners = new ArrayList();
+                selectedPropertiesChangeListeners.put(propertyName, listeners);
+            }
+            
+            listeners.add(listener);
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized PropertyChangeListener[] getPropertyChangeListeners(
+            String propertyName) {
+        ArrayList listeners = null;
+        
+        if(propertyName != null) {
+            listeners = (ArrayList) selectedPropertiesChangeListeners.get(
+                    propertyName);
+        }
+        
+        return (listeners == null) ? new PropertyChangeListener[] {} :
+            getAsPropertyChangeListenerArray(listeners);
+        
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void firePropertyChange(
+            String propertyName, boolean oldValue, boolean newValue) {
+        PropertyChangeEvent event = createPropertyChangeEvent(propertyName,
+                oldValue, newValue);
+        doFirePropertyChange(event);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void firePropertyChange(
+            String propertyName, int oldValue, int newValue) {
+        PropertyChangeEvent event = createPropertyChangeEvent(propertyName,
+                oldValue, newValue);
+        doFirePropertyChange(event);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized boolean hasListeners(String propertyName) {
+        boolean result = allPropertiesChangeListeners.size() > 0;
+        if (!result && propertyName != null) {
+            ArrayList listeners =
+                (ArrayList) selectedPropertiesChangeListeners.get(propertyName);
+            if (listeners != null) {
+                result = listeners.size() > 0;
+            }
+        }
+        return result;    
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized void removePropertyChangeListener(
+            PropertyChangeListener listener) {
+        if (listener != null) {
+            Iterator iterator = allPropertiesChangeListeners.iterator();
+            while (iterator.hasNext()) {
+                PropertyChangeListener pcl =
+                    (PropertyChangeListener) iterator.next();
+                if (pcl == listener) {
+                    iterator.remove();
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized void addPropertyChangeListener(
+            PropertyChangeListener listener) {
+        if (listener != null) {
+            allPropertiesChangeListeners.add(listener);
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
+        ArrayList result = new ArrayList(allPropertiesChangeListeners);
+        
+        Iterator keysIterator =
+                selectedPropertiesChangeListeners.keySet().iterator();
+        while (keysIterator.hasNext()) {
+            String propertyName = (String) keysIterator.next();
+            
+            ArrayList selectedListeners =
+                (ArrayList) selectedPropertiesChangeListeners.get(propertyName);
+            if(selectedListeners != null) {
+
+                Iterator i = selectedListeners.iterator();
+                while(i.hasNext()) {
+                    PropertyChangeListener listener =
+                        (PropertyChangeListener) i.next();
+                    result.add(new PropertyChangeListenerProxy(propertyName,
+                            listener));
+                }
+                
+            }
+            
+        }
+        
+        return getAsPropertyChangeListenerArray(result);
+    }
+    
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    private void writeObject(ObjectOutputStream oos) throws IOException {
+        ArrayList allSerializedPropertiesChangeListeners = new ArrayList();
+        Iterator i = allPropertiesChangeListeners.iterator();
+        while(i.hasNext()) {
+            PropertyChangeListener pcl = (PropertyChangeListener) i.next();
+            if(pcl instanceof Serializable) {
+                allSerializedPropertiesChangeListeners.add(pcl);
+            }
+        }
+        
+        HashMap selectedSerializedPropertiesChangeListeners = new HashMap();
+        Iterator keyIterator =
+            selectedPropertiesChangeListeners.keySet().iterator();
+        while(keyIterator.hasNext()) {
+            String propertyName = (String) keyIterator.next();
+            ArrayList keyValues =
+                (ArrayList) selectedPropertiesChangeListeners.get(propertyName);
+            if(keyValues != null) {
+                ArrayList serializedPropertiesChangeListeners = new ArrayList();
+                
+                Iterator j = keyValues.iterator();
+                while(j.hasNext()) {
+                    PropertyChangeListener pcl =
+                        (PropertyChangeListener) j.next();
+                    if(pcl instanceof Serializable) {
+                        serializedPropertiesChangeListeners.add(pcl);
+                    }
+                }
+                
+                if(!serializedPropertiesChangeListeners.isEmpty()) {
+                    selectedSerializedPropertiesChangeListeners.put(
+                        propertyName, serializedPropertiesChangeListeners);
+                }
+                
+            }
+        }
+        
+        children = new Hashtable(selectedSerializedPropertiesChangeListeners);
+        children.put("", allSerializedPropertiesChangeListeners);
+        oos.writeObject(children);
+        
+        Object source = null;
+        if((sourceBean != null) && (sourceBean instanceof Serializable)) {
+            source = sourceBean;
+        }
+        oos.writeObject(source);
+        
+        oos.writeInt(propertyChangeSupportSerializedDataVersion);
+    }
+    
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    private void readObject(ObjectInputStream ois)
+            throws IOException, ClassNotFoundException {
+        children = (Hashtable) ois.readObject();
+        
+        selectedPropertiesChangeListeners = new HashMap(children);
+        allPropertiesChangeListeners =
+            (ArrayList) selectedPropertiesChangeListeners.remove("");
+        if(allPropertiesChangeListeners == null) {
+            allPropertiesChangeListeners = new ArrayList();
+        }
+        
+        sourceBean = ois.readObject();
+        propertyChangeSupportSerializedDataVersion = ois.readInt();
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void firePropertyChange(PropertyChangeEvent event) {
+        doFirePropertyChange(event);
+    }
+    
+    private PropertyChangeEvent createPropertyChangeEvent(
+            String propertyName, Object oldValue, Object newValue) {
+        return new PropertyChangeEvent(sourceBean, propertyName, oldValue,
+                newValue);
+    }
+    
+    private PropertyChangeEvent createPropertyChangeEvent(
+            String propertyName, boolean oldValue, boolean newValue) {
+        return new PropertyChangeEvent(sourceBean, propertyName,
+                new Boolean(oldValue), new Boolean(newValue));
+    }
+    
+    private PropertyChangeEvent createPropertyChangeEvent(
+            String propertyName, int oldValue, int newValue) {
+        return new PropertyChangeEvent(sourceBean, propertyName,
+                new Integer(oldValue), new Integer(newValue));
+    }
+    
+    private void doFirePropertyChange(PropertyChangeEvent event) {
+        String propertyName = event.getPropertyName();
+        Object oldValue = event.getOldValue();
+        Object newValue = event.getNewValue();
+        
+        if (newValue != null && oldValue != null && newValue.equals(oldValue)) {
+            return;
+        }
+
+        Iterator iterator = allPropertiesChangeListeners.iterator();
+        while (iterator.hasNext()) {
+            PropertyChangeListener listener =
+                (PropertyChangeListener) iterator.next();
+            listener.propertyChange(event);
+        }
+        ArrayList listeners = (ArrayList) selectedPropertiesChangeListeners.get(
+                propertyName);
+        if (listeners != null) {
+            iterator = listeners.iterator();
+            while (iterator.hasNext()) {
+                PropertyChangeListener listener =
+                    (PropertyChangeListener) iterator.next();
+                listener.propertyChange(event);
+            }
+        }
+    }
+
+    private static PropertyChangeListener[] getAsPropertyChangeListenerArray(
+            ArrayList listeners) {
+        Object[] objects = listeners.toArray();
+        PropertyChangeListener[] arrayResult =
+                new PropertyChangeListener[objects.length];
+        
+        for(int i = 0; i < objects.length; ++i) {
+            arrayResult[i] = (PropertyChangeListener) objects[i];
+        }
+        
+        return arrayResult;
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyDescriptor.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyDescriptor.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyDescriptor.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyDescriptor.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,337 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.9.4.3 $
+ */
+package java.beans;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Vector;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.9.4.3 $
+ */
+
+public class PropertyDescriptor extends FeatureDescriptor {
+
+    Class beanClass = null;
+    String propertyName = null;
+    
+    Method getter = null;
+    Method setter = null;
+    
+    Class propertyEditorClass = null;
+    
+    boolean constrained = false;
+    boolean bound = false;
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PropertyDescriptor(
+            String propertyName,
+            Class beanClass,
+            String getterName,
+            String setterName) throws IntrospectionException {
+        super();
+        this.beanClass = beanClass;
+        this.propertyName = propertyName;
+        
+        this.setName(propertyName);
+        this.setDisplayName(propertyName);
+        
+        setWriteMethod(beanClass, setterName);
+        setReadMethod(beanClass, getterName);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PropertyDescriptor(String propertyName, Method getter, Method setter)
+            throws IntrospectionException {
+        super();
+        this.propertyName = propertyName;
+        
+        this.setName(propertyName);
+        this.setDisplayName(propertyName);
+        
+        setWriteMethod(setter);
+        setReadMethod(getter);
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public PropertyDescriptor(String propertyName, Class beanClass)
+            throws IntrospectionException {
+        super();
+        this.propertyName = propertyName;
+        
+        this.setName(propertyName);
+        this.setDisplayName(propertyName);
+        
+        String getterName = createDefaultMethodName(propertyName, "is");
+        if(hasMethod(beanClass, getterName)) {
+            setReadMethod(beanClass, getterName);
+        } else {
+            getterName = createDefaultMethodName(propertyName, "get");
+            if(hasMethod(beanClass, getterName)) {
+                setReadMethod(beanClass, getterName);
+            }
+        }
+        String setterName = createDefaultMethodName(propertyName, "set");
+        if(hasMethod(beanClass, setterName)) {
+            setWriteMethod(beanClass, setterName);
+        }
+    }
+        
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setWriteMethod(Method setter) throws IntrospectionException {
+        if (setter != null) {
+            int modifiers = setter.getModifiers();
+            if (!Modifier.isPublic(modifiers)) {
+                throw new IntrospectionException(
+                        "Modifier for setter method should be public.");
+            }
+            
+            Class[] parameterTypes = setter.getParameterTypes();
+            if (parameterTypes.length != 1) {
+                throw new IntrospectionException(
+                        "Number of parameters in setter method is not "
+                        + "equal to 1.");
+            }
+            
+            Class parameterType = parameterTypes[0];
+            Class propertyType = getPropertyType();
+            if(propertyType != null && !propertyType.equals(parameterType)) {
+                throw new IntrospectionException(
+                        "Parameter type in setter method does not "
+                        + "corresponds to predefined.");
+            }
+        }
+        
+        this.setter = setter;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setReadMethod(Method getter) throws IntrospectionException {
+        if (getter != null) {
+            int modifiers = getter.getModifiers();
+            if (!Modifier.isPublic(modifiers)) {
+                throw new IntrospectionException(
+                        "Modifier for getter method should be public.");
+            }
+            
+            Class[] parameterTypes = getter.getParameterTypes();
+            if (parameterTypes.length != 0) {
+                throw new IntrospectionException(
+                        "Number of parameters in getter method is not "
+                        + "equal to 0.");
+            }
+            
+            Class returnType = getter.getReturnType();
+            Class propertyType = getPropertyType();
+            if((propertyType != null) && !returnType.equals(propertyType)) {
+                throw new IntrospectionException(
+                        "Parameter type in getter method does not "
+                        + "corresponds to predefined.");
+            }
+        }
+        
+        this.getter = getter;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Method getWriteMethod() {
+        return setter;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Method getReadMethod() {
+        return getter;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public boolean equals(Object object) {
+        boolean result = (object != null);
+        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;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setPropertyEditorClass(Class propertyEditorClass) {
+        this.propertyEditorClass = propertyEditorClass;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    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;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Class getPropertyEditorClass() {
+        return propertyEditorClass;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setConstrained(boolean constrained) {
+        this.constrained = constrained;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setBound(boolean bound) {
+        this.bound = bound;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public boolean isConstrained() {
+        return constrained;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    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 matchedMethods = new Vector();
+        for (int i = 0; i < allMethods.length; ++i) {
+            Method method = allMethods[i];
+            if (method.getName().equals(methodName)) {
+                matchedMethods.add(method);
+            }
+        }
+        
+        Method[] result = new Method[matchedMethods.size()];
+        for(int j = 0; j < matchedMethods.size(); ++j) {
+            result[j] = (Method) matchedMethods.elementAt(j);
+        }
+        return result;
+    }
+    
+    private void setReadMethod(Class beanClass, String getterName) {
+        boolean result = false;
+        
+        Method[] getters = findMethods(beanClass, getterName);
+        
+        for (int i = 0; i < getters.length; ++i) {
+            try {
+                setReadMethod(getters[i]);
+                result = true;
+            } catch (IntrospectionException ie) {
+            }
+            
+            if (result) {
+                break;
+            }
+        }
+    }
+
+    private void setWriteMethod(Class beanClass, String setterName)
+            throws IntrospectionException {
+        boolean result = false;
+        
+        Method[] setters = findMethods(beanClass, setterName);
+        
+        for (int i = 0; i < setters.length; ++i) {
+            try {
+                setWriteMethod(setters[i]);
+                result = true;
+            } catch (IntrospectionException ie) {
+            }
+            
+            if (result) {
+                break;
+            }
+        }
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditor.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditor.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditor.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditor.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,93 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.3.6.3 $
+ */
+package java.beans;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.3.6.3 $
+ */
+
+public interface PropertyEditor {
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void paintValue(Graphics gfx, Rectangle box);
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setAsText(String text) throws IllegalArgumentException;
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public String[] getTags();
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public String getJavaInitializationString();
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public String getAsText();
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void setValue(Object value);
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Object getValue();
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void removePropertyChangeListener(PropertyChangeListener listener);
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public void addPropertyChangeListener(PropertyChangeListener listener);
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public Component getCustomEditor();
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public boolean supportsCustomEditor();
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public boolean isPaintable();
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditorManager.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditorManager.java?rev=387239&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditorManager.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex-beans-math/src/common/javasrc/java/beans/PropertyEditorManager.java Mon Mar 20 08:31:09 2006
@@ -0,0 +1,128 @@
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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.
+ */
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.6.6.4 $
+ */
+package java.beans;
+
+import java.util.HashMap;
+
+/**
+ * @author Maxim V. Berkultsev
+ * @version $Revision: 1.6.6.4 $
+ */
+
+public class PropertyEditorManager {
+    
+    private static String[] path = {"org.apache.harmony.beans.editors"};
+    private static HashMap registeredEditors = new HashMap();
+    
+    /**
+     */
+    public PropertyEditorManager() {
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static void registerEditor(Class targetType, Class editorClass) {
+        if (targetType != null) {
+            SecurityManager sm = System.getSecurityManager();
+            if (sm != null) {
+                sm.checkPropertiesAccess();
+            }
+            if (editorClass != null) {
+                registeredEditors.put(targetType, editorClass);
+            } else {
+                registeredEditors.remove(targetType);
+            }
+        }
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static synchronized PropertyEditor findEditor(Class targetType) {
+        Class editorClass = null;
+        PropertyEditor editor = null;
+        
+        if (targetType != null) {
+            editorClass = (Class) registeredEditors.get(targetType);
+            
+            if (editorClass == null) {
+                String editorClassName = targetType.getName() + "Editor";
+                
+                try {
+                    editorClass = Class.forName(
+                        editorClassName, true, targetType.getClassLoader());
+                } catch (ClassNotFoundException cnfe) {
+                    String shortEditorClassName = editorClassName.substring(
+                        editorClassName.lastIndexOf(".") + 1);
+                    
+                    if(targetType.isPrimitive()) {
+                        shortEditorClassName =
+                            shortEditorClassName.substring(0,1).toUpperCase()
+                            + shortEditorClassName.substring(1);
+                    }
+                    
+                    for (int i = 0; i < path.length; ++i) {
+                        editorClassName = path[i] + "." + shortEditorClassName;
+                        
+                        try {
+                            editorClass = Class.forName(editorClassName, true,
+                                targetType.getClassLoader());
+                        } catch (ClassNotFoundException cnfe2) {
+                        } catch (Exception e) {
+                            break;
+                        }
+                    }
+                } catch (Exception e) {
+                }
+            }
+                
+            if (editorClass != null) {
+                try {
+                    editor = (PropertyEditor) editorClass.newInstance();
+                } catch (Exception e) {
+                }
+            }
+            
+        }
+        return editor;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static synchronized void setEditorSearchPath(String[] apath) {
+        SecurityManager sm = System.getSecurityManager();
+        
+        if (sm != null) {
+            sm.checkPropertiesAccess();
+        }
+        
+        path = apath;
+    }
+
+    /**
+     * @com.intel.drl.spec_ref
+     */
+    public static synchronized String[] getEditorSearchPath() {
+        return path;
+    }
+}



Mime
View raw message