Application: gvSIG desktop

 * 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 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.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.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

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

import org.gvsig.tools.util.GetItemWithSizeIsEmptyAndIterator64;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.tools.util.PropertiesSupportHelper;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureStore extends AbstractDataStore implements

    private static final String PERSISTENCE_DEFINITION_NAME = "FeatureStore";

    private FeatureSelection selection;

    private FeatureLocks locks;

    private FeatureCommandsStack commands;

    /*

    TODO: Sustituir estos tres manager por un EditingManager

    private FeatureTypeManager featureTypeManager;

    private FeatureManager featureManager;

    private SpatialManager spatialManager;

    private final StateInformation state;

    private FeatureStoreTimeSupport timeSupport;

    private PropertiesSupportHelper propertiesSupportHelper;

    private DataTransaction transaction;

    private String editingSessionCode;

    private class StateInformation extends HashMap<Object, Object> {

        }

        public void setBreakingsCause(Throwable cause) {

                this.breakingsCause = cause;

            }

            this.broken = true;

        }

    }

    /*

     * TODO:

     *

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

     * hasStrongChanges=false.

     */

    public DefaultFeatureStore() {

        this.state = new StateInformation();

    }

    @Override

    protected DataManager getDataManager() {

        return this.dataManager;

    @Override

    public void intialize(DataManager dataManager,

        DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

        this.metadata = (DelegatedDynObject) dynManager.createDynObject(

        );

        this.dataManager = (DefaultDataManager) dataManager;

        // fixFeatureTypeFromParameters

        this.provider.fixFeatureTypeFromParameters();

        try {

                FeatureAttributeDescriptor attrGeom = defaultFeatureType.getDefaultGeometryAttribute();

                    DefaultFeatureAttributeDescriptor gattr = (DefaultFeatureAttributeDescriptor) attrGeom;

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

                        gattr.setSRSForced(srs);

                    }

                }

            }

        }

    }

    @Override

    public DataStoreParameters getParameters() {

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

        }

        return parameters;

    }

    @Override

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

            return UnmodifiableBasicMap.EMPTY_UNMODIFIABLEBASICMAP;

        }

        return children;

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

            try {

                throw new IllegalStateException();

            }

        }

        }

        this.provider.open();

        this.notifyChange(DataStoreNotification.AFTER_OPEN);

        if (this.mode != MODE_QUERY) {

            throw new IllegalStateException();

        }

        }

            this.load(state);

        } else {

            this.featureCount = null;

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

            try {

                throw new IllegalStateException();

            }

        }

        }

        this.featureCount = null;

        this.provider.close();

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

            try {

                throw new IllegalStateException();

            }

        }

        }

        this.disposeIndexes();

            this.provider.dispose();

        }

        if (this.selection != null) {

    @Override

    public boolean allowWrite() {

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

            return false;

        }

        return this.provider.allowWrite();

    @Override

    public DataServerExplorer getExplorer() throws ReadException,

            try {

                return this.provider.getExplorer();

                return null;

            }

        } else {

     * return this.provider.getMetadata();

     * }

     */

    @Override

    public Envelope getEnvelope() throws DataException {

        if (this.mode == MODE_FULLEDIT) {

        }

        }

        Envelope envelope = this.provider.getEnvelope();

            return envelope;

        }

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

            return null;

        }

        final int index = attrdesc.getIndex();

        try {

            this.accept((Object obj) -> {

                Feature f = (Feature) obj;

                    return;

                }

                    envelopeValue.setValue(g.getEnvelope());

                } else {

                    envelopeValue.getValue().add(g);

    @Override

    public FeatureSelection createDefaultFeatureSelection()

        return new DefaultFeatureSelection(this);

    }

    @Override

    public FeatureProvider createDefaultFeatureProvider(FeatureType type)

        if (type.hasOID()) {

            return new DefaultFeatureProvider(type,

        }

        return new DefaultFeatureProvider(type);

    }

            while (iterAttr.hasNext()) {

                attr = (DefaultFeatureAttributeDescriptor) iterAttr.next();

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

                    attrs.add(attr);

                }

            }

    @Override

    public void loadFromState(final PersistentState persistentState)

        if (this.provider != null) {

            throw new PersistenceStoreAlreadyLoadedException(this.getName());

        }

        state.clear();

        try {

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

            state.setBreakingsCause(th);

        }

        try {

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

            state.setBreakingsCause(th);

        }

            state.setBreakingsCause(th);

        }

        try {

            state.setBreakingsCause(th);

        }

        try {

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

            state.setBreakingsCause(th);

        }

        load(state);

    }

    private void load(StateInformation state) {

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

        try {

            intialize(dataManager, params);

            state.setBreakingsCause(th);

        }

        try {

            DataStoreProvider prov = dataManager.createProvider(

            );

            setProvider(prov);

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

            state.setBreakingsCause(th);

        }

        try {

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

            state.setBreakingsCause(th);

        }

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

            this.transforms.setFeatureStore(this);

                try {

                    transform.setUp();

                    state.setBreakingsCause(th);

                }

            }

            state.setBreakingsCause(th);

        }

        try {

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

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

                    }

            }

            state.setBreakingsCause(th);

        }

        try {

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

            FeatureType ftype;

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

                    }

            }

            state.setBreakingsCause(th);

        }

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

        );

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

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

            definition.addDynFieldObject("parameters")

            definition.addDynFieldObject("selection")

            definition.addDynFieldObject("transforms")

            definition.addDynFieldMap("evaluatedAttributes")

            definition.addDynFieldString("defaultFeatureTypeId")

        }

    }

    public static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

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

            metadataDefinition.extend(manager

        }

    }

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

    // Gestion de la seleccion

    //

    @Override

    public void setSelection(DataSet selection) throws DataException {

        this.setSelection((FeatureSet) selection);

    }

    public void setSelection(FeatureSet selection, boolean undoable)

        if (selection == null) {

            if (undoable) {

                throw new SelectionNotAllowedException(getName());

        if (selection instanceof FeatureSelection) {

            if (undoable && isEditing()) {

                commands.selectionSet(this, this.selection,

            }

            if (this.selection != null) {

                this.selection.dispose();

                commands.startComplex("_selectionSet");

            }

            if (selection instanceof DefaultFeatureSelection) {

                defSelection.deselectAll(undoable);

                defSelection.select(selection, undoable);

            } else {

    @Override

    public FeatureSelection createFeatureSelection() throws DataException {

        long maxSize = dataManager.getMaxSizeForSmallFeatureSelection();

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

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

    // Gestion de notificaciones

    //

    @Override

    public FeatureStoreNotification notifyChange(FeatureStoreNotification storeNotification) {

        if (delegateObservable != null) {

        }

        return storeNotification;

    }

    @Override

    public FeatureStoreNotification notifyChange(String notification) {

    }

    public FeatureStoreNotification notifyChange(String notification, String editingSessionCode) {

    }

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

    }

    public FeatureStoreNotification notifyChange(String notification,

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

    }

    @Override

    public FeatureStoreNotification notifyChange(String notification, FeatureProvider data) {

        Feature f = null;

        }

        return notifyChange(notification, f);

    }

    public FeatureStoreNotification notifyChange(String notification, Feature feature) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification,

    }

    public FeatureStoreNotification notifyChange(String notification, Command command) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification,

    }

    public FeatureStoreNotification notifyChange(String notification, EditableFeatureType type) {

        return notifyChange(new DefaultFeatureStoreNotification(this, notification,

    }

    @Override

    public FeatureStoreNotification notifyChange(String notification, Resource resource) {

        return notifyChange(new DefaultFeatureStoreNotification(this,

    }

    //

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

    // Gestion de bloqueos

    //

    @Override

    public boolean isLocksSupported() {

        return this.provider.isLocksSupported();

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

    // Interface Observable

    //

    @Override

    public void disableNotifications() {

        this.delegateObservable.disableNotifications();

    // - sus bloqueos

    // - sus recursos

    //

    @Override

    public void update(Observable observable, Object notification) {

        if (observable instanceof FeatureSet) {

            }

        } else if (observable instanceof FeatureReferenceSelection) {

            }

        }

    }

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

    // Edicion

    //

    private void newVersionOfUpdate() {

        this.versionOfUpdate++;

    }

    private void checkNotInAppendMode() throws IllegalStateException {

        if (mode == MODE_APPEND) {

        }

    }

    private void checkIsOwnFeature(Feature feature)

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

            throw new IllegalFeatureException(this.getName());

        }

        if (commands != null) {

            try {

                commands.clear();

            }

            commands = null;

        }

        mode = MODE_QUERY;

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

        hasInserts = true;

        this.editingSessionCode = null;

    }

                mode = MODE_FULLEDIT;

            }

            switch (mode) {

                    throw new IllegalStateException(this.getName());

            }

        } catch (Exception e) {

            try {

                if (this.mode != MODE_QUERY) {

                }

                        newSessionCode, mode);

            }

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

        }

    private void setIndexesValidStatus(boolean valid) {

        FeatureIndexes theIndexes = getIndexes();

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

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

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

            if (index instanceof FeatureIndexProviderServices) {

                indexServices.setValid(valid);

            }

        }

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

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

            if (index instanceof FeatureIndexProviderServices) {

                indexServices.fill(true, null);

            }

        }

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

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

            if (index instanceof FeatureIndexProviderServices) {

                indexServices.waitForIndex();

            }

        }

    private void disposeIndexes() {

        FeatureIndexes theIndexes = getIndexes();

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

            return;

        }

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

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

            if (index instanceof FeatureIndexProviderServices) {

                indexServices.dispose();

            }

        }

    @Override

    public boolean isEditing() {

    }

    @Override

    @Override

    synchronized public void update(EditableFeatureType type)

        try {

            if (type == null) {

                throw new NullFeatureTypeException(getName());

            }

                case MODE_QUERY:

                    if (type.hasOnlyMetadataChanges(this.defaultFeatureType)) {

                        }

                        FeatureType theType = type.getNotEditableCopy();

                            defaultFeatureType = theType;

                        }

                        List newtypes = new ArrayList();

                        for (FeatureType featureType : this.featureTypes) {

                                newtypes.add(theType);

                            } else {

                                newtypes.add(featureType);

                        }

                        this.featureTypes = newtypes;

                        saveDALFile();

                        notifyChange(FeatureStoreNotification.AFTER_UPDATE_TYPE, type);

                    }

                    break;

                case MODE_FULLEDIT:

                    }

                    newVersionOfUpdate();

                    FeatureType newt = type.getCopy();

                    commands.update(newt, oldt);

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

                    break;

                case MODE_APPEND:

                case MODE_PASS_THROUGH:

                    throw new NeedEditingModeException(this.getName());

            }

        } catch (Exception e) {

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

    @Override

    public void delete(Feature feature) throws DataException {

            case MODE_PASS_THROUGH:

                checkIsOwnFeature(feature);

                }

                this.provider.passThroughDelete((FeatureReferenceProviderServices) feature.getReference());

                notifyChange(FeatureStoreNotification.AFTER_DELETE, feature);

                break;

            default:

                this.commands.delete(feature);

                break;

        }

    }

    @Override

    public void delete(String filter) {

            return;

        }

        this.delete(ExpressionUtils.createExpression(filter));

    }

    @Override

    public void delete(Expression filter) {

        // TODO: Optimizar pasandolo directamente al proveedor si no estamos en edicion y lo soporta.

            return;

        }

        boolean pendingFinishEditing = false;

        DisposableFeatureSetIterable features = null;

        try {

                case MODE_QUERY:

                    pendingFinishEditing = true;

                    this.edit();

//                    return;

                    break;

                default:

            }

            FeatureSet fset = this.getFeatureSet(filter);

            for (Feature f : features) {

                fset.delete(f);

            }

        } finally {

                this.finishEditingQuietly();

            }

            DisposeUtils.disposeQuietly(features);

        }

    }

    synchronized public void doDelete(Feature feature) throws DataException {

            throw new IllegalArgumentException("feature argument can't be null.");

        }

        try {

            if (feature instanceof EditableFeature) {

                throw new StoreDeleteEditableFeatureException(getName());

            }

            }

            //Update the featureManager and the spatialManager

    @Override

    public synchronized void insert(FeatureSet set) throws DataException {

        switch (mode) {

            try {

                set.accept((Object obj) -> {

                    EditableFeature ef = createNewFeature((Feature) obj);

            break;

        }

    }

    private static EditableFeature lastChangedFeature = null;

    @Override

    public synchronized void insert(EditableFeature feature)

        LOGGER.debug("In editing mode {}, insert feature: {}", mode, feature);

        try {

            switch (mode) {

            }

        } catch (Exception e) {

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

    }

    synchronized public void doInsert(EditableFeature feature)

        checkIsOwnFeature(feature);

        waitForIndexes();

        }

        newVersionOfUpdate();

        if ((lastChangedFeature == null)

            lastChangedFeature = feature;

            lastChangedFeature = null;

        }

        //Update the featureManager and the spatialManager

        ((DefaultFeature) feature).setInserted(true);

        DefaultFeature newFeature = (DefaultFeature) feature.getNotEditableCopy();

        spatialManager.insertFeature(newFeature);

        hasStrongChanges = true;

    @Override

    public void update(EditableFeature feature)

        }

    }

    @Override

    public void update(Object... parameters) throws DataException {

            Object param0 = parameters[0];

            } else {

                throw new IllegalArgumentException("Type of first parameter isn't supported");

            }

            return;

        }

        Expression filter = null;

        long end = parameters.length;

                    filter = (Expression) param;

                } else {

                    filter = ExpressionUtils.createExpression(param.toString());

                }

            }

        } else {

        }