serialize std::variant<...>

[MattiasEppler]

Hi.
I try to serialize std::variant<double,int> to json.
I look for an easy and comfortable way. Is there any solution available?

Or any idea how to do this.

[nlohmann]

This section from the README should help you.

[nlohmann]

@MattiasEppler Do you need further assistance?

[MattiasEppler]

Hi.
I already read this section.

I do it in this way

string value = "";

if(const auto pdouble = std::get_if<double>(&data.Value))
    value = std::to_string(*pdouble);
else if(const auto pint= std::get_if<int>(&data.Value))
    value = std::to_string(*pint);

I thought maybe there is an easier solution.

But if not you can close this issue.

Thanks

[nlohmann]

I'm afraid not - at least I am not aware of a generic way to collect all the possible values from a variant.

[theodelrieu]

You could do something like:

namespace nlohmann {
template <typename ...Args>
struct adl_serializer<std::variant<Args...>> {
  static void to_json(json& j, std::variant<Args...> const& v) {
    std::visit([&](auto&& value) {
      j = std::forward<decltype(value)>(value);
    }, v);
  }
};
}

I don't think it's possible to provide a generic from_json here. Even if we serialize the index, it will be known at runtime, so switching on it would require to write N case, N being sizeof...(Args) - 1...

What I would do is setting the index in the json only when serializing an enclosing type:

struct Example {
  std::variant<int, std::string, float> var;
};

void to_json(json& j, Example const& e) {
  j = {{"index", e.var.index()}, {"variant", e.var}};
}

void from_json(json const&j, Example& e) {
  auto const index = j.at("index").get<int>();
  switch (index) {
    case 0:
      e.var = j.get<int>(); break;
    case 1:
      e.var = j.get<std::string>(); break;
    case 2:
      e.var = j.get<float>(); break;
    default: throw std::runtime_error{""};
  }
}

[theodelrieu]

On a second thought, there might be a way to make it generic, I'll try it out and post the results.

[theodelrieu]

Here is a complete example with the generic variant implementation.

Note that it is far from being efficient, it might be improved with something similar to for_each_args.

#include <iostream>
#include <stdexcept>
#include <string>
#include <variant>

#include <nlohmann/json.hpp>

using json = nlohmann::json;

namespace detail
{
template <std::size_t N>
struct variant_switch
{
  template <typename Variant>
  void operator()(int index, json const &value, Variant &v) const
  {
    if (index == N)
      v = value.get<std::variant_alternative_t<N, Variant>>();
    else
      variant_switch<N - 1>{}(index, value, v);
  }
};

template <>
struct variant_switch<0>
{
  template <typename Variant>
  void operator()(int index, json const &value, Variant &v) const
  {
    if (index == 0)
      v = value.get<std::variant_alternative_t<0, Variant>>();
    else
    {
      throw std::runtime_error(
          "while converting json to variant: invalid index");
    }
  }
};
}

namespace nlohmann
{
template <typename ...Args>
struct adl_serializer<std::variant<Args...>>
{
  static void to_json(json& j, std::variant<Args...> const& v)
  {
    std::visit([&](auto&& value) {
      j["index"] = v.index();
      j["value"] = std::forward<decltype(value)>(value);
    }, v);
  }

  static void from_json(json const& j, std::variant<Args...>& v)
  {
    auto const index = j.at("index").get<int>();
    ::detail::variant_switch<sizeof...(Args) - 1>{}(index, j.at("value"), v);
  }
};
}

struct A
{
  int val;
};

bool operator==(A const& lhs, A const& rhs) noexcept
{
  return lhs.val == rhs.val;
}

bool operator!=(A const& lhs, A const& rhs) noexcept
{
  return !(lhs == rhs);
}

void to_json(json& j, A a)
{
  j["val"] = a.val;
}

void from_json(json const& j, A& a)
{
  a.val = j.at("val").get<int>();
}

int main(int argc, char const *argv[])
{
  std::variant<int, std::string, float, A> v(A{42});

  nlohmann::json j(v);

  auto v2 = j.get<decltype(v)>();
  assert(v == v2);

  std::cout << j.dump(2) << std::endl;
  v = std::string("Hello");
  j = v;
  std::cout << j.dump(2) << std::endl;

  // invalidate the index
  j["index"] = 42;
  try
  {
    auto _ = j.get<decltype(v)>();
  }
  catch (std::runtime_error const& e)
  {
    std::cout << "Caught exception: " << e.what() << std::endl;
  }
}

[MattiasEppler]

Oh.... Thanks a lot for spending your time. I will try it.

[nlohmann]

@MattiasEppler Did you try?

[MattiasEppler]

Hi. Oh sorry.
Yes It works. Thanks to theodelrieu.

Will this be added to nlohmann\json?

[theodelrieu]

Will this be added to nlohmann\json?

I guess we could add it, I'd like users to be able to do the following:

std::variant<int, float, MyType> v(2);

json j = v;
auto i = j.get<int>();
auto v2 = j.get<decltype(v)>();

For this to work, we need to add a library-reserved field in the variant's alternative serialization:

template <typename ...Args>
void to_json(json& j, std::variant<Args...> const& v) {
  std::visit([&](auto const& a) { 
                      j = a;
                    }, v);
  j["__nlohmann_variant_index"] = v.index();
}

template <typename ...Args>
void from_json(json const& j, std::variant<Args...>& v) {
  auto const index = j.at("__nlohmann_variant_index").get<int>();
  // recursive ugliness to get the correct index...
}

[MattiasEppler]

In my case its not necessary to serialize the index.
So maybe it should be possible to set serializeIndex = false.