Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.impl.editing.memory;

import java.util.Iterator;

import java.util.List;

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.EditingManager;

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

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

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

public class MemoryEditingManager implements EditingManager {

    private final FeatureTypeManager featureTypeManager;

    private final FeatureManager featureManager;

    private final SpatialManager spatialManager;

    public MemoryEditingManager(FeatureStore store, Envelope envelope) throws DataException {

        this.featureManager = new FeatureManager();

        this.featureTypeManager = new FeatureTypeManager(store);

        this.spatialManager = new SpatialManager(store, envelope);

    }

    @Override

    public void dispose() {

        this.featureTypeManager.dispose();

        this.spatialManager.clear();

        this.featureManager.clear();

    }

    @Override

    public void delete(Feature feature) {

        this.featureManager.delete(feature.getReference());

        this.spatialManager.deleteFeature(feature);

    }

    @Override

    public void delete(FeatureReference featureReference) {

        // ????????

        this.featureManager.delete(featureReference);

    }

    @Override

    public void add(Feature newFeature) {

        this.featureManager.add(newFeature);

        this.spatialManager.insertFeature(newFeature);

    }

    @Override

    public int update(Feature newFeature, Feature oldFeature) {

        int code = featureManager.update(newFeature, oldFeature);

        spatialManager.updateFeature(newFeature, oldFeature);

        return code;

    }    

    @Override

    public int update(FeatureType newFeatureType, FeatureType oldFeatureType) {

        int code = featureTypeManager.update(oldFeatureType, oldFeatureType);

        return code;

    }

    @Override

    public boolean isSelectionCompromised() {

        return this.featureManager.isSelectionCompromised();

    }

    @Override

    public Iterator<FeatureProvider> getDeletedFeatures() {

        return this.featureManager.getDeleted();

    }

    @Override

    public Iterator<FeatureProvider> getInsertedFeatures() {

        return this.featureManager.getInserted();

    }

    @Override

    public Iterator<FeatureProvider> getUpdatedFeatures() {

        return this.featureManager.getUpdated();

    }

    @Override

    public List<FeatureStoreProvider.FeatureTypeChanged> getFeatureTypesChanged() throws DataException {

        return this.featureTypeManager.getFeatureTypesChanged();

    }

    @Override

    public FeatureType getFeatureType(String id) throws DataException {

        return this.featureTypeManager.getType(id);

    }

    @Override

    public Feature getFeature(FeatureReference reference, FeatureStore store, FeatureType type) throws DataException {

        return this.featureManager.get(reference, store, type);

    }

    @Override

    public void restore(FeatureReference featureReference) {

        this.featureManager.restore(featureReference);

    }

    @Override

    public void restore(FeatureReference featureReference, int code) {

        this.featureManager.restore(featureReference, code);

    }

    @Override

    public void restore(String featureTypeId) {

        this.featureTypeManager.restore(featureTypeId);

    }

    @Override

    public void restore(String featureTypeId, int code) {

        this.featureTypeManager.restore(featureTypeId, code);

    }

    @Override

    public boolean isDeleted(Feature feature) {

        return this.featureManager.isDeleted(feature);

    }

    @Override

    public boolean isDeleted(FeatureReference featureReference) {

        return this.featureManager.isDeleted(featureReference);

    }

    @Override

    public boolean isDeleted(FeatureType type) {

        return this.featureTypeManager.isDeleted(type);

    }

    @Override

    public boolean isDeleted(String featureTypeId) {

        return this.featureTypeManager.isDeleted(featureTypeId);

    }

}