Subversion Repositories mkgmap

/*
 * Copyright (C) 2008 Steve Ratcliffe
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  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.
 *
 *
 * Author: Steve Ratcliffe
 * Create date: 15-Nov-2008
 */
package uk.me.parabola.mkgmap.osmstyle;

import java.util.List;

import uk.me.parabola.mkgmap.osmstyle.actions.Action;
import uk.me.parabola.mkgmap.osmstyle.eval.Op;
import uk.me.parabola.mkgmap.reader.osm.Element;
import uk.me.parabola.mkgmap.reader.osm.GType;
import uk.me.parabola.mkgmap.reader.osm.Relation;
import uk.me.parabola.mkgmap.reader.osm.Rule;
import uk.me.parabola.mkgmap.reader.osm.TypeResult;

/**
 * An action rule modifies the tags on the incoming element.
 *
 * It can also have an expression, and does not need to have a Type.  If
 * there is no type then the resolve method does not send any results.
 * The tags on the element may have been modified however.
 *
 * @author Steve Ratcliffe
 */
public class ActionRule implements Rule {
        private Op expression;
        private final List<Action> actions;
        private final GType type;
        private Rule finalizeRule;

        /** Finalize rules must not have an element type definition so the add method must never be called. */
        private final static TypeResult finalizeTypeResult = new TypeResult() {
                public void add(Element el, GType type) {
                        throw new UnsupportedOperationException("Finalize rules must not contain an action block.");
                }
        };     
       
        public ActionRule(Op expression, List<Action> actions, GType type) {
                assert actions != null;
                this.expression = expression;
                this.actions = actions;
                this.type = type;
        }

        public ActionRule(Op expression, List<Action> actions) {
                assert actions != null;
                this.expression = expression;
                this.actions = actions;
                this.type = null;
        }
       
       
        public int resolveType(int cacheId, Element el, TypeResult result) {
                Element element = el;
                if (expression != null) {
                        if (!expression.eval(cacheId, element))
                                return cacheId;
                               
                        // If this is a continue and we are not to propagate the effects
                        // of the action on the element to further rules, then make
                        // a copy of the element so that the original is unsullied.
                        //
                        // There is another reason we need to copy: since there will be
                        if (type != null && !type.isPropogateActions() && !(element instanceof Relation)) {
                                element = element.copy();
                        }
                }

                // an action will be performed, so we may have to invalidate the cache
                boolean invalidate_cache = false;
                for (Action a : actions){
                        if (a.perform(element)){
                                invalidate_cache = true;
                        }
                }
                if (invalidate_cache)
                        cacheId++;
               
                if (type != null && finalizeRule != null) {
                        if (el == element && type.isContinueSearch())
                                // if there is a continue statement changes performed in
                                // the finalize block must not be persistent
                                element = element.copy();
                        // there is a type so first execute the finalize rules
                        if (type.getDefaultName() != null)
                                element.addTag("mkgmap:default_name", type.getDefaultName());
                        cacheId = finalizeRule.resolveType(cacheId, element, finalizeTypeResult);
                }
               
                result.add(element, type);
                return cacheId;
        }
       
       
        public void resolveType(Element el, TypeResult result) {
                Element element = el;
                if (expression != null) {
                        if (!expression.eval(element))
                                return;
                        // If this is a continue and we are not to propagate the effects
                        // of the action on the element to further rules, then make
                        // a copy of the element so that the original is unsullied.
                        //
                        // There is another reason we need to copy: since there will be
                        if (type != null && !type.isPropogateActions() && !(element instanceof Relation)) {
                                element = element.copy();
                        }
                }

                for (Action a : actions)
                        a.perform(element);

                if (type != null && finalizeRule != null) {
                        if (el == element && type.isContinueSearch())
                                // if there is a continue statement changes performed in
                                // the finalize block must not be persistent
                                element = element.copy();
                        // there is a type so first execute the finalize rules
                        if (type.getDefaultName() != null)
                                element.addTag("mkgmap:default_name", type.getDefaultName());
                        finalizeRule.resolveType(element, finalizeTypeResult);
                }
               
                result.add(element, type);
        }

        public String toString() {
                StringBuilder fmt = new StringBuilder();
                if (expression != null)
                        fmt.append(expression);

                fmt.append(" {");
                for (Action a : actions)
                        fmt.append(a);
                fmt.append("}");

                if (type != null) {
                        fmt.append(' ');
                        fmt.append(type);
                }

                return fmt.toString();
        }

        public void setFinalizeRule(Rule finalizeRule) {
                this.finalizeRule = finalizeRule;
        }


        public Op getOp(){
                return expression;
        }
       
        public void setOp(Op expression){
                this.expression = expression;
        }
       
}