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

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Objects;

import org.gvsig.json.Json;

import javax.json.JsonObject;

import org.gvsig.json.JsonObjectBuilder;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.ObjectUtils;

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.fmap.crs.CRSFactory;

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

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

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

import org.gvsig.tools.util.GetItemWithSize;

import org.gvsig.tools.util.LabeledValue;

@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

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

                this.getScale(),

                this.getRoundMode()

        );

      } 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 : Locale.forLanguageTag(locale_s); // || "null".equalsIgnoreCase(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;

  }

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

    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;

  }

  @Override

    public FeatureAttributeDescriptor setAvailableValuesExpression(String expression) {

        if (StringUtils.isBlank(expression)) {

            this.availableValuesExpression = null;

            return this;

        }

        this.availableValuesExpression = ExpressionUtils.createExpression(expression);

        return this;

    }

  @Override

    public FeatureAttributeDescriptor setAvailableValuesExpression(Expression expression) {

        this.availableValuesExpression = expression;

        return this;

    }

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