boost std :: vector <unsigned> 구문 분석되었지만 캡처되지 않음

Question

"{ABC,HIJ}:{10,15,20}"을 구문 분석하여 struct indicator_rec에 캡처하려고합니다.

구문 분석에 성공했지만 {ABC,HIJ}의 첫 번째 집합 만 std::vector<std::string> 필드에 캡처됩니다.

두 번째 부분 인 {10,15,20}은 올바르게 구문 분석되지만 두 번째 필드 std::vector<unsigned>에 포함되지 않습니다.

내가 뭘 잘못하고 있니?

출력 :

<equation> 
    <try>{ABC,HIJ}:{10,15,20}</try> 
    <indicator> 
    <try>{ABC,HIJ}:{10,15,20}</try> 
    <fail/> 
    </indicator> 
    <indicators> 
    <try>{ABC,HIJ}:{10,15,20}</try> 
    <indicator> 
     <try>ABC,HIJ}:{10,15,20}</try> 
     <success>,HIJ}:{10,15,20}</success> 
     <attributes>[[A, B, C]]</attributes> 
    </indicator> 
    <indicator> 
     <try>HIJ}:{10,15,20}</try> 
     <success>}:{10,15,20}</success> 
     <attributes>[[H, I, J]]</attributes> 
    </indicator> 
    <success>:{10,15,20}</success> 
    <attributes>[[[A, B, C], [H, I, J]]]</attributes> 
    </indicators> 
    <parameters> 
    <try>{10,15,20}</try> 
    <parameter> 
     <try>10,15,20}</try> 
     <success>,15,20}</success> 
     <attributes>[]</attributes> 
    </parameter> 
    <parameter> 
     <try>15,20}</try> 
     <success>,20}</success> 
     <attributes>[]</attributes> 
    </parameter> 
    <parameter> 
     <try>20}</try> 
     <success>}</success> 
     <attributes>[]</attributes> 
    </parameter> 
    <success></success> 
    <attributes>[[]]</attributes> 
    </parameters> 
    <success></success> 
    <attributes>[[[[A, B, C], [H, I, J]], []]]</attributes> 
</equation> 

코드 :

#define BOOST_SPIRIT_DEBUG 
#include <boost/config/warning_disable.hpp> 
#include <boost/spirit/include/qi.hpp> 
#include <boost/spirit/include/phoenix_core.hpp> 
#include <boost/spirit/include/phoenix_operator.hpp> 
#include <boost/spirit/include/phoenix_stl.hpp> 
#include <boost/spirit/include/classic_symbols.hpp> 
#include <boost/fusion/include/adapt_struct.hpp> 
#include <boost/fusion/include/io.hpp> 

#include <boost/algorithm/string.hpp> 
#include <boost/regex.hpp> // std::regex not fully implemented in stdc++ yet 

#include <string> 
#include <map> 
#include <utility> 
#include <functional> 

// ----------------------------------------------------------------------------- 
namespace client 
{ 
    namespace qi  = boost::spirit::qi; 
    namespace ascii = boost::spirit::ascii; 
    namespace spirit = boost::spirit; 
    namespace phoenix = boost::phoenix; 

    // --------------------------------------------------------------------------- 
    struct indicator_rec 
    { 
    public: 
     indicator_rec() { } 

     std::vector<std::string> m_indicators; 
     std::vector<unsigned>  m_parameters; 
    }; 
} 

BOOST_FUSION_ADAPT_STRUCT(
    client::indicator_rec, 
    (std::vector<std::string>, m_indicators) 
    (std::vector<unsigned>,  m_parameters) 
) 

namespace client 
{ 
    // --------------------------------------------------------------------------- 
    template <typename Iterator> 
    struct system_parser : 
     qi::grammar<Iterator, ascii::space_type, indicator_rec()> 
    { 
      system_parser() : 
       system_parser::base_type(equation) 
      { 
        using qi::double_; 
        using qi::_val; 
        using qi::_1; 
        using boost::spirit::ascii::string; 

        equation %= 
          (indicator | indicators)      
          >> ':' 
          >> (parameters | parameter) 
          ; 

        indicator %= (string("ABC")|string("HIJ")) 
          ; 

        indicators %= '{' >> (indicator % ',') >> '}' 
          ; 

        parameter %= qi::uint_ 
          ; 

        parameters %= '{' >> (parameter % ',') >> '}' 
          ; 

        BOOST_SPIRIT_DEBUG_NODE(equation); 
        BOOST_SPIRIT_DEBUG_NODE(parameter); 
        BOOST_SPIRIT_DEBUG_NODE(parameters); 
        BOOST_SPIRIT_DEBUG_NODE(indicator); 
        BOOST_SPIRIT_DEBUG_NODE(indicators); 
      } 

      qi::rule<Iterator, ascii::space_type, indicator_rec()> 
       equation; 

      qi::rule<Iterator, ascii::space_type, std::vector<std::string>()> 
       indicators; 

      qi::rule<Iterator, ascii::space_type, std::string()> 
       designator, indicator; 

      qi::rule<Iterator, ascii::space_type, unsigned> 
       parameter; 

      qi::rule<Iterator, ascii::space_type, std::vector<unsigned>()> 
       parameters; 
    }; 

    template <typename Iterator> 
    bool parse_system(Iterator first, Iterator last, client::indicator_rec& rec) 
    { 
     system_parser<Iterator> parser; 
     bool r = qi::phrase_parse(first, last, parser, ascii::space, rec); 
     if (first != last) // fail if we did not get a full match 
      return false; 
     return r; 
    } 

    template <typename Iterator> 
    bool parse_universe(Iterator first, Iterator last, std::vector<std::string>& v) 
    { 
     bool r = qi::phrase_parse(first, last, 
           // Begin grammar ------------------------------------- 
           (
                 (+(qi::alpha|qi::char_("_"))) >> ':' >> '{' >> 
                  (+~qi::char_(",}")) % ',' 
                  >> '}' 
          ) 
           , 
           // End grammar --------------------------------------- 
           ascii::space, v); 

     if (first != last) // fail if we did not get a full match 
      return false; 
     return r; 
    } 
} 

main(int argc, char* argv[]) 
{ 
    std::string calculator("{ABC,HIJ}:{10,15,20}"); 
    client::indicator_rec rec; 
    client::parse_system(calculator.begin(), calculator.end(), rec); 
} 

Answer 1

This question 어제는 거의 동일합니다. 모든 규칙의 서명은이 함수 선언자 구문을 사용해야합니다. 괄호 앞에있는 유형은 규칙 (합성 된 속성)에서 "반환 된"속성이며 내부 유형은 상속 된 속성입니다 (here을 사용하여 간단한 예를 찾을 수 있음).

따라서 이러한 상속 된 특성을 사용하지 않는 경우 규칙 선언에 rule_attribute_type()을 사용해야합니다. 이상적으로 그렇게하지 않으면 컴파일러 오류가 발생하지만, 분명히 rule's template parameters의 이기종 특성으로 인해 불행하게도 어떤 일이 발생하지 않습니다.