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

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

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

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

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.gvsig.tools.logger.FilteredLogger;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

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 fullEnvelope = null;

//    private List feaOperation=new ArrayList();

    private boolean noSpatialData = false;

//    public SpatialManager(DefaultFeatureStore featureStore, Envelope originalEnvelope)

//            throws DataException {

//        this(featureStore);

//    }

    public SpatialManager(DefaultFeatureStore featureStore)

            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.isFullExtentDirty = true;

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

//        }

    }

    public void updateFeature(Feature feature, Feature oldFeature) {

        if (noSpatialData) {

            return;

        }

        try {

            if( this.fullEnvelope==null ) {

                isFullExtentDirty = true;

            } else if( !isFullExtentDirty &&  

                !this.fullEnvelope.contains(feature.getDefaultEnvelope()) ) {

                isFullExtentDirty = true;

            }

        } catch(Throwable t) {

            isFullExtentDirty = true;

        }

    }

    public void insertFeature(Feature feature) {

        if (noSpatialData ) {

            return;

        }

        try {

            if( this.fullEnvelope==null ) {

                isFullExtentDirty = true;

            } else if( !isFullExtentDirty &&  

                !this.fullEnvelope.contains(feature.getDefaultEnvelope()) ) {

                isFullExtentDirty = true;

            }

        } catch(Throwable t) {

            isFullExtentDirty = true;

        }

    }

    public void deleteFeature(Feature feature) {

        if (noSpatialData) {

            return;

        }

        // 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.

//        isFullExtentDirty = true;

    }

    public void clear() {

    }

    public Envelope getEnvelope() throws DataException {

        if (noSpatialData) {

            return null;

        }

        if(this.isFullExtentDirty) {

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

                FilteredLogger logger = new FilteredLogger(LOG, "SpatialManagerGetEnvelope", 10);

                while (inserted.hasNext()) {

                    EditableFeature next = inserted.next();

                    try {

                        envelope.add(next.getDefaultEnvelope());

                    } catch (Exception e) {

                        String s = "unknown";

                        try {

                            s = next.getReference().toString();

                        } catch (Exception e2){

                            //Do nothing

                        }

                        logger.warn("Can't add envelope from "+s+" feature", e);

                    }

                }

            }

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

//                }           

//            }

//        }

//        isFullExtentDirty = true;

//    }

    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;

    }

}