c++ - 用boost精神解析继承的结构

So there's two questions here, I feel:

• How to adapt derived classes Can I use BOOST_FUSION_ADAPT_STRUCT with inherited stuff?
• How can I use polymorphic attributes with boost::spirit::qi parsers?

Update

有关此问题的方法2的小演示：

Live On Wandbox

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/adapted.hpp>
#include <map>
#include <iomanip> // std::quoted

struct Base {}; // dynamic polymorphism not required for us now, no problem if you want it

struct A : Base {
    int value;
    void operator()() const { std::cout << "Hello A: " << value << std::endl; };
};

struct B : Base {
    float value;
    void operator()() const { std::cout << "Hello B: " << value << std::endl; };
};

using Node = boost::variant<A, B>;
struct BaseContainer {
    using Map = std::multimap<std::string, Node>;
    Map container;
};

BOOST_FUSION_ADAPT_STRUCT(A, value)
BOOST_FUSION_ADAPT_STRUCT(B, value)
BOOST_FUSION_ADAPT_STRUCT(BaseContainer, container)

namespace qi = boost::spirit::qi;

template <typename It> 
struct Parser : qi::grammar<It, BaseContainer()> {
    Parser() : Parser::base_type(start) {
        using namespace qi;
        _key       = lexeme['"' >> *('\\' >> char_ | ~char_('"')) >> '"'];
        _a_node    = "A(" >> int_ >> ")";
        _b_node    = "B(" >> float_ >> ")";
        _node      = _a_node | _b_node;
        _pair      = '{' >> _key >> ',' >> _node >> '}';
        _container = '{' >> -(_pair % ',') >> '}';

        start = skip(space) [ _container ];

        BOOST_SPIRIT_DEBUG_NODES((start)(_container)(_pair)(_key)(_node)(_a_node)(_b_node))
    }
  private:
    qi::rule<It, BaseContainer()> start;

    // lexeme
    qi::rule<It, std::string()> _key;

    using Skipper = qi::space_type;
    using Pair = std::pair<std::string, Node>;

    qi::rule<It, BaseContainer::Map(), Skipper> _container;
    qi::rule<It, Pair(), Skipper> _pair;
    qi::rule<It, Node(), Skipper> _node;
    qi::rule<It, A(), Skipper> _a_node;
    qi::rule<It, B(), Skipper> _b_node;
};

int main() {
    Parser<std::string::const_iterator> const p;
    for (std::string const input : {
            R"({})",
            R"({ { "one", A(42) } })",
            R"({ { "two", B(3.14) } })",
            R"({ { "three", A( -42 ) }, { "four", B( -3.14 ) } })",
            })
    {
        std::cout << "-------\n";
        std::cout << "Parsing " << input << "\n";
        auto f = begin(input), l = end(input);

        BaseContainer result;
        if (qi::parse(f, l, p, result)) {
            for (auto const& [k,v] : result.container) {
                std::cout << " Key " << std::quoted(k) << ": ";
                boost::apply_visitor([](auto const& node) { node(); }, v);
            }
        } else {
            std::cout << "Parse failed\n";
        }

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

版画

-------
Parsing {}
-------
Parsing { { "one", A(42) } }
 Key "one": Hello A: 42
-------
Parsing { { "two", B(3.14) } }
 Key "two": Hello B: 3.14
-------
Parsing { { "three", A( -42 ) }, { "four", B( -3.14 ) } }
 Key "four": Hello B: -3.14
 Key "three": Hello A: -42