Application: gvSIG desktop

/**

 * 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 3

 * 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.fmap.dal.feature.impl;

import java.text.DateFormat;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureAttributeGetter;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

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

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

import org.gvsig.tools.evaluator.AbstractEvaluator;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

public class DefaultFeatureAttributeDescriptor implements

    FeatureAttributeDescriptor, Persistent, DynField {

    protected boolean allowNull;

    protected DataType dataType;

    protected DateFormat dateFormat;

    protected Object defaultValue;

    protected int index;

    protected int maximumOccurrences;

    protected int minimumOccurrences;

    protected int size;

    protected String name;

    protected Class objectClass;

    protected int precision;

    protected Evaluator evaluator;

    protected boolean primaryKey;

    protected boolean readOnly;

    protected IProjection SRS;

    protected GeometryType geomType;

    protected int geometryType;

    protected int geometrySubType;

    protected Map additionalInfo;

    protected boolean isAutomatic;

        protected boolean isTime = false;

        protected FeatureAttributeGetter featureAttributeGetter = null;

    protected DefaultFeatureAttributeDescriptor() {

        this.allowNull = true;

        this.dataType = null;

        this.dateFormat = null;

        this.defaultValue = null;

        this.index = -1;

        this.maximumOccurrences = 0;

        this.minimumOccurrences = 0;

        this.size = 0;

        this.name = null;

        this.objectClass = null;

        this.precision = 0;

        this.evaluator = null;

        this.primaryKey = false;

        this.readOnly = false;

        this.SRS = null;

        this.geometryType = Geometry.TYPES.NULL;

        this.geometrySubType = Geometry.SUBTYPES.UNKNOWN;

        this.additionalInfo = null;

        this.isAutomatic = false;

    }

    protected DefaultFeatureAttributeDescriptor(

        DefaultFeatureAttributeDescriptor other) {

        this.allowNull = other.allowNull;

        this.dataType = other.dataType;

        this.dateFormat = other.dateFormat;

        this.defaultValue = other.defaultValue;

        this.index = other.index;

        this.maximumOccurrences = other.maximumOccurrences;

        this.minimumOccurrences = other.minimumOccurrences;

        this.size = other.size;

        this.name = other.name;

        this.objectClass = other.objectClass;

        this.precision = other.precision;

        this.evaluator = other.evaluator;

        this.primaryKey = other.primaryKey;

        this.readOnly = other.readOnly;

        this.SRS = other.SRS;

        this.geometryType = other.geometryType;

        this.geometrySubType = other.geometrySubType;

        this.geomType = other.geomType;

        if (other.additionalInfo != null) {

            Iterator iter = other.additionalInfo.entrySet().iterator();

            Map.Entry entry;

            this.additionalInfo = new HashMap();

            while (iter.hasNext()) {

                entry = (Entry) iter.next();

                this.additionalInfo.put(entry.getKey(), entry.getValue());

            }

        } else {

            this.additionalInfo = null;

        }

        this.isAutomatic = other.isAutomatic;

                this.isTime = other.isTime;

                this.featureAttributeGetter = other.featureAttributeGetter;

    }

    public String getDataTypeName() {

                if( this.getDataType() == null ) {

            return "(unknow)";

        }

                return this.getDataType().getName();

    }

    public FeatureAttributeDescriptor getCopy() {

        return new DefaultFeatureAttributeDescriptor(this);

    }

    public boolean allowNull() {

        return allowNull;

    }

    public DataType getDataType() {

                if (featureAttributeGetter != null){

                    return featureAttributeGetter.getDataType();

                }

        return this.dataType;

    }

    public DateFormat getDateFormat() {

        return this.dateFormat;

    }

    public Object getDefaultValue() {

        return this.defaultValue;

    }

    public Evaluator getEvaluator() {

        return this.evaluator;

    }

    public int getGeometryType() {

        return this.geometryType;

    }

    public int getGeometrySubType() {

        return this.geometrySubType;

    }

    public GeometryType getGeomType() {

        if (this.geomType == null) {

            try {

                this.geomType =

                    GeometryLocator.getGeometryManager().getGeometryType(

                        this.geometryType, this.geometrySubType);

            } catch (GeometryException e) {

                throw new RuntimeException(

                    "Error getting geometry type with type = "

                        + this.geometryType + ", subtype = "

                        + this.geometrySubType, e);

            }

        }

        return this.geomType;

    }

    public int getIndex() {

        return this.index;

    }

    protected FeatureAttributeDescriptor setIndex(int index) {

        this.index = index;

        return this;

    }

    public int getMaximumOccurrences() {

        return this.maximumOccurrences;

    }

    public int getMinimumOccurrences() {

        return this.minimumOccurrences;

    }

    public String getName() {

        return this.name;

    }

    public Class getObjectClass() {

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

            return objectClass;

        }

                return getDataType().getDefaultClass();

    }

    public int getPrecision() {

        return this.precision;

    }

    public IProjection getSRS() {

        return this.SRS;

    }

    public int getSize() {

        return this.size;

    }

    public boolean isPrimaryKey() {

        return this.primaryKey;

    }

    public boolean isReadOnly() {

        return this.readOnly;

    }

    public Object getAdditionalInfo(String infoName) {

        if (this.additionalInfo == null) {

            return null;

        }

        return this.additionalInfo.get(infoName);

    }

    public boolean isAutomatic() {

        return this.isAutomatic;

    }

    private boolean compareObject(Object a, Object b) {

        if (a != b) {

            if (a == null) {

                return false;

            }

            return a.equals(b);

        }

        return true;

    }

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (!(obj instanceof DefaultFeatureAttributeDescriptor)) {

            return false;

        }

        DefaultFeatureAttributeDescriptor other =

            (DefaultFeatureAttributeDescriptor) obj;

        if (this.allowNull != other.allowNull) {

            return false;

        }

        if (this.index != other.index) {

            return false;

        }

        if (!compareObject(this.name, other.name)) {

            return false;

        }

                if (this.getDataType() != other.getDataType()) {

            return false;

        }

        if (this.size != other.size) {

            return false;

        }

        if (!compareObject(this.defaultValue, other.defaultValue)) {

            return false;

        }

        if (!compareObject(this.defaultValue, other.defaultValue)) {

            return false;

        }

        if (this.primaryKey != other.primaryKey) {

            return false;

        }

        if (this.isAutomatic != other.isAutomatic) {

            return false;

        }

        if (this.readOnly != other.readOnly) {

            return false;

        }

        if (this.precision != other.precision) {

            return false;

        }

        if (this.maximumOccurrences != other.maximumOccurrences) {

            return false;

        }

        if (this.minimumOccurrences != other.minimumOccurrences) {

            return false;

        }

        if (this.geometryType != other.geometryType) {

            return false;

        }

        if (this.geometrySubType != other.geometrySubType) {

            return false;

        }

        if (!compareObject(this.evaluator, other.evaluator)) {

            return false;

        }

        if (!compareObject(this.SRS, other.SRS)) {

            return false;

        }

        if (!compareObject(this.dateFormat, other.dateFormat)) {

            return false;

        }

        if (!compareObject(this.objectClass, other.objectClass)) {

            return false;

        }

        return true;

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        allowNull = state.getBoolean("allowNull");

        dataType =

            ToolsLocator.getDataTypesManager().get(state.getInt("dataType"));

        // FIXME how persist dateFormat ???

        // dateFormat;

        defaultValue = state.get("defaultValue");

        index = state.getInt("index");

        maximumOccurrences = state.getInt("maximumOccurrences");

        minimumOccurrences = state.getInt("minimumOccurrences");

        size = state.getInt("size");

        name = state.getString("name");

        try {

            objectClass = Class.forName(state.getString("objectClass"));

        } catch (ClassNotFoundException e) {

            throw new PersistenceException(e);

        }

        precision = state.getInt("precision");

        evaluator = (Evaluator) state.get("evaluator");

        primaryKey = state.getBoolean("primaryKey");

        readOnly = state.getBoolean("readOnly");

        String srsId = state.getString("srsId");

        if (srsId != null) {

            SRS = CRSFactory.getCRS(srsId);

        }

        geometryType = state.getInt("geometryType");

        geometrySubType = state.getInt("geometrySubType");

        additionalInfo = (Map) state.get("aditionalInfo");

        isAutomatic = state.getBoolean("isAutomatic");

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("allowNull", allowNull);

        state.set("dataType", dataType);

        // FIXME how persist dateFormat ???

        // dateFormat;

        defaultValue = state.get("defaultValue");

        index = state.getInt("index");

        maximumOccurrences = state.getInt("maximumOccurrences");

        minimumOccurrences = state.getInt("minimumOccurrences");

        size = state.getInt("size");

        name = state.getString("name");

        try {

            objectClass = Class.forName(state.getString("objectClass"));

        } catch (ClassNotFoundException e) {

            throw new PersistenceException(e);

        }

        precision = state.getInt("precision");

        evaluator = (Evaluator) state.get("evaluator");

        primaryKey = state.getBoolean("primaryKey");

        readOnly = state.getBoolean("readOnly");

        String srsId = state.getString("srsId");

        if (srsId != null) {

            SRS = CRSFactory.getCRS(srsId);

        }

        geometryType = state.getInt("geometryType");

        geometrySubType = state.getInt("geometrySubType");

        additionalInfo = (Map) state.get("aditionalInfo");

        isAutomatic = state.getBoolean("isAutomatic");

    }

    /**

     * Start of DynField interface Implementation

     * READONLY

     */

    public DynObjectValueItem[] getAvailableValues() {

        return null;

    }

    public String getDescription() {

        return getName();

    }

    public Object getMaxValue() {

        return null;

    }

    public Object getMinValue() {

        return null;

    }

    public int getTheTypeOfAvailableValues() {

        return 0;

    }

    public int getType() {

            if (featureAttributeGetter != null){

            return featureAttributeGetter.getDataType().getType();

        }

        return getDataType().getType();

    }

    public boolean isMandatory() {

        return !allowNull() || isPrimaryKey();

    }

    public boolean isPersistent() {

        return false;

    }

    public DynField setAvailableValues(DynObjectValueItem[] values) {

        throw new UnsupportedOperationException();

    }

    public DynField setDescription(String description) {

        throw new UnsupportedOperationException();

    }

    public DynField setMandatory(boolean mandatory) {

        throw new UnsupportedOperationException();

    }

    public DynField setMaxValue(Object maxValue) {

        throw new UnsupportedOperationException();

    }

    public DynField setMinValue(Object minValue) {

        throw new UnsupportedOperationException();

    }

    public DynField setPersistent(boolean persistent) {

        throw new UnsupportedOperationException();

    }

    public DynField setTheTypeOfAvailableValues(int type) {

        throw new UnsupportedOperationException();

    }

    public DynField setType(int type) {

        throw new UnsupportedOperationException();

    }

    public DynField setDefaultDynValue(Object defaultValue) {

        throw new UnsupportedOperationException();

    }

    public DynField addElementsType() throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    public Class getClassOfValue() {

        return null;

    }

    public DynField getElementsType() {

        return null;

    }

    public DynField setClassOfValue(Class theClass)

        throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    public DynField setElementsType(DynStruct type)

        throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    public DynField setElementsType(int type)

        throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    public DynField setSubtype(String subtype) {

        throw new UnsupportedOperationException();

    }

    public void validate(Object value) throws DynFieldValidateException {

        if (value == null && !this.allowNull()) {

            throw new DynFieldValidateException(value, this, null);

        }

        try {

            this.dataType.coerce(value);

        } catch (CoercionException e) {

            throw new DynFieldValidateException(value, this, e);

        }

        /*

         * Other checks will be needed

         */

    }

    public String getSubtype() {

            if (featureAttributeGetter != null){

            return featureAttributeGetter.getDataType().getSubtype();

        }       

        return this.dataType.getSubtype();

    }

    public Object coerce(Object value) {

        throw new UnsupportedOperationException();

    }

    public DynField setAvailableValues(List values) {

        throw new UnsupportedOperationException();

    }

    public String getGroup() {

        return null;

    }

    public int getOder() {

        return 0;

    }

    public DynField setGroup(String groupName) {

        throw new UnsupportedOperationException();

    }

    public DynField setOrder(int order) {

        throw new UnsupportedOperationException();

    }

    public DynField setHidden(boolean hidden) {

        throw new UnsupportedOperationException();

    }

    public boolean isHidden() {

        return false;

    }

    public DynField setReadOnly(boolean arg0) {

        throw new UnsupportedOperationException();

    }

    public boolean isContainer() {

        return false;

    }

    public Class getClassOfItems() {

        return null;

    }

    public DynField setDefaultFieldValue(Object defaultValue) {

        throw new UnsupportedOperationException();

    }

    public DynField setClassOfItems(Class theClass) {

        throw new UnsupportedOperationException();

    }

    public DynField setType(DataType type) {

        throw new UnsupportedOperationException();

    }

        public boolean isTime() {                

                return isTime;

        }

    public FeatureAttributeGetter getFeatureAttributeGetter() {

       return featureAttributeGetter;        

    }

    public void setFeatureAttributeGetter(

        FeatureAttributeGetter featureAttributeTransform) {

        this.featureAttributeGetter = featureAttributeTransform;              

    }        

    private class ConstantValueEvaluator extends AbstractEvaluator {

        public Object evaluate(EvaluatorData data) throws EvaluatorException {

            return defaultValue;

        }

        public String getName() {

            return "Constant attribute "+name;

        }

    }

    public void setConstantValue(boolean isConstantValue) {

        if( isConstantValue ) {

            /* Cuando un attributo tiene asociado un evaluador, este se interpreta

             * como que no debe cargarse de la fuente de datos subyacente, siendo 

             * el evaluador el que se encarga de proporcionar su valor.

             * Nos limitamos a asignar un evaluador que retorna simpre el valor

             * por defecto para ese attributo.

             */

            this.evaluator = new ConstantValueEvaluator();

        } else {

            this.evaluator = null;

        }

    }

}