是否有可能在另一个语法定义中重用boost :: spirit :: qi语法？

Question

是否可以boost::spirit:qi在另一种语法中重用语法(例如,规则)？

例如,如果我定义一个语法来解析文本行到一个持有街道地址的结构中.

   template< typename iter >
        struct address_grammar : qi::grammar< iter, address() >
   {
     ...

       qi::rule< iter, std::string() > street_name;
       qi::rule< iter, std::string() > street_number;
       qi::rule< iter, address() > address_;
   }

我可能想在另外两个语法中重用该语法,例如,一个可能用于解析存储在文件中的地址向量.另一种重复使用可能是在更复杂的结构中,其中一个字段是此街道地址结构.

  template< typename iter >
      struct company_grammar : qi::grammar< iter, company() >
  {
     ...
     qi::rule< iter, std::string() > comp_name;
     // can I reuse the address grammar somehow here ???
     qi::rule< iter, company() > company;
  }

我没有在一个地方定义整个语法,而是想把它分成更小的可重用块,如果它们在一个头文件中,那就好了.我的数据结构稍微复杂一些(struct中的几个字段和其他结构的列表等等)所以我不想把它放在一个语法中.

是否有可能以boost::spirit::qi这种方式重用语法？

编辑:考虑一下,我只是qi::rule在命名空间中定义s,然后从我需要的规则中汇总一个语法？

Answer 1

当然可以.在您的情况下,只需address_grammar<iter> address_;输入您的代码.

让我再举一个例子.您可以在此处找到可编辑的代码:http: //ideone.com/GW4jO(另见下文)

AFAIK,与qi :: grammar不同,qi :: rule很难重用.

完整样本

#include <string>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

struct Date {
    int year, month, day;
};
struct Time {
    int hour, minute, second;
};

BOOST_FUSION_ADAPT_STRUCT(
    Date,
    (int, year)
    (int, month)
    (int, day)
)

BOOST_FUSION_ADAPT_STRUCT(
    Time,
    (int, hour)
    (int, minute)
    (int, second)
)

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
typedef std::string::const_iterator Iterator;

class DateParser:
    public qi::grammar < Iterator, Date() > {
        qi::rule < Iterator, Date() > main;
    public:
        DateParser(): base_type(main) {
            main %= qi::int_ >> '-' >> // Year
                    qi::int_ >> '-' >> // Month
                    qi::int_;          // Day
        }
};

class TimeParser:
    public qi::grammar < Iterator, Time() > {
        qi::rule < Iterator, Time() > main;
    public:
        TimeParser(): base_type(main) {
            main %= qi::int_ >> ':' >> // Hour
                    qi::int_ >> ':' >> // Minute
                    qi::int_;          // Second
        }
};

class DateTimeParser:
    public qi::grammar < Iterator, boost::variant<Date, Time>() > {
        qi::rule < Iterator, boost::variant<Date, Time>()> main;
    public:
        DateTimeParser(): base_type(main) {
            main %= date_parser | time_parser;
        }
        DateParser date_parser;
        TimeParser time_parser;
};

#include<iostream>
#include<cstdio>

struct Printer : public boost::static_visitor<> {
    void operator()(Date a) const {
        printf("Year: %d, Month: %d, Day: %d\n", a.year, a.month, a.day);
    }
    void operator()(Time a) const {
        printf("Hour: %d, Minute: %d, Second: %d\n", a.hour, a.minute, a.second);
    }
};

int main() {
    std::string s;
    std::getline(std::cin, s);
    Iterator beg = s.begin(), end = s.end();
    boost::variant<Date, Time> ret;
    phrase_parse(beg, end, DateTimeParser(), ascii::space, ret);
    if (beg != end)
        puts("Parse failed.");
    else
        boost::apply_visitor(Printer(), ret);
}