Like jsonpath::replace, except create?

[ganleynovetta]

I have a vector K of strings. I would like to accomplish this:

j[K[0]][K[1]]...[K[n]] = str

I can't figure out for the life of me how to do this in jsoncons. It doesn't appear that jsonpath::replace works unless the path already exists, and all of my attempts to do it as a loop failed in some way that I can't parse without understanding the jsoncons code better than I do.

Help please?

I'm also trying jsonpatch, which seems like it might be the right solution, but no success so far. Every operation produces "error: JSON Patch add operation failed", but no indication as to why.

It looks like maybe jsonpatch add only works one level deep or something?

[danielaparker]

Yes, the JSONPatch replace operation requires that the target location must exist for the operation to be successful, as specified in RFC 6902.

The jsonpointer extension includes functions add and replace that are consistent with the JSONPatch specification. I agree it would be useful to have alternative functions that will fill in the path. I'll look into adding that.

In the meantime, you can do it as follows:

#include <jsoncons/json.hpp>

using jsoncons::json;

void insert_path(json& j, const std::vector<std::string>& keys, const std::string& str)
{
    json* ptr = &j;

    for (const auto& item : keys)
    {
        auto r = ptr->try_emplace(item, json());
        ptr = &r.first->value();
    }
    *ptr = str;
}

int main()
{
    std::vector<std::string> keys = {"foo","bar","baz"};

    json j;
    insert_path(j, keys, "str");
    std::cout << j << "\n";
}

Output:

{"foo":{"bar":{"baz":"str"}}}

[ganleynovetta]

That worked beautifully, thanks!

I love this library.

[XNinety9]

I was searching for this exact use case's solution, thanks a lot!

[danielaparker]

Just FYI, since 0.162.0, another option is

#include <iostream>
#include <jsoncons/json.hpp>
#include <jsoncons_ext/jsonpointer/jsonpointer.hpp>

using jsoncons::json;
namespace jsonpointer = jsoncons::jsonpointer;

int main()
{
    std::vector<std::string> keys = {"foo","bar","baz"};

    jsonpointer::json_pointer location;
    for (const auto& key : keys)
    {
        location /= key;
    }

    json j;
    jsonpointer::add(j, location, "str", true); // create_if_missing set to true

    std::cout << pretty_print(j) << "\n\n";
}

Output:

{"foo":{"bar":{"baz":"str"}}}

[XNinety9]

It would be awesome if we had jsonpath::add too.

[XNinety9]

I have a very relatable issue. I have a map that looks like this:

std::map<std::string, std::string> m {
    {"$.title", "New item"}
    {"$.content", "You got a new item"},
};

And I would like to transform it to a JSON like:

{
    "title": "New item",
    "content": "You got a new item"
}

[danielaparker]

One way would be to use a filter, e.g.

#include <jsoncons/json.hpp>

class name_fixup_filter : public jsoncons::json_filter
{
public:
    name_fixup_filter(jsoncons::json_visitor& visitor)
        : jsoncons::json_filter(visitor)
    {
    }

private:
    bool visit_key(const string_view_type& name,
        const jsoncons::ser_context& context,
        std::error_code& ec) override
    {
        return this->destination().key(name.substr(2), context, ec);
    }
};

int main()
{
    std::map<std::string, std::string> m{
        {"$.title", "New item"},
        {"$.content", "You got a new item"}
    };
     
    jsoncons::json_stream_encoder encoder(std::cout);
    name_fixup_filter filter(encoder);
    jsoncons::encode_json(m, filter);
}

Output:

{
    "content": "You got a new item",
    "title": "New item"
}

[XNinety9]

Awesome, thanks a lot!
It only supports 1 level of JSON though, as

std::map<std::string, std::string> m {
        {"$.foo.bar", "baz"},
        {"$.title", "New item"},
        {"$.content", "You got a new item"}
};

Is transformed into

{
    "content": "You got a new item", 
    "foo.bar": "baz", 
    "title": "New item"
}

instead of

{
    "content": "You got a new item", 
    "foo" {
        "bar": "baz"
     }, 
    "title": "New item"
}

But for my particular use case, that'll do.

[danielaparker]

Multi level requires a more complicated filter. For example

#include <jsoncons/json.hpp>

class multi_level_filter : public jsoncons::json_filter
{
    std::vector<std::string> keys_;
public:
    multi_level_filter(jsoncons::json_visitor& visitor)
        : jsoncons::json_filter(visitor)
    {
    }

private:
    bool visit_key(const string_view_type& name,
        const jsoncons::ser_context& context,
        std::error_code& ec) override
    {
        std::size_t pos = name.find_first_of(".", 0);
        while (pos != std::string::npos)
        {
            std::size_t pos2 = name.find_first_of(".", pos + 1);
            if (pos2 != std::string::npos)
            {
                keys_.push_back(std::string(name.substr(pos + 1, pos2-(pos+1))));
                pos = pos2;
            }
            else
            {
                keys_.push_back(std::string(name.substr(pos + 1)));
                pos = pos2;
            }

        }
        return true;
    }

    bool visit_string(const string_view_type& s, jsoncons::semantic_tag tag, 
        const jsoncons::ser_context& context, std::error_code& ec) override
    {
        for (std::size_t i = 0; i < keys_.size(); ++i)
        {
            if (i == keys_.size() - 1)
            {
                this->destination().key(keys_[i], context, ec);
                this->destination().string_value(s, tag, context, ec);
            }
            else
            {
                this->destination().key(keys_[i], context, ec);
                this->destination().begin_object(jsoncons::semantic_tag::none, context, ec);
            }
        }
        for (std::size_t i = 1; i < keys_.size(); ++i)
        {
            this->destination().end_object(context, ec);
        }
        keys_.clear();
        return true;
    }

};

int main()
{
    std::map<std::string, std::string> m{
        {"$.foo.bar", "baz"},
        {"$.title", "New item"},
        {"$.content", "You got a new item"}
    };

    jsoncons::json_stream_encoder encoder(std::cout);
    multi_level_filter filter(encoder);
    jsoncons::encode_json(m, filter);
}

produces

{
    "content": "You got a new item",
    "foo": {
        "bar": "baz"
    },
    "title": "New item"
}

Here we save the key fragments, delay outputting them, and produce the hierarchical output when the string value is written.