Delete by json_pointer

[SimonEbner]

• Describe the feature in as much detail as possible.
  Use json_pointer for erasing keys from json

• Include sample usage where appropriate.

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

int main() {
    auto j = R"({"x": {"y": 1}})"_json;
    nlohmann::json::json_pointer ptr("/x/y");

    std::cout << "Delete by ptr: " << j.erase(ptr) << std::endl;
    std::cout << "j: " << j << std::endl;
}

Actual output:

Delete by ptr: 0
j: {"x":{"y":1}}

Expected output:

Delete by ptr: 1
j: {"x":{}}

[nlohmann]

Right now, the JSON Pointer is converted to a string and the erase function assuming object keys is called. It would be really nice to support JSON Pointers which should be definitely easier than #1194 as we can just return 0 if an element was not found.

[SimonEbner]

@nlohmann If you point me roughly towards some piece of code, I am happy to take a look if I could provide a PR

[timprepscius]

I made a simple version of this. Just copied existing code and added the erase part. There is also a bug with json pointers when they have only a single forward slash.

I will probably eventually create a different json pointer which doesn't vectorize, but instead provide iterator functionality without vectorization. But no time at the moment.

erase_json_pointer.diff.txt

[nlohmann]

@timprepscius Could you open a PR?

[nlohmann]

@timprepscius And: what is the bug with JSON Pointers with a single slash?

[timprepscius]

Will do, will take a few days.

Bug JSON Pointer, make tests involving just "/". Crashes:
The for loop for unraveling the string is complicated, difficult to modify, so I just put in a statement looking for string length 1, after check that 1st character was '/' and returned if true.

[nlohmann]

I cannot reproduce the bug. This code runs fine:

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

using json = nlohmann::json;

int main()
{
    json::json_pointer ptr("/");
    
    json j;
    j[""] = 42;
    
    std::cout << j[ptr] << std::endl;
}

Output: 42.

[timprepscius]

    json j;
    j["sub"] = "value";

    json j2;
    j2.push_back("value");
	
    json::json_pointer psub("/sub");
    json::json_pointer pindex("/0");
    json::json_pointer prootOK("");
    json::json_pointer prootFAIL("/");

    // these are ok
    std::cout << j.dump() << std::endl;
    std::cout << j[psub] << std::endl;
    std::cout << j[prootOK] << std::endl;
    std::cout << j[prootFAIL] << std::endl;

    // prootFAIL fails, should it?
    std::cout << j2.dump() << std::endl;
    std::cout << j2[pindex] << std::endl;
    std::cout << j2[prootOK] << std::endl;
    std::cout << j2[prootFAIL] << std::endl;

prootFAIL fails for arrays. Should it? I don't know. Seems like a bug.

[nlohmann]

The exception states the problem:

[json.exception.parse_error.109] parse error: array index '' is not a number

j2 is an array, and JSON Pointer / (just a slash) means accessing a JSON object at key "" (empty string) which would be equivalent to j2[""]. The error message states that the value after the slash must be a number, because we are accessing values of an array. As the empty string is not a number, the exception is thrown.

tl;dr: The library is correct to throw an exception in this case.

[timprepscius]

Hmmm. My intuition says something is still wrong, but not in the way I thought. Maybe wrong is not the right word.

If I have:

json j;
j["hi"] = "there";
std::cout << j << std::endl;
std::cout << j["wrong"] << std::endl;
std::cout << j << std::endl;

It seems to me that this should create an exception- not create the key "wrong" with a null value.
But I have a feeling that this change would be extremely difficult, perhaps impossible to do.

[timprepscius]

Any how, has no practical impact on my side, I will make a work around to avoid this scenario, change my understanding of "root" to only be "" not "/"

[nlohmann]

This is the default behavior of operator[] for non-const values. The same code with a std::map:

std::map<std::string, std::string> j;
j["hi"] = "there";
std::cout << j.size() << std::endl;
std::cout << j["wrong"] << std::endl;
std::cout << j.size() << std::endl;

The semantics of operator[] is to add a default value for the given key if it does not exist before returning a reference to that value.

As for the JSON Pointer /: This is part of an example in RFC6901.

[timprepscius]

Yeah. Not my favorite part of the operator[] of map either.

[gregmarr]

If std::map didn't do this, then you couldn't do j["hi"] = "there"; either.