How can I use std::string_view as the json_key to "operator []" ?

[jencoldeng]

//as follow, this will fail as the key_type pof map is std::string_view
std::map<string_view, bool> mv{{"111",true}, {"222", false}, {"333", true}};
nlohmann::json j4{mv};

//another: fail again, the std::string_view is the json_key
nlohmann::json j5;
std::string_view key = "my_key"sv;
j5[key] = 100;

[nlohmann]

The library does not support string views there. Object keys are std::string, so even if you could pass a string view, it would be first converted to a std::string for the lookup.

[jencoldeng]

but I can use string_view in map<std::string, bool>, like this:

std::map<std::string, bool, std::less<>> mp{{"111",true}, {"222", false}, {"333", true}}; //use std::less<>
std::string_view k = "111"sv;
const auto& it = mp.find(k);
cout<second<<endl;

as your json_object is a map type, why can't you do it similarly ?

[jencoldeng]

Maybe some part of your code I have not understand, : )

[nlohmann]

Maybe under the hood, std::map is ready to do the job, but the interfaces of the library mess it up. I need to check. Unfortunately, the library targets C++11, so I cannot do too much for std::string_view being a C++17 feature...

[jencoldeng]

What a pity : )

[nlohmann]

Transparent comparators seem to be a C++14 extension. :/

[nlohmann]

Any idea how to proceed?

[jencoldeng]

See my code, I add a operator[]:

 //by jencol
    template<typename keyT>
    reference operator[](keyT&& key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // at only works for objects
        if (JSON_LIKELY(is_object()))
        {
                        auto it = m_value.object->find(key);
                        if(it == m_value.object->end())
                        {
                                typename std::remove_reference<decltype(*(m_value.object))>::type::key_type _key{key};
                                return (*(m_value.object))[_key];
                        }
                        else
                        {
                                return it->second;
                        }
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
    }

[jencoldeng]

See my code, I add a operator[]:

 //by jencol
    template<typename keyT>
    reference operator[](keyT&& key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // at only works for objects
        if (JSON_LIKELY(is_object()))
        {
                        auto it = m_value.object->find(key);
                        if(it == m_value.object->end())
                        {
                                typename std::remove_reference<decltype(*(m_value.object))>::type::key_type _key{key};
                                return (*(m_value.object))[_key];
                        }
                        else
                        {
                                return it->second;
                        }
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
    }

Of course, it can be faster using std::map::emplace()

[nlohmann]

Wouldn't

reference operator[](std::string_view key)
{
    return operator[](key.data());
}

be already sufficient or is this too naive?

[jencoldeng]

It cannot be this.

when the key is string_view type, map.find(key); and map.find(key.data()); is different.

because a string_view object maybe points to a part of a continuous memory.

[nlohmann]

Looking at your code, you seem to convert the string view in whatever key type the map has? Right? Then it would be:

reference operator[](std::string_view key)
{
    return operator[](std::string(key));
}

[jencoldeng]

yes, exactly.

but my code above can work with cpp11/cpp14/cpp17, the template KeyT can be any type that can convert to key_type (such as std::string), not only for std::string_view. This can be determined at compile time.