Analyse XML avec boost propriété de l'arbre

J'ai le fichier XML suivant et je veux le stocker à l'aide de la ci-dessous structures.

les données des structures:

    struct transitions
    {
     string oldstate;
     string event;
     string newstate;
    };

    struct XML_Diagram
    {
     string diag_name;
     string diag_defaultstate;
     list<string> diag_states;
     list<string> diag_events;
     list<transitions> diag_transitions;
    };

le fichier xml:

    <diagram>
      <diagname>DiagaX</diagname>
      <states>
         <state>A</state>
         .............       
      </states>
      <events>
          <event>ev1</event>
          .................
      </events>
      <defaultstate>A</defaultstate>
      <transitions>
          <transition>
              <oldstate>A</oldstate>
              <event>ev1</event>
              <newstate>B</newstate>
          </transition>
          <transition>
              <oldstate>B</oldstate>
              <event>ev2</event>
              <newstate>C</newstate>
          </transition>
          .........................
      </transitions>
    </diagram>

Il est clair pour moi comment puis-je accéder diagramme.états .
Je peux le faire avec le code suivant:

    using boost::property_tree::ptree;
    ptree pt;

    //Get diagram states
    BOOST_FOREACH(ptree::value_type &v, pt.get_child("diagram.states"))
    {
       diag_states.push_back(v.second.data());
    }

Ce n'est pas clair pour moi est de savoir comment puis-je accéder aux données à partir du diagramme.les transitions.la transition ?

Mon problème est que je ne pouvais pas trouver des exemples dans la documentation sur la façon d'analyser plus complexe des fichiers xml avec plusieurs niveaux.

OriginalL'auteur Tg Cl | 2012-01-01

  1. 4

    Cet utilitaire utile à la fonction de traverse et de jolies gravures à un ensemble de la propriété de l'arbre:

    using boost::property_tree::ptree;

std::string q(const std::string& s) { return "\"" + s + "\""; }

void print_tree(const ptree& pt, int level)
{
    const std::string sep(2 * level, ' ');
    BOOST_FOREACH(const ptree::value_type &v, pt) {
        std::cout
            << sep
            << q(v.first) << " : " << q(v.second.data()) << "\n";
        print_tree(v.second, level + 1);
    }
}

void print_tree(const ptree& pt) { print_tree(pt, 0); }

    La v.second valeurs sont des arbres eux-mêmes qui peuvent être accessibles avec l'habitude get méthodes. Les transitions
    peut par exemple être consulté et imprimé comme ceci:

    using std::string;

void print_transitions(const ptree& pt)
{
    BOOST_FOREACH(
        const ptree::value_type &v,
        pt.get_child("diagram.transitions"))
    {
        const ptree& child = v.second;
        std::cout
            << "Event "
            << child.get<string>("event")
            << " in state "
            << child.get<string>("oldstate")
            << " leads to state "
            << child.get<string>("newstate")
            << "\n";
    }
}

    OriginalL'auteur antonakos

  2. 4

    Voici un autre exemple de la façon d'imprimer ptree avec des attributs:

    namespace pt = boost::property_tree;
//worker
typedef std::pair<const pt::ptree&, unsigned> tree_printer;
//empty ptree helper
const pt::ptree& empty_ptree()
{
static pt::ptree t;
return t;
}
std::ostream& operator <<(std::ostream& os, const tree_printer& p)
{
const pt::ptree& tree = p.first;
if(tree.empty()) return os;
const std::string indent(p.second, ' ');
BOOST_FOREACH(const pt::ptree::value_type& v, tree)
{
const std::string& nodeName = v.first;
if(nodeName == "<xmlattr>") continue;
os << indent << nodeName;
const pt::ptree& attributes =
v.second.get_child("<xmlattr>", empty_ptree());
if(!attributes.empty())
{
os << " [ ";
BOOST_FOREACH(const pt::ptree::value_type& attr, attributes)
{
const std::string& attrName = attr.first;
const std::string& attrVal = attr.second.data();
os << attrName << " = '" << attrVal << "'; ";
}
os << "]";
}
os << "\n";
const pt::ptree& childNode = v.second;
os << tree_printer(childNode, p.second + 1);
}
return os;
}
std::ostream& operator <<(std::ostream& os, const pt::ptree& tree)
{
os << tree_printer(tree, 0);
return os;
}

    Espère que cette aide.

    OriginalL'auteur Alex Blekhman