nlohmann json access nested value by single string - c++

Question

I have a json like :
{
"answer": {
"everything": 42
}
}
Using nlohmann json library in C++, I can access at this nested value like this :
std::cout << my_json["answer"]["everything"];
I'm looking for a way to access it with something like :
std::cout << my_json["answer.everything"];

Answer 1

It won't be possible to implement this with the syntax j["name1.name2"] you used. Many overloads for operators, including the bracket operators () and [] can only be declared inside a class. Furthermore nlohmann::json has already defined the [] operator to work like j["name1"]["name2"]! This means you would have to modify the library in order to achieve this precise syntax. But it seems you are only trying to have an arbitrarily nested Json and be still able to browse through it with a simple input string without necessarily sticking to the square bracket operator.
A simple solution is writing a function get(nlohmann::json, std::string) that takes an nlohmann::json as well as the corresponding dot-separeted names of the form name1.name2.name3 etc. and returns the corresponding value. This can be achieved by splitting the string according to the delimiter and then calling the nlohmann::json[] operator to browse the Json string:
std::vector<std::string> split(std::string const& str, char const delim) noexcept {
std::vector<std::string> res = {};
std::size_t start {0};
std::size_t end {0};
while ((start = str.find_first_not_of(delim, end)) != std::string::npos) {
end = str.find(delim, start);
res.push_back(str.substr(start, end - start));
}
return res;
}
nlohmann::json get(nlohmann::json const& root, std::string const& dot_separated_names) {
std::vector<std::string> const names = split(dot_separated_names, '.');
nlohmann::json const* leaf = &root;
for (auto const& name : names) {
if (leaf->contains(name)) {
leaf = &leaf->at(name);
} else {
// Error handling (e.g. throw error)
std::cerr << "Name '" << name << "' not found!" << std::endl;
}
}
return *leaf;
}
With the functions above you can achieve the desired output with get(j, "name1.name2");.
If you want to be able to set values as well you can similarly write a function set
nlohmann::json& set(nlohmann::json& root, std::string const& dot_separated_names) {
std::vector<std::string> const names = split(dot_separated_names, '.');
nlohmann::json* leaf = &root;
for (auto const& name : names) {
if (leaf->contains(name)) {
leaf = &leaf->at(name);
} else {
// Error handling (e.g. throw error)
std::cerr << "Name '" << name << "' not found!" << std::endl;
}
}
return *leaf;
}
that can be called as set(j, "name1.name2") = "value";. It might be unintuitive to set a value like this so you might want to modify it to something like template <typename T> set(nlohmann::json& root, std::string const& dot_separated_names, T&& value).
Probably it is even better to write this function for std::vector<std::string> instead of std::string and move the splitting of the string to a different routine. This way you can switch delimiter easily and can also browse through a Json just given a vector of names.
If you really wanted to use it as j["name1.name2"] you would have to write your own wrapper class for a nlohmann::json that defines the bracket operator in this way. But in this case you lose a lot of functionality of the wrapped nlohmann::json that you would have to supply by yourself, e.g. the other operators such as << etc.
class YourJsonWrapper {
public:
YourJsonWrapper(nlohmann::json const& j) noexcept
: j{j} {
return;
}
// Your custom bracket operator
nlohmann::json const& operator [] (std::string const& dot_separated_names) const {
// Get implementation (like above)
// ...
}
nlohmann::json& operator [] (std::string const& dot_separated_names) {
// Set implementation (like above)
// ...
}
// Add the other operators you need and forward them to the underlying nlohmann::json
nlohmann::json j; ///< The wrapped nlohmann::json
};
Furthermore - as pointed out in the comments - using dot-separated strings could be problematic as a Json name itself might contain a dot as well. Therefore make sure your Json names can't contain dots by design.