Application: gvSIG desktop

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.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

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.Evaluator;

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 int geometryType;

        protected int geometrySubType;

        protected Map additionalInfo;

        protected boolean isAutomatic;

        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;

                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;

        }

        public String getDataTypeName() {

                if( this.dataType == null ) {

                        return "(unknow)";

                }

                return this.dataType.getName();

        }

        public FeatureAttributeDescriptor getCopy() {

                return new DefaultFeatureAttributeDescriptor(this);

        }

        public boolean allowNull() {

                return allowNull;

        }

        public DataType 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 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 (this.dataType.getType() == DataTypes.OBJECT) {

                        return objectClass;

                } 

                return this.dataType.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.dataType != other.dataType) {

                        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() {

                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 {

                // Do nothing

        }

        public String 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();

        }

}