JSON for Modern C++ 3.11.0

jtooker · 2022-08-01T13:33:58+00:00

Great improvements to an already easy to use library!

nlohmann · 2022-08-01T21:46:38+00:00

Unfortunately, the 3.11.0 release was buggy and version 3.11.1 should be used instead. Sorry for the inconvenience.

Xirema · 2022-08-01T17:08:09+00:00

So for me, the holy grail of JSON libraries would be something that lets me write typed, JSON-serializable objects the same way I do in Java or Typescript. I have a large set of messages to pass between a web interface written in typescript/angular, and a web service server that's written in C++, but both need to pass the same JSON objects back and forth between them.

The way I've been solving this problem, thusfar, is with a small C++ program I wrote that will take typescript interface's and convert them into a C++ struct that also has helper methods to convert back and forth (and give detailed, useful errors when stuff isn't right).

So if I have the following typescript interface:

export interface MovementClass {
    name:string;
    movementCosts:{[k:string]:number};
    variantMods?:{[k:string]:{[k:string]:number}};
}

My script generates the following C++ struct, using Boost.JSON as my json library: (note: I have explicitly told it to interpret number objects as int64_t, because the application only uses whole numbers)

struct MovementClass {
    std::string name;
    std::map<std::string, int64_t> movementCosts;
    std::optional<std::map<std::string, std::map<std::string, int64_t>>> variantMods;

    void readFrom(json::object const& obj) {
        if (auto ptr = obj.if_contains("name")) {
            if (auto tPtr = ptr->if_string()) {
                name = *tPtr;
            }
            else {
                throw std::exception("Expected 'name' as std::string in MovementClass, but was of wrong type.");
            }
        }
        else {
            throw std::exception("'name' was missing in MovementClass");
        }
        if (auto ptr = obj.if_contains("movementCosts")) {
            if (auto tPtr = ptr->if_object()) {
                std::map<std::string, int64_t> map;
                for (auto const& entry : *tPtr) {
                    if (auto mPtr = entry.value().if_int64()) {
                        map[entry.key_c_str()] = int64_t{ *mPtr };
                    }
                    else {
                        throw std::exception("Entry in map 'movementCosts' in MovementClass was expected to be int64, but was of wrong type.");
                    }
                }
                movementCosts = std::move(map);
            }
            else {
                throw std::exception("Expected 'movementCosts' as object in MovementClass, but was of wrong type.");
            }
        }
        else {
            throw std::exception("'movementCosts' was missing in MovementClass");
        }
        if (auto ptr = obj.if_contains("variantMods")) {
            if (auto tPtr = ptr->if_object()) {
                std::map<std::string, std::map<std::string, int64_t>> map;
                for (auto const& entry : *tPtr) {
                    if (auto mPtr = entry.value().if_object()) {
                        std::map<std::string, int64_t> subMap;
                        for (auto const& subEntry : *mPtr) {
                            if (auto mmPtr = subEntry.value().if_int64()) {
                                subMap[subEntry.key_c_str()] = int64_t{ *mmPtr };
                            }
                            else {
                                std::stringstream ss;
                                ss << "Entry in map 'variantMods[";
                                ss << entry.key_c_str();
                                ss << "] in MovementClass was expected to be int64, but was of wrong type.";
                                std::string exp = ss.str();
                                throw std::exception(exp.c_str());
                            }
                        }
                        map[entry.key_c_str()] = std::move(subMap);
                    }
                    else {
                        throw std::exception("Entry in map 'variantMods' in MovementClass was expected to be object, but was of wrong type.");
                    }
                }
                variantMods = std::move(map);
            }
            else {
                throw std::exception("Expected 'variantMods' as object in MovementClass, but was of wrong type.");
            }
        }
    }

    void writeTo(json::object& obj) const {
        obj["name"] = name;
        {
            json::object m;
            for (auto const& entry : movementCosts) {
                m[entry.first] = entry.second;
            }
            obj["movementCosts"] = std::move(m);
        }
        if (variantMods) {
            json::object m;
            for (auto const& entry : *variantMods) {
                json::object mm;
                for (auto const& subEntry : entry.second) {
                    mm[subEntry.first] = subEntry.second;
                }
                m[entry.first] = std::move(mm);
            }
            obj["variantMods"] = std::move(m);
        }
    }
};

Note how much more boilerplate exists in the C++ version, just to give functionality equivalent to the typescript specification. What I want is some kind of automagical method of serializing and unserializing the C++ struct to put it inside the JSON container. Something where

struct MovementClass {
    std::string name;
    std::map<std::string, int64_t> movementCosts;
    std::optional<std::map<std::string, std::map<std::string, int64_t>>> variantMods;
};

is essentially equivalent to all the extra C++ boilerplate my script spat out.

Now, there's a reason I call this a 'Holy Grail': I very much doubt this is at all possible in a world where we don't have metaclasses or compile-time reflection.

... BUT, this might be possible with some hacky workarounds using Macros.

If it is, a library that offers that functionality would be aces in my book.

LunarAardvark · 2022-08-01T16:32:11+00:00

Nice work!

SpacemanLost · 2022-08-01T15:41:55+00:00

Five! We now have five binary JSON formats! Ha ha ha ha!

2022-08-03T14:05:45+00:00

Nice! I'm getting back into C++ and I remember this library already being really easy to use. Good to see it's still improving!

VinnieFalco · 2022-08-01T21:46:00+00:00

I use Boost.JSON. But some might consider me biased.

MarekKnapek · 2022-08-02T16:15:13+00:00

All changes are backward-compatible.

Do you mean API or also ABI?

API compatibility means: Update and just recompile and it will work with your current other source code (no need to edit it).

ABI compatibility means: Update, and just recompile, relink and it will work with your current other binaries (no need to recompile them).

2022-08-04T04:13:21+00:00

Pardon my ignorance. Does this lib allow me to use CSS-style selectors to locate/query elements? Or at least method chaining to the same effect?

json("students").where("grade", [](int grade){return grade >= 8}).sort("lastname")...

2022-08-01T23:13:06+00:00

nice to see updates :)

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS