Разбор унаследованной структуры с буст-духом

Question

У меня есть аннотация struct Base без полей (только абстрактные методы) и struct A, struct B, наследуемые от Base с разными полями в обоих.

Возможно ли иметь правило для синтаксического анализа A или B и сохранить результат в shared_ptr<Base>?

Я хотел бы сделать это, чтобы проанализировать некоторые A или B и сохранить их в контейнере shared_ptr<Base>.

Вот определение для структур:

#include <iostream>
using namespace std;

struct Base
{
  virtual void operator() const = 0;
};

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

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

struct BaseContainer
{
  multimap<string, shared_ptr<Base>> container;
}

Допустим, BaseContainer определяется некоторыми входными данными, отформатированными как:

name: A value
name: B value
name: A value

, где name - это заполнитель для строки, используемой в качестве ключа для multimap в BaseContainer, тогда A или B - ключевое слово для генерации struct A или struct B, и значение - это значение, хранящееся в контейнере.

Как бы я написал парсер BaseContainer?

Реальный пример, к которому я хочу применить его, является более сложным, struct A и struct B не имеют одинакового количества полей, поэтому, пожалуйста, не отвечайте чем-то слишком специфичным для этого примера. Спасибо.

Answer 1

Итак, здесь есть два вопроса, я чувствую:

• Как адаптировать производные классы Можно ли использовать BOOST_FUSION_ADAPT_STRUCT с унаследованными вещами?
• Как я могу использовать полиморфные атрибуты с парсерами boost :: spirit :: qi?

Обновление

Небольшая демонстрация подхода 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