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

import java.util.Arrays;

import java.util.Collections;

import java.util.Date;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.function.Predicate;

import java.util.zip.CRC32;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

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

import org.gvsig.tools.dynobject.Tags;

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

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

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

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;

public class DefaultFeatureType

        extends ArrayList<FeatureAttributeDescriptor>

        implements

        FeatureType,

        Persistent,

        DynClass,

        DynStruct_v2,

        org.gvsig.tools.lang.Cloneable {

    /**

     *

     */

    private static final long serialVersionUID = -7988721447349282215L;

    public static final RecentUsedsAttributesImpl RECENTS_USEDS = new RecentUsedsAttributesImpl();

    private DefaultFeatureRules rules;

    protected boolean hasEvaluators;

    protected boolean hasEmulators;

    protected String defaultGeometryAttributeName;

    protected String defaultTimeAttributeName;

    protected int defaultGeometryAttributeIndex;

    protected int defaultTimeAttributeIndex;

    private String id;

    protected boolean hasOID;

    protected boolean allowAtomaticValues;

    protected FeatureAttributeDescriptor[] pk = null;

    protected String internalID = null;

    private List srsList = null;

    private WeakReference storeRef;

    private boolean requiredFields;

    private String description;

    private String label;

    private Tags tags;

    public DefaultFeatureType() {

        // Usado en la persistencia.

        this.internalID = Integer.toHexString((int) (Math.random() * 100000)).toUpperCase();

        this.id = id = "default";

        this.rules = new DefaultFeatureRules();

        this.hasEvaluators = false;

        this.hasEmulators = false;

        this.defaultGeometryAttributeName = null;

        this.defaultTimeAttributeName = null;

        this.defaultGeometryAttributeIndex = -1;

        this.defaultTimeAttributeIndex = -1;

        this.allowAtomaticValues = false;

        this.tags = new DefaultTags();

    }

    protected DefaultFeatureType(FeatureStore store, String id) {

        this();

        if (StringUtils.isEmpty(id)) {

            id = "default";

        }

        this.id = id;

        setStore(store);

    }

    protected DefaultFeatureType(FeatureStore store) {

        this(store, (String) null);

    }

    protected DefaultFeatureType(DefaultFeatureType other) {

        this(other.getStore(), (String) null);

        copyFrom(other, true);

    }

    protected DefaultFeatureType(DefaultFeatureType other,

            boolean copyAttributes) {

        this(other.getStore(), (String) null);

        this.copyFrom(other, copyAttributes);

    }

    @Override

    public void copyFrom(FeatureType other) {

        String internalIDSaved = this.internalID;

        String idSaved = this.id;

        copyFrom((DefaultFeatureType) other, true);

        this.id = idSaved;

        this.internalID = internalIDSaved;

    }

    protected void addAll(FeatureType attributes) {

        for (FeatureAttributeDescriptor attribute : attributes) {

            DefaultFeatureAttributeDescriptor copy = this.getCopyAttributeDescriptor((DefaultFeatureAttributeDescriptor) attribute);

            super.add(copy);

        }

        DefaultFeatureType ft = (DefaultFeatureType) attributes; 

        this.pk = null;

        this.defaultGeometryAttributeName = ft.defaultGeometryAttributeName;

        this.defaultTimeAttributeName = ft.defaultTimeAttributeName;

        this.defaultGeometryAttributeIndex = ft.defaultGeometryAttributeIndex;

        this.defaultTimeAttributeIndex = ft.defaultTimeAttributeIndex;

    }

    protected void copyFrom(DefaultFeatureType other, boolean copyAttributes) {

        this.id = other.getId();

        if (copyAttributes) {

            this.addAll((FeatureType)other);

        }

        this.hasEvaluators = other.hasEvaluators;

        this.hasEmulators = other.hasEmulators;

        this.rules = (DefaultFeatureRules) other.rules.getCopy();

        this.hasOID = other.hasOID;

        this.id = other.id; // XXX ???? copiar o no esto????

        this.internalID = other.internalID;

        this.label = other.label;

        this.description = other.description;

        try {

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

        } catch (CloneNotSupportedException ex) {

        }

    }

    protected DefaultFeatureAttributeDescriptor getCopyAttributeDescriptor(DefaultFeatureAttributeDescriptor src) {

        DefaultFeatureAttributeDescriptor copy = new DefaultFeatureAttributeDescriptor(src);

        copy.setFeatureType(this);

        return copy;

    }

    @Override

    public String getId() {

        return this.id;

    }

    @Override

    public Object get(String name) {

        FeatureAttributeDescriptor attr;

        Iterator iter = this.iterator();

        while (iter.hasNext()) {

            attr = (FeatureAttributeDescriptor) iter.next();

            if (attr.getName().equalsIgnoreCase(name)) {

                return attr;

            }

        }

        return null;

    }

    @Override

    public FeatureAttributeDescriptor getAttributeDescriptor(String name) {

        FeatureAttributeDescriptor attr;

        Iterator iter = this.iterator();

        while (iter.hasNext()) {

            attr = (FeatureAttributeDescriptor) iter.next();

            if (attr.getName().equalsIgnoreCase(name)) {

                return attr;

            }

        }

        return null;

    }

    @Override

    public FeatureAttributeDescriptor getAttributeDescriptor(int index) {

        return (FeatureAttributeDescriptor) super.get(index);

    }

    @Override

    public FeatureType getCopy() {

        return new DefaultFeatureType(this);

    }

    @Override

    public Object clone() {

        return this.getCopy();

    }

    public int getDefaultGeometryAttributeIndex() {

        return this.defaultGeometryAttributeIndex;

    }

    public String getDefaultGeometryAttributeName() {

        return this.defaultGeometryAttributeName;

    }

    public int getDefaultTimeAttributeIndex() {

        return this.defaultTimeAttributeIndex;

    }

    public String getDefaultTimeAttributeName() {

        return this.defaultTimeAttributeName;

    }

    public EditableFeatureType getEditable() {

        return new DefaultEditableFeatureType(this);

    }

    public int getIndex(String name) {

        FeatureAttributeDescriptor attr;

        Iterator iter = this.iterator();

        while (iter.hasNext()) {

            attr = (FeatureAttributeDescriptor) iter.next();

            if (attr.getName().equalsIgnoreCase(name)) {

                return attr.getIndex();

            }

        }

        return -1;

    }

    public FeatureRules getRules() {

        return this.rules;

    }

    public boolean hasEvaluators() {

        return this.hasEvaluators;

    }

    public boolean hasEmulators() {

        return this.hasEmulators;

    }

    public boolean hasRequiredFields() {

        return this.requiredFields;

    }

    public List getSRSs() {

        if (this.srsList == null) {

            ArrayList tmp = new ArrayList();

            Iterator iter = iterator();

            Iterator tmpIter;

            boolean allreadyHave;

            IProjection tmpSRS;

            FeatureAttributeDescriptor attr;

            while (iter.hasNext()) {

                attr = (FeatureAttributeDescriptor) iter.next();

                if (attr.getDataType().getType() == DataTypes.GEOMETRY

                        && attr.getSRS() != null) {

                    allreadyHave = false;

                    tmpIter = tmp.iterator();

                    while (tmpIter.hasNext()) {

                        tmpSRS = (IProjection) tmpIter.next();

                        if (tmpSRS.getAbrev().equals(attr.getSRS().getAbrev())) {

                            allreadyHave = true;

                            break;

                        }

                    }

                    if (!allreadyHave) {

                        tmp.add(attr.getSRS());

                    }

                }

            }

            this.srsList = Collections.unmodifiableList(tmp);

        }

        return this.srsList;

    }

    public IProjection getDefaultSRS() {

        if (this.getDefaultGeometryAttributeIndex() < 0) {

            return null;

        }

        return this.getAttributeDescriptor(

                this.getDefaultGeometryAttributeIndex()).getSRS();

    }

    public void validateFeature(Feature feature, int mode) throws DataException {

        DefaultFeatureRules rules = (DefaultFeatureRules) this.getRules();

        rules.validate(feature, mode);

    }

    public FeatureType getSubtype() throws DataException {

        return new SubtypeFeatureType(this, null, null, true);

    }

    public FeatureType getSubtype(String[] names) throws DataException {

        return this.getSubtype(names, null, true);

    }

    public FeatureType getSubtype(String[] names, String[] constantsNames) throws DataException {

        return this.getSubtype(names, constantsNames, true);

    }

    public FeatureType getSubtype(String[] names, String[] constantsNames, boolean includePk) throws DataException {

        if (ArrayUtils.isEmpty(names) && ArrayUtils.isEmpty(constantsNames)) {

            return (FeatureType) this.clone();

        }

        return new SubtypeFeatureType(this, names, constantsNames,includePk);

    }

    public boolean isSubtypeOf(FeatureType featureType) {

        return false;

    }

    @Override

    public List<FeatureAttributeDescriptor> toList() {

        return Collections.unmodifiableList(this);

    }

    @Override

    public Tags getTags() {

        return this.tags;

    }

    @Override

    public String getLabel() {

        return this.label;

    }

    @Override

    public void setLabel(String label) {

        this.label = label;

    }

    @Override

    public DynField addDynField(String name, int type) {

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

    }

    class SubtypeFeatureType extends DefaultFeatureType {

        /**

         *

         */

        private static final long serialVersionUID = 6913732960073922540L;

        WeakReference parent;

        SubtypeFeatureType(DefaultFeatureType parent, String[] names, String[] constantsNames, boolean includePk)

                throws DataException {

            super(parent, false);

            DefaultFeatureAttributeDescriptor attrcopy;

            Set<String> attrnames = new LinkedHashSet<>();

            Set<String> requiredAttrnames = new HashSet<>();

            if (ArrayUtils.isEmpty(names)) {

                for (FeatureAttributeDescriptor attrdesc : parent) {

                    attrnames.add(attrdesc.getName().toLowerCase());

                }

            } else { 

                attrnames.addAll(Arrays.asList(names));

                requiredAttrnames.addAll(Arrays.asList(names));

            }

            // Add required fields for emulated fields

            if (parent.hasEmulators) {

                // Ojo, este bucle falla cuando hay un campo calculado que depende

                // de otro campo calculado.

                for (FeatureAttributeDescriptor attrdesc : parent) {

                    FeatureAttributeEmulator emulator = attrdesc.getFeatureAttributeEmulator();

                    if (emulator != null && attrnames.contains(attrdesc.getName().toLowerCase())) {

                        String theNames[] = emulator.getRequiredFieldNames();

                        if (names != null) {

                            for (String name : theNames) {

                                name = name.toLowerCase();

                                attrnames.add(name);

                                requiredAttrnames.add(name);

                            }

                        }

                    }

                }

            }

            // Add missing pk fiels

            if (includePk && !parent.hasOID()) {

                for (FeatureAttributeDescriptor attrdesc : parent) {

                    if (attrdesc.isPrimaryKey()) {

                        String name = attrdesc.getName().toLowerCase();

                        attrnames.add(name);

                        requiredAttrnames.add(name);

                    }

                }

            }

            // Copy attributes

            int i = 0;

            for (String name : attrnames) {

                DefaultFeatureAttributeDescriptor attr = (DefaultFeatureAttributeDescriptor) parent.get(name);

                if (attr == null) {

                    throw new SubtypeFeatureTypeNameException(name, parent.getId());

                }

                attrcopy = new DefaultFeatureAttributeDescriptor(attr);

                this.add(attrcopy);

                attrcopy.index = i++;

            }

            // Set the constants attributes.

            if (!ArrayUtils.isEmpty(constantsNames)) {

                for (String name : constantsNames) {

                    if (!requiredAttrnames.contains(name)) {

                        DefaultFeatureAttributeDescriptor attr = (DefaultFeatureAttributeDescriptor) this.get(name);

                        attr.setConstantValue(true);

                    }

                }

            }

            this.defaultGeometryAttributeIndex = this.getIndex(this.defaultGeometryAttributeName);

            if (this.defaultGeometryAttributeIndex < 0) {

                this.defaultGeometryAttributeName = null;

            }

            this.defaultTimeAttributeIndex = this.getIndex(this.defaultTimeAttributeName);

            if (this.defaultTimeAttributeIndex < 0) {

                this.defaultTimeAttributeName = null;

            }

            this.parent = new WeakReference(parent);

        }

        public FeatureType getSubtype(String[] names, boolean includePk) throws DataException {

            return new SubtypeFeatureType((DefaultFeatureType) this.parent

                    .get(), names, null, includePk);

        }

        public boolean isSubtypeOf(FeatureType featureType) {

            if (featureType == null) {

                return false;

            }

            FeatureType parent = (FeatureType) this.parent.get();

            return featureType.equals(parent);

        }

        public EditableFeatureType getEditable() {

            throw new UnsupportedOperationException();

        }

    }

    public class SubtypeFeatureTypeNameException extends DataException {

        /**

         *

         */

        private static final long serialVersionUID = -4414242486723260101L;

        private final static String MESSAGE_FORMAT = "Attribute name '%(name)' not found in type (%(type)).";

        private final static String MESSAGE_KEY = "_SubtypeFeatureTypeNameException";

        public SubtypeFeatureTypeNameException(String name, String type) {

            super(MESSAGE_FORMAT, MESSAGE_KEY, serialVersionUID);

            setValue("name", name);

            setValue("type", type);

        }

    }

    public boolean hasOID() {

        return hasOID;

    }

    public String toString() {

        StringBuffer s = new StringBuffer();

        s.append(this.getId());

        s.append(":[");

        String attName;

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

            attName = ((FeatureAttributeDescriptor) get(i)).getName().toString();

            s.append(attName);

            if (i < size() - 1) {

                s.append(',');

            }

        }

        s.append(']');

        return s.toString();

    }

    public Iterator<FeatureAttributeDescriptor> iterator() {

        return getIterator(super.iterator());

    }

    protected Iterator getIterator(Iterator iter) {

        return new DelegatedIterator(iter);

    }

    protected class DelegatedIterator implements Iterator {

        protected Iterator iterator;

        public DelegatedIterator(Iterator iter) {

            this.iterator = iter;

        }

        public boolean hasNext() {

            return iterator.hasNext();

        }

        public Object next() {

            return iterator.next();

        }

        public void remove() {

            throw new UnsupportedOperationException();

        }

    }

    public boolean allowAutomaticValues() {

        return this.allowAtomaticValues;

    }

    public FeatureAttributeDescriptor[] getAttributeDescriptors() {

        return (FeatureAttributeDescriptor[]) super

                .toArray(new FeatureAttributeDescriptor[super.size()]);

    }

    @Override

    public boolean hasPrimaryKey() {

        if( pk!=null ) {

            return pk.length>0;

        }

        for (FeatureAttributeDescriptor attr : this) {

            if( attr.isPrimaryKey() ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean supportReferences() {

        return this.hasOID() || this.hasPrimaryKey();

    }

    @Override

    public FeatureAttributeDescriptor[] getPrimaryKey() {

        if (pk == null) {

            List pks = new ArrayList();

            Iterator iter = super.iterator();

            FeatureAttributeDescriptor attr;

            while (iter.hasNext()) {

                attr = (FeatureAttributeDescriptor) iter.next();

                if (attr.isPrimaryKey()) {

                    pks.add(attr);

                }

            }

            if (pks.isEmpty()) {

                pk = new FeatureAttributeDescriptor[0];

            } else {

                pk = (FeatureAttributeDescriptor[]) pks.toArray(new FeatureAttributeDescriptor[pks.size()]);

            }

        }

        return pk;

    }

    public FeatureAttributeDescriptor getDefaultGeometryAttribute() {

        if (this.defaultGeometryAttributeIndex < 0) {

            return null;

        }

        return (FeatureAttributeDescriptor) super

                .get(this.defaultGeometryAttributeIndex);

    }

    public boolean equals(Object o) {

        if (this == o) {

            return true;

        }

        if (!(o instanceof DefaultFeatureType)) {

            return false;

        }

        DefaultFeatureType other = (DefaultFeatureType) o;

        if (!this.id.equals(other.id)) {

            return false;

        }

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

            return false;

        }

        FeatureAttributeDescriptor attr, attrOther;

        Iterator iter, iterOther;

        iter = this.iterator();

        iterOther = other.iterator();

        while (iter.hasNext()) {

            attr = (FeatureAttributeDescriptor) iter.next();

            attrOther = (FeatureAttributeDescriptor) iterOther.next();

            if (!attr.equals(attrOther)) {

                return false;

            }

        }

        if (!StringUtils.equals(defaultGeometryAttributeName, other.defaultGeometryAttributeName)) {

            return false;

        }

        if (!StringUtils.equals(defaultTimeAttributeName, other.defaultTimeAttributeName)) {

            return false;

        }

        return true;

    }

    /**

     * Start of DynClass interface implementation READONLY

     */

    public DynField addDynField(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField getDeclaredDynField(String name) {

        return (DynField) getAttributeDescriptor(name);

    }

    public DynField[] getDeclaredDynFields() {

        return (DynField[]) getAttributeDescriptors();

    }

    public String getDescription() {

        return this.description;

    }

    public DynField getDynField(String name) {

        return (DynField) getAttributeDescriptor(name);

    }

    public DynField[] getDynFields() {

        return (DynField[]) getAttributeDescriptors();

    }

    public String getName() {

        return this.id + "_" + internalID;

    }

    public void removeDynField(String name) {

        throw new UnsupportedOperationException();

    }

    public void addDynMethod(DynMethod dynMethod) {

        throw new UnsupportedOperationException();

    }

    public void extend(DynClass dynClass) {

        throw new UnsupportedOperationException();

    }

    public void extend(String dynClassName) {

        throw new UnsupportedOperationException();

    }

    public void extend(String namespace, String dynClassName) {

        throw new UnsupportedOperationException();

    }

    public DynMethod getDeclaredDynMethod(String name)

            throws DynMethodException {

        return null;

    }

    public DynMethod[] getDeclaredDynMethods() throws DynMethodException {

        return null;

    }

    public DynMethod getDynMethod(String name) throws DynMethodException {

        return null;

    }

    public DynMethod getDynMethod(int code) throws DynMethodException {

        return null;

    }

    public DynMethod[] getDynMethods() throws DynMethodException {

        return null;

    }

    public DynClass[] getSuperDynClasses() {

        return null;

    }

    public boolean isInstance(DynObject dynObject) {

        if (dynObject.getDynClass().getName() == getName()) {

            return true;

        }

        return false;

    }

    public DynObject newInstance() {

        throw new UnsupportedOperationException();

    }

    public void removeDynMethod(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldChoice(String name, int type,

            Object defaultValue, DynObjectValueItem[] values,

            boolean mandatory, boolean persistent) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldRange(String name, int type,

            Object defaultValue, Object min, Object max, boolean mandatory,

            boolean persistent) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldSingle(String name, int type,

            Object defaultValue, boolean mandatory, boolean persistent) {

        throw new UnsupportedOperationException();

    }

    public void validate(DynObject object) throws DynObjectValidateException {

        //FIXME: not sure it's the correct code

        if (object instanceof Feature) {

            Feature fea = (Feature) object;

            if (fea.getType().equals(this)) {

                return;

            }

        }

        throw new DynObjectValidateException(this.id);

    }

    public DynField addDynFieldLong(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldChoice(String name, int type,

            Object defaultValue, DynObjectValueItem[] values) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldRange(String name, int type,

            Object defaultValue, Object min, Object max) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldSingle(String name, int type, Object defaultValue) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldString(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldInt(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldDouble(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldFloat(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldBoolean(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldList(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldMap(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldObject(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldSet(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldArray(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldDate(String name) {

        throw new UnsupportedOperationException();

    }

    public void extend(DynStruct struct) {

        throw new UnsupportedOperationException();

    }

    public String getFullName() {

        // TODO: usar el DynClassName

        return this.id;

    }

    public String getNamespace() {

        return "DALFeature";

    }

    public DynStruct[] getSuperDynStructs() {

        return null;

    }

    public void setDescription(String description) {

        this.description = description;

    }

    public void setNamespace(String namespace) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldFile(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldFolder(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldURL(String name) {

        throw new UnsupportedOperationException();

    }

    public DynField addDynFieldURI(String name) {

        throw new UnsupportedOperationException();

    }

    public boolean isExtendable(DynStruct dynStruct) {

        return false;

    }

    public void extend(DynStruct[] structs) {

        // TODO Auto-generated method stub

    }

    public void remove(DynStruct superDynStruct) {

        // TODO Auto-generated method stub

    }

    public void removeAll(DynStruct[] superDynStruct) {

        // TODO Auto-generated method stub

    }

    public FeatureAttributeDescriptor getDefaultTimeAttribute() {

        if (this.defaultTimeAttributeIndex < 0) {

            return null;

        }

        return (FeatureAttributeDescriptor) super

                .get(this.defaultTimeAttributeIndex);

    }

    public void setDefaultTimeAttributeName(String name) {

        if (name == null || name.length() == 0) {

            this.defaultTimeAttributeIndex = -1;

            return;

        }

        DefaultFeatureAttributeDescriptor attr = (DefaultFeatureAttributeDescriptor) this.get(name);

        if (attr == null) {

            throw new IllegalArgumentException("Attribute '" + name + "' not found.");

        }

        if (attr.getIndex() < 0) {

            fixAll();

        }

        this.defaultTimeAttributeIndex = attr.getIndex();

    }

    protected void fixAll() {

        int i = 0;

        Iterator iter = super.iterator();

        DefaultFeatureAttributeDescriptor attr;

        while (iter.hasNext()) {

            attr = (DefaultFeatureAttributeDescriptor) iter.next();

            if (attr.getOder() < 1) {

                attr.setOrder(i * 10);

            }

            attr.setIndex(i++);

            attr.fixAll();

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

                this.hasEvaluators = true;

            }

            if (attr.getFeatureAttributeEmulator() != null) {

                this.hasEmulators = true;

                String[] x = attr.getFeatureAttributeEmulator().getRequiredFieldNames();

                if (!ArrayUtils.isEmpty(x)) {

                    this.requiredFields = true;

                }

            }

            switch (attr.getType()) {

                case DataTypes.GEOMETRY:

                    if (this.defaultGeometryAttributeName == null) {

                        this.defaultGeometryAttributeName = attr.getName();

                    }

                    break;

                case DataTypes.INSTANT:

                case DataTypes.INTERVAL:

                case DataTypes.DATE:

                    if (this.defaultTimeAttributeName == null && attr.isTime()) {

                        this.defaultTimeAttributeName = attr.getName();

                    }

                    break;

            }

        }

        if (this.defaultGeometryAttributeName != null) {

            this.defaultGeometryAttributeIndex = this.getIndex(this.defaultGeometryAttributeName);

        }

        if (this.defaultTimeAttributeName != null) {

            this.defaultTimeAttributeIndex = this.getIndex(this.defaultTimeAttributeName);

        }

        this.internalID = Long.toHexString(this.getCRC());

    }

    protected long getCRC() {

        StringBuffer buffer = new StringBuffer();

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

            FeatureAttributeDescriptor x = this.getAttributeDescriptor(i);

            buffer.append(x.getName());

            buffer.append(x.getDataTypeName());

            buffer.append(x.getSize());

        }

        CRC32 crc = new CRC32();

        byte[] data = buffer.toString().getBytes();

        crc.update(data);

        return crc.getValue();

    }

    @Override

    public FeatureStore getStore() {

        if (this.storeRef == null) {

            return null;

        }

        return (FeatureStore) this.storeRef.get();

    }

    public void setStore(FeatureStore store) {

        if (store == null) {

            this.storeRef = null;

        } else {

            this.storeRef = new WeakReference(store);

        }

    }

    @Override

    public List<FeatureAttributeDescriptor> getFilteredAttributes(

            Predicate<FeatureAttributeDescriptor> filter,

            int max

    ) {

        List<FeatureAttributeDescriptor> attrs = new ArrayList<>();

        for (FeatureAttributeDescriptor attribute : this) {

            if (filter.test(attribute)) {

                attrs.add(attribute);

            }

        }

        return attrs;

    }

    @Override

    public List<FeatureAttributeDescriptor> getRecentUseds() {

        return RECENTS_USEDS.getAttributes(this);

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

//        FIXME: rules

        hasEvaluators = state.getBoolean("hasEvaluators");

        hasEmulators = state.getBoolean("hasEmulators");

        defaultGeometryAttributeName = state.getString("defaultGeometryAttributeName");

        defaultTimeAttributeName = state.getString("defaultTimeAttributeName");

        defaultGeometryAttributeIndex = state.getInt("defaultGeometryAttributeIndex");

        defaultTimeAttributeIndex = state.getInt("defaultTimeAttributeIndex");

        id = state.getString("id");

        hasOID = state.getBoolean("hasOID");

        allowAtomaticValues = state.getBoolean("allowAtomaticValues");

        requiredFields = state.getBoolean("requiredFields");

        internalID = state.getString("internalID");

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

        if( tags == null ) {

            this.tags = new DefaultTags();

        }

        List<FeatureAttributeDescriptor> elements = state.getList("elements");

        for (FeatureAttributeDescriptor element : elements) {

            ((DefaultFeatureAttributeDescriptor) element).setFeatureType(this);

            super.add(element);

        }

        this.pk = null;

        this.fixAll();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

//        FIXME: rules

        state.set("hasEvaluators", hasEvaluators);

        state.set("hasEmulators", hasEmulators);

        state.set("defaultGeometryAttributeName", defaultGeometryAttributeName);

        state.set("defaultTimeAttributeName", defaultTimeAttributeName);

        state.set("defaultGeometryAttributeIndex", defaultGeometryAttributeIndex);

        state.set("defaultTimeAttributeIndex", defaultTimeAttributeIndex);

        state.set("id", id);

        state.set("hasOID", hasOID);

        state.set("allowAtomaticValues", allowAtomaticValues);

        state.set("requiredFields", requiredFields);

        state.set("internalID", internalID);

        List<FeatureAttributeDescriptor> elements = new ArrayList<>();

        elements.addAll(this);

        state.set("elements", elements);

        state.set("tags", tags);

    }

    private static final String FEATTYPE_PERSISTENCE_DEFINITION_NAME = "FeatureType";

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(FEATTYPE_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(DefaultFeatureType.class,

                    FEATTYPE_PERSISTENCE_DEFINITION_NAME,

                    FEATTYPE_PERSISTENCE_DEFINITION_NAME

                    + " persistent definition",

                    null,

                    null

            );

//            definition.addDynFieldObject("rules");

            definition.addDynFieldBoolean("hasEvaluators");

            definition.addDynFieldBoolean("hasEmulators");

            definition.addDynFieldString("defaultGeometryAttributeName");

            definition.addDynFieldString("defaultTimeAttributeName");

            definition.addDynFieldInt("defaultGeometryAttributeIndex");

            definition.addDynFieldInt("defaultTimeAttributeIndex");

            definition.addDynFieldString("id");

            definition.addDynFieldBoolean("hasOID");

            definition.addDynFieldBoolean("allowAtomaticValues");

            definition.addDynFieldBoolean("requiredFields");

            definition.addDynFieldString("internalID");

            definition.addDynFieldList("elements")

                    .setClassOfItems(FeatureAttributeDescriptor.class);

            definition.addDynFieldObject("tags")

                    .setClassOfValue(Tags.class);

        }

    }

    @Override

    public FeatureStore getAsFeatureStore() {

        FeatureStore store = FeatureTypeToStoreProviderAdapter.createFeatureStore(this);

        return store;

    }

    public String getNewFieldName() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        String prefix = i18n.getTranslation("_Field");

        String fieldName;

        for (int i = 1; i < 1000; i++) {

            fieldName = prefix +"-"+i;

            if( this.get(fieldName)==null ) {

                return fieldName;

            }

        }

        fieldName = prefix + "-" + (new Date()).getTime();

        return fieldName;

    }

   public FeatureType getOriginalFeatureType()  {

        DefaultFeatureStore store = (DefaultFeatureStore) this.getStore();

        if (store==null) {

            return null;

        }

        return store.getOriginalFeatureType(this);

    }

    @Override

    public boolean hasOnlyMetadataChanges(FeatureType old) {

        if( old == null ) {

            throw new NullPointerException();

        }

        // Si hay campos nuevos -> false

        for (FeatureAttributeDescriptor attr : this) {

            if( old.getAttributeDescriptor(attr.getName())==null ) {

                return false;

            }

        }

        // Si se ha eliminado algun campo -> false

        for (FeatureAttributeDescriptor attr : old) {

            if( this.getAttributeDescriptor(attr.getName())==null ) {

                return false;

            }

        }

        // No hay campos nuevos ni se ha eliminado ninguno, asi que comparamos

        // los campos uno a uno.

        for (FeatureAttributeDescriptor attr : this) {

            FeatureAttributeDescriptor attrold = old.getAttributeDescriptor(attr.getName());

            if( !attr.hasOnlyMetadataChanges(attrold) ) {

                return false;

            }

        }

        return true;

    }

}