3

我正在尝试使用其他参数动态构建解析器boost::spirit:qi。目标是解析字符串并std::map<std::string, std::string>使用键和值填充 a。但是，map 的 key 字段是不被解析的（即在解析器生成之前就知道了）。

我猜我需要编写一个语义操作，将地图的键设置为适当的解析值。我可以看到它qi::_1提供了解析器的内容，但是我如何引用返回结构（在本例中为 a std::map）？

如果std::map在范围内，我可以像这样直接分配它：

parser = lit(prefix) >> value_parser[map_[key] = _1];

但就我而言，我想实际生成一个解析器，而不是进行解析。我猜我需要一些东西来代替map_[key]。

提供更多上下文（根据要求）：

我首先解析一个看起来像这样的“模板”字符串：

/path/to/:somewhere:/nifty.json

:somewhere:用于表示以后可以通过 name 引用的任何字符串somewhere。我的解析器运行良好。

接下来，我想从该模板生成另一个解析器，它解析这样的字符串：

/path/to/anywhere/nifty.json

并为我提供一个std::map<std::string, std::string> mwhere m["somewhere"] == "anywhere"。

4

2 回答 2

3

我不确定这是否是您的想法，但继承的属性可能是您的答案。您无需动态创建解析器，而是创建一个解析器，将密钥和对映射的引用作为您在每次调用时提供的继承属性：

// an attempt to demonstrate a parser that takes a std::map by reference and a key by value,
// then stores a parsed value into the map as the value associated with the given key

#include <string>
#include <map>

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

typedef std::string::const_iterator fwd_iter_t;

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

typedef int value_t;  // or whatever
typedef std::map<std::string, value_t> result_map_t;
// key insight - rules can take "inherited" attributes (parameters in 2nd argument):
typedef qi::rule<fwd_iter_t,
                 void(result_map_t&, std::string),       // inherit map ref and key to use
                 boost::spirit::ascii::space_type> map_insert_rule_t;

int main() {

   result_map_t result_map;
   std::vector<std::string> keys = { "A", "B", "C" };
   std::string test_data = "PREFIX 1\nPREFIX 2\nPREFIX 3";

   using boost::phoenix::construct;   // to create pairs
   using boost::phoenix::insert;      // to add pairs to the map
   typedef result_map_t::value_type result_map_pair_t;
   // use Phoenix actions to construct the key/value pair and insert it
   map_insert_rule_t maprule = qi::lit("PREFIX")
                            >> qi::int_[insert(qi::_r1,   // inherited map ref
                                               construct<result_map_pair_t>(qi::_r2, qi::_1))];

   fwd_iter_t beg = test_data.begin();
   fwd_iter_t end = test_data.end();
   for (auto k_it = keys.begin(); k_it != keys.end(); ++k_it) {
      using boost::spirit::ascii::space;
      if (!qi::phrase_parse(beg, end,
                            maprule(phoenix::ref(result_map), *k_it),
                            space)) {
         std::cerr << "parse failed!" << std::endl;
         return 1;
      }
   }

   std::cout << "parse results:" << std::endl;
   for (auto r_it = result_map.begin(); r_it != result_map.end(); ++r_it) {
      std::cout << r_it->first << " " << r_it->second << std::endl;
   }

   return 0;
}

您可以通过从 qi::rule 继承并使其成为私有数据成员来消除调用中的 std::map 引用。

于 2013-02-13T00:33:43.703 回答
1

您应该能够使用 phoenix bind 来完成您所要求的事情，但是如果我们有更多的上下文，似乎可以使用更清洁的解决方案。

parser = lit(prefix) >> value_parser[phx::ref(map)[key] = qi::_1]

根据密钥的来源，您可能还需要使用 phx::ref 。

于 2013-02-12T23:57:56.873 回答