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

import java.util.HashMap;

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

import javax.json.JsonObject;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.Pair;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryCoercionContext;

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.json.Json;

import org.gvsig.json.JsonManager;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.json.SupportToJson;

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

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataType.NumberPrecisionAndScale;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.dynobject.AbstractDynMethod;

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.gvsig.tools.util.GetItemWithSize;

import org.gvsig.tools.util.LabeledValue;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@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<String, String> 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 DynObjectValueItem[] availableValuesCache; // No persistente

    protected Expression availableValuesExpression;

    protected boolean avoidCachingAvailableValues;

    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;

    protected int displaySize;

    public DefaultFeatureAttributeDescriptor() {

        // Usada en la persistencia

        this.precision = DataType.PRECISION_NONE;

        this.scale = DataType.SCALE_NONE;

        this.roundMode = BigDecimal.ROUND_HALF_UP;

    }

    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 = DataType.PRECISION_NONE;

        this.scale = DataType.SCALE_NONE;

        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 = null;

        this.displaySize = 0;

        this.avoidCachingAvailableValues = false;

    }

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

            this.additionalInfo = new HashMap();

            for (Entry<String, String> entry : other.additionalInfo.entrySet()) {

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

        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;

        this.displaySize = other.displaySize;

        this.avoidCachingAvailableValues = other.avoidCachingAvailableValues;

    }

    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;

    }

    @Override

    public Locale getLocale() {

        if (this.locale == null) {

            if (this.dataType.isNumeric()) {

                this.locale = Locale.ENGLISH;

            } else {

                this.locale = Locale.getDefault();

            }

        }

        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

    @Deprecated

    public Object getDefaultValueCoerced() {

        return getCoercedDefaultValue();

    }

    @Override

    public Object getCoercedDefaultValue() {

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

        return (Supplier) this::getDefaultValueCoerced;

    }

    @Override

    public DynField setDefaultValueSupplier(Supplier supplier) {

        //Do nothing

        return this;

    }

    @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.getPrecision(),

                        this.getScale(),

                        this.getRoundMode()

                );

            } else if (this.getType() == DataTypes.GEOMETRY) {

                GeometryCoercionContext context = GeometryLocator.getGeometryManager().createGeometryCoercionContext();

                context.setGeometryType(this.getGeomType());

                context.setMode(GeometryCoercionContext.MODE_ONERROR_DONTCONVERT);

                this.coerceContext = context;

            } else {

                this.coerceContext = DataTypeUtils.coerceContextLocale(

                        this.getLocale()

                );

            }

        }

        return this.coerceContext;

    }

    @Override

    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 String 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".equalsIgnoreCase(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", RELATION_TYPE_NONE);

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

        if (foreingKey != null) {

            this.foreingKey.setDescriptor(this);

        }

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

        if (tags == null) {

            this.tags = new DefaultTags();

        }

        displaySize = state.getInt("displaySize", 0);

        availableValuesExpression = (Expression) state.get("availableValuesExpression");

        avoidCachingAvailableValues = state.getBoolean("avoidCachingAvailableValues", false);

        availableValuesCache = null;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        Coercion toString = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.STRING);

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

        if (this.locale == null) {

            state.setNull("locale");

        } else {

            state.set("locale", this.locale.toLanguageTag()); //toString.coerce(this.locale));

        }

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

        state.set("displaySize", displaySize);

        state.set("availableValuesExpression", availableValuesExpression);

        state.set("avoidCachingAvailableValues", avoidCachingAvailableValues);

    }

    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").setMandatory(false).setDefaultDynValue(DataType.SCALE_NONE);

            definition.addDynFieldInt("roundMode").setMandatory(false).setDefaultDynValue(BigDecimal.ROUND_HALF_UP);

            definition.addDynFieldString("locale").setMandatory(false).setDefaultDynValue("null");

            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.addDynFieldBoolean("avoidCachingAvailableValues");

            definition.addDynFieldString("groupName");

            definition.addDynFieldInt("relationType");

            definition.addDynFieldObject("foreingKey")

                    .setClassOfValue(DefaultForeingKey.class);

            definition.addDynFieldObject("tags")

                    .setClassOfValue(Tags.class);

            definition.addDynFieldInt("displaySize").setMandatory(false);

            definition.addDynFieldObject("availableValuesExpression")

                    .setClassOfValue(Expression.class)

                    .setMandatory(false);

        }

    }

    /*

     * Start of DynField interface Implementation

     *

     */

    @Override

    public Tags getTags() {

        return tags;

    }

    private Expression availableValuesFilter;

    @Override

    public Expression getAvailableValuesFilter() {

        return this.availableValuesFilter;

    }

    public FeatureAttributeDescriptor setAvailableValuesFilter(Expression filter) {

        this.availableValuesFilter = filter;

        return this;

    }

    @Override

    public boolean hasConstantAvailableValues() {

        return this.availableValues != null;

    }

    @Override

    public boolean isAvoidCachingAvailableValues() {

        return this.avoidCachingAvailableValues;

    }

    public boolean hasAvailableValues() {

        return getAvailableValues() != null;

    }

    @Override

    public DynObjectValueItem[] getAvailableValues(DynObject context) {

        if (this.availableValuesMethod != null) {

            DynObjectValueItem[] values;

            try {

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

            } catch (DynMethodException ex) {

                return this.getAvailableValues();

            }

            if (values != null) {

                return values;

            }

        }

        Expression filter = this.availableValuesFilter;

        if (!ExpressionUtils.isEmpty(filter)) {

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

                ContextForeingKey foreingkeyContext = this.foreingKey.createContext();

                foreingkeyContext.setContextValues(context);

                DynObjectValueItem[] values = this.foreingKey.getAvailableValues(foreingkeyContext);

                return values;

            }

            MutableSymbolTable contextSymbolTable = ExpressionUtils.createSymbolTable("feature", context);

            MutableSymbolTable symbolTable = ExpressionUtils.createSymbolTable();

            symbolTable.addSymbolTable(contextSymbolTable);

            DynObjectValueItem[] allValues = this.getAvailableValues();

            List<DynObjectValueItem> filteredValues = new ArrayList<>();

            for (DynObjectValueItem value : allValues) {

                symbolTable.setVar("$value", value.getValue());

                symbolTable.setVar("$label", value.getLabel());

                Object include = filter.execute(symbolTable);

                if (DataTypeUtils.isFalse(include, false)) {

                    continue;

                }

                filteredValues.add(value);

            }

            DynObjectValueItem[] values = filteredValues.toArray(

                    new DynObjectValueItem[filteredValues.size()]

            );

            return values;

        }

        return this.getAvailableValues();

    }

    @Override

    public boolean isAvailableValuesCalculated() {

        return true; //this.availableValuesMethod != null;

    }

    @Override

    public DynObjectValueItem[] getAvailableValues() {

        DynObjectValueItem[] values = this.availableValues;

        if (values != null) {

            return values;

        }

        values = this.availableValuesCache;

        if (values != null) {

            return values;

        }

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

            values = this.foreingKey.getAvailableValues(null);

        } else if (this.availableValuesExpression != null) {

            values = this.getAvailableValuesFromExpression();

        }

        if (!this.avoidCachingAvailableValues) {

            this.availableValuesCache = values;

        }

        return values;

    }

    private DynObjectValueItem[] getAvailableValuesFrom(GetItemWithSize values) {

        if (values.size() == 0) {

            return null;

        }

        DynObjectValueItem[] r = null;

        Object firstelement = values.get(0);

        if (firstelement instanceof LabeledValue) {

            r = new DynObjectValueItem[values.size()];

            for (int i = 0; i < values.size(); i++) {

                LabeledValue v = (LabeledValue) values.get(i);

                r[i] = new DynObjectValueItem(

                        v.getValue(),

                        Objects.toString(v.getLabel(), Objects.toString(v.getValue(), String.valueOf(i)))

                );

            }

        } else if (firstelement instanceof Pair) {

            r = new DynObjectValueItem[values.size()];

            for (int i = 0; i < values.size(); i++) {

                Pair v = (Pair) values.get(i);

                r[i] = new DynObjectValueItem(

                        v.getValue(),

                        Objects.toString(v.getKey(), Objects.toString(v.getValue(), String.valueOf(i)))

                );

            }

        } else if (firstelement instanceof JsonObject) {

            JsonObject v = (JsonObject) firstelement;

            String labelname = null;

            for (String theName : new String[]{

                "name", "label", "key", "description"

            }) {

                if (v.containsKey(theName)) {

                    labelname = theName;

                    break;

                }

                if (v.containsKey(theName.toUpperCase())) {

                    labelname = theName.toLowerCase();

                    break;

                }

            }

            String valuename = null;

            if (v.containsKey("value")) {

                valuename = "value";

            }

            r = new DynObjectValueItem[values.size()];

            for (int i = 0; i < values.size(); i++) {

                v = (JsonObject) values.get(i);

                String theLabel;

                Object theValue;

                if (labelname == null) {

                    theLabel = v.toString();

                } else {

                    theLabel = v.getString(labelname);

                }

                if (valuename == null) {

                    theValue = v.getString(valuename);

                } else {

                    theValue = v;

                }

                r[i] = new DynObjectValueItem(theValue, theLabel);

            }

        } else if (firstelement instanceof Map) {

            Map<String, Object> v = (Map<String, Object>) firstelement;

            String labelname = null;

            for (String theName : new String[]{

                "name", "label", "key", "description"

            }) {

                if (v.containsKey(theName)) {

                    labelname = theName;

                    break;

                }

                if (v.containsKey(theName.toUpperCase())) {

                    labelname = theName.toLowerCase();

                    break;

                }

            }

            String valuename = null;

            if (v.containsKey("value")) {

                valuename = "value";

            }

            r = new DynObjectValueItem[values.size()];

            for (int i = 0; i < values.size(); i++) {

                v = (Map<String, Object>) values.get(i);

                String theLabel;

                Object theValue;

                if (labelname == null) {

                    theLabel = v.toString();

                } else {

                    theLabel = (String) v.get(labelname);

                }

                if (valuename == null) {

                    theValue = v;

                } else {

                    theValue = v.get(valuename);

                }

                r[i] = new DynObjectValueItem(theValue, theLabel);

            }

        } else if (firstelement instanceof Feature) {

            Feature v = (Feature) firstelement;

            FeatureType featureType = v.getType();

            String valuename = null;

            FeatureAttributeDescriptor[] pks = featureType.getPrimaryKey();

            if (pks != null && pks.length == 1) {

                valuename = pks[0].getName();

            }

            String labelname = null;

            for (String theName : new String[]{

                "name", "label", "key", "description"

            }) {

                if (featureType.get(theName) != null) {

                    labelname = theName;

                    break;

                }

            }

            r = new DynObjectValueItem[values.size()];

            for (int i = 0; i < values.size(); i++) {

                v = (Feature) values.get(i);

                String theLabel;

                Object theValue;

                if (labelname == null) {

                    theLabel = v.toString();

                } else {

                    theLabel = v.getString(labelname);

                }

                if (valuename == null) {

                    theValue = v.getReference().getCode();

                } else {

                    theValue = v.get(valuename);

                }

                r[i] = new DynObjectValueItem(theValue, theLabel);

            }

        }

        return r;

    }

    private DynObjectValueItem[] getAvailableValuesFromExpression() {

        if (this.availableValuesExpression == null || this.availableValuesExpression.isEmpty()) {

            return null;

        }

        try {

            Object value = this.availableValuesExpression.execute(null);

            if (value instanceof DynObjectValueItem[]) {

                return (DynObjectValueItem[]) value;

            }

            if (value instanceof List) {

                return this.getAvailableValuesFrom(new GetItemWithSize() {

                    @Override

                    public Object get(int i) {

                        return ((List) value).get(i);

                    }

                    @Override

                    public int size() {

                        return ((List) value).size();

                    }

                });

            }

        } catch (Throwable th) {

            LOGGER.warn("Can't get available values from expression", th);

        }

        return null;

    }

    @Override

    public Expression getAvailableValuesExpression() {

        return this.availableValuesExpression;

    }