与升压::精神

Question

读空值我想读一个CSV到一个结构：

struct data 
{ 
    std::string a; 
    std::string b; 
    std::string c; 
} 

不过，我想读甚至空字符串，以确保所有值都各得其所。 我适应该结构到一个boost ::融合，所以下面的工作：

// Our parser (using a custom skipper to skip comments and empty lines) 
template <typename Iterator, typename skipper = comment_skipper<Iterator> > 
    struct google_parser : qi::grammar<Iterator, addressbook(), skipper> 
{ 
    google_parser() : google_parser::base_type(contacts, "contacts") 
    { 
    using qi::eol; 
    using qi::eps; 
    using qi::_1; 
    using qi::_val; 
    using qi::repeat; 
    using standard_wide::char_; 
    using phoenix::at_c; 
    using phoenix::val; 

    value = *(char_ - ',' - eol) [_val += _1]; 

    // This works but only for small structs 
    entry %= value >> ',' >> value >> ',' >> value >> eol; 
    } 

    qi::rule<Iterator, std::string()> value; 
    qi::rule<Iterator, data()> entry; 
}; 

不幸的是，repeat存储在向量中的所有非空值，从而属性的值可以被混合在一起（即，如果场为b为空，也可能包含来自c内容）：

entry %= repeat(2)[ value >> ','] >> value >> eol; 

我想用类似repeat短规则为我的结构在实践60个属性！不仅是编写60条规则乏味，但似乎Boost不喜欢长规则...

Answer 1

你只是想确保你解析“空”字符串的值。

value = +(char_ - ',' - eol) | attr("(unspecified)"); 
entry = value >> ',' >> value >> ',' >> value >> eol; 

观看演示：

Live On Coliru

//#define BOOST_SPIRIT_DEBUG 
#include <boost/fusion/adapted/struct.hpp> 
#include <boost/spirit/include/qi.hpp> 

namespace qi = boost::spirit::qi; 

struct data { 
    std::string a; 
    std::string b; 
    std::string c; 
}; 

BOOST_FUSION_ADAPT_STRUCT(data, (std::string, a)(std::string, b)(std::string, c)) 

template <typename Iterator, typename skipper = qi::blank_type> 
struct google_parser : qi::grammar<Iterator, data(), skipper> { 
    google_parser() : google_parser::base_type(entry, "contacts") { 
     using namespace qi; 

     value = +(char_ - ',' - eol) | attr("(unspecified)"); 
     entry = value >> ',' >> value >> ',' >> value >> eol; 

     BOOST_SPIRIT_DEBUG_NODES((value)(entry)) 
    } 
    private: 
    qi::rule<Iterator, std::string()> value; 
    qi::rule<Iterator, data(), skipper> entry; 
}; 

int main() { 
    using It = std::string::const_iterator; 
    google_parser<It> p; 

    for (std::string input : { 
      "something, awful, is\n", 
      "fine,,just\n", 
      "like something missing: ,,\n", 
     }) 
    { 
     It f = input.begin(), l = input.end(); 

     data parsed; 
     bool ok = qi::phrase_parse(f,l,p,qi::blank,parsed); 

     if (ok) 
      std::cout << "Parsed: '" << parsed.a << "', '" << parsed.b << "', '" << parsed.c << "'\n"; 
     else 
      std::cout << "Parse failed\n"; 

     if (f!=l) 
      std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n"; 
    } 
} 

打印：

Parsed: 'something', 'awful', 'is' 
Parsed: 'fine', '(unspecified)', 'just' 
Parsed: 'like something missing: ', '(unspecified)', '(unspecified)' 

但是，你有一个更大的问题。假设qi::repeat(2) [ value ]将解析为2个字符串不起作用。

repeat，像operator*,operator+和operator%解析成容器属性。在这种情况下，容器属性（字符串）将接收输入从第二value还有：

Live On Coliru

Parsed: 'somethingawful', 'is', '' 
Parsed: 'fine(unspecified)', 'just', '' 
Parsed: 'like something missing: (unspecified)', '(unspecified)', '' 

