Using custom types as JSON keys

The JSON specification only allows strings as keys in objects. However, the nlohmann::json library provides a way to use other types as keys by converting them to strings.

To do this, you need to specialize the nlohmann::adl_serializer<T> struct for your type and provide to_json and from_json functions:

1struct Weapon {
2  std::string name;
3  int damage;
4};
5
6namespace nlohmann {
7template <>
8struct adl_serializer<Weapon> {
9  static void to_json(json& j, const Weapon& w) {
10    j = w.name;
11  }
12
13  static void from_json(const json& j, Weapon& w) {
14    w.name = j.get<std::string>();
15    w.damage = 10;
16  }
17};
18}

Here we've defined a Weapon struct. The to_json function converts a Weapon to a JSON string (just its name in this case), and from_json converts a JSON string back to a Weapon (setting a default damage of 10 since that information is lost in the string conversion).

Now we can use Weapon as a key in a JSON object:

1#include <iostream>
2#include <json.hpp>
3using json = nlohmann::json;
4
5struct Weapon {
6  std::string name;
7  int damage;
8};
9
10namespace nlohmann {
11template <>
12struct adl_serializer<Weapon> {
13  static void to_json(json& j, const Weapon& w) {
14    j = w.name; }
15
16  static void from_json(const json& j, Weapon& w) {
17    w.name = j.get<std::string>();
18    w.damage = 10;
19  }
20};
21}
22
23int main() {
24  json character = {
25    {"name", "Lancelot"},
26    {"weapon", {{"name", "Sword"}, {"damage", 20}}},
27    {Weapon{"Dagger", 5}, "backup weapon"}
28  };
29
30  std::cout << character.dump(2);
31}

1{
2  "Dagger": "backup weapon",
3  "name": "Lancelot",
4  "weapon": {
5    "damage": 20,
6    "name": "Sword"
7  }
8}

The Weapon{"Dagger", 5} key was converted to the string "Dagger" in the output JSON.

When using custom types as keys, keep in mind that all the type information is lost in the conversion to string. In this case, the damage property of the "Dagger" key is lost and would be set back to the default of 10 if we were to parse this JSON back into a C++ object.

So while custom type keys are possible, they're not always practical. It's often better to stick with string keys and put the custom types as values in the JSON object.