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

import java.text.DateFormat;

import java.util.HashMap;

import java.util.Locale;

import java.util.Objects;

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.fmap.dal.DataTypes;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.AttributeFeatureTypeIntegrityException;

import org.gvsig.fmap.dal.feature.exception.AttributeFeatureTypeSizeException;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.evaluator.Evaluator;

public class DefaultEditableFeatureAttributeDescriptor extends

        DefaultFeatureAttributeDescriptor implements

        EditableFeatureAttributeDescriptor {

    private static Logger logger = LoggerFactory.getLogger(

            DefaultEditableFeatureAttributeDescriptor.class);

    private final DefaultFeatureAttributeDescriptor source;

    private boolean hasStrongChanges;

    private String originalName = null;

    protected DefaultEditableFeatureAttributeDescriptor(

            DefaultFeatureAttributeDescriptor other) {

        super(other);

        if (other instanceof DefaultEditableFeatureAttributeDescriptor) {

            DefaultEditableFeatureAttributeDescriptor other_edi

                    = (DefaultEditableFeatureAttributeDescriptor) other;

            originalName = other_edi.getOriginalName();

            this.source = other_edi.getSource();

        } else {

            this.source = other;

        }

        hasStrongChanges = false;

    }

    public DefaultEditableFeatureAttributeDescriptor(FeatureType type, boolean strongChanges) {

        super(type);

        this.source = null;

        hasStrongChanges = strongChanges;

    }

    public DefaultFeatureAttributeDescriptor getSource() {

        return this.source;

    }

    public void fixAll() {

        super.fixAll();

    }

    public void checkIntegrity() throws AttributeFeatureTypeIntegrityException {

        AttributeFeatureTypeIntegrityException ex

                = new AttributeFeatureTypeIntegrityException(getName());

        if (this.size < 0) {

            ex.add(new AttributeFeatureTypeSizeException(this.size));

        }

        if (this.dataType.isObject() && this.objectClass == null) {

            logger.warn("Incorrect data type object, objectClass is null.");

            ex.add(new AttributeFeatureTypeIntegrityException(this.name));

        }

        // TODO: Add other integrity checks...

        if (ex.size() > 0) {

            throw ex;

        }

    }

    public EditableFeatureAttributeDescriptor setAllowNull(boolean allowNull) {

        updateStrongChanges(this.allowNull, allowNull);

        this.allowNull = allowNull;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableForeingKey getForeingKey() {

        if (this.foreingKey == null) {

            this.foreingKey = new DefaultForeingKey();

            this.foreingKey.setDescriptor(this);

        }

        return this.foreingKey;

    }

    public EditableFeatureAttributeDescriptor setDataType(DataType dataType) {

        updateStrongChanges(this.dataType, dataType);

        this.dataType = dataType;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setDataType(int type) {

        updateStrongChanges(this.dataType, type);

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

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setDefaultValue(

            Object defaultValue) {

        updateStrongChanges(this.defaultValue, defaultValue);

        this.defaultValue = defaultValue;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setDefaultFieldValue(

            Object defaultValue) {

        return setDefaultValue(defaultValue);

    }

    public EditableFeatureAttributeDescriptor setAvoidCachingAvailableValues(boolean avoidCachingAvailableValues) {

        this.avoidCachingAvailableValues = avoidCachingAvailableValues;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setEvaluator(Evaluator evaluator) {

        updateStrongChanges(this.evaluator, evaluator);

        this.evaluator = evaluator;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(FeatureAttributeEmulator featureAttributeEmulator) {

        this.featureAttributeEmulator = featureAttributeEmulator;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(Expression expression) {

        if (ExpressionUtils.isPhraseEmpty(expression)) {

            this.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);

            return this;

        }

        FeatureAttributeEmulatorExpression emulator = DALLocator.getDataManager().createFeatureAttributeEmulatorExpression(

                this.getFeatureType(),

                expression

        );

        return this.setFeatureAttributeEmulator(emulator);

    }

    @Override

    public EditableFeatureAttributeDescriptor setFeatureAttributeEmulator(String expression) {

        if (StringUtils.isBlank(expression)) {

            this.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);

            return this;

        }

        return this.setFeatureAttributeEmulator(ExpressionUtils.createExpression(expression));

    }

    @Override

    public EditableFeatureAttributeDescriptor setGeometryType(int type) {

        this.geometryType = type;

        if (this.geometrySubType == Geometry.SUBTYPES.UNKNOWN) {

            this.geometrySubType = Geometry.SUBTYPES.GEOM2D;

        }

        this.geomType = null;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setGeometrySubType(int subType) {

        this.geometrySubType = subType;

        this.geomType = null;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setGeometryType(

            GeometryType geometryType) {

        updateStrongChanges(this.geomType, geometryType);

        this.geomType = geometryType;

        this.geometryType = this.geomType.getType();

        this.geometrySubType = this.geomType.getSubType();

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setGeometryType(String geometryType) {

        if (StringUtils.isBlank(geometryType)) {

            throw new IllegalArgumentException("Invalid geometry type (null)");

        }

        String separators = ":/-!;#@";

        Character sep = null;

        for (char ch : separators.toCharArray()) {

            if (geometryType.indexOf(ch) >= 0) {

                sep = ch;

                break;

            }

        }

        if (sep == null) {

            throw new IllegalArgumentException("Invalid geometry type (" + geometryType + ") can't find separator, format can be GEOMETRYTYPE[" + separators + "]GEOMETRYSUBTYPE");

        }

        String[] xx = geometryType.split("[" + sep + "]");

        int theGeomType = GeometryUtils.getGeometryType(xx[0]);

        int theGeomSubtype = GeometryUtils.getGeometrySubtype(xx[1]);

        this.setGeometryType(theGeomType, theGeomSubtype);

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setGeometryType(int type, int subType) {

        this.geometryType = type;

        this.geometrySubType = subType;

        this.geomType = null;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setIsPrimaryKey(

            boolean isPrimaryKey) {

        updateStrongChanges(this.primaryKey, isPrimaryKey);

        this.primaryKey = isPrimaryKey;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setIsReadOnly(boolean isReadOnly) {

        updateStrongChanges(this.readOnly, isReadOnly);

        this.readOnly = isReadOnly;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setMaximumOccurrences(

            int maximumOccurrences) {

        updateStrongChanges(this.maximumOccurrences, maximumOccurrences);

        this.maximumOccurrences = maximumOccurrences;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setMinimumOccurrences(

            int minimumOccurrences) {

        updateStrongChanges(this.minimumOccurrences, minimumOccurrences);

        this.minimumOccurrences = minimumOccurrences;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setName(String name) {

        if (StringUtils.equals(this.name, name)) {

            return this;

        }

        if (originalName == null) {

            originalName = this.name;

            if (!isComputed()) {

                hasStrongChanges = true;

            }

        }

        super.setName(name);

        if (!isComputed()) {

            hasStrongChanges = true;

        }

        this.setFixed(false);

        return this;

    }

    public String getOriginalName() {

        return originalName;

    }

    public EditableFeatureAttributeDescriptor setObjectClass(Class theClass) {

        updateStrongChanges(this.objectClass, theClass);

        this.objectClass = theClass;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setPrecision(int precision) {

        updateStrongChanges(this.precision, precision);

        this.precision = precision;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setScale(int scale) {

        updateStrongChanges(this.scale, scale);

        this.scale = scale;

        this.coerceContext = null;

        this.mathContext = null;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setSRS(IProjection SRS) {

        updateStrongChanges(this.SRS, SRS);

        this.SRS = SRS;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setSRS(String SRS) {

        if (StringUtils.isBlank(SRS)) {

            this.setSRS((IProjection) null);

            return this;

        }

        SRS = SRS.replace('@', ':');

        IProjection proj = CRSFactory.getCRS(SRS);

        this.setSRS(proj);

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setInterval(Interval interval) {

        updateStrongChanges(this.getInterval(), interval);

        super.setInterval(interval);

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setSize(int size) {

        updateStrongChanges(this.size, size);

        this.size = size;

        this.setFixed(false);

        return this;

    }

    public boolean hasStrongChanges() {

        return hasStrongChanges;

    }

    @Override

    public EditableFeatureAttributeDescriptor setAdditionalInfo(

            String infoName, Object value) {

        return this.setAdditionalInfo(infoName, Objects.toString(value, ""));

    }

    public EditableFeatureAttributeDescriptor setAdditionalInfo(

            String infoName, String value) {

        if (this.additionalInfo == null) {

            this.additionalInfo = new HashMap();

        }

        this.additionalInfo.put(infoName, value);

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsAutomatic(boolean isAutomatic) {

        this.isAutomatic = isAutomatic;

//        if (isAutomatic) {

//            this.setReadOnly(true);

//        }

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsTime(boolean isTime) {

        updateStrongChanges(this.isTime, isTime);

        this.isTime = isTime;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setDateFormat(DateFormat dateFormat) {

        this.dateFormat = dateFormat;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsIndexed(boolean isIndexed) {

        updateStrongChanges(this.indexed, isIndexed);

        this.indexed = isIndexed;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setAllowIndexDuplicateds(boolean allowDuplicateds) {

        updateStrongChanges(this.allowIndexDuplicateds, allowDuplicateds);

        this.allowIndexDuplicateds = allowDuplicateds;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setIsIndexAscending(boolean ascending) {

        updateStrongChanges(this.isIndexAscending, ascending);

        this.isIndexAscending = ascending;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setDataProfileName(String dataProfile) {

        super.setDataProfileName(dataProfile);

        this.setFixed(false);

        return this;

    }

    private void updateStrongChanges(int previous, int newvalue) {

        if (isComputed()) {

            return;

        }

        if (previous == newvalue) {

            return;

        }

        this.hasStrongChanges = true;

    }

    private void updateStrongChanges(DataType previous, int newvalue) {

        if (isComputed()) {

            return;

        }

        if (previous != null) {

            if (previous.getType() == newvalue) {

                return;

            }

        }

        this.hasStrongChanges = true;

    }

    private void updateStrongChanges(boolean previous, boolean newvalue) {

        if (isComputed()) {

            return;

        }

        if (previous == newvalue) {

            return;

        }

        this.hasStrongChanges = true;

    }

    private void updateStrongChanges(Object previous, Object newvalue) {

        if (isComputed()) {

            return;

        }

        if (Objects.equals(newvalue, previous)) {

            return;

        }

        this.hasStrongChanges = true;

    }

    @Override

    public EditableFeatureAttributeDescriptor setLocale(Locale locale) {

        if (locale == null) {

            this.locale = Locale.ENGLISH;

        } else {

            this.locale = locale;

        }

        this.coerceContext = null;

        this.mathContext = null;

        this.setFixed(false);

        return this;

    }

    public EditableFeatureAttributeDescriptor setLocale(String locale) {

        Locale l;

        try {

            String s = DataTypeUtils.toString(locale, null);

            if (StringUtils.isBlank(s)) {

                return this.setLocale((Locale) null);

            }

            l = new Locale(s);

            return this.setLocale(l);

        } catch (Exception ex) {

            return this.setLocale((Locale) null);

        } finally {

            this.setFixed(false);

        }

    }

    @Override

    public EditableFeatureAttributeDescriptor setRoundMode(int roundMode) {

        switch (roundMode) {

            case BigDecimal.ROUND_UP:

            case BigDecimal.ROUND_DOWN:

            case BigDecimal.ROUND_CEILING:

            case BigDecimal.ROUND_FLOOR:

            case BigDecimal.ROUND_HALF_UP:

            case BigDecimal.ROUND_HALF_DOWN:

            case BigDecimal.ROUND_HALF_EVEN:

            case BigDecimal.ROUND_UNNECESSARY:

                this.roundMode = roundMode;

                this.coerceContext = null;

                this.mathContext = null;

                break;

            default:

                throw new IllegalArgumentException("round mode '" + roundMode + "' not valid.");

        }

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor set(String name, Object value) {

        if (StringUtils.isBlank(name)) {

            throw new IllegalArgumentException("Name can't be empty");

        }

        String ss;

        switch (name.trim().toLowerCase()) {

            case "isavoidcachingavailablevalues":

            case "avoidcachingavailablevalues":

            case "nocachingavailablevalues":

                this.setAvoidCachingAvailableValues(DataTypeUtils.toBoolean(value, false));

                break;

            case "availablevalues":

                this.setAvailableValuesExpression(DataTypeUtils.toString(value, null));

                break;

            case "isreadonly":

            case "readonly":

                this.setIsReadOnly(DataTypeUtils.toBoolean(value, false));

                break;

            case "mandatory":

                this.setMandatory(DataTypeUtils.toBoolean(value, false));

                break;

            case "hidden":

                this.setHidden(DataTypeUtils.toBoolean(value, false));

                break;

            case "allownull":

                this.setAllowNull(DataTypeUtils.toBoolean(value, false));

                break;

            case "indexed":

            case "isindexed":

                this.setIsIndexed(DataTypeUtils.toBoolean(value, false));

                break;

            case "indexasc":

            case "indexascending":

            case "isindexascending":

                this.setIsIndexAscending(DataTypeUtils.toBoolean(value, false));

                break;

            case "pk":

            case "ispk":

            case "primarykey":

            case "isprimarykey":

                this.setIsPrimaryKey(DataTypeUtils.toBoolean(value, false));

                break;

            case "allowindexduplicateds":

                this.setAllowIndexDuplicateds(DataTypeUtils.toBoolean(value, false));

                break;

            case "isautomatic":

            case "automatic":

                this.setIsAutomatic(DataTypeUtils.toBoolean(value, false));

                break;

            case "time":

            case "istime":

                this.setIsTime(DataTypeUtils.toBoolean(value, false));

                break;

            case "profile":

                this.setDataProfileName(DataTypeUtils.toString(value, null));

                break;

            case "group":

                this.setGroup(DataTypeUtils.toString(value, null));

                break;

            case "description":

                this.setDescription(DataTypeUtils.toString(value, null));

                break;

            case "label":

                this.setLabel(DataTypeUtils.toString(value, null));

                break;

            case "shortlabel":

                this.setShortLabel(DataTypeUtils.toString(value, null));

                break;

            case "expression":

                this.setFeatureAttributeEmulator(DataTypeUtils.toString(value, null));

                break;

            case "size":

                this.setSize(DataTypeUtils.toInteger(value, 50));

                break;

            case "displaysize":

                this.setDisplaySize(DataTypeUtils.toInteger(value, 50));

                break;

            case "precision":

                this.setPrecision(DataTypeUtils.toInteger(value, 10));

                break;

            case "scale":

                this.setScale(DataTypeUtils.toInteger(value, 10));

                break;

            case "roundmode":

                this.setRoundMode(DataTypeUtils.toInteger(value, BigDecimal.ROUND_UNNECESSARY));

                break;

            case "locale":

                this.setLocale(DataTypeUtils.toString(value, null));

                break;

            case "order":

                this.setOrder(DataTypeUtils.toInteger(value, 0));

                break;

            case "fk":

            case "foreingkey":

                this.getForeingKey().setForeingKey(DataTypeUtils.toBoolean(value, false));

                break;

            case "fk_code":

            case "foreingkey_code":

            case "foreingkey.code":

                this.getForeingKey().setCodeName(DataTypeUtils.toString(value, ""));

                break;

            case "fk_label":

            case "foreingkey_label":

            case "foreingkey.label":

                this.getForeingKey().setLabelFormula(DataTypeUtils.toString(value, ""));

                break;

            case "fk_closed":

            case "fk_closedlist":

            case "fk.closedlist":

            case "foreingkey_closedlist":

            case "foreingkey.closedlist":

                this.getForeingKey().setClosedList(DataTypeUtils.toBoolean(value, false));

                break;

            case "fk_table":

            case "foreingkey_table":

            case "foreingkey.table":

                this.getForeingKey().setTableName(DataTypeUtils.toString(value, null));

                break;

            case "interval":

                this.setInterval(DataTypeUtils.toInterval(value, null));

                break;

            case "geomtype":

            case "geometrytype":

                this.setGeometryType(DataTypeUtils.toString(value, null));

                break;

            case "srs":

                this.setSRS(DataTypeUtils.toString(value, null));

                break;

            case "relation":

                this.setRelationType(toRelation(value));

                break;

            case "name":

                this.setName(DataTypeUtils.toString(value, null));

                break;

            case "type":

            case "datatype":

                ss = DataTypeUtils.toString(value, null);

                if (!StringUtils.isBlank(ss)) {

                    this.setDataType(ToolsLocator.getDataTypesManager().getType(ss));

                }

                break;

            case "defaultvalue":

                this.setDefaultValue(value);

                break;

            case "availablevaluesfilter":

                this.setAvailableValuesFilter(DataTypeUtils.toString(value, null));

                break;

            case "format":

            case "defaultformat":

                this.setDefaultFormat(DataTypeUtils.toString(value, null));

            default:

                throw new IllegalArgumentException("Name attribute '" + name + "' not valid.");

        }

        this.setFixed(false);

        return this;

    }

    private int toRelation(Object value) {

        if (value == null) {

            return DynField.RELATION_TYPE_NONE;

        }

        Integer x = (Integer) DataTypeUtils.coerce(DataTypes.INT, value, null);

        if (x != null) {

            return x;

        }

        try {

            String s = value.toString().toUpperCase();

            switch (s) {

                case "NONE":

                default:

                    return DynField.RELATION_TYPE_NONE;

                case "IDENTITY":

                    return DynField.RELATION_TYPE_IDENTITY;

                case "COLLABORATION":

                    return DynField.RELATION_TYPE_COLLABORATION;

                case "COMPOSITION":

                    return DynField.RELATION_TYPE_COMPOSITION;

                case "AGGREGATE":

                    return DynField.RELATION_TYPE_AGGREGATE;

            }

        } catch (Exception ex) {

            return DynField.RELATION_TYPE_NONE;

        }

    }

    @Override

    public EditableFeatureAttributeDescriptor setDisplaySize(int size) {

        this.displaySize = size;

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setAvailableValuesFilter(Expression filter) {

        super.setAvailableValuesFilter(filter);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setAvailableValuesFilter(String filter) {

        super.setAvailableValuesFilter(filter);

        return this;

    }

    private static class TheJsonSerializer implements JsonManager.JsonSerializer {

        public TheJsonSerializer() {

        }

        @Override

        public Class getObjectClass() {

            return DefaultEditableFeatureAttributeDescriptor.class;

        }

        @Override

        public Object toObject(JsonObject json) {

            DefaultFeatureAttributeDescriptor o = new DefaultFeatureAttributeDescriptor();

            o.fromJson(json);

            return o;

        }

        @Override

        public JsonObjectBuilder toJsonBuilder(Object value) {

            return ((SupportToJson) value).toJsonBuilder();

        }

    }

    @Override

    public EditableFeatureAttributeDescriptor setForeingkey(

            boolean isForeingkey,

            boolean isClosedList,

            String tableName,

            String codeName,

            String labelFormula

    ) {

        if (isForeingkey) {

            EditableForeingKey fk = this.getForeingKey();

            fk.setForeingKey(isForeingkey);

            fk.setClosedList(isClosedList);

            fk.setTableName(tableName);

            fk.setCodeName(codeName);

            fk.setLabelFormula(labelFormula);

        } else {

            this.foreingKey = null;

        }

        this.setFixed(false);

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor setTag(String name, Object value) {

        this.getTags().set(name, value);

        this.setFixed(false);

        return this;

    }

    public static void selfRegister() {

        Json.registerSerializer(new TheJsonSerializer());

    }

    @Override

    public EditableFeatureAttributeDescriptor setDefaultFormat(String format) {

        this.defaultFormat = format;

        this.setFixed(false);

        return this;

    }

}