Add support for json::string to std::string_view conversion

[elegracer]

When I'm using Boost.JSON along with Boost.Beast, it's common to parse a json frame from a remote http/websocket server and do some processing with it.

A typical scenario is, I need to pass a json::string to a function where a std::string_view is expected.

I can use standalone Boost.JSON with macro BOOST_JSON_STANDALONE to replace boost::string_view with std::string_view. But since I also need Boost.Beast, mixing Boost and standalone Boost.JSON would result in a lot of "macro redefinition" error.

So now I have to tediously do the conversion like this everytime

void process_sv(std::string_view sv);

auto j_str = j_v.as_string();
auto j_sv = std::string_view(j_str.data(), j_str.size());

process_sv(j_sv);

It would make it much more convenient if a direct conversion from json::string to std::string_view is available.

Thank you!

[elegracer]

Much better if in non-standalone Boost.JSON, json::parse() is able to receive a std::string_view.

[saurik]

I'd also really love some easy way to get std::string from boost::json::string (maybe .str() or something).

[vinniefalco]

Could this be done by adding json::string::operator string_view() ? Could this allow passing to functions which accept std::string and would it create implicit conversion / ambiguous conversion problems? We could check for the availability of the string_view header and make it conditional.

[saurik]

Oh! I had somehow never looked into how std::string is created from std::string_view: FWIW, assuming the (explicit) templated constructor on std::string that uses std::is_convertible (to check if the arbitrary argument can be converted to an std::string_view) would apply if you added this new operator (which I presume it would), it seems like the usage through to std::string would be as easy as it currently is directly from std::string_view (which is only as easy as is likely appropriate ;P); had I understood that, I wouldn't have suggested .str().

[grisumbras]

If we add a conversion operator to std::string_view we'd automatically get implicit conversion to std::string. The thing is, we already have this conversion in standalone mode. We can try providing it non-standalone mode when std::string_view is avaliable.

[grisumbras]

IMO, it would have been great if boost::string_view simply provided that conversion operator itself, but AFAIK this is not going to happen.

[saurik]

FWIW, I am not using standalone mode as I am using a lot of other parts of boost (particularly asio and beast); but using boost shouldn't opt me entirely out of being able to easily use libraries that use std::string ;P. (Also: if boost::string_view had an operator to implicit cast to std::string_view, it wouldn't actually help either the people who want to use json::string with std::string APIs or std::string_view APIs, as that would involve a two-level indirect conversion; it in fact does have an explicit cast operator for std::string, but to even get to use it I first have to .operator boost::string_view(), which seems excessive since I still have to explicit std::string().)

[vinniefalco]

Yes I agree we need to make it Just Work, somehow.

[Mike-Devel]

Personal opinion: Implicit conversion to std::string_view (when available) is a must have for any custom string type ( As pointed out by saurik, going through boost::string_view isn't good enough, even if it was supported) .

For everything else, I prefer explicit conversion memberfunctions (.to_std_str()) instead of conversion operators EDIT: in particular, if there is the "danger" of allocation.

[grisumbras]

Can you explain why would it not solve the issue, if boost::string_view had an implicit conversion operator to std::string_view?

[saurik]

@grisumbras C++ doesn't attempt to follow multiple indirect conversion operators (for reasonable reasons), so it wouldn't actually do anything: you have a boost::json::string and you want to get to an std::string_view, but there is no direct implicit conversion from json::string to std::string_view, so you would have to manually perform one of the casts (which is not at all much better than what you currently have).

[Mike-Devel]

A minimal example demonstrating this: https://godbolt.org/z/Pj1xxfvTh

[grisumbras]

Sorry, my bad. Somehow that completely escaped me. So, in the end, operator std::string_view in boost::string_view would not have simplified this conversion much. Meanwhile, operator std::string_view in json::string would allow implicit conversion to std::string_view and explicit conversion to std::string (although, only with C++17 standard library).

json::string  jv = "foobar";
foo(std::string(jv))

Is this good enough?

[grisumbras]

BTW, @elegracer, the "macro redefinition" error you had most likely had been already solved and standalone JSON should work alongside Boost. The fix is now not only in develop and master, but also in the latest Boost release. You can try it while we are deciding on the best way to handle this issue in non-standalone mode.