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 org.gvsig.fmap.dal.feature.FeatureReference;

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultTopologyReportLine implements TopologyReportLine {

    private final TopologyReport report;

    private final TopologyRule rule;

    private final TopologyDataSet dataSet1;

    private final TopologyDataSet dataSet2;

    private final Geometry geometry;

    private final FeatureReference feature1;

    private final FeatureReference feature2;

    private final int primitive1;

    private final int primitive2;

    private boolean exception;

    private final String description;

    private final String data;

    private final Geometry errorGeometry;

    DefaultTopologyReportLine(DefaultTopologyReport report, 

            TopologyRule rule, 

            TopologyDataSet dataSet1, 

            TopologyDataSet dataSet2, 

            Geometry geometry,

            Geometry error,

            FeatureReference feature1, 

            FeatureReference feature2, 

            int primitive1,

            int primitive2,

            boolean exception,

            String description,

            String data

        ) {

        this.report = report;

        this.rule = rule;

        this.dataSet1 = dataSet1;

        this.dataSet2 = dataSet2;

        this.geometry = geometry;

        this.feature1 = feature1;

        this.feature2 = feature2;

        this.primitive1 = primitive1;

        this.primitive2 = primitive2;

        this.exception = exception;

        this.description = description;

        this.errorGeometry = error;

        this.data = data;

    }

    @Override

    public TopologyRule getRule() {

        return this.rule;

    }

    @Override

    public TopologyDataSet getDataSet1() {

        return this.dataSet1;

    }

    @Override

    public TopologyDataSet getDataSet2() {

        return this.dataSet2;

    }

    @Override

    public Geometry getGeometry() {

        return this.geometry;

    }

    @Override

    public FeatureReference getFeature1() {

        return this.feature1;

    }

    @Override

    public FeatureReference getFeature2() {

        return this.feature2;

    }

    @Override

    public boolean isException() {

        return this.exception;

    }

    public void setException(boolean exception) {

        this.exception = exception;

    }

    @Override

    public String getDescription() {

        return description;

    }

    @Override

    public Geometry getError() {

        return this.errorGeometry;

    }

    @Override

    public int getPrimitiveNumber1() {

        return this.primitive1;

    }

    @Override

    public int getPrimitiveNumber2() {

        return this.primitive2;

    }

    @Override

    public String getData() {

        return this.data;

    }

}

