mapcss_grammar.hpp

Go to the documentation of this file.

#pragma once
#ifndef MAPCSS_GRAMMAR_HPP
#define MAPCSS_GRAMMAR_HPP




#include "mapcss_def.hpp"
#include "comment_skipper.hpp"
#include "server/eval/eval.hpp"
#include "eval_grammar.hpp"

#include "server/style_template.hpp"
#include "config.hpp"


namespace phx = boost::phoenix;


struct Zoom
{
    Zoom()
        : top(ALAC_ZOOM_TOP), bottom(ALAC_ZOOM_BOTTOM)
    {
    }

    Zoom(int bottom, int top)
        : top(top), bottom(bottom)
    {

    }

    void expand(const Zoom& other)
    {
        top = std::max(top, other.top);
        bottom = std::min(bottom, other.bottom);
    }

    void focus(const Zoom& other)
    {
        top = std::min(top, other.top);
        bottom = std::max(bottom, other.bottom);
    }


    bool operator == (const Zoom& z) const
    {
        return top == z.top && bottom == z.bottom;
    }

    int top;

    int bottom;
};


typedef fsio::vector<   op::UnaryTypesEnum,     /* operator */
                        string                  /* tag */
                    > UnaryCondition;

typedef fsio::vector<   string,             /* tag */
                        op::BinaryTypesEnum,    /* operator */
                        string              /* tag */
                    > BinaryCondition;

typedef boost::variant<UnaryCondition, BinaryCondition> ConditionType;

struct SelectorItem
{
    SelectorItem()
        : objectType(obj::Any)
    {}

    SelectorItem(obj::ObjectTypeEnum o, const Zoom& zoom, const std::vector<ConditionType>& conds)
        : objectType(o)
        , zoom(zoom)
        , conditions(conds)
    {}

    bool operator == (const SelectorItem& i) const
    {
        return objectType == i.objectType && zoom == i.zoom && conditions == i.conditions;
    }

    obj::ObjectTypeEnum objectType;
    Zoom zoom;
    std::vector<ConditionType> conditions;
};



BOOST_FUSION_ADAPT_STRUCT(SelectorItem,
                          (obj::ObjectTypeEnum, objectType)
                          (Zoom, zoom)
                          (std::vector<ConditionType>, conditions)
                          )


struct UnitTypes : qi::symbols<char, unit::UnitTypesEnum>
{

    UnitTypes()
    {
        this->add
            ("px", unit::Pixel)
            ("pt", unit::Points)
            ("%", unit::Percent)
            ;
    }

};

struct ObjectTypes : qi::symbols<char, obj::ObjectTypeEnum>
{

    ObjectTypes()
    {
        this->add
            ("node", obj::Node)
            ("way", obj::Way)
            ("relation", obj::Relation)
            ("area", obj::Area)
            ("line", obj::Line)
            ("*", obj::Any)
            ;
    }

};

struct BinaryTypes : qi::symbols<char, op::BinaryTypesEnum>
{

    BinaryTypes()
    {
        this->add
            ("=", op::Equal)
            ("!=", op::Unequal)
            ("=~", op::SameAs)
            ("<", op::LessThen)
            (">", op::GreaterThen)
            ("<=", op::LessEqual)
            (">=", op::GreaterEqual)
            ;
    }

};

struct UnaryTypes : qi::symbols<char, op::UnaryTypesEnum>
{

    UnaryTypes()
    {
        this->add
            ("!", op::Not)
            ("-", op::Minus)
            ;
    }

};

struct AttributeCreator
{
    virtual void addAttribute(const shared_ptr<StyleTemplate>& styleTemplate, const string& specifier, const shared_ptr<ParserLogger>& logger, const ParseInfo& info) = 0;
};

struct AttributeTypes : qi::symbols<char, shared_ptr<AttributeCreator> >
{
    AttributeTypes();
};



struct MapCssParser;

struct MapCSSGrammar : public qi::grammar<GrammarIterator, StylesheetPtr(), qi::locals<std::vector<RulePtr>, StylePtr>, CommentSkipper>
{
    typedef GrammarIterator ItType;
    typedef CommentSkipper Skipper;

    ObjectTypes selectorObject_;
    BinaryTypes binaryOperator_;
    UnaryTypes unaryOperator_;
    AttributeTypes attributeType_;

    MapCSSGrammar(MapCssParser& parser);

    qi::rule<ItType, StylePtr(), qi::locals<shared_ptr<AttributeCreator>, ParseInfo>, Skipper> rule_styleset;
    qi::rule<ItType, string(), Skipper> attribute_name;
    qi::rule<ItType, string(), Skipper> rule_specifier;
    qi::rule<ItType, string()> rule_value;
    qi::rule<ItType, string()> rule_tag;
    qi::rule<ItType, Zoom(), qi::locals<int, int>, Skipper> rule_zoom;
    qi::rule<ItType, BinaryCondition()> rule_binary_condition;
    qi::rule<ItType, UnaryCondition()> rule_unary_condition;
    qi::rule<ItType> rule_class;
    qi::rule<ItType, SelectorItem(), Skipper> rule_subselector;
    qi::rule<ItType, RulePtr(), qi::locals<std::vector<SelectorItem> >, Skipper> rule_selector;

    qi::rule<ItType, std::vector<RulePtr>(), Skipper> rule_cssrule;
    qi::rule<ItType, StylesheetPtr(), qi::locals<std::vector<RulePtr>, StylePtr>, Skipper> rule_stylesheet;
};



#endif