Condionally serialize or deserialize JSON

[manuelgavidia]

First, thank you all for this great library.

I am using it to de/serialize data from JSON and up to now it was a regular use case: do it all.

But now I need to do it conditionally based in some data attribute classification. This data is a large nested C++ struct and I need to control if I should do to_json and from_json for each one of my attribute types.

My first approach was to separate each needed combination in different namespaces and explicitly call the dump/parse that I want. It worked for two types of attributes, now I need to do it for three.

My question ... what is the best approach to do it?

More context : my attributes types are for a sofware API and could be classified in: CONFIG, NOCONF, FACTORY_CONFIG

[nlohmann]

In order to asses your issue, we need the following information:

• Please describe the steps to reproduce the issue. Can you provide a small but working code example?

• What is the expected behavior?

• And what is the actual behavior instead?

[manuelgavidia]

• Please describe the steps to reproduce the issue. Can you provide a small but working code example?

#include <nlohmann/json.hpp>
using nlohmann::json;

// noconf_ prefixes attributes that must not be updated via JSON
// factory_ prefixes attributes that must be updated only when an criteria is satisfied

struct Hardware {
  int noconf_temperature = 0;
  bool enabled = false;
  int factory_low_temperature_threshold = -5 ;
  int factory_high_temperature_threshold = 50 ;
};

struct System {
  bool areWeInProduction = false;
  Hardware hw;
};

System mySystem;

namespace config {
  void from_json(const json & j, Hardware & hw) {
    j.at("enabled").get_to<bool>(hw.enabled);
  }
  void to_json(json & j, const Hardware & hw) {
    j["enabled"] = hw.enabled;
  }
}

namespace noconf {
  // there is no from_json(j, hw) for no configurable data
  void to_json(json & j, const Hardware & hw) {
    j["noconf_temperature"] = hw.noconf_temperature;
  }
}

namespace factory {
  void to_json(const json & j, Hardware & hw) {
    j["factory_low_temperature"] = hw.factory_low_temperature_threshold;
    j["factory_high_temperature"] = hw.factory_high_temperature_threshold;
  }
  void from_json(const json & j, Hardware & hw) {
    j.at("factory_low_temperature").get_to<int>(hw.factory_low_temperature_threshold);
    j.at("factory_high_temperature").get_to<int>(hw.factory_high_temperature_threshold);
  }
}

void from_json(const json & j, Hardware & hw) {
  config::from_json(j, hw);

  // How we control the use of factory::from_json with a criteria not present in Hardware class ?
  //   1 - with a global scope condition as we do below?
  //   2 - or somehow we can inject this criteria information in this scope?
  if( not mySystem.areWeInProduction) {
    factory::from_json(j, hw);
  }
}
void to_json(json & j, const Hardware & hw) {
    config::to_json(j, hw);
    noconf::to_json(j, hw);
    factory::to_json(j, hw);
}

• What is the expected behavior?
  I want to be able to decide in runtime what should be deserialize in ::from_json.

• And what is the actual behavior instead?
  There is no clear way to refer in runtime to a condition that controls the use of factory::from_json in ::from_json.

[nlohmann]

I guess there is nothing you can do at this point, because ADL just chooses based on the namespace. What you could do is to have a global variable that you set to the desired configuration and read this in the conversion functions.