gvSIG projects pool

org.gvsig.topology.lib.impl.TopologyImplLibrary

{

    "id": "ContainsPoint",

    "name": "Contains Point",

    "description": [ 

        "<img src=\"@@@.d/contains_point2.png\">\n",

        "The top polygon is an error because it does not contain a point.\n\n",

        "Requires that a polygon in the primary dataset contain at least one",

        "point from the secondary dataset.\n",

        "Points must be within the polygon, not on the boundary.\n",

        "This is useful when every polygon should have at least one associated",

        "point, such as when parcels must have an address point."

    ],

    "actions" : {

        "CreateFeature": {

            "name" : "Create feature",

            "description": [ 

                "The Create Feature fix creates a new point feature at the centroid",

                "of the polygon feature that is causing the error.\n",

                "The point feature that is created is guaranteed to be within the polygon feature."

            ]

        }

    }

}

{

    "id": "MustNotOverlapPolygon",

    "name": "Must Not Overlap",

    "description": [ 

        "<img src=\"@@@.d/must_not_overlap.png\">\n",

        "Requires that the interior of polygons in the dataset not overlap.",

        "The polygons can share edges or vertices.",

        "This rule is used when an area cannot belong to two or more polygons.",

        "The polygons overlaps when the geometries have some points in common;",

        "but not all points in common (so if one geometry is inside the other",

        "overlaps would be false).",

        "The overlapping section must be the same kind of shape as the two geometries;",

        "so two polygons that touch on a point are not considered to be overlapping.",

        "It is useful for modeling administrative boundaries, such as ZIP Codes",

        "or voting districts, and mutually exclusive area classifications,",

        "such as land cover or landform type."

    ],

    "actions" : {

        "CreateFeature": {

            "name" : "Create feature",

            "description": [ 

                "The Create Feature fix creates a new polygon feature out of",

                "the error shape and removes the portion of overlap from each",

                "of the features, causing the error to create a planar",

                "representation of the feature geometry.\n",

                "This fix can be applied to one or more selected Must Not Overlap errors."

            ]

        },

        "Subtract": {

            "name" : "Subtract",

            "description": [ 

                "The Subtract fix removes the overlapping portion of geometry",

                "from each feature that is causing the error and leaves a gap",

                "or void in its place. This fix can be applied to one or more",

                "selected Must Not Overlap errors."

            ]

        },

        "Merge": {

            "name" : "Merge",

            "description": [ 

                "The Merge fix adds the portion of overlap from one feature",

                "and subtracts it from the others that are violating the rule.",

                "You need to pick the feature that receives the portion of",

                "overlap using the Merge dialog box.",

                "This fix can be applied to one Must Not Overlap error only."

            ]

        }

    }

}

{

    "id": "MustBeLargerThanToleranceLine",

    "name": "Must Be Larger Than Tolerance",

    "description": [ 

        "<img src=\"@@@.d/MustBeLargerThanToleranceLine.png\">\n",

        "Requires that a feature does not collapse during a validate process.\n",

        "This rule is mandatory for a topology and applies to all line feature classes.\n",

        "In instances where this rule is violated, the original geometry is left unchanged.\n"

    ],

    "actions" : {

        "delete": {

            "name" : "Delete",

            "description": [ 

                "Removes line features that would collapse during the validate",

                "process based on the topology's tolerance."

            ]

        }

    }

}

{

    "id": "MustBeLargerThanToleranceLine",

    "name": "Debe ser mayor que la tolerancia",

    "description": [ 

        "<img src=\"@@@.d/MustBeLargerThanToleranceLine.png\">\n",

        "Requiere que una feature no colapse durante el proceso de validacion.\n",

        "Esta regla es obligatoria para una topologia y aplica a todas las features de typo linea.\n",

        "En instancias donde esta regla es violada, la geometria original permanece sin cambios.\n"

    ],

    "actions" : {

        "delete": {

            "name" : "Eliminar",

            "description": [ 

                "Elimina las  Removes features que colapsaran durante el proceso",

                "de validacion basado en la tolerancia topologica."

            ]

        }

    }

}

{

    "id": "ContainsPoint",

    "name": "Contiene un punto",

    "description": [ 

        "<img src=\"@@@.d/contains_point2.png\">\n",

        "El poligono superior es un error porque no contiene ningun punto.\n\n",

        "Requiere que cada poligono del conjunto de datos contenga al menos un punto del otro conjunto de datos.\n",

        "Los puntos deben estar contenidos en el poligono, no en su perimetro,\n"

    ],

    "actions" : {

        "CreateFeature": {

            "name" : "Crear feature",

            "description": [ 

                "<i>Crear feature</i> realiza la correccion creando un nuevo punto en",

                "la feature, en el centroide del poligono que ha causado el error.\n",

                "El punto creado en la feature se garantiza que estara dentro del polygono de la feature."

            ]

        }

    }

}

/**

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

    }

    public void setCompleted(boolean completed) {

        this.completed = completed;

    }    

}

/**

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

import org.gvsig.fmap.geom.GeometryLibrary;

import org.gvsig.tools.ToolsLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

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

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

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

import org.gvsig.topology.rule.ContainsNullRuleFactory;

import org.gvsig.topology.rule.ContainsPointRuleFactory;

import org.gvsig.topology.rule.MustBeLargerThanToleranceLineRuleFactory;

import org.gvsig.topology.rule.MustNotOverlapPolygonRuleFactory;

import org.gvsig.topology.rule.PointMustBeProperlyInsidePolygonRuleFactory;

/**

 *

 * @author jjdelcerro

 */

public class TopologyImplLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        super.doRegistration();

        registerAsImplementationOf(TopologyLibrary.class);

        this.require(ToolsLibrary.class);

        this.require(DALLibrary.class);

        this.require(GeometryLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        TopologyLocator.registerDefaultTopologyManager(DefaultTopologyManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        ContainsNullRuleFactory.selfRegister();

        ContainsPointRuleFactory.selfRegister();

        MustBeLargerThanToleranceLineRuleFactory.selfRegister();

        MustNotOverlapPolygonRuleFactory.selfRegister();

        PointMustBeProperlyInsidePolygonRuleFactory.selfRegister();

    }

}

/**

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