Open Source Repository

Home /json/flexjson-2.1 | Repository Home



flexjson/BeanAnalyzer.java
package flexjson;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.*;

public class BeanAnalyzer {

    private static ThreadLocal<Map<Class,BeanAnalyzer>> cache = new ThreadLocal<Map<Class,BeanAnalyzer>>();

    private Class clazz;
    private BeanAnalyzer superBean;
    private Map<String,BeanProperty> properties;

    public static BeanAnalyzer analyzeClass clazz ) {
        ifcache.get() == null cache.setnew HashMap<Class,BeanAnalyzer>() );
        ifclazz == null return null;
        if!cache.get().containsKey(clazz) ) {
            cache.get().putclazz, new BeanAnalyzer(clazz) );
        }
        return cache.get().getclazz );
    }

    public static void clearCache() {
        cache.remove();
    }

    protected BeanAnalyzer(Class clazz) {
        this.clazz = clazz;
        superBean = analyzeclazz.getSuperclass() );
        populateProperties();
    }

    private void populateProperties() {
        properties = new TreeMap<String,BeanProperty>();
        forMethod method : clazz.getDeclaredMethods() ) {
            int modifiers = method.getModifiers();
            ifModifier.isStatic(modifiers) ) continue;

            int numberOfArgs = method.getParameterTypes().length;
            String name = method.getName();
            ifname.length() <= && !name.startsWith("is") ) continue;
            
            ifnumberOfArgs == ) {
                ifname.startsWith("get") ) {
                    String property = uncapitalizename.substring(3) );
                    if!properties.containsKeyproperty ) ) {
                        properties.putproperty, new BeanProperty(property, this) );
                    }
                    properties.getproperty ).setReadMethodmethod );
                else ifname.startsWith("is") ) {
                    String property = uncapitalizename.substring(2) );
                    if!properties.containsKeyproperty ) ) {
                        properties.putproperty, new BeanProperty(property, this) );
                    }
                    properties.getproperty ).setReadMethod(method);
                }
            else ifnumberOfArgs == ) {
                ifname.startsWith("set") ) {
                    String property = uncapitalizename.substring(3) );
                    if!properties.containsKeyproperty ) ) {
                        properties.putproperty, new BeanProperty(property, this) );
                    }
                    properties.getproperty ).addWriteMethod(method);
                }
            }
        }

        forField publicProperties : clazz.getFields() ) {
            int modifiers = publicProperties.getModifiers();
            ifModifier.isStaticmodifiers || Modifier.isTransient(modifiers) ) continue;
            if!properties.containsKeypublicProperties.getName() ) ) {
                properties.putpublicProperties.getName()new BeanPropertypublicProperties, this ) );
            }
        }
    }

    public BeanAnalyzer getSuperBean() {
        return superBean;
    }

    private String uncapitalizeString value ) {
        ifvalue.length() ) {
             return value.toLowerCase();
        else ifCharacter.isUpperCase(value.charAt(0)) && Character.isUpperCase(value.charAt(1)) ) {
            return value;
        else {
            return Character.toLowerCasevalue.charAt(0) ) + value.substring(1);
        }
    }

    public BeanProperty getProperty(String name) {
        BeanAnalyzer current = this;
        whilecurrent != null ) {
            BeanProperty property = current.properties.getname );
            ifproperty != null return property;
            current = current.superBean;
        }
        return null;
    }

    public Collection<BeanProperty> getProperties() {
        Map<String,BeanProperty> properties = new TreeMap<String,BeanProperty>(this.properties);
        BeanAnalyzer current = this.superBean;
        whilecurrent != null ) {
            mergeproperties, current.properties );
            current = current.superBean;
        }
        return properties.values();
    }

    private void merge(Map<String, BeanProperty> destination, Map<String, BeanProperty> source) {
        forString key : source.keySet() ) {
            if!destination.containsKeykey ) ) {
                destination.putkey, source.get(key) );
            }
        }
    }

    public boolean hasProperty(String name) {
        return properties.containsKey(name);
    }

    protected Field getDeclaredField(String name) {
        try {
            return clazz.getDeclaredFieldname );
        catch (NoSuchFieldException e) {
            // ignore field does not exist.
            return null;
        }
    }
}