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

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.dynobject.impl;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectRuntimeException;

import org.gvsig.tools.dynobject.DynObject_v2;

import org.gvsig.tools.dynobject.DynStruct;

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

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

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

public class DefaultDynObject implements DelegatedDynObject, DynObject_v2 {

    protected DynClass dynClass;

    protected Map values;

    protected DynObject[] delegateds;

    public DefaultDynObject(DynStruct dynClass) {

        this.dynClass = (DynClass) dynClass;

        this.delegateds = null;

        this.values = createValues(null);

    }

    private Map createValues(Map oldValues) {

        HashMap extended = new HashMap();

        if ( oldValues != null ) {

            extended.putAll(oldValues);

        }

        return extended;

    }

    public void implement(DynClass dynClass) {

        this.dynClass = (DefaultDynClass) ((DefaultDynObjectManager) ((DefaultDynClass) dynClass)

                .getManager()).get(new DynClass[]{this.dynClass, dynClass});

        this.values = createValues(this.values);

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        boolean defined = false;

        Object defaultValue = null;

        name = name.toLowerCase();

        DynField field = dynClass.getDynField(name);

        if( field != null ) {

            if( field instanceof DynField_v2 && ((DynField_v2)field).isCalculated() ) {

                return ((DynField_v2)field).getCalculatedValue(this);

            }

            if( values.containsKey(name) ) {

                return values.get(name);

            }

            defined = true;

            defaultValue = field.getDefaultValue();

        }

//        

//        FieldAndIndex fieldAndIndex = dynClass.getDynFieldAndIndex(name);

//        if ( fieldAndIndex != null ) {

//            if ( values.containsKey(name) ) {

//                return values.get(name);

//            }

//            defined = true;

//            defaultValue = fieldAndIndex.getDynField().getDefaultValue();

//        }

        if ( delegateds != null ) {

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

                DynObject dynObj = delegateds[i];

                try {

                    if ( dynObj.hasDynValue(name) ) {

                        return dynObj.getDynValue(name);

                    } else {

                        defined = true;

                        defaultValue = dynObj.getDynValue(name);

                    }

                } catch (DynFieldNotFoundException ex) {

                    ;

                }

            }

        }

        if ( defined ) {

            return defaultValue;

        }

