Question

I have a map of string-rule pairs and I would like to create a “joint rule”(rule_t joint_rule;) of them somehow. If I do this this way:

joint_rule = convert_logformat["%h"] >> convert_logformat["%t"];

than the joint rule with the parse_phrase matches the string

std::string entry = "127.0.0.1 [16/Aug/2012:01:50:02 +0000]";

But if I create the joint rule this way:

for (it = convert_logformat.begin(); it != convert_logformat.end(); it++)
{
   joint_rule = joint_rule.copy() >> (*it).second.copy();
}

It does not match the same string. Why? How could I achieve something similar to the latter?

---

Relevant code:

    template <typename Iterator>
bool parse_logentry(Iterator first, Iterator last, std::vector<char>& ip, std::vector<char>& timestamp, std::vector<char>& req, unsigned int& status, unsigned int& transferred_bytes, std::vector<char>& referer, std::vector<char>& ua)
{
    using boost::spirit::qi::char_;
    using boost::spirit::qi::int_;
    using boost::spirit::qi::uint_;
    using boost::spirit::qi::phrase_parse;
    using boost::spirit::ascii::space;
    using boost::spirit::ascii::space_type;
    using boost::phoenix::ref;
    using boost::phoenix::push_back;
    using boost::spirit::qi::_1;
    using boost::spirit::qi::lexeme;
    using boost::spirit::qi::rule;

    typedef boost::spirit::qi::rule<Iterator, std::string(), space_type> rule_t;
    rule_t ip_rule, timestamp_rule, user_rule, req_rule, ref_rule, ua_rule, bytes_rule, status_rule;
    ip_rule %= lexeme[(+char_("0-9."))[ref(ip) = _1]];
    timestamp_rule %= lexeme[('[' >> +(~char_(']')) >> ']')[ref(timestamp) = _1]];
    user_rule %= lexeme[(+~char_(" "))];
    req_rule %= lexeme[('"' >> +(~char_('"')) >> '"')[ref(req) = _1]];
    ref_rule %= lexeme[('"' >> +(~char_('"')) >> '"')[ref(referer) = _1]];
    ua_rule %= lexeme[('"' >> +(~char_('"')) >> '"')[ref(ua) = _1]];
    bytes_rule %= uint_[ref(transferred_bytes) = _1];
    status_rule %= uint_[ref(status) = _1];
    std::map<std::string, rule_t> convert_logformat;
    typename std::map<std::string, rule_t>::iterator it;

    convert_logformat.insert(std::pair<std::string, rule_t>("%h", ip_rule));
    convert_logformat.insert(std::pair<std::string, rule_t>("%t", timestamp_rule));
    //convert_logformat.insert(std::pair<std::string, rule_t>("%r", req_rule));
    //convert_logformat.insert(std::pair<std::string, rule_t>("%>s", status_rule));
    //convert_logformat.insert(std::pair<std::string, rule_t>("%b", bytes_rule));
    //convert_logformat.insert(std::pair<std::string, rule_t>("%u", user_rule));
    //convert_logformat.insert(std::pair<std::string, rule_t>("%{User-agent}i", ua_rule));
    //convert_logformat.insert(std::pair<std::string, rule_t>("%{Referer}i", ref_rule));

    rule_t joint_rule;

    //joint_rule = convert_logformat["%h"] >> convert_logformat["%t"];

    for (it = convert_logformat.begin(); it != convert_logformat.end(); it++)
    {
        joint_rule = joint_rule.copy() >> (*it).second.copy();
        std::cout << (*it).first << ": " << typeid((*it).second).name() << "\n";
    }

    std::cout << "convert_logformath: " << typeid(convert_logformat["%h"]).name() << "\n";

    bool r = phrase_parse(first, last, joint_rule, space);
    if (first != last)
        return false;
    return r;
}

Answer 1

Ahem. It is really quite simple. You should initialize your variables 🙂

rule_t joint_rule; // what is it initialized to?

for (auto it = convert_logformat.begin(); it != convert_logformat.end(); it++)
{
    joint_rule = joint_rule.copy() >> (*it).second.copy();
}

Change the first line to

rule_t joint_rule = qi::eps;

And it works:

sehe@mint12:/tmp$ ./test 
127.0.0.1
16/Aug/2012:01:50:02 +0000