/**

 * 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.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

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

                Expression expression = ExpressionUtils.createExpression();

                GeometryExpressionBuilder expressionBuilder = GeometryExpressionUtils.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();

                Expression expression = ExpressionUtils.createExpression();

                GeometryExpressionBuilder expressionBuilder = GeometryExpressionUtils.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;

        }

    }

}

/**

 * 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.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.DataStore;

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

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

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

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

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultTopologyManager implements TopologyManager {

    private final Map<String,TopologyRuleFactory> factories;

    private TopologyServices services;

    public DefaultTopologyManager() {

        this.factories = new HashMap<>();

    }

    @Override

    public TopologyPlan createTopologyPlan() {

        TopologyPlan plan = new DefaultTopologyPlan(this, this.services);

        return plan;

    }

    @Override

    public List<TopologyRuleFactory> getRuleFactories() {

        List<TopologyRuleFactory> l = new ArrayList<>(this.factories.values());

        return Collections.unmodifiableList(l);

    }

    @Override

    public List<TopologyRuleFactory> getRuleFactories(TopologyDataSet dataSet) {

        List<TopologyRuleFactory>  f = new ArrayList<>();

        for (TopologyRuleFactory factory : this.factories.values()) {

            if( factory.canApplyToDataSet(dataSet) ) {

                f.add(factory);

            }

        }

        return f;

    }

    @Override

    public TopologyRuleFactory getRulefactory(String id) {

        if( id==null ) {

            return null;

        }

        TopologyRuleFactory factory = this.factories.get(id.toLowerCase());

        return factory;

    }

    @Override

    public void addRuleFactories(TopologyRuleFactory factory) {

        if( factory==null ) {

            throw new IllegalArgumentException("Invalid null value.");

        }

        this.factories.put(factory.getId().toLowerCase(), factory);

    }

    @Override

    public TopologyDataSet createDataSet(String name, DataStore store) {

        TopologyDataSet dataSet = new DefaultTopologyDataSet(this.services, name, store);

        return dataSet;

    }

    @Override

    public void setDefaultServices(TopologyServices services) {

        this.services = services;

    }

    @Override

    public TopologyServices getDefaultServices() {

        return this.services;

    }

}

/**

 * 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.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.DataStore;

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

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

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

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

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

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

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

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

import org.json.JSONArray;

import org.json.JSONObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultTopologyPlan implements TopologyPlan {

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

    private final TopologyManager manager;

    private final Map<String,TopologyDataSet> dataSets;

    private final List<TopologyRule> rules;

    private String name;

    private DefaultTopologyReport report;

    private TopologyServices services;

    private double tolerance;

    private SimpleTaskStatus taskStatus;

    public DefaultTopologyPlan(TopologyManager manager, TopologyServices services) {

        this.manager = manager;

        this.services = services;

        this.dataSets = new HashMap<>();

        this.rules = new ArrayList<>();

        this.report = null;

        this.name = "TopologyPlan-" + String.format("%08X", new Date().getTime());

        this.tolerance = 0;

    }

    @Override

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void clear() {

        this.name = "";

        this.tolerance = 0;

        this.services = null;

        this.report = null;

        this.dataSets.clear();

        this.rules.clear();

    }

    @Override

    public double getTolerance() {

        return tolerance;

    }

    @Override

    public void setTolerance(double tolerance) {

        this.tolerance = tolerance;

    }

    @Override

    public void setTopologyServices(TopologyServices services) {

        this.services = services;

    }

    @Override

    public TopologyServices getTopologyServices() {

        return this.services;

    }

    public SimpleTaskStatus getTaskStatus() {

        if( this.taskStatus == null ) {

            this.taskStatus = ToolsLocator.getTaskStatusManager()

                    .createDefaultSimpleTaskStatus(this.getName());

        }

        return this.taskStatus;

    }

    @Override

    public void execute() {

        SimpleTaskStatus theTaskStatus = this.getTaskStatus();

        try {

            theTaskStatus.restart();

            theTaskStatus.message("Preparing the execution of the plan");

            theTaskStatus.setAutoremove(true);

            theTaskStatus.setIndeterminate();

            for (TopologyDataSet dataSet : this.dataSets.values()) {

                dataSet.restart();

            }

            this.getReport().removeAllLines();

            long steps = 0;

            for (TopologyRule rule : this.rules) {

                steps += rule.getSteps();

                steps++;

            }

            theTaskStatus.setRangeOfValues(0, steps);

            theTaskStatus.setCurValue(0);

            for (TopologyRule rule : this.rules) {

                if( theTaskStatus.isCancellationRequested() ) {

                    theTaskStatus.cancel();

                    break;

                }

                theTaskStatus.message(rule.getName());

                rule.execute(theTaskStatus, this.getReport());

                theTaskStatus.incrementCurrentValue();

            }

        } catch(Exception ex) {

            LOGGER.warn("Problems executing topology plan '"+this.getName()+"'.", ex);

            theTaskStatus.abort();

        } finally {

            if( theTaskStatus.isRunning() ) {

                theTaskStatus.terminate();

            }

            this.getReport().setCompleted(true);

        }

    }

    @Override

    public TopologyDataSet addDataSet(String name, DataStore store) {

        TopologyDataSet dataSet = manager.createDataSet(name, store);

        return this.addDataSet(dataSet);

    }

    @Override

    public TopologyDataSet addDataSet(TopologyDataSet dataSet) {

        if( this.dataSets.containsKey(dataSet.getName()) ) {

            throw new IllegalArgumentException("Already exists a dataSet with this name ("+dataSet.getName()+").");

        }

        this.dataSets.put(dataSet.getName(), dataSet);

        return dataSet;

    }

    @Override

    public TopologyDataSet getDataSet(String name) {

        return this.dataSets.get(name);

    }

    @Override

    public boolean containsDataSet(String name) {

        return this.dataSets.containsKey(name);

    }

    @Override

    public Collection<TopologyDataSet> getDataSets() {

        Collection<TopologyDataSet> x = dataSets.values();

        return Collections.unmodifiableCollection(x);

    }

    @Override

    public Collection<TopologyDataSet> getSecondaryDataSets(TopologyRuleFactory ruleFactory) {

        List<TopologyDataSet> secondaryDataSets = new ArrayList<>();

        for (TopologyDataSet dataSet : dataSets.values()) {

            if( ruleFactory.canApplyToSecondaryDataSet(dataSet) ) {

                secondaryDataSets.add(dataSet);

            }

        }

        return secondaryDataSets;

    }

    @Override

    public TopologyRule addRule(String id, String dataSet1, String dataSet2, double tolerance) {

        TopologyRuleFactory factory = this.manager.getRulefactory(id);

        if( factory == null ) {

            throw new IllegalArgumentException("Can't locate factory for rule '"+id+"'.");

        }

        if( ! this.canApplyRule(factory, dataSet1, dataSet2) ) {

            throw new IllegalArgumentException(

                    "Can't apply rule '"+factory.getName()+"' to the datasets '"+dataSet1+"/"+dataSet2+"'."

            );

        }

        TopologyRule rule = factory.createRule(this, dataSet1, dataSet2, tolerance);

        return this.addRule(rule);

    }

    @Override

    public TopologyRule addRule(TopologyRule rule) {

        this.rules.add(rule);

        return rule;

    }

    private boolean canApplyRule(TopologyRuleFactory factory, String dataSet1, String dataSet2) {

        try {

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            TopologyDataSet dataset = this.getDataSet(dataSet1);

            FeatureStore store = (FeatureStore) dataset.getStore();

            GeometryType gt = store.getDefaultFeatureType().getDefaultGeometryAttribute().getGeomType();

            for (Integer geometryType1 : factory.getGeometryTypeDataSet1()) {

                if( gt.isTypeOf(geometryType1) ) {

                    if( factory.getGeometryTypeDataSet2()==null ) {

                        return true;

                    }

                    dataset = this.getDataSet(dataSet2);

                    store = (FeatureStore) dataset.getStore();

                    gt = store.getDefaultFeatureType().getDefaultGeometryAttribute().getGeomType();

                    for (Integer geometryType2 : factory.getGeometryTypeDataSet2()) {

                        if( gt.isTypeOf(geometryType2) ) {

                            return true;

                        }

                    }

                }

            }

            return false;

        } catch(Exception ex) {

            return false;

        }

    }    

    @Override

    public Collection<TopologyRule> getRules() {

        return Collections.unmodifiableList(rules);

    }

    @Override

    public DefaultTopologyReport getReport() {

        if( this.report == null ) {

            this.report = new DefaultTopologyReport(this);

        }

        return this.report;

    }

    @Override

    public JSONObject toJSON() {

        JSONObject me = new JSONObject();

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

        me.put("tolerance", this.tolerance);

        JSONArray jsonDataSets=  new JSONArray();

        for (TopologyDataSet dataSet : this.dataSets.values()) {

            jsonDataSets.put(((DefaultTopologyDataSet)dataSet).toJSON());

        }

        me.put("dataSets", jsonDataSets);

        JSONArray jsonRules = new JSONArray();

        for (TopologyRule rule : this.rules) {

            JSONObject jsonRule = rule.toJSON();

            jsonRule.put("__factoryId", rule.getFactory().getId());

            jsonRules.put(jsonRule);

        }

        me.put("rules", jsonRules);

        return me;

    }

    @Override

    public void fromJSON(String json) {

        this.fromJSON(new JSONObject(json));

    }

    @Override

    public void fromJSON(JSONObject jsonPlan) {

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

        this.tolerance = jsonPlan.getDouble("tolerance");

        JSONArray jsonDataSets = jsonPlan.getJSONArray("dataSets");

        for (Object o : jsonDataSets) {

            TopologyDataSet dataSet = new DefaultTopologyDataSet();

            dataSet.fromJSON((JSONObject) o);

            this.dataSets.put(dataSet.getName(),dataSet);

        }

        JSONArray jsonRules = jsonPlan.getJSONArray("rules");

        for (Object o : jsonRules) {

            JSONObject jsonRule = (JSONObject) o;

            TopologyRuleFactory factory = this.manager.getRulefactory(jsonRule.getString("__factoryId"));

            TopologyRule rule = factory.createRule(this,null, null, -1);

            rule.fromJSON(jsonRule);

            this.addRule(rule);

        }        

    }

    @Override

    public void removeDataSet(TopologyDataSet dataSet) {

        this.dataSets.remove(dataSet.getName());

    }

    @Override

    public void removeRule(TopologyRule rule) {

        this.rules.remove(rule);

    }

}

/**

 * 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.ArrayList;

import java.util.Collections;

import java.util.List;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.MutableSymbolTable;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.task.SimpleTaskStatus;

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

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

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

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultTopologyReport 

        extends AbstractTopologyReportLineSet

        implements TopologyReport 

    {

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

    private class DefaultTopologyReportLineSet extends AbstractTopologyReportLineSet {

        public DefaultTopologyReportLineSet() {

            super();

        }

        public void polulate(List<TopologyReportLine> allLines, String filter) {

            this.lines.clear();

            if (filter == null) {

                this.lines.addAll(allLines);

                this.completed = true;

                return;

            }

            SimpleTaskStatus theTaskStatus = plan.getTaskStatus();

            try {

                theTaskStatus.push();

                theTaskStatus.restart();

                theTaskStatus.message("Preparing filter");

                theTaskStatus.setAutoremove(true);

                theTaskStatus.setIndeterminate();

                ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

                TopologyReportLineSymbolTable lineSymbolTable = new TopologyReportLineSymbolTable();

                MutableSymbolTable symbolTable = manager.createSymbolTable();

                symbolTable.addSymbolTable(lineSymbolTable);

                Code code = manager.compile(filter);

                code = manager.optimize(symbolTable, code);

                theTaskStatus.setRangeOfValues(0, allLines.size());

                theTaskStatus.setCurValue(0);

                for (TopologyReportLine line : allLines) {

                    lineSymbolTable.setLine(line);

                    Object value = manager.evaluate(symbolTable, code);

                    if (value instanceof Boolean && ((Boolean) value)) {

                        this.lines.add(line);

                        this.changeListenerHelper.fireEvent();

                    }

                    theTaskStatus.incrementCurrentValue();

                }

            } catch (Exception ex) {

                LOGGER.warn("Problems filtering.", ex);

                theTaskStatus.abort();

            } finally {

                if (theTaskStatus.isRunning()) {

                    theTaskStatus.terminate();

                }

                theTaskStatus.pop();

                this.completed = true;

            }

        }

    }

    // TODO: Habria que meter las lineas del report en disco

    private final TopologyPlan plan;

    public DefaultTopologyReport(TopologyPlan plan) {

        this.plan = plan;

    }

    @Override

    public TopologyReportLine addLine(TopologyRule rule, TopologyDataSet dataSet1,

            TopologyDataSet dataSet2, Geometry geometry, Geometry error,

            FeatureReference feature1, FeatureReference feature2,

            boolean exception, String description

    ) {

        TopologyReportLine line = new DefaultTopologyReportLine(

                this, rule, dataSet1, dataSet2, geometry, error, feature1, 

                feature2, -1, -1, exception, description, null

        );

        this.lines.add(line);

        this.fireChangeEvent();

        return line;

    }

    @Override

    public TopologyReportLine addLine(TopologyRule rule, 

            TopologyDataSet dataSet1,TopologyDataSet dataSet2, 

            Geometry geometry, Geometry error,

            FeatureReference feature1, FeatureReference feature2,

            int primitive1, int primitive2,

            boolean exception, 

            String description,

            String data

    ) {

        TopologyReportLine line = new DefaultTopologyReportLine(

                this, rule, dataSet1, dataSet2, geometry, error, feature1, 

                feature2, primitive1, primitive2, exception, description, data

        );

        this.lines.add(line);

        this.fireChangeEvent();

        return line;

    }

    @Override

    public void removeAllLines() {

        this.lines.clear();

        this.fireChangeEvent();

    }

    @Override

    public TopologyReportLineSet getLineSet(final String filter) {

        final DefaultTopologyReportLineSet set = new DefaultTopologyReportLineSet();

        Thread th = new Thread(new Runnable() {

            @Override

            public void run() {

                set.polulate(lines, filter);

            }

        });

        th.start();

        return set;

    }

    @Override

    public List<TopologyReportLine> getLines(String filter) {

        if (filter == null) {

            return Collections.unmodifiableList(this.lines);

        }

        List<TopologyReportLine> ll = new ArrayList<>();

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        TopologyReportLineSymbolTable lineSymbolTable = new TopologyReportLineSymbolTable();

        MutableSymbolTable symbolTable = manager.createSymbolTable();

        symbolTable.addSymbolTable(lineSymbolTable);

        Code code = manager.compile(filter);

        code = manager.optimize(symbolTable, code);

        for (TopologyReportLine line : this.lines) {

            lineSymbolTable.setLine(line);

            Object value = manager.evaluate(symbolTable, code);

            if (value instanceof Boolean && ((Boolean) value)) {

                ll.add(line);

            }

        }

        return Collections.unmodifiableList(ll);

    }

}

package org.gvsig.topology.lib.impl;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

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

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

/**

 *

 * @author jjdelcerro

 */

