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

import java.util.Set;

import java.util.UUID;

import javax.json.JsonObject;

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

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.gvsig.fmap.dal.BaseStoresRepository;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import static org.gvsig.fmap.dal.DataManager.DAL_STORE_ENVELOPE;

import static org.gvsig.fmap.dal.DataManager.DAL_USE_LARGE_SELECTION;

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

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.StoresRepository;

import org.gvsig.fmap.dal.SupportTransactions;

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

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 static org.gvsig.fmap.dal.feature.Feature.CHECK_BASIC;

import static org.gvsig.fmap.dal.feature.Feature.CHECK_REQUIREDS;

import static org.gvsig.fmap.dal.feature.Feature.CHECK_RULES_AT_EDITING;

import static org.gvsig.fmap.dal.feature.Feature.CHECK_RULES_AT_FINISH;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceFactory;

import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceIteratorToFeatureIterator;

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

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

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

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

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.dal.spi.DataTransactionServices;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

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

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

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

import org.gvsig.tools.util.CachedValue;

import org.gvsig.tools.util.ChainedIterator;

import org.gvsig.tools.util.GetItemWithSizeIsEmptyAndIterator64;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.gvsig.tools.util.UnmodifiableBasicMap;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureStore extends AbstractDataStore implements

        DataStoreInitializer2, FeatureStoreProviderServices, FeatureStore,

        SupportTransactions, Observer {

    public static long sample_feature_cache_timeout_ms = 15000;

    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<FeatureType> featureTypes = new ArrayList<>();

    private int mode = MODE_QUERY;

    private long versionOfUpdate = 0;

    private boolean hasStrongChanges = true;

    private DefaultDataManager dataManager = null;

    private FeatureStoreProvider provider = null;

    private DefaultFeatureIndexes indexes;

    private DefaultFeatureStoreTransforms transforms;

    /*friend*/ DelegatedDynObject metadata;

    private Set metadataChildren;

    private Long featureCount = null;

    private long temporalOid = 0;

    private FeatureCacheProvider cache;

    private final StateInformation state;

    private FeatureStoreTimeSupport timeSupport;

    private PropertiesSupportHelper propertiesSupportHelper;

    private DataTransaction transaction;

    private String editingSessionCode;

    private CachedValue<Feature> sampleFeatureCache;

    private final Observer transactionObserver;

    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();

        this.sampleFeatureCache = null;

        this.transactionObserver = new Observer() {

            @Override

            public void update(Observable o, Object o1) {

                if( o1 instanceof BaseNotification && (

                        ((BaseNotification)o1).isOfType("ROLLBACK") ||

                        ((BaseNotification)o1).isOfType("COMMIT")

                        ) ) {

                    featureCount = null;

                }

            }

        };

    }

    @Override

    protected DataManager getDataManager() {

        return this.dataManager;

    }

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

        if (!this.ignoreDALResource) {

            loadDALFile();

            // Habria que crear un metodo en el proveedor para que de prioidad

            // a los parametros frente a lo que se a leido en el fichero dal

            // DataStoreProvider arreglalo segun los parametros del usuario

            // fixFeatureTypeFromParameters

            this.provider.fixFeatureTypeFromParameters();

            try {

                if (defaultFeatureType != null) {

                    FeatureAttributeDescriptor attrGeom = defaultFeatureType.getDefaultGeometryAttribute();

                    if (attrGeom != null) {

                        DefaultFeatureAttributeDescriptor gattr = (DefaultFeatureAttributeDescriptor) attrGeom;

                        IProjection srs = (IProjection) this.getDynValue(METADATA_CRS);

                        if (srs != null && srs != gattr.getSRS()) {

                            gattr.setSRSForced(srs);

                        }

                    }

                }

            } catch (Throwable th) {

                LOGGER.warn("Can't patch DAL file", th);

            }

        }

    }

    @Override

    public DataStoreParameters getParameters() {

        if (this.parameters == null) {

            LOGGER.warn("Store parametes are null");

        }

        return parameters;

    }

    @Override

    public int getMode() {

        return this.mode;

    }

    @Override

    public DataManager getManager() {

        return this.dataManager;

    }

    @Override

    public UnmodifiableBasicMap<String, DataStore> getChildren() {

        UnmodifiableBasicMap<String, DataStore> children = this.provider.getChildren();

        if (children == null) {

            return UnmodifiableBasicMap.EMPTY_UNMODIFIABLEBASICMAP;

        }

        return children;

    }

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

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

            }

        }

        if (this.notifyChange(DataStoreNotification.BEFORE_OPEN).isCanceled()) {

            return;

        }

        this.provider.open();

        this.notifyChange(DataStoreNotification.AFTER_OPEN);

    }

    @Override

    public void refresh() throws OpenException, InitializeException {

        if (this.mode != MODE_QUERY) {

            throw new IllegalStateException();

        }

        if (this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH).isCanceled()) {

            return;

        }

        if (state.isBroken()) {

            this.load(state);

        } else {

            this.featureCount = null;

            this.provider.refresh();

        }

        this.resourcesStorage = null;

        loadDALFile();

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

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

            }

        }

        if (this.notifyChange(DataStoreNotification.BEFORE_CLOSE).isCanceled()) {

            return;

        }

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

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

            }

        }

        if (this.notifyChange(DataStoreNotification.BEFORE_DISPOSE).isCanceled()) {

            return;

        }

        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;

        }

        DisposeUtils.disposeQuietly(this.resourcesStorage);

        if( this.transaction!=null ) {

            this.transaction.deleteObserver(transactionObserver);

            this.transaction = 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();

            }

        }

        try {

            FeatureType featureType = this.getDefaultFeatureTypeQuietly();

            if( featureType!=null ) {

                Tags tags = featureType.getTags();

                if( tags.has(DAL_STORE_ENVELOPE) ) {

                    String geom_s = tags.getString(DAL_STORE_ENVELOPE,null);

                    if( StringUtils.isNotBlank(geom_s) ) {

                        Geometry geom = GeometryUtils.createFrom(geom_s);

                        if( geom!=null ) {

                            return geom.getEnvelope();

                        }

                    }

                }

            }

        } catch(Throwable th) {

            LOGGER.debug("Can't retrieve envelope from featrure type tag '"+DAL_STORE_ENVELOPE+"'.", th);

        }

        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((Object obj) -> {

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

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

        ((DefaultDataManager) this.getDataManager()).addObservers(this);

    }

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

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

        }

        LOGGER.debug("load() broken:{}, {}, {}.",

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

        );

    }

    public DataStoreProviderServices getStoreProviderServices() {

        return this;

    }

    public static void selfRegister(List<Exception> exs) {

        registerPersistenceDefinition();

        try {

            registerMetadataDefinition();

        } catch (MetadataException e) {

            exs.add(e);

        }

        try {

            DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

            dynObjectManager.registerTag(

                    DAL_USE_LARGE_SELECTION,

                    "Indicates whether the store should use a memory-based or a disk-based selection."

            ).setType(DataTypes.BOOLEAN);

            dynObjectManager.registerTag(

                    DAL_STORE_ENVELOPE,

                    "If specified, this geometry will be used to calculate the store envelope."

            ).setType(DataTypes.STRING);

        } catch (Exception e) {

            exs.add(e);

        }

    }

    private 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);

        }

    }

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

