How to deserialize array with derived objects

[MattiasEppler]

Hi

I need to deserialize a array that have derived objects.

{
 "systems":
  [ 
     {"type": "system1", "name": "system_1"  special_param_1 : 1 },
     {"type": "system2", "name": "system_2", special_param_2 : "Value2" },
     {"type": "system3", "name": "system_3", special_param_3 : 3.0, special_param_3_1 : "Value_3"  }
  ]
}

so in my from_json I have to do what? Sorry but I do not realy know how to solve this.
I started with:

void from_json(cons json& j, settings& settings)
{
   settings.systems = j.at("systems").get<vector<systembase>>();
   ??
}

void from_json(cons json& j, systembase& base)
{
  base.type =j.at["type"].get<string>();
  base.name =j.at["name"].get<string>();

  switch (base.type)
  {
   case :
   ...? 
  }
}

void from_json(cons json& j, systemderived_1& derived)
{
 derived = j.at["special_param_1"].get<int>();
}

[nlohmann]

I am not sure what you want to do exactly, but this may be helpful:

#include <iostream>
#include <fstream>
#include <array>
#include "json.hpp"

using json = nlohmann::json;

class systembase
{
  public:
    std::string type;
    std::string name;
};

void from_json(const json& j, systembase& sb) {
    sb.type = j.at("type");
    sb.name = j.at("name");
}

class settings {
  public:
    std::vector<systembase> systems;
};

void from_json(const json& j, settings& s) {
    const json& sj = j.at("systems");
    s.systems.resize(sj.size());
    std::copy(sj.begin(), sj.end(), s.systems.begin());
}


int main() {
    std::string text = R"(

    {
        "systems": [
        {
            "type": "system1",
            "name": "system_1",
            "special_param_1": 1
        },
        {
            "type": "system2",
            "name": "system_2",
            "special_param_2": "Value2"
        },
        {
            "type": "system3",
            "name": "system_3",
            "special_param_3": 3.0,
            "special_param_3_1": "Value_3"
        }
        ]
    }
    )";

    json j = json::parse(text);
    settings s = j;
}

[MattiasEppler]

Than I have only deserilized the systembaseclass with parameter type and name. But I have not deserialized the derived classes with the special parameter

I solved it now in this way

void from_json(const json& j, shared_ptr<systembase>& sb)
{
	// used Better_Enum 
       const auto type = SystemType::_from_string_nocase(j.at("type").get<string>().c_str());
		
	switch (type)
	{
		case SystemType::Derived1:
			sb= j.get<shared_ptr<systemderived_1>>();
			break;

		case SystemType::Derived2:
			sb= j.get<shared_ptr<systemderived_2>>();
			break;
		
		default: ;
	}
	sb->type = type;
	sb->name = j.at("name").get<string>();
}

void from_json(const json& j, shared_ptr<systemderived_1>& sd) 
{
	sd= make_shared<systemderived_1>();
	sd->special_param_1= j.at("special_param_1").get<int>();
}

[nlohmann]

Thanks for checking back!

[MattiasEppler]

Hi... you closed... ok so you also the opinion thats the best/only solution?

[nlohmann]

I have no real opinion on this. If it works for you, then it's OK. If not, are there issues left?

[theodelrieu]

Looks good to me.

[MattiasEppler]

I think its not possible to determine the type of derived class automaticaly. So the way with the switch was the only solution for me.

[MattiasEppler]

The to_json method for the sake of completeness

void to_json(json& j, const shared_ptr<systembase>& sb)
{		
	switch (sb->type)
	{
		case SystemType::Derived1:
			j = json(dynamic_pointer_cast<systemderived_1>(sb));
			break;
		case SystemType::Derived2:
			j = json(dynamic_pointer_cast<systemderived_2>(sb));
			break;			
		default: ;
	}
	j["type"] = metaData->type._to_string();
	j["name"] = metaData->name;
}

void to_json(json& j, const shared_ptr<systemderived_1>& sd)
{
	j = json
	{
		{ "special_param_1", sd->special_param_1}
	};
}

void to_json(json& j, const shared_ptr<systemderived_2>& sd)
{
	j = json
	{
		{ "special_param_2", sd->special_param_2}
	};
}

[cwreynolds]

Sorry if I am reopening a can of worms…

I have a similar issue, a base class, and two derived classes. The base class handles the bulk of the serialization, and the derived classes have some unique properties which also need to be serialized. The difference in perspective is that there will be more derived classes down the road, which might include “user defined” classes. Generally it would be messy for the base class to have to know about all the potential derived classes (e.g. in a big switch statement as in MattiasEppler’s to_json example above).

I already have a solution to the basic functionality I need. I define a virtual function on the base class (virtual void serializeToJson(nlohmann::json& j);) and override that in the derived classes. (The overrides calls the base class method then do their specialize stuff.) This is fine, but does not provide the nice syntax that I could get from using the standard to_json() interface.

So I am not stuck, but it would be more convenient if I could use to_json() and treat it as a virtual function I could override. In the meantime I will continue to use my ad hoc interface.

[nlohmann]

@theodelrieu to the rescue...