c++ - ¿Cómo fusiono/actualizo un boost:: property_tree:: ptree?

boost-propertytree

Question

He leído la documentación de boost :: property_tree y no he encontrado una manera de actualizar o fusionar un preeree con otro preeree. ¿Cómo hago esto?

Dado el siguiente código, ¿cómo se vería la función update_ptree?

#include <iostream>
#include <boost/property_tree/ptree.hpp>
using boost::property_tree::ptree;

class A
{
  ptree pt_;
public:
  void set_ptree(const ptree &pt)
  {
    pt_ = pt;
  };
  void update_ptree(const ptree &pt)
  {
    //How do I merge/update a ptree?
  };
  ptree get_ptree()
  {
    return pt_;
  };
};

int main()
{
  A a;
  ptree pt;
  pt.put<int>("first.number",0);
  pt.put<int>("second.number",1);
  pt.put<int>("third.number",2);
  a.set_ptree(pt);
  ptree pta = a.get_ptree();

  //prints "0 1 2"
  std::cout << pta.get<int>("first.number") << " "
            << pta.get<int>("second.number") << " "
            << pta.get<int>("third.number") << "/n";


  ptree updates;
  updates.put<int>("first.number",7);
  a.update_ptree(updates);
  pta = a.get_ptree();

  //Because the update_tree function doesn''t do anything it just prints "0 1 2".
  //I would like to see "7 1 2"
  std::cout << pta.get<int>("first.number") << " " 
            << pta.get<int>("second.number") << " " 
            << pta.get<int>("third.number") << "/n";

  return 0;
}

He pensado en iterar sobre el nuevo ptree y usar "put" para insertar valores. Pero "poner" requiere un tipo y no sé cómo obtener esa información del nuevo pree y usarlo como argumento para el antiguo pree.

Una cosa que he intentado en la función update_ptree es usar:

pt_.add_child(".",pt);

Básicamente trato de agregar pt como un niño a la raíz de pt_. Lamentablemente, esto no parece funcionar.

¿Algunas ideas?

Estoy agradecido por cualquier ayuda.

Gracias.

(Intenté agregar las etiquetas property_tree y pree a esta pregunta, pero no me fue permitido)

Answer 1

Creo que tienes que recorrer recursivamente el property_tree.

Puede definir una función que itera recursivamente en cada nodo y llama a un método para cada nodo:

template<typename T>
void traverse_recursive(const boost::property_tree::ptree &parent, const boost::property_tree::ptree::path_type &childPath, const boost::property_tree::ptree &child, T &method)
{
  using boost::property_tree::ptree;

  method(parent, childPath, child);
  for(ptree::const_iterator it=child.begin();it!=child.end();++it) {
    ptree::path_type curPath = childPath / ptree::path_type(it->first);
    traverse_recursive(parent, curPath, it->second, method);
  }
}

Podemos definir una función más simple para llamar a la anterior:

template<typename T>
void traverse(const boost::property_tree::ptree &parent, T &method)
{
  traverse_recursive(parent, "", parent, method);
}

Ahora puede modificar la clase A para agregar un método para fusionar solo un nodo y completar el método update_ptree:

#include <boost/bind.hpp>

class A {  
  ptree pt_; 

public:   
  void set_ptree(const ptree &pt)   {    
    pt_ = pt; 
  }

  void update_ptree(const ptree &pt)   {  
    using namespace boost;
    traverse(pt, bind(&A::merge, this, _1, _2, _3));
  }

  ptree get_ptree()   { 
    return pt_;  
  }

protected:
  void merge(const ptree &parent, const ptree::path_type &childPath, const ptree &child) {
    pt_.put(childPath, child.data());
  }    
}; 

La única limitación es que es posible tener varios nodos con la misma ruta. Cada uno de ellos sería utilizado, pero solo el último se fusionará.

Answer 2

El árbol Boost.Property aún no es compatible con esto: boost.org/doc/libs/1_48_0/doc/html/property_tree/appendices.html . Mira la sección de trabajo futuro.

Relaciones matemáticas: diferencia libre, unión, intersección.

Una actualización es simplemente una diferencia seguida de una unión. a = (a - b) + b .

La solución general requeriría un recorrido de actualización recurrente y poner cada hoja.

Sin embargo, una buena solución se puede construir con put_child . Esto puede hacer todo lo que necesite, sin la complejidad de una solución general.

void merge( ptree& pt, const ptree& updates )
{
   BOOST_FOREACH( auto& update, updates )
   {
      pt.put_child( update.first, update.second );
   }
}

La solución lo suficientemente buena tiene dos limitaciones, por coincidencia son las mismas limitaciones que el ini_parser.

• el árbol solo puede tener dos capas (por ejemplo, "first.number", pero no "first.again.number")
• los valores solo se pueden almacenar en nodos hoja.