[Feature request] Access by path

[SylvainCorlay]

It would be great if there was accessors by path in a JSON object:

for example, if we have a JSON object x containing

{
    "foo": {
        "bar": {
            "value": 1   
        },
        "baz": {
            "value": 3
        }
    }
}

x[{"foo", "baz"}] would return a JSON object containing

{
    "value": 3
}

[SylvainCorlay]

cc @martinRenou

[nlohmann]

What is the difference to x["foo"]["baz"]?

[SylvainCorlay]

What is the difference to x["foo"]["baz"]?

The difference is the unknown number of elements in the sequence.

I guess that we could have an API based on iterator pairs for the sequence, and have the initializer list and container-based version rebind to it.

[SylvainCorlay]

What about an accessor with an iterator pair

JSON.at(first, last)

although the value type for the iterator should be a string / integral, or a variant containing string or some integral type. I guess it is not that simple.

[theodelrieu]

Isn't json_pointer what you're looking for?

[nlohmann]

@theodelrieu is right. JSON Pointers can do this:

#include <iostream>
#include "json.hpp"

using json = nlohmann::json;

int main()
{
    json j = R"({
        "foo": {
            "bar": {
                "value": 1
            },
            "baz": {
                "value": 3
            }
        }
    })"_json;

    std::cout << j["/foo/baz"_json_pointer] << std::endl;
}

[SylvainCorlay]

Thanks! I did not know about this!

[juzzlin]

Stupid question, but how do you use _json_pointer with a string variable instead of a literal?

[sentiment-bot]

Please be sure to review the code of conduct and be respectful of other users. cc/ @nlohmann
Keep in mind, this repository uses the Contributor Covenant.

[nlohmann]

json_pointer is also a class. You can pass a string to create a JSON Pointer.

[juzzlin]

Could you give an example?

I'm trying to do something like this, but I don't understand why it won't compile:

using nlohmann::json;
using nlohmann::json_pointer;

json root;
std::string path = "/foo/bar";
root[json_pointer(path)] = 42;

[nlohmann]

What is the compiler error?

[juzzlin]

This is the first one:

test.cpp:18:25: error: class template argument deduction failed:
   root[json_pointer(path)] = 42;
                         ^

Also:

json.hpp:10459:14: note: candidate: template<class BasicJsonType> json_pointer(const string&)-> nlohmann::json_pointer<BasicJsonType>
     explicit json_pointer(const std::string& s = "")
              ^~~~~~~~~~~~

[juzzlin]

Seems that it just had to be root[json_pointer<std::string>(...). Thanks a lot!

[anirudh582]

#include <iostream>
#include "json.hpp"

using json = nlohmann::ordered_json;

int main()
{
    json j = R"({
        "foo": {
            "bar": {
                "value": 1
            },
            "baz": {
                "value": 3
            }
        }
    })"_json;

    std::cout << j["/foo/baz"_json_pointer] << std::endl;
}

This code prints null. The only difference here is I am using ordered_json instead of json. Is there a way to make this work for ordered_json? Thanks.

[falbrechtskirchinger]

@anirudh582 Works fine here: https://godbolt.org/z/ExaTeeMTd

What version/compiler are you using?

[anirudh582]

I am using version 3.10.5. I checked with the latest version and it is working. Thank you!

[falbrechtskirchinger]

I am using version 3.10.5. I checked with the latest version and it is working. Thank you!

j[json::json_pointer("/foo/baz")] should work in 3.10.5. Due to a bug, your code is equivalent to: j["/foo/baz"] (i.e., the json_pointer is converted to string)

[anirudh582]

j[json::json_pointer("/foo/baz")] should work in 3.10.5. Due to a bug, your code is equivalent to: j["/foo/baz"] (i.e., the json_pointer is converted to string)

I checked this and j[json::json_pointer("/foo/baz")] does indeed work in 3.10.5. Thank you very much!