gvSIG projects pool

/**

 * 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.topology.lib.impl;

import java.util.Iterator;

import java.util.Map;

import org.apache.commons.collections.IteratorUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableObject;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.EditingNotification;

import org.gvsig.fmap.dal.EditingNotificationManager;

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.gvsig.topology.lib.api.CancelOperationException;

import org.gvsig.topology.lib.api.PerformOperationException;

import org.gvsig.topology.lib.api.TopologyDataSet;

import org.gvsig.topology.lib.api.TopologyLocator;

import org.gvsig.topology.lib.api.TopologyManager;

import org.json.JSONObject;

import org.gvsig.topology.lib.api.TopologyServices;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings({"EqualsAndHashcode","UseSpecificCatch"})

public class DefaultTopologyDataSet implements TopologyDataSet {

    private final static Logger LOGGER = LoggerFactory.getLogger(DefaultTopologyDataSet.class);

    private TopologyServices services;

    private String name;

    private DataStore store;

    private boolean needFinishEditing;

    private String fullName;

    private PropertiesSupportHelper propertiesHelper;

    private MutableObject<SpatialIndex> spatialIndex = null;

    public DefaultTopologyDataSet() {

        this.services = null;

        this.name = null;

        this.store = null;

        this.needFinishEditing = false;

        this.fullName = null;

        this.propertiesHelper = new PropertiesSupportHelper();

    }

    public DefaultTopologyDataSet(TopologyServices services, String name, DataStore store) {

        this.services = services;

        this.name = name;

        this.store = store;

        this.needFinishEditing = false;

        if( store!=null ) {

            this.fullName = store.getFullName();

        }

    }

    @Override

    public void restart() {

        this.store  = null;

        this.spatialIndex = null;

    }

    @Override

    public boolean equals(Object obj) {

        if( !(obj instanceof DefaultTopologyDataSet) ) {

            return false;

        }

        DefaultTopologyDataSet other = (DefaultTopologyDataSet)obj;

        if( this.store != other.store ) {

            return false;

        }

        if( !StringUtils.equals(this.getName(), other.getName()) ) {

            return false;

        }

        return true;

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        try {

            FeatureAttributeDescriptor attr = this.getFeatureStore().getDefaultFeatureType().getDefaultGeometryAttribute();

            String geomType = attr.getGeomType().getName();

            return this.name + " ("+ geomType + ")";

        } catch(Exception ex) {

            return this.name ;

        }

    }

    @Override

    public DataStore getStore() {

        if (this.store == null) {

            this.store = this.services.getFeatureStore(this);

        }

        return this.store;

    }

    @Override

    public FeatureStore getFeatureStore() {

        if (this.store == null) {

            this.store = this.services.getFeatureStore(this);

        }

        return (FeatureStore) this.store;

    }

    @Override

    public long getSize() {

        try {

            long size = this.getFeatureStore().getFeatureCount();

            return size;

        } catch (DataException ex) {

            // TODO: mensage al log

            return 0;

        }

    }

    @Override

    public boolean isThisStore(FeatureStore store) {

        if( store == null ) {

            return false;

        }

        return StringUtils.equals(this.fullName, store.getFullName());

    }

    @Override

    public int getGeometryType() {

        try {

            FeatureStore theStore = this.getFeatureStore();

            FeatureType featureType = theStore.getDefaultFeatureType();

            FeatureAttributeDescriptor attr = featureType.getDefaultGeometryAttribute();

            GeometryType geomType = attr.getGeomType();

            return geomType.getType();

        } catch (Exception ex) {

            return Geometry.TYPES.GEOMETRY;

        }

    }

    @Override

    public void accept(Visitor visitor) throws VisitCanceledException {

        FeatureStore st = this.getFeatureStore();

        try {

            st.accept(visitor);

        } catch(VisitCanceledException ex) {

            throw ex;

        } catch(BaseException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public void edit() throws DataException {

        FeatureStore theStore = this.getFeatureStore();

        if (!theStore.isEditing()) {

            theStore.edit();

            this.needFinishEditing = true;

        }

    }

    @Override

    public void finishEditing() throws DataException {

        if (this.needFinishEditing) {

            this.getFeatureStore().finishEditing();

        }

    }

    @Override

    public EditableFeature createNewFeature() throws DataException {

        EditableFeature f = this.getFeatureStore().createNewFeature();

        return f;

    }

    public void perform(

            String operation,

            Feature feature

    ) throws DataException {

        this.edit();

        EditingNotificationManager editingNotificationManager

                = DALSwingLocator.getEditingNotificationManager();

        FeatureStore theStore = this.getFeatureStore();

        EditingNotification notification

                = editingNotificationManager.notifyObservers(this, // source

                        operation, // type

                        null,// document

                        null,// layer

                        theStore,// store

                        feature// feature

                );

        if (notification.isCanceled()) {

            String msg = String.format(

                    "Can't insert feature into %1$s, canceled by some observer.",

                    this.getName());

            throw new CancelOperationException(msg);

        }

        String after = null;

        if( operation.equalsIgnoreCase(EditingNotification.BEFORE_REMOVE_FEATURE) ) {

            theStore.delete(feature);

            after = EditingNotification.AFTER_REMOVE_FEATURE;

        } else {

            if (notification.shouldValidateTheFeature()) {

                if (!editingNotificationManager.validateFeature(feature)) {

                    String msg = String.format("%1$s is not valid", feature.toString());

                    throw new PerformOperationException(msg);

                }

            }

            switch(operation) {

                case EditingNotification.BEFORE_UPDATE_FEATURE:

                    theStore.update((EditableFeature) feature);

                    after = EditingNotification.AFTER_UPDATE_FEATURE;

                    break;

                case EditingNotification.BEFORE_INSERT_FEATURE:

                    theStore.insert((EditableFeature) feature);

                    after = EditingNotification.AFTER_INSERT_FEATURE;

                    break;

            }

        }

        editingNotificationManager.notifyObservers(this,

                after, null, null,

                theStore, feature);

    }

    @Override

    public void insert(final EditableFeature feature) throws DataException {

        perform(

            EditingNotification.BEFORE_INSERT_FEATURE,

            feature

        );

    }

    @Override

    public void update(final EditableFeature feature) throws DataException {

        perform(

            EditingNotification.BEFORE_UPDATE_FEATURE,

            feature

        );

    }

    @Override

    public void delete(final Feature feature) throws DataException {

        perform(

            EditingNotification.BEFORE_REMOVE_FEATURE,

            feature

        );

    }

    @Override

    public void delete(final FeatureReference feature) throws DataException {

        perform(

            EditingNotification.BEFORE_REMOVE_FEATURE,

            feature.getFeature()

        );

    }

    @Override

    public JSONObject toJSON() {

        JSONObject jsonDataSet = new JSONObject();

        jsonDataSet.put("name", this.name);

        jsonDataSet.put("fullName", this.fullName);

        return jsonDataSet;

    }

    @Override

    public void fromJSON(String json) {

        this.fromJSON(new JSONObject(json));

    }

    @Override

    public void fromJSON(JSONObject json) {

        TopologyManager manager = TopologyLocator.getTopologyManager();

        this.name = json.getString("name");

        this.fullName = null;

        if( json.has("fullName") ) {

            this.fullName = json.getString("fullName");

        }

        this.store = null;

        this.needFinishEditing = false;

        this.services = manager.getDefaultServices();

    }

    @Override

    public Object getProperty(String string) {

        return this.propertiesHelper.getProperty(name);

    }

    @Override

    public void setProperty(String string, Object o) {

        this.propertiesHelper.setProperty(name, o);

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesHelper.getProperties();

    }

    @Override

    public SpatialIndex getSpatialIndex() {

        if( this.spatialIndex == null ) {

            this.spatialIndex = new MutableObject<>();

            FeatureStore theStore = this.getFeatureStore();

            FeatureStoreProviderFactory storeFactory = (FeatureStoreProviderFactory) theStore.getProviderFactory();

            if( storeFactory.useLocalIndexesCanImprovePerformance()==FeatureStoreProviderFactory.YES ) {

                try {

                    GeometryManager geomManager = GeometryLocator.getGeometryManager();

                    final SpatialIndex geomIndex = geomManager.createSpatialIndex(

                            GeometryManager.SPATIALINDEX_DEFAULT_QUADTREE,

                            null

                    );

                    final SpatialIndex dataIndex = theStore.wrapSpatialIndex(geomIndex);

                    try {

                        store.accept(new Visitor() {

                            @Override

                            public void visit(Object o) throws VisitCanceledException, BaseException {

                                Feature f = (Feature) o;

                                Geometry geom = f.getDefaultGeometry();

                                if (geom != null) {

                                    dataIndex.insert(geom, f);

                                }

                            }

                        });

                    } catch (VisitCanceledException ex) {

                    }

                    this.spatialIndex.setValue(dataIndex);

                } catch (Exception ex) {

                    LOGGER.warn("Can't create spatial index", ex);

                }

            }

        }

        return this.spatialIndex.getValue();

    }

    @Override

    public Iterable<FeatureReference> query(Geometry geom) {

        return this.queryReferences(geom);

    }

    @Override

    public Iterable<FeatureReference> queryReferences(Geometry geom) {

        SpatialIndex index = this.getSpatialIndex();

        if( index == null ) {

            try {

                FeatureStore theStore = (FeatureStore) this.getStore();

                ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

                Expression expression = manager.createExpression();

                ExpressionBuilder expressionBuilder = manager.createExpressionBuilder();

                String geomName = theStore.getDefaultFeatureType().getDefaultGeometryAttributeName();

                if( GeometryUtils.isSubtype(Geometry.TYPES.POINT, geom.getType()) )  {

                    expression.setPhrase(

                        expressionBuilder.ifnull(

                            expressionBuilder.column(geomName),

                            expressionBuilder.constant(false),

                            expressionBuilder.ST_Intersects(

                                    expressionBuilder.column(geomName),

                                    expressionBuilder.geometry(geom)

                            )

                        ).toString()

                    );

                } else {

                    expression.setPhrase(

                        expressionBuilder.ifnull(

                            expressionBuilder.column(geomName),

                            expressionBuilder.constant(false),

                            expressionBuilder.ST_Overlaps(

                                    expressionBuilder.column(geomName),

                                    expressionBuilder.envelope(geom.getEnvelope())

                            )

                        ).toString()

                    );

                }

                FeatureSet set = theStore.getFeatureSet(expression);

                final DisposableIterator it = set.fastIterator();

                return new Iterable<FeatureReference>() {

                    @Override

                    public Iterator<FeatureReference> iterator() {

                        return new Iterator<FeatureReference>() {

                            @Override

                            public boolean hasNext() {

                                return it.hasNext();

                            }

                            @Override

                            public FeatureReference next() {

                                Feature f = (Feature) it.next();

                                return f.getReference();

                            }

                        };

                    }

                };

            } catch(Exception ex) {

                return (Iterable<FeatureReference>) IteratorUtils.EMPTY_ITERATOR;

            }

        }

        final Iterator it = index.query(geom);

        if( it == null ) {

            return (Iterable<FeatureReference>) IteratorUtils.EMPTY_ITERATOR;

        }

        return new Iterable<FeatureReference>() {

            @Override

            public Iterator<FeatureReference> iterator() {

                return it;

            }

        };

    }

    @Override

    public Iterable<Feature> queryFeatures(Geometry geom) {

        SpatialIndex index = this.getSpatialIndex();

        if( index == null ) {

            try {

                FeatureStore theStore = (FeatureStore) this.getStore();

                ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

                Expression expression = manager.createExpression();

                ExpressionBuilder expressionBuilder = manager.createExpressionBuilder();

                String geomName = theStore.getDefaultFeatureType().getDefaultGeometryAttributeName();

                if( GeometryUtils.isSubtype(Geometry.TYPES.POINT, geom.getType()) )  {

                    expression.setPhrase(

                        expressionBuilder.ifnull(

                            expressionBuilder.column(geomName),

                            expressionBuilder.constant(false),

                            expressionBuilder.ST_Intersects(

                                    expressionBuilder.column(geomName),

                                    expressionBuilder.geometry(geom)

                            )

                        ).toString()

                    );

                } else {

                    expression.setPhrase(

                        expressionBuilder.ifnull(

                            expressionBuilder.column(geomName),

                            expressionBuilder.constant(false),

                            expressionBuilder.ST_Overlaps(

                                    expressionBuilder.column(geomName),

                                    expressionBuilder.envelope(geom.getEnvelope())

                            )

                        ).toString()

                    );

                }

                FeatureSet set = theStore.getFeatureSet(expression);

                final DisposableIterator it = set.fastIterator();

                return new Iterable<Feature>() {

                    @Override

                    public Iterator<Feature> iterator() {

                        return it;

                    }

                };

            } catch(Exception ex) {

                return (Iterable<Feature>) IteratorUtils.EMPTY_ITERATOR;

            }

        }

        final Iterator it = index.query(geom);

        if( it == null ) {

            return (Iterable<Feature>) IteratorUtils.EMPTY_ITERATOR;

        }

        return new Iterable<Feature>() {

            @Override

            public Iterator<Feature> iterator() {

                return new Iterator<Feature>() {

                    @Override

                    public boolean hasNext() {

                        return it.hasNext();

                    }

                    @Override

                    public Feature next() {

                        FeatureReference ref = (FeatureReference) it.next();

                        try {

                            return ref.getFeature();

                        } catch (DataException ex) {

                            return null;

                        }

                    }

                };

            }

        };

    }

    @Override

    public Feature findFirst(Expression filter) {

        try {

            return this.getFeatureStore().findFirst(filter);

        } catch (Exception ex) {

            return null;

        }

    }

}