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 org.gvsig.fmap.dal.feature.impl.editing.memory.SpatialManager;

import org.gvsig.fmap.dal.feature.impl.editing.memory.FeatureTypeManager;

import org.gvsig.fmap.dal.feature.impl.editing.memory.FeatureManager;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableObject;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataQuery;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataSet;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.featureset.DefaultFeatureSet;

import org.gvsig.fmap.dal.feature.impl.dynobjectutils.DynObjectFeatureFacade;

import org.gvsig.fmap.dal.feature.impl.undo.DefaultFeatureCommandsStack;

import org.gvsig.fmap.dal.feature.impl.undo.FeatureCommandsStack;

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.fmap.dal.feature.spi.DefaultFeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;

import org.gvsig.fmap.dal.impl.DALResourcesStorage;

import org.gvsig.fmap.dal.impl.DefaultDataManager;

import org.gvsig.fmap.dal.resource.Resource;

import org.gvsig.fmap.dal.spi.DataStoreInitializer2;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObject_v2;

import org.gvsig.tools.dynobject.DynStruct;

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.identitymanagement.SimpleIdentityManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.impl.DelegateWeakReferencingObservable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

import org.gvsig.tools.undo.command.Command;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.tools.util.ResourcesStorage;

import org.gvsig.tools.util.UnmodifiableBasicMap;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.gvsig.tools.util.UnmodifiableBasicSetChained;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureStore extends AbstractDisposable implements

    DataStoreInitializer2, FeatureStoreProviderServices, FeatureStore, Observer {

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultFeatureStore.class);

    private static final String PERSISTENCE_DEFINITION_NAME = "FeatureStore";

    private DataStoreParameters parameters = null;

    private FeatureSelection selection;

    private FeatureLocks locks;

    private DelegateWeakReferencingObservable delegateObservable =

        new DelegateWeakReferencingObservable(this);

    private FeatureCommandsStack commands;

    /*

    TODO: Sustituir estos tres manager por un EditingManager

    */

    private FeatureTypeManager featureTypeManager;

    private FeatureManager featureManager;

    private SpatialManager spatialManager;

    private FeatureType defaultFeatureType = null;

    private List featureTypes = new ArrayList();

    private int mode = MODE_QUERY;

    private long versionOfUpdate = 0;

    private boolean hasStrongChanges = true;

    private boolean hasInserts = true;

    private DefaultDataManager dataManager = null;

    private FeatureStoreProvider provider = null;

    private DefaultFeatureIndexes indexes;

    private DefaultFeatureStoreTransforms transforms;

    DelegatedDynObject metadata;

    private Set metadataChildren;

    private Long featureCount = null;

    private long temporalOid = 0;

    private FeatureCacheProvider cache;

    StateInformation state;

    FeatureStoreTimeSupport timeSupport;

    private class StateInformation extends HashMap<Object, Object> {

        private static final long serialVersionUID = 4109026189635185666L;

        private boolean broken;

        private Throwable breakingsCause;

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public StateInformation() {

            this.clear();

        }

        @Override

        public void clear() {

            this.broken = false;

            this.breakingsCause = null;

            super.clear();

        }

        public boolean isBroken() {

            return this.broken;

        }

        public void broken() {

            this.broken = true;

        }

        public Throwable getBreakingsCause() {

            return this.breakingsCause;

        }

        public void setBreakingsCause(Throwable cause) {

            if( this.breakingsCause==null ) {

                this.breakingsCause = cause;

            }

            this.broken = true;

        }

    }

    /*

     * TODO:

     *

     * - Comprobar que solo se pueden a?adir reglas de validacion sobre un

     * EditableFeatureType. - Comprobar que solo se puede hacer un update con un

     * featureType al que se le han cambiado las reglas de validacion cuando

     * hasStrongChanges=false.

     */

    public DefaultFeatureStore() {

        this.state = new StateInformation();

    }

    @Override

    public void intialize(DataManager dataManager,

        DataStoreParameters parameters) throws InitializeException {

        DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

        this.metadata = (DelegatedDynObject) dynManager.createDynObject(

            FeatureStore.METADATA_DEFINITION_NAME,

            MetadataManager.METADATA_NAMESPACE

        );

        this.dataManager = (DefaultDataManager) dataManager;

        this.parameters = parameters;

        this.transforms = new DefaultFeatureStoreTransforms(this);

        try {

            indexes = new DefaultFeatureIndexes(this);

        } catch (DataException e) {

            throw new InitializeException(e);

        }

    }

    @Override

    public void setProvider(org.gvsig.fmap.dal.DataStoreProvider provider) {

        this.provider = (FeatureStoreProvider) provider;

        this.delegate((DynObject) provider);

        this.metadataChildren = new HashSet();

        this.metadataChildren.add(provider);

        loadDALFile();

    }

    @Override

    public DataStoreParameters getParameters() {

        return parameters;

    }

    public int getMode() {

        return this.mode;

    }

    @Override

    public DataManager getManager() {

        return this.dataManager;

    }

    @Override

    public UnmodifiableBasicMap<String,DataStore> getChildren() {

        return this.provider.getChildren();

    }

    @Override

    public FeatureStoreProvider getProvider() {

        return this.provider;

    }

    public FeatureManager getFeatureManager() {

        return this.featureManager;

    }

    @Override

    public void setFeatureTypes(List types, FeatureType defaultType) {

        this.featureTypes = types;

        this.defaultFeatureType = defaultType;

    }

    public void open() throws OpenException {

        if (this.mode != MODE_QUERY) {

            // TODO: Se puede hacer un open estando en edicion ?

            try {

                throw new IllegalStateException();

            } catch(Exception ex) {

                LOG.warn("Opening a store in editing/append mode ("+this.getFullName()+").",ex);

            }

        }

        this.notifyChange(DataStoreNotification.BEFORE_OPEN);

        this.provider.open();

        this.notifyChange(DataStoreNotification.AFTER_OPEN);

    }

    @Override

    public void refresh() throws OpenException, InitializeException {

        if (this.mode != MODE_QUERY) {

            throw new IllegalStateException();

        }

        this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH);

        if( state.isBroken() ) {

            this.load(state);

        } else {

            this.featureCount = null;

            this.provider.refresh();

        }

        this.notifyChange(FeatureStoreNotification.AFTER_REFRESH);

    }

    public void close() throws CloseException {

        if (this.mode != MODE_QUERY) {

            // TODO: Se puede hacer un close estando en edicion ?

            try {

                throw new IllegalStateException();

            } catch(Exception ex) {

                LOG.warn("Clossing a store in editing/append mode ("+this.getFullName()+").",ex);

            }

        }

        this.notifyChange(DataStoreNotification.BEFORE_CLOSE);

        this.featureCount = null;

        this.provider.close();

        this.notifyChange(DataStoreNotification.AFTER_CLOSE);

    }

    @Override

    protected void doDispose() throws BaseException {

        if (this.mode != MODE_QUERY) {

            // TODO: Se puede hacer un dispose estando en edicion ?

            try {

                throw new IllegalStateException();

            } catch(Exception ex) {

                LOG.warn("Dispossing a store in editing/append mode ("+this.getFullName()+").",ex);

            }

        }

        this.notifyChange(DataStoreNotification.BEFORE_DISPOSE);

        this.disposeIndexes();

        if( this.provider!=null ) {

            this.provider.dispose();

        }

        if (this.selection != null) {

            this.selection.dispose();

            this.selection = null;

        }

        this.commands = null;

        this.featureCount = null;

        if (this.locks != null) {

            // this.locks.dispose();

            this.locks = null;

        }

        if (this.featureTypeManager != null) {

            this.featureTypeManager.dispose();

            this.featureTypeManager = null;

        }

        this.featureManager = null;

        this.spatialManager = null;

        this.parameters = null;

        this.notifyChange(DataStoreNotification.AFTER_DISPOSE);

        if (delegateObservable != null) {

            this.delegateObservable.deleteObservers();

            this.delegateObservable = null;

        }

    }

    @Override

    public boolean allowWrite() {

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        if( ! identityManager.getCurrentIdentity().isAuthorized(DataManager.WRITE_STORE_AUTHORIZATION,this.getParameters(), this.getName()) ) {

            return false;

        }

        return this.provider.allowWrite();

    }

    @Override

    public boolean canWriteGeometry(int geometryType) throws DataException {

        return this.provider.canWriteGeometry(geometryType, 0);

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException,

        ValidateDataParametersException {

        if( this.state.isBroken() ) {

            try {

                return this.provider.getExplorer();

            } catch(Throwable th) {

                return null;

            }

        } else {

            return this.provider.getExplorer();

        }

    }

    /*

     * public Metadata getMetadata() throws MetadataNotFoundException {

     * // TODO:

     * // Si el provider devuelbe null habria que ver de construir aqui

     * // los metadatos basicos, como el Envelope y el SRS.

     *

     * // TODO: Estando en edicion el Envelope deberia de

     * // actualizarse usando el spatialManager

     * return this.provider.getMetadata();

     * }

     */

    @Override

    public Envelope getEnvelope() throws DataException {

        if (this.mode == MODE_FULLEDIT) {

                // Just in case another thread tries to write in the store

                synchronized (this) {

                        return this.spatialManager.getEnvelope();

                        }

        }

        if (hasDynValue(DataStore.METADATA_ENVELOPE)){

            return (Envelope)getDynValue(DataStore.METADATA_ENVELOPE);

        }

        Envelope envelope = this.provider.getEnvelope();

        if( envelope!=null ) {

            return envelope;

        }

        FeatureAttributeDescriptor attrdesc = this.getDefaultFeatureType().getDefaultGeometryAttribute();

        if( attrdesc == null || !attrdesc.isComputed() ) {

            return null;

        }

        final int index = attrdesc.getIndex();

        final MutableObject<Envelope> envelopeValue = new MutableObject<>();

        try {

            this.accept(new Visitor() {

                @Override

                public void visit(Object obj) throws VisitCanceledException, BaseException {

                    Feature f = (Feature) obj;

                    Geometry g =  (Geometry) f.get(index);

                    if( g == null ) {

                        return;

                    }

                    if( envelopeValue.getValue()==null ) {

                        envelopeValue.setValue(g.getEnvelope());

                    } else {

                        envelopeValue.getValue().add(g);

                    }

                }

            });

        } catch (Throwable th) {

            LOG.warn("Can't calculate envelope", th);

            return null;

        }

        return envelopeValue.getValue();

    }

    /**

     * @throws org.gvsig.fmap.dal.exception.DataException

     * @deprecated use getDefaultFeatureType().getDefaultSRS()

     */

    @Override

    public IProjection getSRSDefaultGeometry() throws DataException {

        return this.getDefaultFeatureType().getDefaultSRS();

    }

    @Override

    public FeatureSelection createDefaultFeatureSelection()

        throws DataException {

        return new DefaultFeatureSelection(this);

    }

    @Override

    public FeatureProvider createDefaultFeatureProvider(FeatureType type)

        throws DataException {

        if (type.hasOID()) {

            return new DefaultFeatureProvider(type,

                this.provider.createNewOID());

        }

        return new DefaultFeatureProvider(type);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        /*if (this.mode != FeatureStore.MODE_QUERY) {

            throw new PersistenceException(new IllegalStateException(

                this.getName()));

        }*/

        state.set("dataStoreName", this.getName());

        state.set("parameters", this.parameters);

        state.set("selection", this.selection);

        state.set("transforms", this.transforms);

        // TODO locks persistence

        // state.set("locks", this.locks);

        // TODO indexes persistence

        // state.set("indexes", this.indexes);

        Map evaluatedAttr = new HashMap(1);

        Iterator iterType = featureTypes.iterator();

        Iterator iterAttr;

        FeatureType type;

        DefaultFeatureAttributeDescriptor attr;

        List attrs;

        while (iterType.hasNext()) {

            type = (FeatureType) iterType.next();

            attrs = new ArrayList();

            iterAttr = type.iterator();

            while (iterAttr.hasNext()) {

                attr = (DefaultFeatureAttributeDescriptor) iterAttr.next();

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

                    && (attr.getEvaluator() instanceof Persistent)) {

                    attrs.add(attr);

                }

            }

            if (!attrs.isEmpty()) {

                evaluatedAttr.put(type.getId(), attrs);

            }

        }

        if (evaluatedAttr.isEmpty()) {

            evaluatedAttr = null;

        }

        state.set("evaluatedAttributes", evaluatedAttr);

        state.set("defaultFeatureTypeId", defaultFeatureType.getId());

    }

    @Override

    public void loadFromState(final PersistentState persistentState)

        throws PersistenceException {

        if (this.provider != null) {

            throw new PersistenceStoreAlreadyLoadedException(this.getName());

        }

        if (this.getManager() == null) {

            this.dataManager = (DefaultDataManager) DALLocator.getDataManager();

        }

        state.clear();

        try {

            state.put("parameters", persistentState.get("parameters"));

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            state.put("selection", persistentState.get("selection"));

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            state.put("transforms",  persistentState.get("transforms"));

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            state.put("evaluatedAttributes",  persistentState.get("evaluatedAttributes"));

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            state.put("defaultFeatureTypeId", persistentState.getString("defaultFeatureTypeId"));

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        load(state);

    }

    private void load(StateInformation state) {

        this.featureTypes = new ArrayList();

        this.defaultFeatureType = null;

        this.featureCount = null;

        DataStoreParameters params = (DataStoreParameters) state.get("parameters");

        try {

            intialize(dataManager, params);

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            DataStoreProvider prov = dataManager.createProvider(

                getStoreProviderServices(),

                params

            );

            setProvider(prov);

        } catch(Throwable th) {

            LOG.warn("Can't load store from state.", th);

            state.setBreakingsCause(th);

        }

        try {

            selection = (FeatureSelection) state.get("selection");

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            this.transforms = (DefaultFeatureStoreTransforms) state.get("transforms");

            this.transforms.setFeatureStore(this);

            for( FeatureStoreTransform transform : this.transforms ) {

                try {

                    transform.setUp();

                } catch(Throwable th) {

                    state.setBreakingsCause(th);

                }

            }

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            Map evaluatedAttributes = (Map) state.get("evaluatedAttributes");

            if ((evaluatedAttributes != null) && !evaluatedAttributes.isEmpty()) {

                    Iterator iterEntries = evaluatedAttributes.entrySet().iterator();

                    while (iterEntries.hasNext()) {

                            Entry entry = (Entry) iterEntries.next();

                            List attrs = (List) entry.getValue();

                            if (attrs.isEmpty()) {

                                    continue;

                            }

                            int fTypePos = -1;

                            DefaultFeatureType type = null;

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

                                    type = (DefaultFeatureType) featureTypes.get(i);

                                    if (type.getId().equals(entry.getKey())) {

                                            fTypePos = i;

                                            break;

                                    }

                            }

                            if (type == null) {

                                    throw new PersistenceCantFindFeatureTypeException(

                                            getName(), (String) entry.getKey());

                            }

                            DefaultEditableFeatureType eType = (DefaultEditableFeatureType) type.getEditable();

                            Iterator<FeatureAttributeDescriptor> iterAttr = attrs.iterator();

                            while (iterAttr.hasNext()) {

                                    FeatureAttributeDescriptor attr = iterAttr.next();

                                    eType.addLike(attr);

                            }

                            featureTypes.set(fTypePos, eType.getNotEditableCopy());

                    }

            }

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        try {

            String defaultFeatureTypeId = (String) state.get("defaultFeatureTypeId");

            FeatureType ftype;

            if (defaultFeatureType == null ||

                    defaultFeatureType.getId() == null ||

                    !defaultFeatureType.getId().equals(defaultFeatureTypeId)) {

                    ftype = getFeatureType(defaultFeatureTypeId);

                    if (ftype == null) {

                            /*

                             * Un error en el m?todo de PostgreSQL getName(), hace que

                             * el nombre del featureType sea valor retornado por el getProviderName()

                             * De momento se pone este parche para apa?arlo y poder mantener compatibilidad

                             * con proyectos antiguos (2.1 y 2.2)

                             */

                            ftype = getFeatureType(getName());

                            if(ftype == null ) {

                                    throw new RuntimeException("Can't locate feature type");

                            }

                    }

                    defaultFeatureType = ftype;

            }

        } catch(Throwable th) {

            state.setBreakingsCause(th);

        }

        LOG.info("load() broken:{}, {}, {}.",

                new Object[] { state.isBroken(), this.getProviderName(), params }

        );

    }

        public DataStoreProviderServices getStoreProviderServices() {

                return this;

        }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(DefaultFeatureStore.class,

                    PERSISTENCE_DEFINITION_NAME, PERSISTENCE_DEFINITION_NAME

                        + " Persistent definition", null, null);

            definition.addDynFieldString("dataStoreName").setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldObject("parameters")

                .setClassOfValue(DynObject.class).setMandatory(true)

                .setPersistent(true);

            definition.addDynFieldObject("selection")

                .setClassOfValue(FeatureSelection.class).setMandatory(false)

                .setPersistent(true);

            definition.addDynFieldObject("transforms")

                .setClassOfValue(DefaultFeatureStoreTransforms.class)

                .setMandatory(true).setPersistent(true);

            definition.addDynFieldMap("evaluatedAttributes")

                .setClassOfItems(List.class) // List<DefaultFeatureAttributeDescriptor>

                .setMandatory(false).setPersistent(true);

            definition.addDynFieldString("defaultFeatureTypeId")

                .setMandatory(true).setPersistent(true);

        }

    }

    public static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(FeatureStore.METADATA_DEFINITION_NAME) == null) {

            DynStruct metadataDefinition =

                manager.addDefinition(FeatureStore.METADATA_DEFINITION_NAME, null);

            metadataDefinition.extend(manager

                .getDefinition(DataStore.METADATA_DEFINITION_NAME));

        }

    }

    //

    // ====================================================================

    // Gestion de la seleccion

    //

    @Override

    public void setSelection(DataSet selection) throws DataException {

        this.setSelection((FeatureSet) selection);

    }

    @Override

    public DataSet createSelection() throws DataException {

        return createFeatureSelection();

    }

    @Override

    public DataSet getSelection() throws DataException {

        return this.getFeatureSelection();

    }

    @Override

    public void setSelection(FeatureSet selection) throws DataException {

        setSelection(selection, true);

    }

    public void setSelection(FeatureSet selection, boolean undoable)

        throws DataException {

        if (selection == null) {

            if (undoable) {

                throw new SelectionNotAllowedException(getName());

            }

        } else {

            if (selection.equals(this.selection)) {

                return;

            }

            if (!selection.isFromStore(this)) {

                throw new SelectionNotAllowedException(getName());

            }

        }

        if (this.selection != null) {

            this.selection.deleteObserver(this);

        }

        if (selection == null) {

            if (this.selection != null) {

                this.selection.dispose();

            }

            this.selection = null;

            return;

        }

        if (selection instanceof FeatureSelection) {

            if (undoable && isEditing()) {

                commands.selectionSet(this, this.selection,

                    (FeatureSelection) selection);

            }

            if (this.selection != null) {

                this.selection.dispose();

            }

            this.selection = (FeatureSelection) selection;

        } else {

            if (undoable && isEditing()) {

                commands.startComplex("_selectionSet");

            }

            if (selection instanceof DefaultFeatureSelection) {

                DefaultFeatureSelection defSelection =

                    (DefaultFeatureSelection) selection;

                defSelection.deselectAll(undoable);

                defSelection.select(selection, undoable);

            } else {

                this.selection.deselectAll();

                this.selection.select(selection);

            }

            if (undoable && isEditing()) {

                commands.endComplex();

            }

        }

        this.selection.addObserver(this);

        this.notifyChange(DataStoreNotification.SELECTION_CHANGE);

    }

    @Override

    public FeatureSelection createFeatureSelection() throws DataException {

        return this.provider.createFeatureSelection();

    }

    @Override

    public FeatureSelection getFeatureSelection() throws DataException {

        if (selection == null) {

            this.selection = createFeatureSelection();

            this.selection.addObserver(this);

        }

        return selection;

    }

    //

    // ====================================================================

    // Gestion de notificaciones

    //

    @Override

    public void notifyChange(FeatureStoreNotification storeNotification) {

        try {

            delegateObservable.notifyObservers(storeNotification);

        } catch (Throwable ex) {

            LOG.warn("Problems notifying changes in the store '"+this.getName()+" ("+storeNotification.getType()+").",ex);

        }

    }

    @Override

    public void notifyChange(String notification) {

        if (delegateObservable != null) {

            notifyChange(new DefaultFeatureStoreNotification(this, notification));

        }

    }

    @Override

    public void notifyChange(String notification, FeatureProvider data) {

        Feature f = null;

        try {

            f = createFeature(data);

        } catch (Throwable ex) {

            LOG.warn("Problems creating a feature to notifying changes in the store '"+this.getName()+" ("+notification+").",ex);

        }

        notifyChange(notification, f);

    }

    public void notifyChange(String notification, Feature feature) {

        notifyChange(new DefaultFeatureStoreNotification(this, notification,

            feature));

    }

    public void notifyChange(String notification, Command command) {

        notifyChange(new DefaultFeatureStoreNotification(this, notification,

            command));

    }

    public void notifyChange(String notification, EditableFeatureType type) {

        notifyChange(new DefaultFeatureStoreNotification(this, notification,

            type));

    }

    @Override

    public void notifyChange(String notification, Resource resource) {

        notifyChange(new DefaultFeatureStoreNotification(this,

            DataStoreNotification.RESOURCE_CHANGED));

    }

    //

    // ====================================================================

    // Gestion de bloqueos

    //

    @Override

    public boolean isLocksSupported() {

        return this.provider.isLocksSupported();

    }

    @Override

    public FeatureLocks getLocks() throws DataException {

        if (!this.provider.isLocksSupported()) {

            LOG.warn("Locks not supported");

            return null;

        }

        if (locks == null) {

            this.locks = this.provider.createFeatureLocks();

        }

        return locks;

    }

    //

    // ====================================================================

    // Interface Observable

    //

    @Override

    public void disableNotifications() {

        this.delegateObservable.disableNotifications();

    }

    @Override

    public void enableNotifications() {

        this.delegateObservable.enableNotifications();

    }

    @Override

    public void beginComplexNotification() {

        this.delegateObservable.beginComplexNotification();

    }

    @Override

    public void endComplexNotification() {

        this.delegateObservable.endComplexNotification();

    }

    @Override

    public void addObserver(Observer observer) {

        if (delegateObservable != null) {

            this.delegateObservable.addObserver(observer);

        }

    }

    @Override

    public void deleteObserver(Observer observer) {

        if (delegateObservable != null) {

            this.delegateObservable.deleteObserver(observer);

        }

    }

    @Override

    public void deleteObservers() {

        this.delegateObservable.deleteObservers();

    }

    //

    // ====================================================================

    // Interface Observer

    //

    // Usado para observar:

    // - su seleccion

    // - sus bloqueos

    // - sus recursos

    //

    @Override

    public void update(Observable observable, Object notification) {

        if (observable instanceof FeatureSet) {

            if (observable == this.selection) {

                this.notifyChange(DataStoreNotification.SELECTION_CHANGE);

            } else if (observable == this.locks) {

                this.notifyChange(FeatureStoreNotification.LOCKS_CHANGE);

            }

        } else if (observable instanceof FeatureStoreProvider) {

            if (observable == this.provider) {

            }

        } else if (observable instanceof FeatureReferenceSelection) {

            if(notification instanceof String){

                    this.notifyChange((String)notification);

            }

        }

    }

    //

    // ====================================================================

    // Edicion

    //

    private void newVersionOfUpdate() {

        this.versionOfUpdate++;

    }

    private long currentVersionOfUpdate() {

        return this.versionOfUpdate;

    }

    private void checkInEditingMode() throws NeedEditingModeException {

        if (mode != MODE_FULLEDIT) {

            throw new NeedEditingModeException(this.getName());

        }

    }

    private void checkNotInAppendMode() throws IllegalStateException {

        if (mode == MODE_APPEND) {

                        throw new IllegalStateException("Error: store "

                                        + this.getFullName() + " is in append mode");

        }

    }

    private void checkIsOwnFeature(Feature feature)

        throws IllegalFeatureException {

        if (((DefaultFeature) feature).getStore() != this) {

            throw new IllegalFeatureException(this.getName());

        }

        // FIXME: fixFeatureType no vale para el checkIsOwnFeature

        // fixFeatureType((DefaultFeatureType) feature.getType());

    }

    private void exitEditingMode() {

        if (commands != null) {

            commands.clear();

            commands = null;

        }

        if (featureTypeManager != null) {

            featureTypeManager.dispose();

            featureTypeManager = null;

        }

        // TODO implementar un dispose para estos dos

        featureManager = null;

        spatialManager = null;

        featureCount = null;

        mode = MODE_QUERY;

        hasStrongChanges = true; // Lo deja a true por si las moscas

        hasInserts = true;

    }

    @Override

    synchronized public void edit() throws DataException {

        edit(MODE_FULLEDIT);

    }

    @Override

    synchronized public void edit(int mode) throws DataException {

        LOG.debug("Starting editing in mode: {}", mode);

        try {

            if (this.mode != MODE_QUERY) {

                throw new AlreadyEditingException(this.getName());

            }

            if (!this.provider.supportsAppendMode()) {

                mode = MODE_FULLEDIT;

            }

            switch (mode) {

            case MODE_QUERY:

                throw new IllegalStateException(this.getName());

            case MODE_FULLEDIT:

                if (!this.transforms.isEmpty()) {

                    throw new IllegalStateException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                invalidateIndexes();

                featureManager = new FeatureManager();

                featureTypeManager = new FeatureTypeManager(this);

                spatialManager = new SpatialManager(this, provider.getEnvelope());

                commands = new DefaultFeatureCommandsStack(

                        this, featureManager,

                        spatialManager, featureTypeManager);

                this.mode = MODE_FULLEDIT;

                hasStrongChanges = false;

                hasInserts = false;

                notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                break;

            case MODE_APPEND:

                if (!this.transforms.isEmpty()) {

                    throw new IllegalStateException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                invalidateIndexes();

                this.provider.beginAppend();

                this.mode = MODE_APPEND;

                hasInserts = false;

                notifyChange(FeatureStoreNotification.AFTER_STARTEDITING);

                break;

            }

        } catch (Exception e) {

            throw new StoreEditException(e, this.getName());

        }

    }

    private void invalidateIndexes() {

        setIndexesValidStatus(false);

    }

    private void setIndexesValidStatus(boolean valid) {

        FeatureIndexes theIndexes = getIndexes();

        LOG.debug("Setting the store indexes to valid status {}: {}", (valid

            ? Boolean.TRUE : Boolean.FALSE), theIndexes);

        for (Iterator iterator = theIndexes.iterator(); iterator.hasNext();) {

            FeatureIndex index = (FeatureIndex) iterator.next();

            if (index instanceof FeatureIndexProviderServices) {

                FeatureIndexProviderServices indexServices =

                    (FeatureIndexProviderServices) index;

                indexServices.setValid(valid);

            }

        }

    }

    private void updateIndexes() throws FeatureIndexException {

        FeatureIndexes theIndexes = getIndexes();

        LOG.debug("Refilling indexes: {}", theIndexes);

        for (Iterator iterator = theIndexes.iterator(); iterator.hasNext();) {

            FeatureIndex index = (FeatureIndex) iterator.next();

            if (index instanceof FeatureIndexProviderServices) {

                FeatureIndexProviderServices indexServices =

                    (FeatureIndexProviderServices) index;

                indexServices.fill(true, null);

            }

        }

    }

    private void waitForIndexes() {

        FeatureIndexes theIndexes = getIndexes();

        LOG.debug("Waiting for indexes to finish filling: {}", theIndexes);

        for (Iterator iterator = theIndexes.iterator(); iterator.hasNext();) {

            FeatureIndex index = (FeatureIndex) iterator.next();

            if (index instanceof FeatureIndexProviderServices) {

                FeatureIndexProviderServices indexServices =

                    (FeatureIndexProviderServices) index;

                indexServices.waitForIndex();

            }

        }

    }

    private void disposeIndexes() {

        FeatureIndexes theIndexes = getIndexes();

        LOG.debug("Disposing indexes: {}", theIndexes);

        if( theIndexes==null ) {

            return;

        }

        for (Iterator iterator = theIndexes.iterator(); iterator.hasNext();) {

            FeatureIndex index = (FeatureIndex) iterator.next();

            if (index instanceof FeatureIndexProviderServices) {

                FeatureIndexProviderServices indexServices =

                    (FeatureIndexProviderServices) index;

                indexServices.dispose();

            }

        }

    }

    @Override

    public boolean isEditing() {

        return mode == MODE_FULLEDIT;

    }

    @Override

    public boolean isAppending() {

        return mode == MODE_APPEND;

    }

    @Override

    synchronized public void update(EditableFeatureType type)

        throws DataException {

        try {

            if (type == null) {

                throw new NullFeatureTypeException(getName());

            }

            boolean typehasStrongChanges = ((DefaultEditableFeatureType) type).hasStrongChanges();

            if (typehasStrongChanges) {

                checkInEditingMode();

            }  else if(this.isAppending()) {

                throw new NeedEditingModeException(this.getName());

            }

            // FIXME: Comprobar que es un featureType aceptable.

            notifyChange(FeatureStoreNotification.BEFORE_UPDATE_TYPE, type);

            newVersionOfUpdate();

            FeatureType oldt = type.getSource().getCopy();

            FeatureType newt = type.getCopy();

            commands.update(newt, oldt);

            if (typehasStrongChanges) { 

                hasStrongChanges = true;

            }

            notifyChange(FeatureStoreNotification.AFTER_UPDATE_TYPE, type);

        } catch (Exception e) {

            throw new StoreUpdateFeatureTypeException(e, this.getName());

        }

    }

    @Override

    public void delete(Feature feature) throws DataException {

        this.commands.delete(feature);

    }

    synchronized public void doDelete(Feature feature) throws DataException {

        try {

            checkInEditingMode();

            checkIsOwnFeature(feature);

            if (feature instanceof EditableFeature) {

                throw new StoreDeleteEditableFeatureException(getName());

            }

            notifyChange(FeatureStoreNotification.BEFORE_DELETE, feature);

            //Update the featureManager and the spatialManager

            featureManager.delete(feature.getReference());

            spatialManager.deleteFeature(feature);

            newVersionOfUpdate();

            hasStrongChanges = true;

            notifyChange(FeatureStoreNotification.AFTER_DELETE, feature);

        } catch (Exception e) {

            throw new StoreDeleteFeatureException(e, this.getName());