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.editing.memory;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.logging.Level;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * DOCUMENT ME!

 *

 * @author Vicente Caballero Navarro

 */

public class SpatialManager {

    private static final Logger LOG = LoggerFactory.getLogger(SpatialManager.class);

    protected boolean isFullExtentDirty = true;

    private DefaultFeatureStore featureStore;

    private FeatureIndex featureIndex = null;

    private Envelope originalEnvelope = null;

    private Envelope fullEnvelope = null;

    private ArrayList feaOperation=new ArrayList();

    private boolean noSpatialData = false;

    public SpatialManager(DefaultFeatureStore featureStore, Envelope originalEnvelope)

            throws DataException {

        this.featureStore=featureStore;

        FeatureIndexes findexes=featureStore.getIndexes();

        // Comprobamos si hay algun campo espacial a manejar

        FeatureType fType = this.featureStore.getDefaultFeatureType();

        // TODO Multy FType !!

        if (fType.getDefaultGeometryAttributeIndex() < 0) {

            noSpatialData = true;

            return;

        }

        FeatureAttributeDescriptor attr = fType.getDefaultGeometryAttribute();

        this.originalEnvelope = originalEnvelope;

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

            this.fullEnvelope = originalEnvelope.getGeometry().getEnvelope();

        } else {

            try {

                this.fullEnvelope = GeometryLocator.getGeometryManager()

                        .createEnvelope(attr.getGeometrySubType());

            } catch (Exception e) {

                // FIXME Excpetion

                throw new RuntimeException(e);

            }

        }

        if (!fType.hasOID()) {

            return;

        }

        Iterator iterator = findexes.iterator();

        FeatureIndex index;

        while (iterator.hasNext()) {

            index = (FeatureIndex) iterator.next();

            if (index.getAttributeNames().size() == 1

                    && index.getAttributeNames().contains(attr.getName())) {

                featureIndex = index;

                break;

            }

        }

        if (featureIndex instanceof DefaultFeatureIndex) {

            ((DefaultFeatureIndex) featureIndex).setValid(true);

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @param feature DOCUMENT ME!

     * @param oldFeature DOCUMENT ME!

     */

    public void updateFeature(Feature feature, Feature oldFeature) {

        if (noSpatialData) {

            return;

        }

        try {

            if (oldFeature != null) {

                if (featureIndex != null) {

                    featureIndex.delete(oldFeature);

                }

                final FeatureReference reference = oldFeature.getReference();

                feaOperation.add(new FeatureOperation(reference, FeatureOperation.DELETE));

            }

            if (featureIndex != null) {

                featureIndex.insert(feature);

            }

            feaOperation.add(

                    new FeatureOperation(

                            feature.getReference(),

                            FeatureOperation.INSERT

                    )

            );

        } catch (DataException e) {

            throw new RuntimeException("Exception updating feature: "

                    + feature, e);

        }

        isFullExtentDirty = true;

    }

    /**

     * DOCUMENT ME!

     *

     * @param feature DOCUMENT ME!

     */

    public void insertFeature(Feature feature) {

        if (noSpatialData) {

            return;

        }

            try {

                    if (featureIndex != null) {

                            featureIndex.insert(feature);

                    }

                feaOperation.add(new FeatureOperation(

                    ((DefaultFeature) feature).getReference(),

                    FeatureOperation.INSERT));

            } catch (DataException e) {

                throw new RuntimeException("Exception inserting feature: "

                    + feature, e);

            }

            isFullExtentDirty = true;

    }

    /**

     * DOCUMENT ME!

     *

     * @param feature DOCUMENT ME!

     */

    public void deleteFeature(Feature feature) {

        if (noSpatialData) {

            return;

        }

            try {

                    if (featureIndex != null) {

                            featureIndex.delete(feature);

                    }

                feaOperation.add(new FeatureOperation(((DefaultFeature) feature)

                        .getReference(), FeatureOperation.DELETE));

            } catch (DataException e) {

                throw new RuntimeException("Exception deleting feature: "

                    + feature, e);

            }

        isFullExtentDirty = true;

    }

    public void clear() {

    }

    public Envelope getEnvelope() throws DataException {

        if (noSpatialData) {

            return null;

        }

        if(this.isFullExtentDirty) {

            FeatureAttributeDescriptor attr = featureStore.getDefaultFeatureType().getDefaultGeometryAttribute();

            Envelope envelope = getProviderEnvelope();

            if (envelope == null) {

                try {

                    envelope = GeometryLocator.getGeometryManager().createEnvelope(

                            this.featureStore.getDefaultFeatureType().getDefaultGeometryAttribute().getGeomType().getSubType());

                } catch (CreateEnvelopeException ex) {

                    throw new CreateException("envelope", ex);

                }

            } else {

                try {

                    envelope = (Envelope) envelope.clone();

                } catch (Exception ex) {

                    throw new CloneException(ex);

                }

            }

            FeatureManager featManager = featureStore.getFeatureManager();

            // Si en edicion se provoca un disminucion en el envelope. no hacemos nada 

            // para premiar la velocidad de pintado. Ya se resolvera al finalizar edicion.

            Iterator<EditableFeature> inserted = featManager.getInsertedFeatures();

            if(inserted != null){

                while (inserted.hasNext()) {

                    EditableFeature next = inserted.next();

                    envelope.add(next.getDefaultEnvelope());

                }

            }

            Iterator<EditableFeature> updated = featManager.getUpdatedFeatures();

            if(updated != null){

                while (updated.hasNext()) {

                    EditableFeature next = updated.next();

                    envelope.add(next.getDefaultEnvelope());

                }

            }

            this.fullEnvelope = envelope;

            this.isFullExtentDirty = false;

        }

        return this.fullEnvelope;

    }

    public void cancelModifies() {

        if (noSpatialData) {

            return;

        }

        if (featureIndex != null){

            for (int i = feaOperation.size()-1 ; i>=0 ; i--){

                try {

                    FeatureOperation fo = (FeatureOperation) feaOperation.get(i);

                    if (fo.getOperation() == FeatureOperation.INSERT){                     

                        featureIndex.delete(fo.getFeatureReference().getFeature());

                    }else if (fo.getOperation() == FeatureOperation.DELETE){

                        featureIndex.insert(fo.getFeatureReference().getFeature());

                    }

                } catch (DataException e) {

                    LOG.error("Error canceling the edition", e);

                }           

            }

        }

        if (originalEnvelope!=null){

            try {

                fullEnvelope = (Envelope) originalEnvelope.clone();

            } catch (CloneNotSupportedException e) {

                // Should never happen

                LOG.error("While cloning envelope", e);

            }

        } else {

            fullEnvelope = null;

        }

        isFullExtentDirty = false;

    }

    private class FeatureOperation{

        final static int INSERT=0;

        final static int DELETE=1;

        private FeatureReference ref;

        private int operation;

        public FeatureOperation(FeatureReference fe,int op){

            ref=fe;

            operation=op;

        }

        public FeatureReference getFeatureReference() {

            return ref;

        }

        public void setFeatureReference(FeatureReference ref) {

            this.ref = ref;

        }

        public int getOperation() {

            return operation;

        }

        public void setOperation(int operation) {

            this.operation = operation;

        }

    }

    private Envelope getProviderEnvelope() throws DataException {

        FeatureStoreProvider provider = this.featureStore.getProvider();

        Envelope envelope = provider.getEnvelope();

        return envelope;

    }

}