Generador de Karma Boost para la composición de clases.

Tengo el siguiente diagrama de clase:

Hay una clase no utilizada comoBinaryOperator, pero mi código real los necesita, así que quiero mantenerlos también en el ejemplo.

Quiero usarimpulso :: karma para obtener una representación JSON de esto. El JSON debería ser como el siguiente:

{
  "name": "Plus",
  "type": "Function",
  "arguments": [
    {
      "name": "IntegerValue",
      "type": "Value",
      "value": "4"
    },
    {
      "name": "Plus",
      "type": "Function",
      "arguments": [
        {
          "name": "IntegerValue",
          "type": "Value",
          "value": "5"
        },
        {
          "name": "IntegerValue",
          "type": "Value",
          "value": "6"
        }
      ]
    }
  ]
}

Como es un ejemplo simple, me gustaría usarBOOST_FUSION_ADAPT_ADT macro para mis clases para modularizar el generador.

Soy nuevo en Karma, he leído el tutorial en el sitio de impulso pero no entiendo cómo atacar mi problema. No puedo encontrar un buen tutorial sobre esa macro.

No quiero usar las bibliotecas existentes para JSON porque al principio quiero aprender Karma, y en segundo lugar, JSON es solo un ejemplo, necesito exportar mi expresión en muchos formatos, y puedo hacerlo simplemente cambiando los generadores mientras el código que usaBOOST_FUSION_ADAPT_ADT para mis clases debe ser lo mismo

Puede encontrar el código para crear una expresión de muestra. ¿Dónde debo comenzar para resolver mi problema?

#include <boost/lexical_cast.hpp>
#include <iostream>
#include <vector>

class Expression {
public:

  virtual std::string getName() const = 0;
};

class Value : public Expression {
public:

  virtual std::string getValue() const = 0;
};

class IntegerValue : public Value {
public:

  IntegerValue(int value) : m_value(value) {}
  virtual std::string getName() const override { return "IntegerValue"; }
  virtual std::string getValue() const override { return boost::lexical_cast<std::string>(m_value); }

private:

  int m_value;
};

class Function : public Expression {
public:

  void addArgument(Expression* expression) { m_arguments.push_back(expression); }
  virtual std::string getName() const override { return m_name; }

protected:

  std::vector<Expression*> m_arguments;
  std::string m_name;
};

class Plus : public Function {
public:

  Plus() : Function() { m_name = "Plus"; }
};

///////////////////////////////////////////////////////////////////////////////

int main(int argc, char **argv) {

  // Build expression 4 + 5 + 6 as 4 + (5 + 6)
  Function* plus1 = new Plus();
  Function* plus2 = new Plus();
  Value* iv4   = new IntegerValue(4);
  Value* iv5   = new IntegerValue(5);
  Value* iv6   = new IntegerValue(6);
  plus2->addArgument(iv5);
  plus2->addArgument(iv6);
  plus1->addArgument(iv4);
  plus1->addArgument(plus2);

  // Generate json string here, but how?

  return 0;
}

Respuestas a la pregunta(2)

Su respuesta a la pregunta