Boost Property_Tree itérateurs, comment les gérer?

Je suis désolé, j'ai posé une question sur le même sujet avant, mais mon problème concerne un autre aspect de celui qui y sont décrits (Comment itérer un coup de pouce...).

Prendre un coup d'oeil au code suivant:

#include <iostream>
#include <string>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/algorithm/string/trim.hpp>
int main(int argc, char** argv) {
     using boost::property_tree::ptree;
     ptree pt;
     read_xml("try.xml", pt);
     ptree::const_iterator end = pt.end();
     for (ptree::const_iterator it = pt.begin(); it != end; it++)
           std::cout << "Here " << it->? << std::endl;
}

Bien, comme je l'ai dit a dit dans la question, je l'ai mentionné, il ya la possibilité d'utiliser des itérateurs sur property_tree en Boost, mais je ne sais pas de quel type il est, et quelles sont les méthodes ou propriétés que je peux utiliser.

Bien, je suppose que ça doit être une autre ptree ou quelque chose qui représente une autre hiérarchie xml être consultée à nouveau (si je veux), mais la documentation à ce sujet est très mauvais. Je ne sais pas pourquoi, mais en boost docs je ne trouve rien de bon, juste quelque chose sur une macro pour parcourir les nœuds, mais cette approche est celle que je voudrais vraiment éviter.

Donc arriver à ma question ici: une Fois l'obtention de l'itérateur sur un ptree, comment puis-je accéder nom du nœud, de la valeur des paramètres (un nœud dans un fichier xml)?
Merci

OriginalL'auteur Andry | 2011-01-04

boost-propertytree c++iterator

18

Je suis d'accord avec Andry, et trouver de la documentation de property_tree être extrêmement minime, à tout le moins. J'avais besoin de ptree pour le chargement d'objets identiques avec des paramètres différents, et avait de la difficulté à déterminer ce que l'itérateur parcourt, le type la retourne, et si oui ou non elle va rester sur les objets de niveau, ou de passer par chaque nœud BFS-comme. Enfin, j'ai réussi à obtenir mon code de travail pour un cas semblable à la suivante:

fichier de paramètres:
```
<object1>
    <enable>true</enable>
    <label>hello</label>
</object1>
<object2>
    <enable>false</enable>
    <label>goodbye</label>
</object2>
```
Tout d'abord, j'ai ajouté un constructeur pour mon objet, qui peut initialiser un ptree. Notez que je suis à l'aide de l'obtenir avec l'option par défaut, pour éviter d'exception sur échec de get()'s:
```
object::object(const boost::property_tree::ptree &pt_)
{
    enable = pt_.get<bool>("enable", true); //usage is: get<type>(path, default)
    label  = pt_.get<std::string>("label", "empty");
}
```
Enfin le code suivant charge à la fois les objets, et les place dans une carte:
```
std::map<std::string, my_object> objects_map;

//parse settings file and add loggers
if(filesystem::exists(logger_settings_file))
{
    boost::property_tree::ptree pt;

    read_xml(logger_settings_file, pt);
    BOOST_FOREACH(boost::property_tree::ptree::value_type &v, pt)
    {
        objects_map[v.first] = my_object(v.second);
    }
}
```
Donc, pour répondre à mes propres questions:
- L'itérateur parcourt le fichier de paramètres, sans descendre dans les niveaux inférieurs. Exécute le code ci-dessus, vous trouverez que itération de la boucle deux fois - une fois pour chaque objet dans le fichier XML.
- L'itérateur renvoie une value_type objet qui ressemble à une paire, et a la first et second accesseurs. v.first est un std::chaîne de caractères contenant le nœud parent (dans mon cas "objet1", "objet2"), et v.second est un boost::property_tree::ptree, qui peut être utilisé pour analyser les champs de l'objet.
Merci bavaza... votre réponse a expliqué une meilleure approche... j'ai bien aimé. Merci
Cheers mate.

OriginalL'auteur bavaza

d'impression complète de l'arbre:

void print(boost::property_tree::ptree const& pt)
{
    using boost::property_tree::ptree;
    ptree::const_iterator end = pt.end();
    for (ptree::const_iterator it = pt.begin(); it != end; ++it) {
        std::cout << it->first << ": " << it->second.get_value<std::string>() << std::endl;
        print(it->second);
    }
}

Salut, j'ai rejeté un anonyme édition sur ce post (changement de code). Vous pouvez check it out pour voir si elle doit être intégrée dans votre réponse.
tnx. C'était bien, donc je l'ai insérée.

OriginalL'auteur Andriy Tylychko

0

Vous devez avoir la connaissance préalable sur l'entrée de la propriété de fichier.

Boost propriété de l'arbre n'est pas un document général de l'analyseur. Il le fera d'analyse et de donner l'accès aux données, mais doit rechercher manuellement.

Je ne sais pas il y a des méthode pour naviguer à travers tout le document, mais si vous avez uniquement besoin les propriétés de votre fichier vous pouvez le faire avec un code très simple.

De la stimuler la documentation:

1) Le fait de lancer la version (get):
```
ptree pt;
/* ... */
float v = pt.get<float>("a.path.to.float.value");
```
2) La valeur par défaut de la valeur de la version de (se):
```
ptree pt;
/* ... */
float v = pt.get("a.path.to.float.value", -1.f);
```
3) La version optionnelle (get_optional):
```
ptree pt;
/* ... */
boost::optional<float> v = pt.get_optional<float>("a.path.to.float.value");
```
OriginalL'auteur 9dan

Vous devez vous connecter pour publier un commentaire.