Support non-throwing-style error handling

[bryceschober]

Describe the proposed feature

At least in the context of CBOR and UBJSON support (all of json_ext/*?), the underlying basic_*_reader::read() and decode() functions support a non-throwing std::error_code interface, but then those get turned into exception objects that are either thrown or terminate in the implementations of decode_*().

Instead, providing an alternative interface that returns an std::expected-like object that could contain the value type or an error type that contains the underlying exception information (what()).

What other libraries (C++ or other) have this feature?

See getml/reflect-cpp#429 and reflect-cpp/include/rfl/Result.hpp

Include a code fragment with sample data that illustrates the use of this feature

Intead of the try { ... } catch(e) { ... } logic in getml/reflect-cpp#432, it could run something more like:

auto jsoncons_result = jsoncons::cbor::decode_cbor<jsoncons::json>(_bytes);
if( jsoncons_result ) {
  auto r = Reader();
  return Parser<T, Processors<Ps...>>::read(r, InputVarType{&jsoncons_result.value()});
} else {
  std::string msg("Could not parse CBOR: ");
  msg.append(jsoncons_result.error().what());
  return rfl::error(msg);
}

[danielaparker]

Thanks for the suggestion. It's something we've been thinking about and experimenting with, along with some other improvements to our reflection capabilities. Our current support is pretty widely used, so we'd need to have backwards compatibility. So either we add alternate names for json_type_traits, decode_json, decode_cbor, etc., or we introduce a new namespace,

auto result = jsoncons::cbor::reflect::decode_cbor<jsoncons::json>(_bytes);

Although I think we can unambiguously alias jsoncons::ubjson::reflect, jsoncons::cbor::reflect etc. to jsoncons::reflect, so allow

auto result = jsoncons::reflect::decode_cbor<jsoncons::json>(_bytes);

The macro names can stay the same, they'll simple generate the new jsoncons::reflect::json_type_traits, which can be used with both old and new apis.

[bryceschober]

Sounds great! So that'll take you only a couple hours, right? 😜

[danielaparker]

"until the day God will deign to reveal the future to man, all human wisdom is contained in these two words, 'Wait and Hope'."

-- The Count of Monte Cristo

[danielaparker]

I've moved the code to support this feature to master. Here's an example:

#include <jsoncons/json.hpp>
#include <iostream>
#include <cassert>

namespace {
namespace ns {

struct book
{
    std::string author;
    std::string title;
    double price{0};
};

} // namespace ns
} // namespace

JSONCONS_ALL_MEMBER_TRAITS(ns::book, author, title, price)

int main()
{
    // Parsing error
    {
        std::string input = R"(
{
    "author" : "Haruki Murakami", 
    "title" : "Kafka on the Shore",
    "price" 25.17        
}
        )";

        auto result = jsoncons::try_decode_json<ns::book>(input);
        if (!result)
            std::cout << "(1) " << result.error().message() << "\n\n";
    }

    // Unexpected JSON
    {
        std::string input = R"(["Haruki Murakami", "Kafka on the Shore", 25.17])";

        auto result = jsoncons::try_decode_json<ns::book>(input);
        if (!result)
            std::cout << "(2) " << result.error().message() << "\n\n";
    }

    // Missing required member
    {
        std::string input = R"(
{
    "author" : "Haruki Murakami", 
    "title" : "Kafka on the Shore"        
}
        )";

        auto result = jsoncons::try_decode_json<ns::book>(input);
        if (!result)
            std::cout << "(3) " << result.error().message() << "\n\n";
    }

    // Success
    {
        std::string input = R"(
{
    "author" : "Haruki Murakami", 
    "title" : "Kafka on the Shore",
    "price" : 25.17        
}
        )";

        auto result = jsoncons::try_decode_json<ns::book>(input);
        if (!result)
            std::cout << "(4) " << result.error().message() << "\n\n";
        else
        {
            ns::book& book{*result};
            std::cout << "(4) " << book.author << ", " << book.title << ", " << book.price << "\n\n";
        }
    }
}

Output:

(1) Expected name separator ':' at line 5 and column 13

(2) ns::book: Expected JSON object at line 1 and column 2

(3) ns::book : price: Missing required JSON object member at line 2 and column 2

(4) Haruki Murakami, Kafka on the Shore, 25.17

We've added try_decode_*() functions for json, csv, bson, cbor, msgpack, and ubjson. The exception versions decode_*() are now implemented in terms of the versions that return an std::expected-like result.

We have new traits classes replacing json_type_traits, but they default back to json_type_traits, so any custom traits specializations implemented by users should still work. The macros JSONCONS_ALL_MEMBER_TRAITS etc. generate the new trait specializations. All existing tests pass.

There's still some work needed to improve test coverage and replace some last remaining exception versions of conversion code.

[bryceschober]

Wow!, "Ask you will receive"! I will add an updated non-throwing solution to getml/reflect-cpp/#429 to my backlog.

[bryceschober]

@danielaparker Do you think it might be possible to cut a point release that includes this feature? As mentioned above, I'm working on implementing support for it in a "downstream" library, and until there is a release version that includes it that can be pinned by vcpkg and/or conan users, it probably won't be mergeable. I see that you've been active here working on bigger things, so I'm guessing you're working towards a larger-scope release that is probably further out...

[danielaparker]

I think we're looking at a release in late September.

[danielaparker]

In 1.4.0