Output multiprecision as a number instead of a string

[eungenue]

There is an example of how to read multiprecision number from a Json.
However, the number is stored as a string (surrounded by quotes) when parsed Json is stored back to string.
Is this expected/consistent? Is there a way to keep values as numbers?

The example below demonstrates the behavior:

#include <jsoncons/json.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>

namespace jsoncons 
{
    template <typename Json,typename Backend>
    struct json_type_traits<Json,boost::multiprecision::number<Backend>>
    {
        using multiprecision_type = boost::multiprecision::number<Backend>;

        static bool is(const Json& val) noexcept
        {
            if (!(val.is_string() && val.semantic_tag() == semantic_tag::bigdec))
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        static multiprecision_type as(const Json& val)
        {
            return multiprecision_type(val.template as<std::string>());
        }

        static Json to_json(multiprecision_type val)
        {
            return Json(val.str(), semantic_tag::bigdec);
        }
    };
}

using namespace jsoncons;

int main()
{
    typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float_50> multiprecision_type;

    std::string s = "[100000000000000000000000000000000.1234]";
    auto options = json_options{}
        .lossless_number(true);
    json j = json::parse(s, options);

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

the output is:

["100000000000000000000000000000000.1234"]

[danielaparker]

Unlike other languages such as Java and C#, which have BigDecimal, C++ doesn't have a standard type for storing arbitrary precision big numbers. So what other type besides a string would we use for internal storage?

We could have our own jsoncons::bigdec type and store it as that, but users of this library needing big numbers are likely to already have their preferred big number type, whether that's
[boost::multiprecision::number]https://www.boost.org/doc/libs/1_83_0/libs/multiprecision/doc/html/index.html), or Bill Seymour's bigdec, or something else. Practically every big number type will have a constructor that creates one from a string, and a to_string function to convert it back to a string, so it's straightforward for users to implement a json_type_traits specialization for their preferred type.

[danielaparker]

Apologies, I think I misunderstood your question!

You can output a string tagged with semantic_tag::bigint or semantic_tag::bigdec with a bigint_chars_format::number option, viz:

    std::string s = "[100000000000000000000000000000000.1234]";
    auto options = json_options{}
        .lossless_number(true)
        .bigint_format(bigint_chars_format::number);
    json j = json::parse(s, options);

    std::cout << print(j,options) << "\n"; // or pretty_print

Output:

[100000000000000000000000000000000.1234]

It's arguable that that should be the default, as you suggest, that would be more consistent. bigint_format and bigint_chars_format would also have been better named bignum_format and bignum_chars_format, I believe they originally applied only to bigint's.

[eungenue]

Yes, I confirm this .bigint_format(bigint_chars_format::number) option works. Thanks for the quick response!