Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.dynform.main;

import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.impl.DefaultDynClass;

import org.gvsig.tools.dynobject.impl.DefaultDynField;

public class DynClassBuilder {

    private Class theClass;

    private DefaultDynClass struct = null;

    private Map dynClasses = null;

    public DynClassBuilder() {

        this.dynClasses = new HashMap();

    }

    private DynObjectManager getManager() {

        return ToolsLocator.getDynObjectManager();

    }

    private DefaultDynField getOrCreateDynField(String name) {

        DefaultDynField dynfield = (DefaultDynField) this.struct.getDynField(name);

        if ( dynfield == null ) {

            dynfield = new DefaultDynField(name, DataTypes.UNKNOWN);

            dynfield = (DefaultDynField) this.struct.addDynField(dynfield);

        }

        return dynfield;

    }

    private dynobjectmetadata getDynobjectMetadata(Annotation[] annotations) {

        for ( int i = 0; i < annotations.length; i++ ) {

            Annotation annotation = annotations[i];

            if ( annotation instanceof dynobjectmetadata ) {

                return (dynobjectmetadata) annotation;

            }

        }

        return null;

    }

    private DynField createOrUpdateDynField(String name, Class declaringClass, Annotation[] annotations) {

        DataType type = null;

        try {

            DataTypesManager dataManager = ToolsLocator.getDataTypesManager();

            type = dataManager.getDataType(declaringClass);

        } catch (IllegalArgumentException ex) {

        } catch (Exception ex) {

        }

        DefaultDynField dynfield = getOrCreateDynField(name);

        if ( dynfield.getType() == DataTypes.UNKNOWN ) {

            dynfield.setType(type);

            DynClass declaringDynClass = null;

            if ( type.getType() == DataTypes.OBJECT ) {

                declaringDynClass = getManager().get(declaringClass.getName());

                if ( declaringDynClass == null ) {

                    declaringDynClass = (DynClass) this.dynClasses.get(declaringClass.getName());

                }

                if ( declaringDynClass == null ) {

                    DynClassBuilder builder = new DynClassBuilder();

                    declaringDynClass = builder.createDynClass(declaringClass);

                    this.dynClasses.put(declaringDynClass.getName(), declaringDynClass);

                }

                if ( declaringDynClass != null ) {

                    dynfield.setType(DataTypes.DYNOBJECT);

                    dynfield.setClassOfValue(declaringDynClass);

                }

            }

        }

        dynobjectmetadata metadata = this.getDynobjectMetadata(annotations);

        if ( metadata != null ) {

            dynfield.setReadOnly(metadata.readonly());

            dynfield.setMandatory(metadata.mandatory());

            if ( !StringUtils.isBlank(metadata.label()) ) {

                dynfield.setLabel(metadata.label());

            }

            if ( !StringUtils.isBlank(metadata.description()) ) {

                dynfield.setDescription(metadata.description());

            }

            if ( !StringUtils.isBlank(metadata.subtype()) ) {

                dynfield.setSubtype(metadata.subtype());

            }

            if ( !StringUtils.isBlank(metadata.defaultValue()) ) {

                dynfield.setDefaultDynValue(metadata.defaultValue());

            }

            if ( !StringUtils.isBlank(metadata.group()) ) {

                dynfield.setGroup(metadata.group());

            }

//            if ( !StringUtils.isBlank(metadata.name()) ) {

//                this.struct.renameField(dynfield.getName(),metadata.name());

//            }

            if ( metadata.order() >= 0 ) {

                dynfield.setOrder(metadata.order());

            }

        }

        return dynfield;

    }

    private boolean isGetter(Method method) {

        String name = method.getName();

        return name.startsWith("get") && Character.isUpperCase(name.charAt(3));

    }

    private String getAttributeName(Method method) {

        if ( !isGetter(method) ) {

            return null;

        }

        String name = method.getName();

        return name.substring(3, 4).toLowerCase() + name.substring(4);

    }

    private Method getSetter(Method getter) {

        Method[] methods = this.theClass.getMethods();

        String setterName = "set" + getter.getName().substring(3);

        for ( int i = 0; i < methods.length; i++ ) {

            Method method = methods[i];

            if ( method.getName().equals(setterName) ) {

                return method;

            }

        }

        return null;

    }

    private void createAttributesfOfFields() {

        Field[] fields = theClass.getFields();

        for ( int i = 0; i < fields.length; i++ ) {

            Field field = fields[i];

            DynField dynfield = createOrUpdateDynField(

                    field.getName(),

                    field.getType(),

                    field.getAnnotations()

            );

        }

    }

    private void createAttributesOfMethods() {

        Method[] methods = theClass.getMethods();

        for ( int i = 0; i < methods.length; i++ ) {

            Method method = methods[i];

            if ( isGetter(method) ) {

                Method setter = getSetter(method);

                if ( setter != null ) {

                    createOrUpdateDynField(

                            getAttributeName(method),

                            method.getReturnType(),

                            method.getAnnotations()

                    );

                } else {

                    dynobjectmetadata metadata = this.getDynobjectMetadata(method.getAnnotations());

                    if ( metadata != null && metadata.readonly() ) {

                        createOrUpdateDynField(

                                getAttributeName(method),

                                method.getReturnType(),

                                method.getAnnotations()

                        );

                    }

                }

            }

        }

    }

    public DynClass createDynClass(Object obj) {

        return this.createDynClass(obj.getClass());

    }

    public DynClass createDynClass(Class theClass) {

        this.theClass = theClass;

        this.struct = new DefaultDynClass(theClass.getName());

        this.struct.setLabel(theClass.getCanonicalName());

        this.dynClasses.put(this.struct.getName(), this.struct);

        this.createAttributesfOfFields();

        this.createAttributesOfMethods();

        return this.struct;

    }

    public void addAllClasses() {

        DynClass dynClass = null;

        DynObjectManager manager = this.getManager();

        Iterator it = this.dynClasses.values().iterator();

        while( it.hasNext() ) {

            dynClass = (DynClass) it.next();

            manager.add(dynClass);

        }

    }

}