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.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.impl.customizablerule.CustomizableRule0ActionsFactory;

import org.gvsig.topology.rule.GeometryIsValidFactory;

import org.gvsig.topology.rule.GeometryMustNotBeNullRuleFactory;

import org.gvsig.topology.rule.LineMustBeCoveredByBoundaryOfPolygonRuleFactory;

import org.gvsig.topology.rule.PolygonContainsPointRuleFactory;

import org.gvsig.topology.rule.LineMustBeLargerThanToleranceRuleFactory;

import org.gvsig.topology.rule.PolygonMustNotOverlapPolygonRuleFactory;

import org.gvsig.topology.rule.PointMustBeProperlyInsidePolygonRuleFactory;

import org.gvsig.topology.rule.PolygonContainsOnePointRuleFactory;

import org.gvsig.topology.rule.PolygonContainsPolygonRuleFactory;

import org.gvsig.topology.rule.PolygonMustBeCoveredByPolygonRuleFactory;

import org.gvsig.topology.rule.PolygonMustNotOverlapWithPolygonRuleFactory;

/**

 *

 * @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 {

        CustomizableRule0ActionsFactory.selfRegister();

        GeometryMustNotBeNullRuleFactory.selfRegister();

        LineMustBeCoveredByBoundaryOfPolygonRuleFactory.selfRegister();

        LineMustBeLargerThanToleranceRuleFactory.selfRegister();

        PointMustBeProperlyInsidePolygonRuleFactory.selfRegister();

        PolygonContainsPointRuleFactory.selfRegister();

        PolygonMustBeCoveredByPolygonRuleFactory.selfRegister();

        PolygonMustNotOverlapPolygonRuleFactory.selfRegister();

        PolygonContainsPolygonRuleFactory.selfRegister();

        PolygonContainsOnePointRuleFactory.selfRegister();

        PolygonMustNotOverlapWithPolygonRuleFactory.selfRegister();

        GeometryIsValidFactory.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 javax.json.JsonObject;

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.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.json.Json;

import org.gvsig.json.JsonObjectBuilder;

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.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 void setStore(DataStore store) {

        this.store = store;

    }

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

        return this.toJsonBuilder().build();

    }

    @Override

    public JsonObjectBuilder toJsonBuilder() {

        JsonObjectBuilder jsonDataSet = Json.createObjectBuilder();

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

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

        return jsonDataSet;

    }

    @Override

    public void fromJson(JsonObject json) {

        TopologyManager manager = TopologyLocator.getTopologyManager();

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

        this.fullName = null;

        if( json.containsKey("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((Object o) -> {

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

        }

    }

    void setTopologyServices(TopologyServices services) {

        this.services = services;

        this.restart();

    }

}

package org.gvsig.topology.lib.impl.customizablerule;

import javax.json.JsonObject;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.json.SupportJson;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

import org.gvsig.topology.lib.spi.AbstractTopologyRuleAction;

/**

 *

 * @author gvSIG Team

 */