//                // FIXME: Estas lineas parece que no tienen sentido.

//                DefaultFeatureSelection defSelection = (DefaultFeatureSelection) selection;

//                defSelection.deselectAll(undoable);

//                defSelection.select(selection, undoable);

//            } else {

                if( this.selection == null ) {

                    this.selection = createDefaultFeatureSelection();

                }

                this.selection.deselectAll();

                this.selection.select(selection);

//            }

            if (undoable && isEditing()) {

                commands.endComplex();

            }

        }

        this.getFeatureSelection().addObserver(this);

        this.notifyChange(DataStoreNotification.SELECTION_CHANGE);

    }

    @Override

    public FeatureSelection createFeatureSelection() throws DataException {

        FeatureType featureType = this.getDefaultFeatureTypeQuietly();

        if( featureType!=null ) {

            Tags tags = featureType.getTags();

            if( tags.has(DataManager.DAL_USE_LARGE_SELECTION) ) {

                boolean useLargeSelection = tags.getBoolean(DataManager.DAL_USE_LARGE_SELECTION,true);

                if( useLargeSelection ) {

                    return createLargeFeatureSelection();

                }

                return this.provider.createFeatureSelection();

            }

        }

        long maxSize = dataManager.getMaxSizeForSmallFeatureSelection();

        if (this.provider.getFeatureCount() > maxSize) {

            return createLargeFeatureSelection();

        }

        return this.provider.createFeatureSelection();

    }

    @Override

    public FeatureSelection createLargeFeatureSelection() throws DataException {

        return new LargeFeatureSelection(this);

    }

    @Override

    public FeatureSelection createMemoryFeatureSelection() throws DataException {

        return this.provider.createFeatureSelection();

    }

    @Override

    public FeatureSelection getFeatureSelection() throws DataException {

        if (selection == null) {

            this.selection = createFeatureSelection();

            this.selection.addObserver(this);

        }

        return selection;

    }

    @Override

    public boolean isFeatureSelectionEmpty() {

        if( selection == null ) {

            return true;

        }

        return selection.isEmpty();

    }

    //

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

    // Gestion de notificaciones

    //

    @Override

    public FeatureStoreNotification notifyChange(FeatureStoreNotification storeNotification) {

        if (delegateObservable != null) {

            try {

                delegateObservable.notifyObservers(storeNotification);

            } catch (Throwable ex) {

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

            }

        }

        return storeNotification;

    }

    @Override

    public FeatureStoreNotification notifyChange(String notification) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification));

    }

    public FeatureStoreNotification notifyChange(String notification, String editingSessionCode) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification, editingSessionCode));

    }

    public FeatureStoreNotification notifyChange(String notification, String editingSessionCode, int editMode) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification, editingSessionCode, editMode));

    }

    public FeatureStoreNotification notifyChange(String notification,

            String editingSessionCode,

            Iterator<FeatureReference> deleteds,

            Iterator<EditableFeature> inserteds,

            Iterator<EditableFeature> updateds,

            Iterator<FeatureTypeChanged> featureTypesChanged,

            boolean isSelectionCompromised) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification, editingSessionCode,

                deleteds, inserteds, updateds, featureTypesChanged, isSelectionCompromised));

    }

    @Override

    public FeatureStoreNotification notifyChange(String notification, FeatureProvider data) {

        Feature f = null;

        if (data != null) {

            try {

                f = createFeature(data);

            } catch (Throwable ex) {

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

            }

        }

        return notifyChange(notification, f);

    }

    public FeatureStoreNotification notifyChange(String notification, Feature feature) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification,

                feature));

    }

    public FeatureStoreNotification notifyChange(String notification, Command command) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification,

                command));

    }

    public FeatureStoreNotification notifyChange(String notification, EditableFeatureType type) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification,

                type));

    }

    @Override

    public FeatureStoreNotification notifyChange(String notification, Resource resource) {

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

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

            try {

                commands.clear();

            } catch (Exception ex) {

                LOGGER.trace("Can't clear commands", ex);

            }

            commands = null;

        }

        if (featureTypeManager != null) {

            DisposeUtils.disposeQuietly(featureTypeManager);

            featureTypeManager = null;

        }

        // TODO implementar un dispose para estos dos