Modifying the DOM of nested arrays of json objects

[WBIGitHub]

This JSON package is most impressive! We are thinking about using it to implement both a persistent file format, and DOM-style access to nested objects.

Is there a canonical method to work with nested objects, for example:

At the top level, an array of FOO, where each element contains an array of BAR, where each BAR itself contains a json object:

FOO:
     FOO1
          BAR1
               SomeJSONObject
          BAR2
                SomeJSONObject
         BARn
     FOO2
          BAR1
                SomeJSONObject
          BAR2
                SomeJSONObject
     FOOn

Clearly, I could create arrays (or stl containers) of all the FOO objects, which each contain the BAR objects, which each contain their JSON. But it might not be necessary if:

1. Is there a method to get the json object of any [FOO][BAR] (where FOO is a unique name, and BAR is a unique name within FOO).

2. If I made a COPY of that json someJSONObject addressed by [FOO][BAR], could I modify the values in that json copy, then re-write (IE REPLACE) it in the [FOO][BAR] of the DOM model?

3. Can entire elements of the FOO array be removed/deleted from the DOM? Similarly, any can specific BAR be deleted from the DOM?

The overall (admittedly unoriginal) idea – which seems like a common pattern – is to read in the JSON from a file, use and modify the SomeJasonObject(s) at the [FOO][BAR] of our choosing (adding, deleting or modifying key/values), even possibly deleting entire sections of [FOO] or individual BAR items, then saving the whole edited JSON back out to file.

[nlohmann]

I don't fully understand your issue, so I try to answer as much as possible:

1. Assuming your value is parsed to a json variable j, then j[FOO][BAR] gives you a reference to the value. For arrays, you need to provide integer indices.
2. The library stores the JSON value in a tree without references: every value can be changed independently. In fact, you can see the library as syntactic sugar around a mix of a std::vector (for arrays) and std::map (for objects).
3. You can erase elements just like in other STL containers, see https://json.nlohmann.me/api/basic_json/erase.

Your overall idea should be possible without any headaches with this library.

[WBIGitHub]

@nlohmann -- This totally worked, and it was even more intuitive than I expected:

FOO is a textual name (in our case a four-character name, like "GIST", or "LOCK", or "RESP". BAR is a number, but it's an ID, not the nth element of the array. So another unique textual name. So neither needed to be an array:

{
    "GIST": {
        "0": {
            "aValue": 1000,
            "aComment": "This is GIST ID 0!"
        },
        "128": {
            "aValue": 1128,
            "aComment": "This is GIST ID 128!"
        }
    },
    "RESP": {
        "0": {
            "aValue": 1000,
            "aComment": "This is RESP ID 0!"
        },
        "130": {
            "aValue": 1000,
            "aComment": "This is RESP ID 130!"
        }
    }
}

YES, I can get a json reference to ["GIST"]["128"]. Or, I can also get a reference to "GIST", then from that json reference get a reference to "128". This has been so easy it's almost criminal!

And YES -- If I assign to a json instead of a json&, I can optionally assign my modified copy back to the original tree ["GIST"]["128"], which does the expected thing of modifying the original tree.

So all is good as I move through my tests. Thank you for creating such an easy-to-use and comprehensive library!

(I've since found the answer to my iteration question -- again more obvious than I expected!)