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.math.BigDecimal;

import java.math.MathContext;

import java.math.RoundingMode;

import java.text.DateFormat;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Locale;

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.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

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

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.dal.feature.ForeingKey;

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

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypeUtils;

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.i18n.I18nManager;

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;

import org.gvsig.tools.dataTypes.CoercionContext;

@SuppressWarnings("UseSpecificCatch")

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

    protected int roundMode;

    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;

    private Map<Object,String> labelOfValueMap; // No persistente

    protected String description;

    protected Object minValue;

    protected Object maxValue;

    protected String label;

    protected String shortLabel;

    protected int order;

    protected boolean hidden;

    protected String groupName;

    protected Tags tags = new DefaultTags();

    private DynMethod availableValuesMethod;

    private DynMethod calculateMethod;

    private WeakReference typeRef;

    protected DefaultForeingKey foreingKey = null;

    protected CoercionContext coerceContext = null; // not persistent

    protected MathContext mathContext = null; // not persistent

    private int relationType = RELATION_TYPE_NONE;

    protected Locale locale;

    public DefaultFeatureAttributeDescriptor() {

        // Usada en la persistencia

    }

    protected DefaultFeatureAttributeDescriptor(FeatureType type) {

        this();

//        LOGGER.info(String.format("Created FeatureAttributeDescriptor [%08x].", this.hashCode()));

        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.scale = 0;

        this.roundMode = BigDecimal.ROUND_HALF_UP;

        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;

        this.relationType = RELATION_TYPE_NONE;

        this.locale = Locale.ENGLISH;

    }

    protected DefaultFeatureAttributeDescriptor(

            DefaultFeatureAttributeDescriptor other

        ) {

        this();

        copyFrom(other);

//        LOGGER.info(String.format("Created FeatureAttributeDescriptor [%08x] [%s] (copy).", this.hashCode(), this.name));

    }

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

        this.roundMode = other.roundMode;

        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;

        this.availableValues = other.availableValues;

        this.description = other.description;

        this.minValue = other.minValue;

        this.maxValue = other.maxValue;

        this.label = other.label;

        this.order = other.order;

        this.groupName = other.groupName;

        if( other.tags==null ) {

            this.tags = null;

        } else {

            try {

                this.tags = (Tags) other.tags.clone();

            } catch (Exception ex) {

            }

        }

        this.foreingKey = null;

        if( other.foreingKey!=null ) {

            try {

                this.foreingKey = (DefaultForeingKey) other.foreingKey.clone();

            } catch (CloneNotSupportedException ex) {

            }

        }

        if( this.foreingKey!=null ) {

            this.foreingKey.setDescriptor(this);

        }

        // TODO: ? Habria que clonarlos ?

        this.availableValuesMethod = other.availableValuesMethod;

        this.calculateMethod = other.calculateMethod;

        this.relationType = other.relationType;

        this.locale = other.locale;

    }

    public void setFeatureType(FeatureType type) {

        // Usada en la persistencia

        if( type == null ) {

            this.typeRef = null;

        } else {

            this.typeRef = new WeakReference(type);

//            LOGGER.info(String.format("FeatureAttributeDescriptor[%08x] set FeatureType [%08x], ref [%08x].", this.hashCode(), type.hashCode(), typeRef.hashCode()));

        }

    }

    @Override

    public String getDataTypeName() {

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

            return "(unknow)";

        }

        return this.getDataType().getName();

    }

    @Override

    public DefaultFeatureAttributeDescriptor getCopy() {

        return new DefaultFeatureAttributeDescriptor(this);

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        return new DefaultFeatureAttributeDescriptor(this);

    }

    @Override

    public boolean allowNull() {

        return allowNull;

    }

    public Locale getLocale() {

      return this.locale;

    }

    @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 Object getDefaultValueCoerced() {        

        try {

            Object value = this.defaultValue;

            if( value == null ) {

                return null;

            }

            if( ExpressionUtils.isDynamicText(value.toString()) ) {

                value = ExpressionUtils.evaluateDynamicText(value.toString());

            }

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

        } catch (CoercionException ex) {

            return null;

        }

    }

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