Your parser lacks some (good) common practice. See below for tidied up source (C++11).

Note that using a map to store the rules looks odd, because maps iteration will order by the key, not insertion order.

See the code live at http://liveworkspace.org/code/a7f2f94840d63fce43d8c3f56236330e

// #define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <typeinfo>

namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;

template <typename Iterator>
struct Grammar : qi::grammar<Iterator, std::string(), qi::space_type>
{
    Grammar() : Grammar::base_type(joint_rule)
    {
        using namespace qi;
        ip_rule        %= lexeme[ (+char_("0-9."))[phx::ref(ip)                      =  _1] ]; 
        timestamp_rule %= lexeme[ ('[' >> +(~char_(']')) >> ']')[phx::ref(timestamp) =  _1] ]; 
        user_rule      %= lexeme[ (+~char_(" "))                                ]; 
        req_rule       %= lexeme[ ('"' >> +(~char_('"')) >> '"')[phx::ref(req)       =  _1] ]; 
        ref_rule       %= lexeme[ ('"' >> +(~char_('"')) >> '"')[phx::ref(referer)   =  _1] ]; 
        ua_rule        %= lexeme[ ('"' >> +(~char_('"')) >> '"')[phx::ref(ua)        =  _1] ]; 
        bytes_rule     %= uint_[phx::ref(transferred_bytes)                          =  _1  ]; 
        status_rule    %= uint_[phx::ref(status)                                     =  _1  ]; 

        auto convert_logformat = std::map<std::string, rule_t> {
            { "%h"            , ip_rule }       ,
            { "%t"            , timestamp_rule },
        //  { "%r"            , req_rule }      ,
        //  { "%>s"           , status_rule }   ,
        //  { "%b"            , bytes_rule }    ,
        //  { "%u"            , user_rule }     ,
        //  { "%{User-agent}i", ua_rule }       ,
        //  { "%{Referer}i"   , ref_rule }
        };

        joint_rule = eps;

        for (auto const& p: convert_logformat)
        {
            joint_rule = joint_rule.copy() >> p.second.copy();
        }

        BOOST_SPIRIT_DEBUG_NODE(ip_rule);
        BOOST_SPIRIT_DEBUG_NODE(timestamp_rule);
        BOOST_SPIRIT_DEBUG_NODE(user_rule);
        BOOST_SPIRIT_DEBUG_NODE(req_rule);
        BOOST_SPIRIT_DEBUG_NODE(ref_rule);
        BOOST_SPIRIT_DEBUG_NODE(ua_rule);
        BOOST_SPIRIT_DEBUG_NODE(bytes_rule);
        BOOST_SPIRIT_DEBUG_NODE(status_rule);
    }

    typedef qi::rule<Iterator, std::string(), qi::space_type> rule_t;
    rule_t ip_rule, timestamp_rule, user_rule, req_rule, ref_rule, ua_rule, bytes_rule, status_rule;
    rule_t joint_rule;

    std::vector<char> ip;
    std::vector<char> timestamp;
    std::vector<char> req;
    unsigned int status;
    unsigned int transferred_bytes;
    std::vector<char> referer;
    std::vector<char> ua;
};

template <typename Iterator>
bool parse_logentry(Iterator first, Iterator last, 
        Grammar<Iterator>& parser)
{
    bool r = phrase_parse(first, last, parser, qi::space);

    return (r && (first == last));
}

int main(void)
{
    std::string entry = "127.0.0.1 [16/Aug/2012:01:50:02 +0000]";
    //std::string entry = "127.0.0.1 [16/Aug/2012:01:50:02 +0000] \"GET /check.htm HTTP/1.1\" 200 17 \"-\" \"AgentName/0.1 libwww-perl/5.833\"";

    Grammar<std::string::iterator> parser;

    if (parse_logentry(entry.begin(), entry.end(), parser))
    {
        for (auto i : parser.ip)
            std::cout << i;
        std::cout << "\n";

        for (auto ts: parser.timestamp)
            std::cout << ts;
        std::cout << "\n";
    }
    else
    {
        std::cout << "not ok\n";
    }

    return 0;
}

Note that, among other things, this setup allows you to enable debugging of your grammar by simply defining BOOST_SPIRIT_DEBUG at the start.