由于这是不是你想要的，考虑你的数据类型：

• 要么不调整结构，而要写一个自定义特征来分配字段（参见http://www.boost.org/doc/libs/1_57_0/libs/spirit/doc/html/spirit/advanced/customize.html）

• 变化的结构来含有的std :: string的向量匹配的暴露属性

• 或创建自动解析器生成器：

的auto_方法：

如果您教Qi如何提取单个值，您可以使用一个简单的规则，如

entry = skip(skipper() | ',') [auto_] >> eol; 

这样一来，Spirit本身就会为给定的Fusion序列生成正确数量的值提取！

这里有一个快速的脏方法：

CAVEAT专业为std::string直接像这可能不是最好的主意（它可能并不总是合适的，并可能与其他解析器严重交互）。然而，在默认情况下create_parser<std::string>未定义（因为，​​它会做什么？），所以我抓住了机会，这个演示的目的：

namespace boost { namespace spirit { namespace traits { 
    template <> struct create_parser<std::string> { 
     typedef proto::result_of::deep_copy< 
      BOOST_TYPEOF(
       qi::lexeme [+(qi::char_ - ',' - qi::eol)] | qi::attr("(unspecified)") 
      ) 
     >::type type; 

     static type call() { 
      return proto::deep_copy(
       qi::lexeme [+(qi::char_ - ',' - qi::eol)] | qi::attr("(unspecified)") 
      ); 
     } 
    }; 
}}} 

再次，看演示输出：

Live On Coliru

Parsed: 'something', 'awful', 'is' 
Parsed: 'fine', 'just', '(unspecified)' 
Parsed: 'like something missing: ', '(unspecified)', '(unspecified)' 

备注有些先进的魔法让船长“恰到好处”工作（见skip()[]和lexeme[]）。一些一般性的解释可以在这里找到：Boost spirit skipper issues

UPDATE

容器方法

有一个微妙了这一点。其实两个。所以这里有一个演示：

Live On Coliru

//#define BOOST_SPIRIT_DEBUG 
#include <boost/fusion/adapted/struct.hpp> 
#include <boost/spirit/include/qi.hpp> 

namespace qi = boost::spirit::qi; 

struct data { 
    std::vector<std::string> parts; 
}; 

BOOST_FUSION_ADAPT_STRUCT(data, (std::vector<std::string>, parts)) 

template <typename Iterator, typename skipper = qi::blank_type> 
struct google_parser : qi::grammar<Iterator, data(), skipper> { 
    google_parser() : google_parser::base_type(entry, "contacts") { 
     using namespace qi; 
     qi::as<std::vector<std::string> > strings; 

     value = +(char_ - ',' - eol) | attr("(unspecified)"); 
     entry = strings [ repeat(2) [ value >> ',' ] >> value ] >> eol; 

     BOOST_SPIRIT_DEBUG_NODES((value)(entry)) 
    } 
    private: 
    qi::rule<Iterator, std::string()> value; 
    qi::rule<Iterator, data(), skipper> entry; 
}; 

int main() { 
    using It = std::string::const_iterator; 
    google_parser<It> p; 

    for (std::string input : { 
      "something, awful, is\n", 
      "fine,,just\n", 
      "like something missing: ,,\n", 
     }) 
    { 
     It f = input.begin(), l = input.end(); 

     data parsed; 
     bool ok = qi::phrase_parse(f,l,p,qi::blank,parsed); 

     if (ok) { 
      std::cout << "Parsed: "; 
      for (auto& part : parsed.parts) 
       std::cout << "'" << part << "' "; 
      std::cout << "\n"; 
     } 
     else 
      std::cout << "Parse failed\n"; 

     if (f!=l) 
      std::cout << "Remaining unparsed: '" << std::string(f,l) << "'\n"; 
    } 
} 

的精妙之处是：

• 适应的单元素序列命中边缘的情况下，自动属性处理：Spirit Qi attribute propagation issue with single-member struct
• 精神需要在这种特殊情况下手持repeat[...]>>value合成一个单一的容器/原子/。 as<T> directive solves that here