Assigning reference to nlohmann::json object inside a function

[AitorMonreal]

Hello everyone,

I'm attempting to iteratively / step-wise build up a nlohmann::json object with multiple hierarchies, the following being a simple example of the final desired output:

{
    "test": {
        "sub-test": "value"
    }
}

I have tried to achieve this through two functions, one to add a new hierarchy level containing an empty object ("test in the example above), and another to write a "leaf" containing a key and a specific value ("sub-test": "value" int he example above). I'm having issues adding a new hierarchy level and retrieving a reference to it. My initial idea was to create an empty nlohmann::json object outside of the function, pass it by reference to the function, and make it reference to the newly created empty object inside the function, like so:

nlohmann::json parent;
nlohmann::json child;
emplaceGroupToMetadata(parent, "test", child);
emplaceValueToMetadata(child, "sub-test", "value");

void emplaceGroupToMetadata(nlohmann::json& parent, const std::string& key, nlohmann::json& groupRef) {
        try {
            auto it = parent.emplace(key, nlohmann::json::object());
            if( ! it.second ) {
                // fail
            }
            groupRef = parent[key];
//            also tried:
//            groupRef = it.first.value();
//            groupRef = std::ref(parent[key]);
        } catch (const nlohmann::json::exception& e) {
            // fail
        }
    }

 template <typename T>
 void emplaceValueToMetadata(nlohmann::json& parent, const std::string& key, const T& value) {
        try {
            auto it = parent.emplace(key, value);
            if( ! it.second ) {
                // fail
            }
        } catch (const nlohmann::json::exception& e) {
            // fail
        }
    }

Where parent should hold the final desired output at the end. This didn't work, as child seemed to be a copy to parent[key], instead of holding a reference, so I would end up with parent being equal to:

{
    "test": {}
}

and independently child being equal to:

{
    "sub-test": "value"
}

I then tried the following, which worked, but I don't understand why the above did not:

nlohmann::json parent;
nlohmann::json& child = emplaceGroupToMetadata(parent, "test");
emplaceValueToMetadata(child, "sub-test", "value");

nlohmann::json& emplaceGroupToMetadata(nlohmann::json& parent, const std::string& key) {
        try {
            auto it = parent.emplace(key, nlohmann::json::object());
            if( ! it.second ) {
                // fail
            }
            return parent[key];
        } catch (const nlohmann::json::exception& e) {
            // fail
        }
    }

 template <typename T>
 void emplaceValueToMetadata(nlohmann::json& parent, const std::string& key, const T& value) {
        try {
            auto it = parent.emplace(key, value);
            if( ! it.second ) {
                // fail
            }
        } catch (const nlohmann::json::exception& e) {
            // fail
        }
    }

I would be very happy to receive any feedback on my code, but most importantly on why the first solution may not be working and how I could get it to work. Could it have to do with internal nlohmann::json move semantics? Or am I missing something?

Thank you very much in advance, I hope my question was clear enough.

[nomadwolf0]

In your first attempt, 'child' is an object on the stack of the first, while parent[key] is constructed elsewhere (on the heap). There is no way to 'reseat' child to the location of parent[key].
In your second version, child is constructed to reference that parent[key] location on the heap. Recall that a reference is essentially a pointer with the limitation that it can't be nullptr nor can it be changed to point somewhere else.

There are ways to make the first way work, but they're generally ugly. The 2nd is better. Generally you prefer to return values (and especially references!) through the function return rather than through parameters.

[AitorMonreal]

Yes, you're completely right. And there is no easy way to assign a reference directly to parent[key] to groupRef instead of making a copy of parent[key]?

[nomadwolf0]

You'd need to work with pointers to accomplish that sort of thing.

[AitorMonreal]

Ok, that makes sense then. And may I ask then, what would the behaviour of the following two be (I understand that they would still not achieve the desired outcome, but I don't fully understand why, in the case of the get_ref because I don't actually understand what it's supposed to be used for).

 groupRef = std::move(parent[key]);

groupRef = parent[key].get_ref<nlohmann::json::object_t&>();

Thank you very much for the help by the way.

[nomadwolf0]

Unless I'm missing something, basic_json doesn't have a move assignment operator, so the first does the same as if you didn't use std::move().
get_ref() gives you direct access to the object_t and allows you to make changes to it, but just assigning that to groupRef will just create a copy of it.

[AitorMonreal]

Understood. Again, thank you very much for your time and patience. I'll close this now. Thanks!