class TopologyReportLineSymbolTable extends AbstractSymbolTable {

    private TopologyReportLine line = null;

    private final List<String> fieldNames;

    public TopologyReportLineSymbolTable() {

        this.fieldNames = new ArrayList<>();

        this.fieldNames.add(TopologyReport.RULE_ID);

        this.fieldNames.add(TopologyReport.IS_ERROR);

        this.fieldNames.add(TopologyReport.IS_EXCEPTION);

        this.fieldNames.add(TopologyReport.GEOMETRY);

    }

    public void setLine(TopologyReportLine line) {

        this.line = line;

    }

    @Override

    public boolean exists(String name) {

        if (name == null) {

            return false;

        }

        return this.fieldNames.contains(name.toUpperCase());

    }

    @Override

    public Object value(String name) {

        switch (name.toUpperCase()) {

            case TopologyReport.RULE_ID:

                return this.line.getRule().getId();

            case TopologyReport.IS_ERROR:

                return !this.line.isException();

            case TopologyReport.IS_EXCEPTION:

                return this.line.isException();

            case TopologyReport.GEOMETRY:

                return this.line.getGeometry();

            default:

                return null;

        }

    }

}

package org.gvsig.topology.lib.impl;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import javax.swing.event.ChangeListener;

import org.gvsig.tools.swing.api.ChangeListenerHelper;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

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

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

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractTopologyReportLineSet implements TopologyReportLineSet {

    protected final List<TopologyReportLine> lines;

    protected final ChangeListenerHelper changeListenerHelper;

    protected boolean completed = false;

    public AbstractTopologyReportLineSet() {

        this.lines = new ArrayList<>();

        this.changeListenerHelper = ToolsSwingLocator.getToolsSwingManager().createChangeListenerHelper();

    }

    @Override

    public List<TopologyReportLine> getLines() {

        return Collections.unmodifiableList(this.lines);

    }

    @Override

    public void addChangeListener(ChangeListener cl) {

        this.changeListenerHelper.addChangeListener(cl);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return this.changeListenerHelper.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener cl) {

        this.changeListenerHelper.removeChangeListener(cl);

    }

    @Override

    public void removeAllChangeListener() {

        this.changeListenerHelper.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return this.changeListenerHelper.hasChangeListeners();

    }

    protected void fireChangeEvent() {

        this.changeListenerHelper.fireEvent();        

    }

    @Override

    public boolean isComplete() {

        return this.completed;

    }

    @Override

    public int size() {

        return this.lines.size();

    }

    @Override

    public TopologyReportLine get(int index) {

        return this.lines.get(index);

    }