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.lang.ref.WeakReference;

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 java.util.Objects;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.timesupport.Interval;

import org.gvsig.timesupport.RelativeInterval;

import org.gvsig.timesupport.TimeSupportLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynField_LabelAttribute;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.Tags;

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

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

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

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

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

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultFeatureAttributeDescriptor implements

        FeatureAttributeDescriptor, Persistent, DynField_v2, DynField_LabelAttribute {

    protected static final Logger LOGGER = LoggerFactory.getLogger(DefaultFeatureAttributeDescriptor.class);

    protected boolean allowNull;

    protected DataType dataType;

    protected String dataProfile; 

    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 Interval interval;

    protected FeatureAttributeGetter featureAttributeGetter = null;

    protected FeatureAttributeEmulator featureAttributeEmulator = null;

    protected boolean indexed = false;

    protected boolean isIndexAscending = true;

    protected boolean allowIndexDuplicateds = true;

    protected DynObjectValueItem[] availableValues;

    protected String description;

    protected Object minValue;

    protected Object maxValue;

    protected String label;

    protected int order;

    protected boolean hidden;

    protected String groupName;

    protected Tags tags = new DefaultTags();

    private DynMethod availableValuesMethod;

    private DynMethod calculateMethod;

    private WeakReference typeRef;

    public DefaultFeatureAttributeDescriptor() {

        // Usada en la persistencia

    }

    protected DefaultFeatureAttributeDescriptor(FeatureType type) {

        setFeatureType(type);

        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;

        this.hidden = false;

    }

    protected DefaultFeatureAttributeDescriptor(

            DefaultFeatureAttributeDescriptor other

        ) {

        copyFrom(other);

    }

    @Override

    public void copyFrom(DynField other1) {

        if( !(other1 instanceof DefaultFeatureAttributeDescriptor) ) {

            throw new IllegalArgumentException("Can't copy from a non DefaultFeatureAttributeDescriptor");

        }

        DefaultFeatureAttributeDescriptor other = (DefaultFeatureAttributeDescriptor) other1;

        this.typeRef = other.typeRef;

        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.featureAttributeEmulator = other.featureAttributeEmulator;

        this.indexed = other.indexed;

        this.isIndexAscending = other.isIndexAscending;

        this.allowIndexDuplicateds = other.allowIndexDuplicateds;

        this.hidden = other.hidden;

        this.dataProfile = other.dataProfile;

    }

    public void setFeatureType(FeatureType type) {

        // Usada en la persistencia

        if( type == null ) {

            this.typeRef = null;

        } else {

            this.typeRef = new WeakReference(type);

        }

    }

    @Override

    public String getDataTypeName() {

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

            return "(unknow)";

        }

        return this.getDataType().getName();

    }

    @Override

    public FeatureAttributeDescriptor getCopy() {

        return new DefaultFeatureAttributeDescriptor(this);

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        return new DefaultFeatureAttributeDescriptor(this);

    }

    @Override

    public boolean allowNull() {

        return allowNull;

    }

    @Override

    public DataType getDataType() {

        if (featureAttributeGetter != null) {

            return featureAttributeGetter.getDataType();

        }

        return this.dataType;

    }

    public FeatureAttributeDescriptor setDataType(int type) {

        this.dataType = ToolsLocator.getDataTypesManager().get(type);

        return this;

    }

    @Override

    public DateFormat getDateFormat() {

        return this.dateFormat;

    }

    @Override

    public Object getDefaultValue() {

        return this.defaultValue;

    }

    @Override

    public Evaluator getEvaluator() {

        return this.evaluator;

    }

    @Override

    public int getGeometryType() {

        if( this.dataType.getType()!=DataTypes.GEOMETRY ) {

            return Geometry.TYPES.UNKNOWN;

        }

        return this.geometryType;

    }

    @Override

    public int getGeometrySubType() {

        if( this.dataType.getType()!=DataTypes.GEOMETRY ) {

            return Geometry.SUBTYPES.UNKNOWN;

        }

        return this.geometrySubType;

    }

    @Override

    public GeometryType getGeomType() {

        if( this.dataType.getType()!=DataTypes.GEOMETRY ) {

            return null;

        }

        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;

    }

    @Override

    public int getIndex() {

        return this.index;

    }

    protected FeatureAttributeDescriptor setIndex(int index) {

        this.index = index;

        return this;

    }

    @Override

    public int getMaximumOccurrences() {

        return this.maximumOccurrences;

    }

    @Override

    public int getMinimumOccurrences() {

        return this.minimumOccurrences;

    }

    @Override

    public String getName() {

        return this.name;

    }

    public FeatureAttributeDescriptor setName(String name) {

        this.name = name;

        return this;

    }

    @Override

    public Class getObjectClass() {

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

            return objectClass;

        }

        return getDataType().getDefaultClass();

    }

    @Override

    public int getPrecision() {

        return this.precision;

    }

    @Override

    public IProjection getSRS() {

        return this.SRS;

    }

    @Override

    public Interval getInterval() {

        return this.interval;

    }

    public IProjection getSRS(WeakReference storeRef) {

        if( this.SRS==null ) {

            FeatureStore store = (FeatureStore) storeRef.get();

            this.SRS = (IProjection) store.getDynValue(DataStore.METADATA_CRS);

        }

        return this.SRS;

    }

    @Override

    public int getSize() {

        return this.size;

    }

    @Override

    public boolean isPrimaryKey() {

        return this.primaryKey;

    }

    @Override

    public boolean isReadOnly() {

        if (this.readOnly) {

            return true;

        }

        if (this.getEvaluator() != null) {

            return true;

        }

        if (this.featureAttributeEmulator != null) {

            return !this.featureAttributeEmulator.allowSetting();

        }

        return false;

    }

    @Override

    public Object getAdditionalInfo(String infoName) {

        if (this.additionalInfo == null) {

            return null;

        }

        return this.additionalInfo.get(infoName);

    }

    @Override

    public boolean isAutomatic() {

        return this.isAutomatic;

    }

    @Override

    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 (!Objects.equals(this.name, other.name)) {

            return false;

        }

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

            return false;

        }

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

            return false;

        }

        if (!Objects.equals(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 (!Objects.equals(this.evaluator, other.evaluator)) {

            return false;

        }

        if (!Objects.equals(this.featureAttributeEmulator, other.featureAttributeEmulator)) {

            return false;

        }

        if (!Objects.equals(this.SRS, other.SRS)) {

            return false;

        }

        if (!Objects.equals(this.dateFormat, other.dateFormat)) {

            return false;

        }

        if (!Objects.equals(this.objectClass, other.objectClass)) {

            return false;

        }

        if (!Objects.equals(this.dataProfile, other.dataProfile)) {

            return false;

        }

        return true;

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        allowNull = state.getBoolean("allowNull");

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

        dataProfile = state.getString("dataProfile");

//        FIXME: dateFormat;

        try {

            defaultValue = dataType.coerce(state.get("defaultValue"));

        } catch (CoercionException ex) {

        }

        index = state.getInt("index");

        maximumOccurrences = state.getInt("maximumOccurrences");

        minimumOccurrences = state.getInt("minimumOccurrences");

        size = state.getInt("size");

        name = state.getString("name");

        try {

            String objectClassName = state.getString("objectClass"); 

            if( !StringUtils.isBlank(objectClassName) ) { 

                objectClass = Class.forName(objectClassName); 

            }

        } catch (Throwable e) {

            LOGGER.warn("Can't restore the objectClass of the FeatureAttributreDescriptor", e);

        }

        precision = state.getInt("precision");

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

        primaryKey = state.getBoolean("primaryKey");

        readOnly = state.getBoolean("readOnly");

        SRS = (IProjection) state.get("SRS");

        geometryType = state.getInt("geometryType");

        geometrySubType = state.getInt("geometrySubType");

        if( geometryType!=Geometry.TYPES.UNKNOWN && 

                geometrySubType!=Geometry.SUBTYPES.UNKNOWN ) {

            geomType = GeometryUtils.getGeometryType(

                    geometryType, 

                    geometrySubType

            );

        }

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

        isAutomatic = state.getBoolean("isAutomatic");

        isTime = state.getBoolean("isTime");

        if( state.hasValue("intervalStart") ) {

            long intervalStart = state.getLong("interval_start");

            long intervalEnd = state.getLong("interval_end");

            interval = TimeSupportLocator.getManager().createRelativeInterval(intervalStart, intervalEnd);

        } else {

            interval = null;

        }

        featureAttributeEmulator = (FeatureAttributeEmulator) state.get("featureAttributeEmulator");

        indexed = state.getBoolean("indexed");

        isIndexAscending = state.getBoolean("isIndexAscending");

        allowIndexDuplicateds = state.getBoolean("allowIndexDuplicateds");

//        FIXME: availableValues 

        description = state.getString("description");

        minValue = state.get("minValue");

        maxValue = state.get("maxValue");

        label = state.getString("label");

        order = state.getInt("order");

        hidden = state.getBoolean("hidden");

        groupName = state.getString("groupName");

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("allowNull", allowNull);

        state.set("dataType", dataType.getType());

        state.set("dataProfile", dataProfile);

//        FIXME: dateFormat;

        state.set("defaultValue", Objects.toString(defaultValue));

        state.set("index", index);

        state.set("maximumOccurrences", maximumOccurrences);

        state.set("minimumOccurrences", minimumOccurrences);

        state.set("size", size);

        state.set("name", name);

        state.set("objectClass", objectClass==null? null:objectClass.getName());

        state.set("precision", precision);

        state.set("evaluator", evaluator);

        state.set("primaryKey", primaryKey);

        state.set("readOnly", readOnly);

        state.set("SRS", SRS);

        GeometryType theGeomType = this.getGeomType();

        if( theGeomType==null ) {

            state.set("geometryType", Geometry.TYPES.UNKNOWN);

            state.set("geometrySubType", Geometry.SUBTYPES.UNKNOWN);

        } else {

            state.set("geometryType", theGeomType.getType());

            state.set("geometrySubType", theGeomType.getSubType());

        }

//      FIXME: additionalInfo

        state.set("isAutomatic", isAutomatic);

        state.set("isTime", isTime);

        if( this.interval==null ) {

            state.setNull("interval_start");

            state.setNull("interval_end");

        } else {

            state.set("interval_start", ((RelativeInterval)interval).getStart().toMillis());

            state.set("interval_end", ((RelativeInterval)interval).getEnd().toMillis());

        }

        state.set("SRS", SRS);

//      FIXME: featureAttributeGetter

        if( featureAttributeEmulator instanceof Persistent ) {

            state.set("featureAttributeEmulator", featureAttributeEmulator);

        } else {

            state.setNull("featureAttributeEmulator");

        }

        state.set("indexed", indexed);

        state.set("isIndexAscending", isIndexAscending);

        state.set("allowIndexDuplicateds", allowIndexDuplicateds);

//        FIXME: availableValues 

        state.set("description", description);

        state.set("minValue", minValue);

        state.set("maxValue", maxValue);

        state.set("label", label);

        state.set("order", order);

        state.set("hidden", hidden);

        state.set("groupName", groupName);

    }

    private static final String FEATATTRDESC_PERSISTENCE_DEFINITION_NAME = "FeatureAttributeDescriptor";

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(FEATATTRDESC_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(DefaultFeatureAttributeDescriptor.class,

                    FEATATTRDESC_PERSISTENCE_DEFINITION_NAME,

                    FEATATTRDESC_PERSISTENCE_DEFINITION_NAME

                        + " persistent definition",

                    null,

                    null

            );

            definition.addDynFieldBoolean("allowNull");

            definition.addDynFieldInt("dataType");

            definition.addDynFieldString("dataProfile");

//            definition.addDynFieldString("dateFormat");

            definition.addDynFieldString("defaultValue");

            definition.addDynFieldInt("index");

            definition.addDynFieldInt("maximumOccurrences");

            definition.addDynFieldInt("minimumOccurrences");

            definition.addDynFieldInt("size");

            definition.addDynFieldString("name");

            definition.addDynFieldString("objectClass");

            definition.addDynFieldInt("precision");

            definition.addDynFieldObject("evaluator")

                    .setClassOfValue(Evaluator.class);

            definition.addDynFieldBoolean("primaryKey");

            definition.addDynFieldBoolean("readOnly");

            definition.addDynFieldObject("SRS")

                    .setClassOfValue(IProjection.class);

            definition.addDynFieldInt("geometryType");

            definition.addDynFieldInt("geometrySubType");

//            definition.addDynFieldMap("additionalInfo");

            definition.addDynFieldBoolean("isAutomatic");

            definition.addDynFieldBoolean("isTime");

            definition.addDynFieldLong("interval_start");

            definition.addDynFieldLong("interval_end");

            definition.addDynFieldObject("featureAttributeEmulator")

                    .setClassOfValue(FeatureAttributeEmulator.class);

            definition.addDynFieldBoolean("indexed");

            definition.addDynFieldBoolean("isIndexAscending");

            definition.addDynFieldBoolean("allowIndexDuplicateds");

//            definition.addDynFieldInt("availableValues");

            definition.addDynFieldInt("description");

            definition.addDynFieldInt("minValue");

            definition.addDynFieldInt("maxValue");

            definition.addDynFieldInt("label");

            definition.addDynFieldInt("order");

            definition.addDynFieldBoolean("hidden");

            definition.addDynFieldInt("groupName");

        }

    }

    /*

     * Start of DynField interface Implementation

     *

     */

    @Override

    public Tags getTags() {

        return tags;

    }

    @Override

    public DynObjectValueItem[] getAvailableValues() {

        return this.availableValues;

    }

    @Override

    public String getDescription() {

        if( this.description == null ) {

            return getName();

        }

        return this.description;

    }

    @Override

    public Object getMaxValue() {

        return this.maxValue;

    }

    @Override

    public Object getMinValue() {

        return this.minValue;

    }

    @Override

    public int getTheTypeOfAvailableValues() {

        return 1;

    }

    @Override

    public int getType() {

        if (featureAttributeGetter != null) {

            return featureAttributeGetter.getDataType().getType();

        }

        return getDataType().getType();

    }

    @Override

    public boolean isMandatory() {

        return !allowNull() || isPrimaryKey();

    }

    @Override

    public boolean isPersistent() {

        return false;

    }

    @Override

    public DynField setAvailableValues(DynObjectValueItem[] values) {

        if ( ArrayUtils.isEmpty(values) ) {

            this.availableValues = null;

        } else {

            this.availableValues = values;

        }

        return this;

    }

    @Override

    public DynField setDescription(String description) {

        this.description = description;

        return this;

    }

    @Override

    public DynField setMandatory(boolean mandatory) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setMaxValue(Object maxValue) {

        try {

            this.maxValue = this.coerce(maxValue);

        } catch (CoercionException e) {

            throw new IllegalArgumentException(e);

        }

        return this;

    }

    @Override

    public DynField setMinValue(Object minValue) {

        try {

            this.maxValue = this.coerce(minValue);

        } catch (CoercionException e) {

            throw new IllegalArgumentException(e);

        }

        return this;

    }

    @Override

    public DynField setPersistent(boolean persistent) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setTheTypeOfAvailableValues(int type) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setType(int type) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setDefaultDynValue(Object defaultValue) {

        throw new UnsupportedOperationException();

    }

    @Override

    public Class getClassOfValue() {

        return null;

    }

    @Override

    public DynField getElementsType() {

        return null;

    }

    @Override

    public DynField setClassOfValue(Class theClass)

            throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setElementsType(DynStruct type)

            throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setElementsType(int type)

            throws DynFieldIsNotAContainerException {

        throw new UnsupportedOperationException();

    }

    public FeatureAttributeDescriptor setDataProfileName(String dataProfile) {

        this.dataProfile = dataProfile;

        return this;

    }

    @Override

    public String getDataProfileName() {

        return dataProfile;

    }

    @Override

    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

         */

    }

    @Override

    public String getSubtype() {

        if (featureAttributeGetter != null) {

            return featureAttributeGetter.getDataType().getSubtype();

        }

        return this.dataType.getSubtype();

    }

    @Override

    public Object coerce(Object value) throws CoercionException {

        if ( value == null ) {

            return value; // O debe devolver this.defaultValue

        }

        try {

            return this.getDataType().coerce(value);

        } catch(Exception ex){

            throw new RuntimeException(ex);

        }

    }

    @Override

    public DynField setAvailableValues(List values) {

        if (  values == null || values.isEmpty() ) {

            this.availableValues = null;

        } else {

            this.availableValues = (DynObjectValueItem[]) values.toArray(

                new DynObjectValueItem[values.size()]

            );

        }

        return this;

    }

    @Override

    public String getGroup() {

        return this.groupName;

    }

    @Override

    public int getOder() {

        return this.order;

    }

    @Override

    public String getLabel() {

        if( this.label == null ) {

            return this.getName();

        }

        return this.label;

    }

    @Override

    public DynField setLabel(String label) {

        this.label = label;

        return this;

    }

    @Override

    public DynField setGroup(String groupName) {

        this.groupName = groupName;

        return this;

    }

    @Override

    public DynField setOrder(int order) {

        this.order = order;

        return this;

    }

    @Override

    public DynField setHidden(boolean hidden) {

        this.hidden = hidden;

        return this;

    }

    @Override

    public boolean isHidden() {

        return this.hidden;

    }

    @Override

    public DynField setReadOnly(boolean arg0) {

        throw new UnsupportedOperationException();

    }

    @Override

    public boolean isContainer() {

        return false;

    }

    @Override

    public Class getClassOfItems() {

        return null;

    }

    @Override

    public DynField setDefaultFieldValue(Object defaultValue) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setClassOfItems(Class theClass) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setType(DataType type) {

        throw new UnsupportedOperationException();

    }

    @Override

    public DynField setSubtype(String subtype) {

        throw new UnsupportedOperationException();

    }

    @Override

    public boolean isTime() {

        return isTime;

    }

    @Override

    public FeatureAttributeGetter getFeatureAttributeGetter() {

        return featureAttributeGetter;

    }

    @Override

    public void setFeatureAttributeGetter(

            FeatureAttributeGetter featureAttributeTransform) {

        this.featureAttributeGetter = featureAttributeTransform;

    }

    @Override

    public FeatureAttributeEmulator getFeatureAttributeEmulator() {

        return this.featureAttributeEmulator;

    }

    public FeatureAttributeDescriptor setFeatureAttributeEmulator(FeatureAttributeEmulator featureAttributeEmulator) {

        this.featureAttributeEmulator = featureAttributeEmulator;

        return this;

    }

    @Override

    public boolean isIndexed() {

        return this.indexed;

    }

    @Override

    public boolean allowIndexDuplicateds() {

        return this.allowIndexDuplicateds;

    }

    @Override

    public boolean isIndexAscending() {

        return this.isIndexAscending;

    }

    @Override

    public DynField setClassOfValue(DynStruct dynStrct) {

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

    }

    @Override

    public DynField setClassOfValue(String theClassNameOfValue) {

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

    }

    @Override

    public String getClassNameOfValue() {

        return null;

    }

    @Override

    public DynStruct getDynClassOfValue() {

        return null;

    }

    @Override

    public DynField setTypeOfItems(int type) {

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

    }

    @Override

    public int getTypeOfItems() {

        return DataTypes.INVALID;

    }

    @Override

    public DynField setClassOfItems(DynStruct dynStrct) {

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

    }

    @Override

    public DynField setClassOfItems(String theClassNameOfValue) {

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

    }

    @Override

    public String getClassNameOfItems() {

        return null;

    }

    @Override

    public DynStruct getDynClassOfItems() {

        return null;

    }

    @Override

    public DynField setRelationType(int relationType) {

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

    }

    @Override

    public int getRelationType() {

        return RELATION_TYPE_NONE;

    }

    @Override

    public DynField setAvailableValues(DynMethod availableValuesMethod) {

        this.availableValuesMethod = availableValuesMethod;

        return this;

    }

    @Override

    public DynObjectValueItem[] getAvailableValues(DynObject self) {

        if( this.availableValuesMethod != null ) {

            DynObjectValueItem[] values;

            try {

                values = (DynObjectValueItem[]) this.availableValuesMethod.invoke(self,new Object[] {this});

            } catch (DynMethodException ex) {

                return this.availableValues;

            }

            if( values != null ) {

                return values;

            }

        }

        return this.availableValues;

    }

    @Override

    public DynMethod getAvailableValuesMethod() {

        return this.availableValuesMethod;

    }

    @Override

    public boolean isAvailableValuesCalculated() {

        return this.availableValuesMethod!=null;

    }

    @Override

    public DynMethod getCalculateMethod() {

        return this.calculateMethod;

    }

    @Override

    public DynField setCalculateMethod(DynMethod method) {

        this.calculateMethod = method;

        return this;

    }

    @Override

    public boolean isCalculated() {

        return this.calculateMethod != null;

    }

    @Override

    public Object getCalculatedValue(DynObject self) {

        try {

            return this.calculateMethod.invoke(self, new Object[] { this });

        } catch (DynMethodException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public DynField setValidateElements(boolean validate) {

        return this;

    }

    @Override

    public boolean getValidateElements() {

        return false;

    }

    private class ConstantValueEvaluator extends AbstractEvaluator {

        @Override

        public Object evaluate(EvaluatorData data) throws EvaluatorException {

            return defaultValue;

        }

        @Override

        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;

        }

    }

    @Override

    public boolean isComputed() {

        return featureAttributeEmulator!=null || evaluator!=null || isCalculated();

    }

    @Override

    public FeatureStore getStore() {

        FeatureType ftype = this.getFeatureType();

        if( ftype == null ) {

            return null;

        }

        return ftype.getStore();

    }

    @Override

    public FeatureType getFeatureType() {

        if( this.typeRef==null ) {

            return null;

        }

        return (FeatureType) this.typeRef.get();

    }

    public FeatureAttributeDescriptor setInterval(Interval interval) {

        this.interval = interval;

        return this;

    }

    public void fixAll() {

        switch(this.getType()) {

            case DataTypes.INSTANT:

            case DataTypes.INTERVAL:

            case DataTypes.DATE:

                if( this.getInterval()!=null ) {

                    this.isTime = true;

                }

                break;

        }

    }

    @Override

    public String[] getRequiredFieldNames() {

        FeatureAttributeEmulator emulator = this.getFeatureAttributeEmulator();

        if( emulator==null ) {

            return null;

        }

        return emulator.getRequiredFieldNames();

    }

}