How to use nlohmann::ordered_json with to_json?

[ashleyzhang216]

Hi, I was using nlohmann::basic_json and was trying to prevent alphabetical reordering of my keys during construction of a json object using to_json() and found nlohmann::ordered_json, but haven't gotten it to work. My issue is similar to that of #2361, but in my case, it compiles and runs fine except for the runtime output. I tried following the steps here and here but to no avail.

For the latter, I commented out the macro in cw_timetracker_data_types.h because of the following note in the docs page, but the issue persisted:

The macros only work for the nlohmann::json type; other specializations such as nlohmann::ordered_json are currently unsupported.

For context, I'm working on a timetracker object which stores details about the execution tree. I have a basic version working, but currently, the key children is listed first. Since children can contain many elements, this made debugging the json output tricky and I'd like to move it to be the last key.

cw_timetracker_data_types.h:

...
using ordered_json = nlohmann::ordered_json;

NLOHMANN_JSON_SERIALIZE_ENUM( ts_type_t, {
    {TS_CSP_INITIALIZE,        "Initialize"},
    ...
})
...

cw_timetracker.h:

#include "cw_timetracker_data_types.h"
...
namespace cw_timetracker_ns {
    struct cw_timestep {
        // basic constructor, starts timestep measurement
        cw_timestep(ts_type_t type, string name, uint id, shared_ptr<cw_timestep> prev);

        // ends timestep measurement
        void resolve(uint expected_id, const optional<string>& r);

        // returns true iff timestep has been resolved
        bool resolved() { return end.has_value(); }

        // type of this timestep
        ts_type_t type;

        // description of this timestep
        string name;

        // id of this timestep, for invariant validation
        uint id;

        // parent step that this step is nested in and is a subset of, or this step is the root step if null
        weak_ptr<cw_timestep> prev;

        // timestamp right before this step started
        time_point<high_resolution_clock> start; 

        // child timesteps nested in, or happened during, this timestep
        vector<shared_ptr<cw_timestep> > children;

        // timestamp right after this step ended, if finished
        optional<time_point<high_resolution_clock>> end; 

        // context as to how or why this timestep ended
        optional<string> result;
    }; // cw_timestep

    class cw_timetracker : public common_parent {
        public:
            // start new timestep
            uint start_timestep(ts_type_t type, string name);
            
            // end previous timestep
            void end_timestep(uint id, const optional<string>& result);

            // write results into JSON file and resolves root timestep
            void save_results(string filepath);

            // basic constructor, initializes root timestep
            cw_timetracker(string init_name, bool enabled);        

        private:
            // whether this object should do anything at all
            bool enabled;

            // next id to assign, for invariant checking
            uint next_id;

            // root of whole execution tree
            shared_ptr<cw_timestep> root;

            // node of current deepest unresolved timestep
            shared_ptr<cw_timestep> cur;
    }; // cw_timetracker

    // conversion from cw_timestep to json
    void to_json(ordered_json& j, const shared_ptr<cw_timestep>& step); 
    ...
} // cw_timetracker_ns

cw_timetracker.cpp:

#include "cw_timetracker.h"
...
void cw_timetracker::save_results(const string& filepath) {
    if(enabled) {
        assert(root);
        assert(root == cur);
        assert(!root->resolved());
        end_timestep(0, std::nullopt);

        ordered_json j = root;
        std::ofstream file(filepath);
        file << std::setw(4) << j << endl;
    }
}

void cw_timetracker_ns::to_json(ordered_json& j, const shared_ptr<cw_timestep>& step) {
    assert(step->end.has_value());
    j["type"] = step->type;
    j["name"] = step->name;
    j["result"] = step->result.value_or("");
    j["duration_us"] = std::chrono::duration_cast<std::chrono::microseconds>(step->end.value() - step->start).count();
    j["children"] = step->children;
}
...

Example desired output:

{
"type": "Try Assign",
"name": "admit",
"result": "fail ac3",
"duration_us": 82364,
"children": [
    {
        "type": "AC3",
        "name": "",
        "result": "fail",
        "duration_us": 82363,
        "children": [
            {
                "type": "Undo AC3",
                "name": "",
                "result": "",
                "duration_us": 30904,
                "children": []
            }
        ]
    }
]
}

Example actual output:

{
"children": [
    {
        "children": [
            {
                "children": [],
                "duration_us": 30904,
                "name": "",
                "result": "",
                "type": "Undo AC3"
            }
        ],
        "duration_us": 82363,
        "name": "",
        "result": "fail",
        "type": "AC3"
    }
],
"duration_us": 82364,
"name": "admit",
"result": "fail ac3",
"type": "Try Assign"
}

Thank you very much in advance.

[gregmarr]

Both of these are producing output in the expected order. Are you sure that you're quoting the relevant code here?

    std::cout << j.dump(4);

    std::stringstream file;
    file << std::setw(4) << j << std::endl;
    std::cout << file.str() << std::endl;

https://godbolt.org/z/o5hPM7879

[ashleyzhang216]

Ah, this is an anticlimactic resolution: after investigating some more, looks like the code was working correctly this entire time. What had happened was that my text editor cached an old version since I was writing to the same output filename each time. When I would open the file, it showed me the old version instead of reading the new contents. cat'ing the file displayed the right result, and restarting my text editor fixed the issue entirely.

Thank you for your help!

[gregmarr]

Wow, weird.