object tree conversion to json?

[jlmxyz]

hello,
I have objects like this

class SolarFieldPower : public std::vector<MonthlyIrradiance>
class MonthlyIrradiance : public std::map<std::u8string_view, Value<double>>
struct Value
{
  T mValue;
  std::u8string_view mUnit;
  std::u8string_view mDesc;
};
class SolarFieldPower : public std::vector<MonthlyIrradiance>

this means

SolarFieldPower
   |-MonthlyIrradiance[0]
   |             |-std::u8string_view
   |             |                 |-mValue
   |             |                 |-mUnit
   |             |                 |-mDesc
   |             |-std::u8string_view
   |             |                 |-mValue
   |             |                 |-mUnit
   |             |                 |-mDesc
.....
   |-MonthlyIrradiance[1]
   |             |-std::u8string_view
   |             |                 |-mValue
   |             |                 |-mUnit
   |             |                 |-mDesc
.....

that I want to convert to/from json
in the doc there is only simple exemple (just key/value) but no "recursive" objects or vector/map based serialization/desieralization....

for example there is https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/#examples

but it's only basic type, strings, int.... no object type....
I tried some stuff, but until couldn't manage to make it works...
can you provide me some example with std::map, std::vector... or more advanced objects?
thanks a lot

[jlmxyz]

I tried to add from/to json serializer,
since IrradianceInformation is a std::map and DailyProfile a std::vector I was hopping that a single cast would suffice... but gcc keeps saying it don't find matching conversion....

class IrradianceInformation : public std::map<std::string, double>
{
public:
  IrradianceInformation ()
  {
    this->insert ({
        { "G(i)", 0.0 }, // Global irradiance on a fixed plan "W/m2"
        { "G(n)", 0.0 }, // Global irradiance on 2-axis tracking plane "W/m2"
        { "Gb(i)", 0.0 }, // Direct irradiance on a fixed plane "W/m2"
        { "Gb(n)", 0.0 }, // Direct normal irradiance "W/m2"
        { "Gcs(i)",
          0.0 }, // Global clear-sky irradiance on a fixed plane "W/m2"
        { "Gcs(n)",
          0.0 }, // Global clear-sky irradiance on 2-axis tracking plane "W/m2"
        { "Gd(i)", 0.0 }, // Diffuse irradiance on a fixed plane "W/m2"
        { "Gd(n)",
          0.0 },          // Diffuse irradiance on 2-axis tracking plane "W/m2"
        { "T2m", 0.0 }, // 2-m air temperature "degree Celsius"
    });
  };

  template <typename BasicJsonType>
  friend void
  to_json (BasicJsonType &nlohmann_json_j, const IrradianceInformation &nlohmann_json_t)
  {
        to_json(nlohmann_json_j, *(static_cast<const std::map<std::string, double>*>(&nlohmann_json_t)));
  }

  template <typename BasicJsonType>
  friend void
  from_json (const BasicJsonType &nlohmann_json_j,
             IrradianceInformation &nlohmann_json_t)
  {
      from_json(nlohmann_json_j, *(static_cast<const std::map<std::string, double>*>(&nlohmann_json_t)));
  }
};

class DailyProfile : public std::vector<IrradianceInformation>
{
public:
  DailyProfile ()
      : std::vector<IrradianceInformation> (24)
  {
  }

    template<typename BasicJsonType>
      friend void to_json(BasicJsonType& nlohmann_json_j, const DailyProfile& nlohmann_json_t)
    {
        to_json(nlohmann_json_j, *(static_cast<const std::vector<IrradianceInformation>*>(&nlohmann_json_t)));
    }

    template<typename BasicJsonType>
    friend void from_json(const BasicJsonType& nlohmann_json_j, DailyProfile& nlohmann_json_t)
    {
      from_json(nlohmann_json_j, *(static_cast<const std::vector<IrradianceInformation>*>(&nlohmann_json_t)));
    }

};

[gregmarr]

Works just fine for me in compiler explorer. FYI, there should be a constraint on the template type. You also don't need to take the address and then dereference, just cast the reference.

https://www.godbolt.org/z/3zfq5ozh3