Есть ли альтернатива для boost :: phoenix :: at_c в сочетании с boost :: spirit :: qi :: grammar - PullRequest
Новая
       12

Есть ли альтернатива для boost :: phoenix :: at_c в сочетании с boost :: spirit :: qi :: grammar

4 голосов
/ 20 июля 2010

Я создал тестовое приложение, чтобы проиллюстрировать мою проблему. Он анализирует список целых чисел, которым предшествует "a =" или "b =", и разделяется "\ r \ n". Список содержит несколько вхождений этих полей в любом порядке. 

#include <string>
#include <vector>
#include <iostream>

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

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

#include <boost/fusion/include/adapt_struct.hpp>


typedef std::vector<unsigned int> uint_vector_t;

std::ostream& operator<<(std::ostream& out, const uint_vector_t &data)
{
    for (unsigned int i(0); i < data.size(); i++)
    {
        out << data[i] << '\n';
    }
    return out;
}

struct MyStruct
{
    uint_vector_t m_aList;
    uint_vector_t m_bList;
};

BOOST_FUSION_ADAPT_STRUCT
(
    MyStruct,
    (uint_vector_t, m_aList)
    (uint_vector_t, m_bList)
)
;

template<typename Iterator>
struct MyParser : public boost::spirit::qi::grammar<Iterator,
        MyStruct()>
{
    MyParser() :
        MyParser::base_type(Parser, "Parser")
    {
        using boost::spirit::qi::uint_;
        using boost::spirit::qi::_val;
        using boost::spirit::qi::_1;

        using boost::phoenix::at_c;
        using boost::phoenix::push_back;

        Parser =
                *(
                        aParser [push_back(at_c<0>(_val), _1)]
                    |
                        bParser [push_back(at_c<1>(_val), _1)]
                );
        aParser = "a=" >> uint_ >> "\r\n";
        bParser = "b=" >> uint_ >> "\r\n";
    }
        boost::spirit::qi::rule<Iterator, MyStruct()> Parser;
        boost::spirit::qi::rule<Iterator, unsigned int()> aParser, bParser;
};

int main()
{
    using boost::spirit::qi::phrase_parse;

    std::string input("a=0\r\nb=7531\r\na=2\r\na=3\r\nb=246\r\n");
    std::string::const_iterator begin = input.begin();
    std::string::const_iterator end = input.end();
    MyParser<std::string::const_iterator> parser;

    MyStruct result;
    bool succes = phrase_parse(begin, end, parser, "", result);
    assert(succes);

    std::cout << "===A===\n" <<result.m_aList << "===B===\n" << result.m_bList << std::endl;
}

На практике есть больше полей с разными типами, которые необходимо проанализировать. Я возражаю против такого подхода в следующем выражении: [push_back (at_c <0> (_ val), _1)] Вот «скрытая зависимость» между назначением и первым элементом MyStruct. Это делает код хрупким к изменениям. Если структура будет изменена, она все равно может скомпилироваться, но больше не будет делать то, что ожидается.

Я надеюсь на такую ​​конструкцию, как: [push_back (at_c <0> bind (& MyStruct :: aList, arg1) (_ val), _1)] См. this. Так что это действительно связано по имени.

Возможно ли что-то подобное? Или я должен использовать совершенно другой подход?

1 Ответ

8 голосов
/ 20 июля 2010

Phoenix также позволяет связывать элементы данных, поэтому вы можете написать: 

Parser = 
   *(  aParser [push_back(bind(&MyStruct::m_aList, _val), _1)] 
    |  bParser [push_back(bind(&MyStruct::m_bList, _val), _1)] 
    );

Более того, в этом случае вам больше не нужна магия FUSION_ADAPT для вашей структуры.

...