//        LOGGER.info(String.format("FeatureAttributeDescriptor[%08x] set name [%s].", this.hashCode(), 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 int getScale() {

        return this.scale;

    }

    @Override

    public Coercion getCoercion() {

      return this.getDataType().getCoercion();

    }

    @Override

    public MathContext getMathContext() {

      if( this.mathContext==null ) {

        if( this.getDataType().isNumeric() ) {

          this.mathContext = new MathContext(

                  this.getPrecision(), 

                  RoundingMode.valueOf(this.getRoundMode())

          );

        } else {

          this.mathContext = MathContext.UNLIMITED;

        }

      }

      return this.mathContext;

    }

    @Override

    public CoercionContext getCoercionContext() {

      if( this.coerceContext==null ) {

        if( this.getDataType().isNumeric() ) {

          this.coerceContext = DataTypeUtils.coerceContextDecimal(

                  this.getLocale(), 

                  this.getSize(), 

                  this.getPrecision(),

                  this.getRoundMode()

          );

        } else {

            this.coerceContext = DataTypeUtils.coerceContextLocale(

                    this.getLocale()

            );

        }

      }

      return this.coerceContext;

    }

    public int getRoundMode() {

      return this.roundMode;

    }

    @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;

        }

        return this.isComputed();

    }

    @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");

        scale = state.getInt("scale");

        roundMode = state.getInt("roundMode");

        String locale_s = state.getString("locale");

        locale = StringUtils.isBlank(locale_s)? null:Locale.forLanguageTag(locale_s);

        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");

        Map<String,Object> values = state.getMap("availableValues");

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

            this.availableValues = null;

        } else {

            this.availableValues = new DynObjectValueItem[values.size()];

            int n = 0;

            for (Entry<String, Object> entry : values.entrySet()) {

                this.availableValues[n++] = new DynObjectValueItem(entry.getValue(), entry.getKey());

            }

        }

        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");

        relationType = state.getInt("relationType");

        foreingKey = (DefaultForeingKey) state.get("foreingKey");

        if( foreingKey!=null ) {

            this.foreingKey.setDescriptor(this);

        }

        tags = (Tags) state.get("tags");

        if( tags == null ) {

            this.tags = new DefaultTags();

        }

    }

    @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, null));

        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("scale", scale);

        state.set("roundMode", roundMode);

        state.set("locale", this.locale==null? null:this.locale.toLanguageTag());

        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);

        if( this.availableValues==null ) {

            state.setNull("availableValues");

        } else {

            Map<String,Object> values = new LinkedHashMap<>();

            for (DynObjectValueItem value : availableValues) {

                values.put(value.getLabel(),value.getValue());

            }

            state.set("availableValues", values);

        }

        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);

        state.set("relationType",relationType);

        state.set("foreingKey" ,this.foreingKey);

        state.set("tags" ,this.tags);

    }

    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.addDynFieldInt("scale");

            definition.addDynFieldInt("roundMode");

            definition.addDynFieldString("locale");

            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.addDynFieldMap("availableValues")

                    .setClassOfItems(Object.class);

            definition.addDynFieldString("description");

            definition.addDynFieldObject("minValue");

            definition.addDynFieldObject("maxValue");

            definition.addDynFieldString("label");

            definition.addDynFieldInt("order");

            definition.addDynFieldBoolean("hidden");

            definition.addDynFieldString("groupName");

            definition.addDynFieldInt("relationType");

            definition.addDynFieldObject("foreingKey")

                    .setClassOfValue(DefaultForeingKey.class);

            definition.addDynFieldObject("tags")

                    .setClassOfValue(Tags.class);

        }

    }

    /*

     * Start of DynField interface Implementation

     *

     */

    @Override

    public Tags getTags() {

        return tags;

    }

    @Override

    public DynObjectValueItem[] getAvailableValues() {

        if( this.availableValues == null ) {

            if( this.isForeingKey() && this.foreingKey.isClosedList() ) {

                return this.foreingKey.getAvailableValues(null);

            }

        }

        return this.availableValues;

    }

    @Override

    public String getLabelOfValue(Object value) {

        if( this.labelOfValueMap != null ) {

            String theLabel = this.labelOfValueMap.get(value);

            if( theLabel == null ) {

                theLabel = Objects.toString(value, "");

            }

            return theLabel;

        }

        DynObjectValueItem[] values = this.getAvailableValues();

        if( values == null ) {

            return Objects.toString(value, "");

        }

        Map<Object, String> map = new LinkedHashMap<>();

        for (DynObjectValueItem theValue : values) {

            map.put(theValue.getValue(), theValue.getLabel());

        }

        this.labelOfValueMap = map;

        String theLabel = this.labelOfValueMap.get(value);

        if( theLabel == null ) {

            theLabel = Objects.toString(value, "");

        }

        return theLabel;

    }

    @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 DataProfile getDataProfile() {

        if( StringUtils.isBlank(dataProfile) ) {

            return null;

        }

        DataProfile profile = DALLocator.getDataManager().getDataProfile(dataProfile);

        return profile;

    }

    @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 String getLocalizedLabel() {

        if( StringUtils.isBlank(this.label) ) {

            return this.getName();

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation(this.label);

    }

    @Override

    public DynField setLabel(String label) {

        this.label = label;

        return this;

    }

    @Override

    public DynField setShortLabel(String shortLabel) {

        this.shortLabel = shortLabel;

        return this;

    }

    @Override

    public String getShortLabel() {

        return StringUtils.isBlank(shortLabel) ? getLabel() : shortLabel;

    }

    @Override

    public String getLocalizedShortLabel() {

        if( StringUtils.isBlank(shortLabel) ) {

            return this.getLocalizedLabel();

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation(shortLabel);

    }

    @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 readOnly) {

        this.readOnly = readOnly;

        return this;

    }

    @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;

    }