How to append a custom data field to nlohmann::json object

[Ju1He1]

Hey,
Thx for all your great work. This json library works well for many of our use cases :)

We have created our own Variant which allows converting types to arbitrary other types at run time (not at compile time like std::variant).
(Basically it will throw a bad cast exception if no type conversion can be performed at run time, and our Variant does not depend on a template)
To perform this conversions to arbitrary types our Variant needs to know the actual datatype it's currently containing.

Now I’d like to deserialise a class which contains some std::strings and our variant. The type info is provided a class member.
I have provided proper fo/from_json functions for all classes

///this is our simplified vairant class
class Variant
{
  friend void to_json(nlohmann::json& outputJson, const std::shared_ptr<Variant>& inputData)
  {
    const auto asJsonString = inputData->toJsonString();
    outputJson = nlohmann::json::parse(asJsonString);
  }

  friend void from_json(const nlohmann::json& inputJson, SharedVariantPtr& outputData)
  {
    const std::string strKeyType = "variant_datatype";
    //we need to ensure that inputJson["variant_datatype"] is a string which contains the type
    const auto findItType = inputJson.find(strKeyType);
    if (findItType == inputJson.end())
   {
     throw std::runtime_error("Error: from_json: inputJson does not contain a variant_datatype field");
   }
    const std::string strJsonData = inputJson.dump();
    auto fromString = Variant::fromJsonString(inputJson[strKeyType], strJsonData);
    outputData = fromString;
  }
}

///this is a class containing the variant
class MyClass
{
  public:
  std::string m_foo;
  std::string m_datatype; // (for ex. "string" or "MyCoolDataType")
  std::shared_ptr<Variant> m_pVar;

//to_json() works well
friend void to_json(nlohmann::json& jsonOuputObject, const MyClass& dataInput)
{
  //stright forward 
  jsonOuputObject["m_foo"] = m_foo;
  jsonOuputObject["m_datatype"] = m_datatype;
  if (nullptr == dataInput.m_sptrData)
  {
    jsonOuputObject["m_pVar"] = nullptr;
  }
  else
  {
     jsonOuputObject["m_pVar"] = m_pVar;
  }
  
}
friend void from_json(const nlohmann::json& jsonInputObjext, MyClass& dataOutputObject)
{
  jsonInputObjext.at("m_foo").get_to(dataOutputObject.m_foo);
  jsonInputObjext.at("m_datatype").get_to(dataOutputObject.m_datatype);
  
  //unfortunately Variants from_json() Method does not have access to the parent jsonInputObjext, so i need to copy the datatype to 
  //the subobject 
  auto subObject = jsonInputObjext.at("m_pVar");
   //now here comes the error 
  //this will throw if subObject is not an object (i.e. string or number)
  subObject["variant_datatype"] = dataOutputObject.m_datatype;
  subObject.get_to(dataOutputObject.m_sptrData);
}
};

Unfortunately subObject["variant_datatype"] = dataOutputObject.m_datatype; will throw it subObject is a number or a string.

[json.exception.type_error.305] cannot use operator[] with a string argument with string

Is there any way to pass the custom data type field (m_datatype) to the Variants from_json() method?

I'm using version 3.11.3 of this library.

Thx for your help :)

[gregmarr]

It's because you're writing the datatype in

friend void to_json(nlohmann::json& jsonOuputObject, const MyClass& dataInput)

but trying to read it in

  friend void from_json(const nlohmann::json& inputJson, SharedVariantPtr& outputData)

You need to either put variant_datatype in the Variant class, or do all the loading and saving in the MyClass functions.

You can use a member function in Variant, but you have to create the Variant object in the shared_ptr, call the Variant function yourself passing in the type, and not use the std::shared_ptr<Variant> built-in handling.

[Ju1He1]

Hey Greg. thx for your very fast explaination. Now it makes more sense to me. I have directly converted the stuff within MyClass :)