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 copyFrom(DefaultFeatureType other, boolean copyAttributes) {

        this.id = other.getId();

        if (copyAttributes) {

            Iterator iter = other.iterator();

            DefaultFeatureAttributeDescriptor attr;

            while (iter.hasNext()) {

                attr = (DefaultFeatureAttributeDescriptor) iter.next();

                DefaultFeatureAttributeDescriptor copy = this.getCopyAttributeDescriptor(attr);

                super.add(copy);

            }

            this.pk = null;

        }

        this.defaultGeometryAttributeName = other.defaultGeometryAttributeName;

        this.defaultTimeAttributeName = other.defaultTimeAttributeName;

        this.hasEvaluators = other.hasEvaluators;

        this.hasEmulators = other.hasEmulators;

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

        this.defaultGeometryAttributeIndex = other.defaultGeometryAttributeIndex;

        this.defaultTimeAttributeIndex = other.defaultTimeAttributeIndex;

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