Création de tableaux JSON dans Boost en utilisant la Propriété des Arbres

Je suis en train de créer un tableau JSON à l'aide de boost propriété des arbres.

La la documentation dit: "JSON tableaux sont mappés à des nœuds. Chaque élément est un nœud enfant avec un nom vide."

Donc je voudrais créer une propriété de l'arbre avec vide noms, puis d'appeler write_json(...) pour obtenir la matrice de sortie. Toutefois, la documentation n'est pas dis-moi comment faire pour créer sans nom nœuds enfants. J'ai essayé ptree.add_child("", value), mais cela donne:

Assertion `!p.empty() && "Empty path not allowed for put_child."' failed

La documentation ne semble pas aborder ce point, au moins pas de toute façon je peux comprendre. Quelqu'un peut-il aider?

InformationsquelleAutor Chris Stucchio | 2010-01-22

boost boost-propertytree c++json

100

Tableau Simple:

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

ptree pt;
ptree children;
ptree child1, child2, child3;

child1.put("", 1);
child2.put("", 2);
child3.put("", 3);

children.push_back(std::make_pair("", child1));
children.push_back(std::make_pair("", child2));
children.push_back(std::make_pair("", child3));

pt.add_child("MyArray", children);

write_json("test1.json", pt);

résultats dans:

{
    "MyArray":
    [
        "1",
        "2",
        "3"
    ]
}

Tableau sur les Objets:

ptree pt;
ptree children;
ptree child1, child2, child3;


child1.put("childkeyA", 1);
child1.put("childkeyB", 2);

child2.put("childkeyA", 3);
child2.put("childkeyB", 4);

child3.put("childkeyA", 5);
child3.put("childkeyB", 6);

children.push_back(std::make_pair("", child1));
children.push_back(std::make_pair("", child2));
children.push_back(std::make_pair("", child3));

pt.put("testkey", "testvalue");
pt.add_child("MyArray", children);

write_json("test2.json", pt);

résultats dans:

{
    "testkey": "testvalue",
    "MyArray":
    [
        {
            "childkeyA": "1",
            "childkeyB": "2"
        },
        {
            "childkeyA": "3",
            "childkeyB": "4"
        },
        {
            "childkeyA": "5",
            "childkeyB": "6"
        }
    ]
}

espère que cette aide

Veuillez noter que les nombres sont codés comme des chaînes de caractères et non des nombres.
Salut @Luc, je vais avoir ce problème avec les cordes. Comment puis-je encoder comme chiffres?
Je ne pouvais pas trouver une bonne solution lors de l'utilisation de la bibliothèque boost. Je suis passé à rapidjson à la place.
Il y a un tas de restrictions: Vous ne pouvez pas créer des tableaux avec un seul élément, et en répétant le même élément plusieurs fois ne fonctionne pas pour moi non plus.

InformationsquelleAutor JustAnotherLinuxNewbie

20

Ce que vous devez faire est de cette pièce de plaisir. C'est à partir de la mémoire, mais quelque chose comme cela fonctionne pour moi.
```
boost::property_tree::ptree root;
boost::property_tree::ptree child1;
boost::property_tree::ptree child2;

//.. fill in children here with what you want
//...

