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

package org.gvsig.tools.dynform.main;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Map;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

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

public class DynObjectProxy implements DynObject {

    private DynClass dynClass;

    private Object obj;

    private Class<? extends Object> theClass;

    private Map fields = null;

    private Map getters = null;

    private Map setters = null;

    private Map coercions = null;

    public DynObjectProxy(DynClass dynClass, Object obj) {

        this.dynClass = dynClass;

        this.theClass = obj.getClass();

        this.obj = obj;

        this.fields = new HashMap();

        this.getters = new HashMap();

        this.setters = new HashMap();

        this.coercions = new HashMap();

    }

    public DynClass getDynClass() {

        return this.dynClass;

    }

    private DynObjectManager getManager() {

        return ToolsLocator.getDynObjectManager();

    }

    private DataTypesManager getDataTypesManager() {

        return ToolsLocator.getDataTypesManager();

    }

    private Object coerce(Object value, Class type) {

        Coercion coercion = (Coercion) this.coercions.get(type);

        if( coercion == null ) {

            DataType dataType = getDataTypesManager().getDataType(type);

            if( dataType != null ) {

                coercion = dataType.getCoercion();

                this.coercions.put(type, coercion);

            }

        }

        if( coercion != null ) {

            try {

                value = coercion.coerce(value);

            } catch (CoercionException ex) {

                // Do nothing

            }

        }

        return value;

    }

    private Field getField(String name) {

        Field field = (Field) this.fields.get(name);

        if ( field == null ) {

            Field[] fields = this.theClass.getFields();

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

                if ( fields[i].getName().equals(name) ) {

                    field = fields[i];

                    this.fields.put(name, field);

                    break;

                }

            }

        }

        return field;

    }

    private Method getGetter(String name) {

        Method method = (Method) this.getters.get(name);

        if ( method == null ) {

            String gettername = "get" + name.substring(0, 1).toUpperCase() + name.substring(1);

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

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

                if ( methods[i].getName().equals(gettername) ) {

                    method = methods[i];

                    this.getters.put(name, method);

                    break;

                }

            }

        }

        return method;

    }

    private Method getSetter(String name) {

        Method method = (Method) this.setters.get(name);

        if ( method == null ) {

            String settername = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);

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

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

                if ( methods[i].getName().equals(settername) ) {

                    method = methods[i];

                    this.setters.put(name, method);

                    break;

                }

            }

        }

        return method;

    }

    public void implement(DynClass dynClass) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public void delegate(DynObject dynObject) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        Object r = null;

        Field field = this.getField(name);

        if ( field != null ) {

            try {

                r = field.get(this.obj);

            } catch (IllegalArgumentException ex) {

                throw new RuntimeException("Can't get value to field '"+name+"'.",ex);

            } catch (IllegalAccessException ex) {

                throw new RuntimeException("Can't get value to field '"+name+"'.",ex);

            }

        }

        if ( r == null ) {

            Method getter = this.getGetter(name);

            if ( getter != null ) {

                try {

                    r = getter.invoke(this.obj);

                } catch (IllegalAccessException ex) {

                throw new RuntimeException("Can't get value to field '"+name+"'.",ex);

                } catch (IllegalArgumentException ex) {

                throw new RuntimeException("Can't get value to field '"+name+"'.",ex);

                } catch (InvocationTargetException ex) {

                    throw new RuntimeException();

                }

            }

        }

        if ( r != null ) {

            DynClass dynClass = getManager().get(r.getClass().getName());

            if( dynClass!=null ) {

                r = new DynObjectProxy(dynClass, r);

            }

        }

        return r;

    }

    public void setDynValue(String name, Object value) throws DynFieldNotFoundException {

        Field field = this.getField(name);

        if ( field != null ) {

            try {

                Class<?> type = field.getType();

                field.set(this.obj, coerce(value,type));

            } catch (IllegalArgumentException ex) {

                throw new RuntimeException("Can't set value to field '"+name+"'.",ex);

            } catch (IllegalAccessException ex) {

                throw new RuntimeException("Can't set value to field '"+name+"'.",ex);

            }

        }

        Method setter = this.getSetter(name);

        if ( setter != null ) {

            try {

                Class<?> type = setter.getParameterTypes()[0];

                setter.invoke(this.obj, coerce(value,type));

            } catch (IllegalAccessException ex) {

                throw new RuntimeException("Can't set value to field '"+name+"'.",ex);

            } catch (IllegalArgumentException ex) {

                throw new RuntimeException("Can't set value to field '"+name+"'.",ex);

            } catch (InvocationTargetException ex) {

                throw new RuntimeException("Can't set value to field '"+name+"'.",ex);

            }

        }

    }

    public boolean hasDynValue(String name) {

        Field field = this.getField(name);

        if ( field != null ) {

            return true;

        }

        Method setter = this.getSetter(name);

        if ( setter != null ) {

            return true;

        }

        return false;

    }

    public Object invokeDynMethod(String name, Object[] args) throws DynMethodException {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public Object invokeDynMethod(int code, Object[] args) throws DynMethodException {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public void clear() {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public String toString() {

        return DefaultDynObject.toString(this);

    }

}