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

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

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

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

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

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

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

import org.json.JSONObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractTopologyRule implements TopologyRule {

    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractTopologyRule.class);

    private final TopologyPlan plan;

    private final TopologyRuleFactory factory;

    private double tolerance;

    private String dataSet1;

    private String dataSet2;

    protected List<TopologyRuleAction> actions;

    private DynObject parameters;

    protected AbstractTopologyRule(

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1,

            String dataSet2

    ) {

        this.plan = plan;

        this.factory = factory;

        this.tolerance = tolerance;

        this.dataSet1 = dataSet1;

        this.dataSet2 = dataSet2;

        this.actions = new ArrayList<>();

    }

    protected AbstractTopologyRule(

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1

    ) {

        this(plan, factory, tolerance, dataSet1, null);

    }

    protected TopologyPlan getPlan() {

        return this.plan;

    }

    @Override

    public TopologyRuleFactory getFactory() {

        return this.factory;

    }

    @Override

    public String getName() {

        return this.getFactory().getName();

    }

    @Override

    public String getId() {

        return this.getFactory().getId();

    }

    public final void addAction(TopologyRuleAction action) {

        this.actions.add(action);

    }

    @Override

    public boolean equals(Object obj) {

        if( !(obj instanceof TopologyRule) ) {

            return false;

        }

        AbstractTopologyRule other = (AbstractTopologyRule)obj;

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

            return false;

        }

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

            return false;

        }

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

            return false;

        }

        // Ojo con la comparacion de doubles

//        if( this.tolerance != other.tolerance ) {

//            return false;

//        }

        return true;

    }

    @Override

    public String toString() {

        return this.getName();

    }

    @Override

    public TopologyDataSet getDataSet1() {

        return this.getPlan().getDataSet(dataSet1);

    }

    @Override

    public TopologyDataSet getDataSet2() {

        return this.getPlan().getDataSet(dataSet2);

    }

    @Override

    public double getTolerance() {

        return this.tolerance;

    }

    @Override

    public List<TopologyRuleAction> getActions() {

        return Collections.unmodifiableList(actions);

    }

    @Override

    public TopologyRuleAction getAction(String id) {

        for (TopologyRuleAction action : actions) {

            if (StringUtils.equalsIgnoreCase(id, action.getId())) {

                return action;

            }

        }

        return null;

    }

    @Override

    public long getSteps() {

        return this.getDataSet1().getSize();

    }

    @Override

    public void execute(final SimpleTaskStatus taskStatus, final TopologyReport report) {

        try {

            this.getDataSet1().accept(new Visitor() {

                @Override

                public void visit(final Object o1) throws VisitCanceledException, BaseException {

                    if( taskStatus.isCancellationRequested() ) {

                        throw new VisitCanceledException();

                    }

                    taskStatus.incrementCurrentValue();

                    try {

                        check(taskStatus, report, (Feature) o1);

                    } catch (Exception ex) {

                        throw new RuntimeException(ex);

                    }

                }

            });

        } catch(VisitCanceledException ex) {

            // return;

        }

    }

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

    }

    @Override

    public JSONObject toJSON() {

        JSONObject me = new JSONObject();

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

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

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

        DynObject params = this.getParameters();

        if(params!= null) {

            JSONObject jsonParams = new JSONObject();

            DynClass parametersDefinition = params.getDynClass();

            for (DynField dynField : parametersDefinition.getDynFields()) {

                jsonParams.put(dynField.getName(), params.getDynValue(dynField.getName()));

            }

            me.put("params", jsonParams);

        }

        return me;

    }

    @Override

    public void fromJSON(String json) {

        this.fromJSON(new JSONObject(json));

    }

    @Override

    public void fromJSON(JSONObject json) {

//        this.report = null;

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

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

        }

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

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

        }

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

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

        }

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

            JSONObject jsonParams = json.getJSONObject("params");

            DynObject params = this.getFactory().createRuleParameters();

            DynClass parametersDefinition = params.getDynClass();

            for (DynField dynField : parametersDefinition.getDynFields()) {

                String paramName = dynField.getName();

                if (jsonParams.has(paramName)){

                    params.setDynValue(paramName, jsonParams.getString(paramName));

                }

            }

            this.setParameters(params);

        }

    }

    @Override

    public void setParameters(DynObject parameters) {

        this.parameters=parameters;

    }

    @Override

    public DynObject getParameters() {

        return this.parameters;

    }

}