        throw new DynFieldNotFoundException(name, dynClass.getName());

    }

    public void setDynValue(String name, Object value)

            throws DynFieldNotFoundException {

        name = name.toLowerCase();

        if ( this.dynClass.getDynField(name) == null ) {

            throw new DynFieldNotFoundException(name, this.getDynClass()

                    .getName());

        }

        try {

            values.put(name, this.dynClass.getDynField(name).coerce(value));

        } catch (CoercionException e) {

            throw new CoerceValueException(this.dynClass, name, value, e);

        }

    }

    public class CoerceValueException extends DynObjectRuntimeException {

        /**

         *

         */

        private static final long serialVersionUID = 8974502669097158348L;

        public CoerceValueException(DynStruct dynStruct, String fieldName,

                Object value, Throwable cause) {

            super(

                    "Can't convert value %(value) for field %(field) of class %(class).",

                    cause,

                    "Cant_convert_value_XvalueX_for_field_XfieldX_of_class_XclassX",

                    serialVersionUID);

            setValue("field", fieldName);

            setValue("class", dynStruct.getFullName());

            try {

                setValue("value", value.toString());

            } catch (Exception e1) {

                setValue("value", "???");

            }

        }

    }

    public boolean instanceOf(DynClass dynClass) {

        return dynClass.isInstance(this);

    }

    public DynClass getDynClass() {

        return this.dynClass;

    }

    @Override

    public boolean hasDynMethod(String name) {

        name = name.toLowerCase();

        DynMethod method;

        try {

            method = this.dynClass.getDynMethod(name);

            if( method!=null ) {

                return true;

            }

        } catch (DynMethodException ex) {

        }

        if ( delegateds != null ) {

            for( DynObject dynObj : delegateds ) {

                try {

                    if( dynObj instanceof DynObject_v2 ) {

                        if( ((DynObject_v2)dynObj).hasDynMethod(name) ) {

                            return true;

                        }

                    } else {

                        DynClass dynClass = dynObj.getDynClass();

                        if( dynClass.getDynMethod(name)!=null ) {

                            return true;

                        }

                    }

                } catch(Throwable th) {

                    // continue checking others

                }

            }

        }

        return false;

    }

    public boolean hasDynValue(String name) throws DynFieldNotFoundException {

        boolean defined = false;

        name = name.toLowerCase();

        DynField field = dynClass.getDynField(name);

        if( field!=null ) {

            if ( this.values.containsKey(name) ) {

                return true;

            }

            defined = true;

        }

//        int index = dynClass.getFieldIndex(name); xxxx

//        if ( index >= 0 ) {

//            if ( this.values.containsKey(name) ) {

//                return true;

//            }

//            defined = true;

//        }

        if ( delegateds != null ) {

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

                DynObject dynObj = delegateds[i];

                try {

                    if ( dynObj.hasDynValue(name) ) {

                        return true;

                    } else {

                        defined = true;

                    }

                } catch (DynFieldNotFoundException ex) {

                    ;

                }

            }

        }

        if ( defined ) {

            return false;

        }

        throw new DynFieldNotFoundException(name, dynClass.getName());

    }

    public void delegate(DynObject dynObjects) {

        if ( delegateds == null ) {

            this.delegateds = new DynObject[1];

            this.delegateds[0] = dynObjects;

            return;

        }

        DynObject[] newValues = new DynObject[this.delegateds.length + 1];

        System.arraycopy(delegateds, 0, newValues, 0, delegateds.length);

        newValues[delegateds.length] = dynObjects;

        this.delegateds = newValues;

    }

    @Override

    public Object invokeDynMethod(String name, Object[] args)

            throws DynMethodException {

        return this.invokeDynMethod(this, name, args);

    }

    @Override

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

        return this.invokeDynMethod(this, code, args);

    }

    @Override

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

        DynMethod method = this.dynClass.getDynMethod(methodName);

        if (method != null) {

            return method.invoke((DynObject)self, args);

        }

        if ( delegateds != null ) {

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

                try {

                    return delegateds[i].invokeDynMethod(methodName,args);

                } catch (DynMethodNotSupportedException e) {

                    // continue next delegated

                }

            }

        }

        throw new DynMethodNotSupportedException(methodName, self.getClass().getName());

    }

    @Override

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

        DynMethod method = this.dynClass.getDynMethod(methodCode);

        if (method != null) {

            return method.invoke((DynObject)self, args);

        }

        if ( delegateds != null ) {

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

                try {

                    return delegateds[i].invokeDynMethod(methodCode,args);

                } catch (DynMethodNotSupportedException e) {

                    // continue next delegated

                }

            }

        }

        throw new DynMethodNotSupportedException(methodCode, self.getClass().getName());

    }

    public void clear() {

        DynField[] fields = getDynClass().getDeclaredDynFields();

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

            this.setDynValue(fields[i].getName(), fields[i].getDefaultValue());

        }

    }

    public String toString() {

        return DefaultDynObject.toString(this);

    }

    public static String toString(DynObject obj) {

        StringBuffer buffer = new StringBuffer();

        DynClass dynClass = obj.getDynClass();

        buffer.append("DynClass name: ").append(dynClass.getName()).append(

                ";  Fields: ");

        DynField[] fields = dynClass.getDynFields();

        if ( fields == null || fields.length == 0 ) {

            buffer.append("(none)");

        } else {

            buffer.append("[");

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

                if ( i != 0 ) {

                    buffer.append(", ");

                }

                buffer.append(fields[i].getName()).append(" = ")

                        .append(obj.getDynValue(fields[i].getName()));

            }

            buffer.append("]");

        }

        return buffer.toString();

    }

    public boolean hasEmptyValues() {

        return this.values.isEmpty();

    }

}