Adding a stuct to a json object

[ventsyv]

Can I append the content of a struct that's serializable via the NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE macro to a json object?
For example:

struct TestStruct
{
   int field1;
   int field2;
   string someStr;
   std::array<int, 5> myArray;

 TestStruct() : field1(5), field2(10), someStr("Abcd"), myArray() {}
};

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(TestStruct, field1, field2, someStr, myArray)


int main()
{
   nlohmann::json testJson;
   testJson["A"] = "A";
   testJson["B"] = "B";
   
   TestStruct myStruct;
   testJson.push_back(myStruct);

I would expect the output to be:

{
   "A": "A",
   "B": "B",
   "field1": 5,
   "field2": 10,
   "someStr": "Abcd",
    "myArray": [ ]
}

The documentation doesn't make it clear how something like that would work.
The example I gave throws an exception. Using testJson += myStruct; also doesn't work.

[gregmarr]

If you really want those added directly to the existing object like that, you would need to call to_json: to_json(testJson, myStruct).

The push_back that you called in your example is to be called on an array, not an object.
https://json.nlohmann.me/api/basic_json/push_back/

[gistrec]

push_back(myStruct) does not merge object fields. Once you've done testJson["A"] = "A", the json value is an object, and pushing a plain value into an object is not the operation you want; it throws a type_error. += fails for the same reason.

What you want is a merge — update() does exactly this:

testJson["A"] = "A";
testJson["B"] = "B";

TestStruct myStruct;
testJson.update(nlohmann::json(myStruct));

Result:

{
    "A": "A",
    "B": "B",
    "field1": 5,
    "field2": 10,
    "someStr": "Abcd",
    "myArray": [0, 0, 0, 0, 0]
}

update(const json&) constructs a temporary json from myStruct via the to_json produced by your NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE macro, then folds its keys into the receiver. Collisions are overwritten by the right-hand side.

@gregmarr's to_json(testJson, myStruct) works for the same underlying reason — the macro expands to j["field1"] = t.field1; ..., so calling it on an already-populated object adds keys instead of replacing them. update is the more idiomatic call site though, and it generalises to merging two arbitrary json objects, not just struct→object.

(Side note: std::array<int, 5> value-initialises to all-zero, so myArray will render as [0, 0, 0, 0, 0], not [ ] as in your expected output.)