ptree.push_back( std::make_pair("", child1 ) );
ptree.push_back( std::make_pair("", child2 ) );
```
Mais attention il y a plusieurs bugs dans le json l'analyse et de l'écriture. Plusieurs de qui je l'ai soumis des rapports de bogues pour - avec pas de réponse 🙁

EDIT: à l'adresse de souci, c'sérialisation de manière incorrecte en tant que {"":"","":""}

Cela se produit uniquement lorsque le tableau est l'élément racine. Le coup de pouce ptree écrivain traite tous les éléments racines comme des objets - ne jamais tableaux ou des valeurs. Ceci est causé par la ligne suivante dans boost/propert_tree/detail/json_parser_writer.php
```
else if (indent > 0 && pt.count(Str()) == pt.size())
```
Se débarrasser de la "tiret > 0 &&" permettra d'écrire des tableaux correctement.

Si vous n'aimez pas la façon dont l'espace est produit, vous pouvez utiliser le patch que j'ai fourni ici
- Ce n'est pas le bon. Après dumping en JSON, plutôt que d'obtenir un tableau, j'obtiens ceci: { "": "", "": "" }.
- Mis à jour le poste de réfléchir pourquoi ce qui se passe et comment le résoudre.
- Triste pour signaler qu'il me semble qu'il est encore impossible de créer des tableaux en tant que root éléments dans 1.53.0.
- Vous pouvez également essayer d'appeler l'assistance interne direct, et de faux retrait de la. boost::property_tree::json_parser::write_json_helper(flux, de la racine,1,false);
- Aucune raison pourquoi vous êtes de passage pretty=false là? Il fonctionne, mais la valeur par défaut dans write_json est à-peu-près d'impression.
- c'est un "simple" moyen de sauter l'indentation du code, et d'obtenir de sauter le indenter le code arbitré par la réponse. Avec de jolies=fausse le résultat est plus petit, et il fonctionne. Parce que c'est il y a longtemps, j'attends que avec la version actuelle fonctionner sans cette solution de contournement.
InformationsquelleAutor Michael Anderson
11

Lors du démarrage d'utilisation de la Propriété de l'Arbre pour représenter une structure JSON, j'ai rencontré des problèmes similaires que je n'ai pas de résoudre. Notez aussi qu'à partir de la documentation, de la propriété de l'arbre n'est pas entièrement en charge les informations de type:

JSON valeurs sont mappés à des nœuds contenant la valeur. Cependant, tout type d'information est perdue; les nombres, ainsi que les littéraux "null", "vrai" et "faux" sont simplement transformés en leur la forme d'une chaîne.

Après avoir appris cela, je suis passé à la plus complète JSON mise en œuvre JSON Esprit. Cette bibliothèque utilise Boost Esprit pour le JSON de la grammaire de la mise en œuvre et soutient pleinement JSON y compris les tableaux.

Je vous suggère d'utiliser une variante C++ JSON mise en œuvre.
- Beaucoup de nouvelles bibliothèques depuis que j'ai écrit cette réponse. Voici une belle sur lequel je suis tombé récemment: github.com/nlohmann/json
InformationsquelleAutor Yukiko
6

Dans mon cas, je voulais ajouter un tableau à une plus ou moins arbitraire, de sorte que, à l'instar de Michael réponse, créez un enfant un arbre et de le remplir avec les éléments du tableau:
```
using boost::property_tree::ptree;

ptree targetTree;
ptree arrayChild;
ptree arrayElement;

//add array elements as desired, loop, whatever, for example
for(int i = 0; i < 3; i++)
{
  arrayElement.put_value(i);
  arrayChild.push_back(std::make_pair("",arrayElement))
}
```
Lorsque l'enfant a été rempli, l'utilisation de la put_child() ou add_child() fonction pour ajouter la totalité de l'enfant de l'arbre à l'arbre, comme ça...
```
targetTree.put_child(ptree::path_type("target.path.to.array"),arrayChild)
```
la put_child fonction prend un chemin d'accès et un arbre pour un argument et "la greffe" arrayChild en targetTree

InformationsquelleAutor 2NinerRomeo

De boost 1.60.0, le problème persiste.

Offrant un Python 3 solution de contournement (Gist), qui peut être syscalled juste après boost::property_tree::write_json.

#!/usr/bin/env python3


def lex_leaf(lf: str):
    if lf.isdecimal():
        return int(lf)
    elif lf in ['True', 'true']:
        return True
    elif lf in ['False', 'false']:
        return False
    else:
        try:
            return float(lf)
        except ValueError:
            return lf

def lex_tree(j):
    tj = type(j)
    if tj == dict:
        for k, v in j.items():
            j[k] = lex_tree(v)
    elif tj == list:
        j = [lex_tree(l) for l in j]
    elif tj == str:
        j = lex_leaf(j)
    else:
        j = lex_leaf(j)
    return j


def lex_file(fn: str):
    import json
    with open(fn, "r") as fp:
        ji = json.load(fp)
    jo = lex_tree(ji)
    with open(fn, 'w') as fp:
        json.dump(jo, fp)


if __name__ == '__main__':
    import sys
    lex_file(sys.argv[1])

InformationsquelleAutor Patrizio Bertoni

Vous devez vous connecter pour publier un commentaire.