public class CustomizableRuleActionImpl 

        extends AbstractTopologyRuleAction 

        implements SupportJson {

    protected Expression action;

    protected MutableSymbolTable symbolTable;

    public CustomizableRuleActionImpl() {

        super(CustomizableRule0ActionsFactory.NAME);

    }

    public Expression getAction() {

        return this.action;

    }

    public void setAction(Expression action) {

        this.action = action;

    }

    public void setId(String id) {

        this.idAction = id;

    }

    public void setName(String name) {

        this.name = name;

    }

    public void setShortDescription(String description) {

        this.shortDescription = description;

    }

    public MutableSymbolTable getSymbolTable() {

        if (this.symbolTable == null) {

            this.symbolTable = ExpressionUtils.createSymbolTable();

            this.symbolTable.setVar("action", this);

        }

        return this.symbolTable;

    }

    @Override

    public int execute(TopologyRule rule, TopologyReportLine line, DynObject parameters) throws ExecuteTopologyRuleActionException {

        MutableSymbolTable st = this.getSymbolTable();

        st.setVar("rule", rule);

        st.setVar("line", line);

        st.setVar("parameters", parameters);

        this.action.execute(symbolTable);

        return EXECUTE_OK;

    }

    @Override

    public void fromJson(JsonObject json) {

        this.idAction = (String) Json.toObject(json, "idAction");

        this.idRule = (String) Json.toObject(json, "idRule");

        this.name = (String) Json.toObject(json, "name");

        this.shortDescription = (String) Json.toObject(json, "shortDescription");

        this.action = (Expression) Json.toObject(json, "expression");

    }

    @Override

    public JsonObject toJson() {

        return toJsonBuilder().build();

    }

    @Override

    public JsonObjectBuilder toJsonBuilder() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        builder.add("idAction", idAction);

        builder.add("idRule", idRule);

        builder.add("name", name);

        builder.add("shortDescription", shortDescription);

        builder.add("expression", action);

        return builder;

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2021 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.customizablerule;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypeUtils;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

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

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

import static org.gvsig.topology.lib.impl.customizablerule.CustomizableRule0ActionsFactory.PARAM_CHECK_NAME;

import static org.gvsig.topology.lib.impl.customizablerule.CustomizableRule0ActionsFactory.PARAM_ERRMSG_NAME;

import static org.gvsig.topology.lib.impl.customizablerule.CustomizableRule0ActionsFactory.PARAM_NAME_NAME;

import org.gvsig.topology.lib.spi.AbstractTopologyRule;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class CustomizableRule0ActionsImpl

        extends AbstractTopologyRule 

    {

    protected Expression check;

    protected String errmsg;

    protected FeatureSymbolTable featureSymbolTable;

    protected MutableSymbolTable symbolTable;

    public CustomizableRule0ActionsImpl() {

    }

    public CustomizableRule0ActionsImpl(

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1,

            String dataSet2

    ) {

        super(factory, tolerance, dataSet1, dataSet2);

    }

    @Override

    public String getName() {

        try {

            return super.getName()+ "("+(String) this.getParameters().getDynValue(PARAM_NAME_NAME)+")";

        } catch(Exception ex) {

            return super.getName();

        }

    }

    @Override

    protected void check(SimpleTaskStatus taskStatus, TopologyReport report, Feature feature1) throws Exception {

        if (this.symbolTable == null) {

            this.featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

            this.symbolTable = this.featureSymbolTable.createParent();

            this.symbolTable.setVar("rule", this);

        }

        if( this.check == null ) {

            this.check = (Expression) this.getParameters().getDynValue(PARAM_CHECK_NAME);

        }

        this.symbolTable.setVar("taskStatus", taskStatus);

        this.symbolTable.setVar("report", report);

        this.symbolTable.setVar("feature1", feature1);

        this.featureSymbolTable.setFeature(feature1);

        Object n = this.check.execute(this.featureSymbolTable);

        if( DataTypeUtils.isTrue(n, false) ) {

            return;

        }

        report.addLine(

                this, 

                this.getDataSet1(), 

                null, // Dataset2

                feature1.getDefaultGeometry(),

                null, // Error

                feature1.getReference(), 

                null, // feature2

                false, // is an exception?

                getErrorMessage()

        );

    }

    private String getErrorMessage() {

        if( this.errmsg == null ) {

            this.errmsg = (String) this.getParameters().getDynValue(PARAM_ERRMSG_NAME);

            if( StringUtils.isBlank(this.errmsg) ) {

                this.errmsg = ToolsLocator.getI18nManager().getTranslation("_The_verification_expression_was_not_met");

            }

        }

        return this.errmsg;

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2021 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.customizablerule;

import org.gvsig.expressionevaluator.DataTypes;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct_v2;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

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

import org.gvsig.topology.lib.spi.AbstractTopologyRuleFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class CustomizableRule0ActionsFactory extends AbstractTopologyRuleFactory {

    public static final String NAME = "Customizable0";

    public static final String PARAM_NAME_NAME = "name";

    public static final String PARAM_CHECK_NAME = "check";

    public static final String PARAM_ERRMSG_NAME = "errmsg";

    private DynStruct_v2 ruleParametersDefinition;

    public CustomizableRule0ActionsFactory() {

        super(

                NAME, 

                "Customizable0", 

                "",

                null

        );

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

        this.ruleParametersDefinition = (DynStruct_v2) dynObjectManager.get("Topology", "CustomizableRule0Parameters");

        if( ruleParametersDefinition==null ) {

            ruleParametersDefinition = (DynStruct_v2) dynObjectManager.createDynClass("Topology", "CustomizableRule0Parameters", null);

            DynField_v2 param;

            param = (DynField_v2) ruleParametersDefinition.addDynFieldString(PARAM_NAME_NAME);

            param.setMandatory(true);

            param.setLabel("_Name");

            param.setDescription("_Name_of_the_rule");

            param = (DynField_v2) ruleParametersDefinition.addDynField(PARAM_CHECK_NAME,DataTypes.EXPRESSION);

            param.setMandatory(true);

            param.setLabel("_Check_expression");

            param.setDescription("_Verification_expression_If_false_the_rule_fails");

            param = (DynField_v2) ruleParametersDefinition.addDynFieldString(PARAM_ERRMSG_NAME);

            param.setMandatory(true);

            param.setLabel("_Error_message");

            param.setDescription("_Message_to_show_if_check_fail");

//            DynField_v2 action = (DynField_v2) ruleParametersDefinition.addDynField("action");

//            action.setType(DataTypes.EXPRESSION);

        }

    }

    @Override

    public String getName() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation("_Customizable");

    }

    @Override

    public boolean canApplyToDataSet(TopologyDataSet dataSet) {

        return true;

    }

    @Override

    public boolean canApplyToSecondaryDataSet(TopologyDataSet dataSet) {

        return true;

    }

    @Override

    public TopologyRule createRule(String dataSet1, String dataSet2, double tolerance) {

        TopologyRule rule = new CustomizableRule0ActionsImpl(this, tolerance, dataSet1, dataSet2);

        return rule;

    }    

    @Override

    public boolean hasRuleParameters() {

        return true;

    }

    @Override

    public DynObject createRuleParameters() {

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

        DynObject param = dynObjectManager.createDynObject(this.ruleParametersDefinition);

        return param;

    }

    public static void selfRegister() {

        try {

            TopologyManager manager = TopologyLocator.getTopologyManager();

            manager.addRuleFactories(new CustomizableRule0ActionsFactory());

            Json.registerSerializer(CustomizableRule0ActionsImpl.class);

        } catch(Exception ex) {

            LOGGER.warn("Can't register topology rule from "+CustomizableRule0ActionsFactory.class.getSimpleName(), ex);

        }

    }

}

/**

 * 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 javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

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.json.Json;

import org.gvsig.json.JsonArrayBuilder;

import org.gvsig.json.JsonObjectBuilder;

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.gvsig.topology.lib.spi.AbstractTopologyRule;

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;

    private boolean useUI;

    private boolean acceptExceptions;

    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;

        this.useUI = true;

    }

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

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

            if(dataSet instanceof DefaultTopologyDataSet){

                ((DefaultTopologyDataSet)dataSet).setTopologyServices(services);

            }

        }

    }

    @Override

    public TopologyServices getTopologyServices() {

        return this.services;

    }

    @Override

    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(dataSet1, dataSet2, tolerance);

        return this.addRule(rule);

    }

    @Override

    public TopologyRule addRule(TopologyRule rule) {

        if( rule.getPlan()!=null && rule.getPlan()!=this ) {

            rule = (AbstractTopologyRule) org.gvsig.tools.lang.Cloneable.cloneQuietly(rule);

        }

        ((AbstractTopologyRule)rule).setPlan(this);

        this.rules.add(rule);