How to read and write a json with bigint / big decimal ?

[ghost]

Im trying to both read and write a json with big decimal / bigint
but can't get it working. is it supported?

code example (not compiling):

#include "glaze/glaze.hpp"
#include "glaze/json.hpp"
#include "glaze/json/prettify.hpp"
#include <iostream>
#include <boost/multiprecision/cpp_dec_float.hpp>

using boost_decimal_type = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<128>>;


int main() {
  glz::json_t json = {
   {"pi", 3.141},
   {"happy", true},
   {"bigint", boost_decimal_type("1.1234567890123456789012345678901234567")},
   {"nothing", nullptr},
   {"answer", {{"everything", 42.0}}},
   {"list", {1.0, 0.0, 2.0}},
   {"object", {
      {"currency", "USD"},
      {"value", 42.99}
   }}
  };
  std::string buffer{};
  glz::write_json(json, buffer);

  std::cout<<glz::prettify(buffer)<<std::endl;
  return 0;
}

[justend29]

@atheelm I don't believe glaze provides (de)serialization support for those multiprecision types. However, you're free to (de)serialize any type you'd like by providing implementations for to_json/from_json as described in the custom serialization docs.

A quick look through boost::multiprecision seems to indicate these types can be serialized to strings natively. Implementations for to_json/from_json would merely adapt multiprecision's serialization calls to glaze's interface. I believe the options raw & raw_string in glz::opts will be useful here to write 1.234... instead of "1.234...". My apologies, as I don't currently have the time to offer implementations for these, just a quick comment.

[ghost]

thanks @justend29 for you comment, with to_json/from_json I can compile code with boost_decimal_type but it still printed with "" around the number (tried with raw string)

code:

#include "glaze/glaze.hpp"
#include "glaze/json.hpp"
#include "glaze/json/prettify.hpp"
#include <iostream>
#include <boost/multiprecision/cpp_dec_float.hpp>

using boost_decimal_type = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<128>>;

namespace glz::detail
{
   template <>
   struct from_json<boost_decimal_type>
   {
      template <auto Opts>
      static void op(boost_decimal_type& value, auto&&... args)
      {
         std::string dec_str;
         read<json>::op<glz::opts{.raw=true, .raw_string = true}>(dec_str, args...);
         //read<json>::op<opt_true<Opts, &opts::raw_string>>(dec_str, args...);
         value = boost_decimal_type(dec_str);
      }
   };

   template <>
   struct to_json<boost_decimal_type>
   {
      template <auto Opts>
      static void op(boost_decimal_type& value, auto&&... args) noexcept
      {
         //write<json>::op<opt_true<Opts, &opts::raw_string>>(boost::lexical_cast<std::string>(value), args...);
         write<json>::op<glz::opts{.raw=true, .raw_string = true}>(boost::lexical_cast<std::string>(value), args...);
      }
   };
}

int main() {
  boost_decimal_type dec_val("1.123");
  std::string s_json;
  glz::write_json(dec_val, s_json);
  std::cout<<"json: "<<s_json<<std::endl;
  boost_decimal_type dec_val_r;
  glz::read_json(dec_val_r, s_json);
  std::cout<<"pretty: "<<glz::prettify(s_json)<<std::endl;
  std::cout<<"bigdec: "<<dec_val_r<<std::endl;
  return 0;
  }

output:
json: "1.123"
pretty: "1.123"
bigdec: 1.123

with jsoncons lib I can print it as number without quotes which is critical for me

[justend29]

Okay, I thought those new options would be the easiest way to avoid quotes.
What will surely do it is wrapping your serialized result in glz::raw_json_view and writing that. The held contents will be written verbatim without formatting of any kind.