NLOHMANN_JSON_SERIALIZE_ENUM should not silently choose first value by default

[MHebes]

What is the issue you have?

The automatic enum serialization, per the docs, chooses the first pair in the map if the json value does not map to an enum.

This doesn't make sense for many cases where the enum doesn't include an INVALID option.

It would be useful if there were another macro which throws an exception for invalid values instead.

Please describe the steps to reproduce the issue.

1. Use NLOHMANN_JSON_SERIALIZE_ENUM to generate to_json/from_json methods.
2. Try to deserialize an invalid value.
3. Deserialized value silently falls back to first defined pair.

Can you provide a small but working code example?

#include <iostream>

#include "json.hpp"

using namespace std;
using json = nlohmann::json;

enum class things { a, b, c };

NLOHMANN_JSON_SERIALIZE_ENUM(things, {{things::a, "a"},
                                      {things::b, "b"},
                                      {things::c, "c"}});

int main() {
  things a = json("a");
  things b = json("b");
  things c = json("c");
  things d = json("d");

  cout << json("a").dump(4) << " -> " << int(a) << endl;
  cout << json("b").dump(4) << " -> " << int(b) << endl;
  cout << json("c").dump(4) << " -> " << int(c) << endl;
  cout << json("d").dump(4) << " -> " << int(d) << endl;

  return 0;
}

Output:

"a" -> 0
"b" -> 1
"c" -> 2
"d" -> 0    <-- prefer to throw an exception

What is the expected behavior?

things d = json("d"); should throw an exception.

The existing macro's behavior is fine for certain cases -- I am proposing another macro or option.

And what is the actual behavior instead?

d is silently set to things::a with no way to see that it was an invalid value.

Which compiler and operating system are you using?

• Compiler: Visual Studio 2019
• Operating system: Windows

Which version of the library did you use?

• latest release version 3.9.1
• other release - please state the version: ___
• the develop branch

[MHebes]

I wrote the following macro which does this:

#define SERIALIZE_ENUM_EX(ENUM_TYPE, ...)                                     \
  template <typename BasicJsonType>                                           \
  inline void to_json(BasicJsonType &j, const ENUM_TYPE &e) {                 \
    static_assert(std::is_enum<ENUM_TYPE>::value,                             \
                  #ENUM_TYPE " must be an enum!");                            \
    static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;       \
    auto it = std::find_if(                                                   \
        std::begin(m), std::end(m),                                           \
        [e](const std::pair<ENUM_TYPE, BasicJsonType> &ej_pair) -> bool {     \
          return ej_pair.first == e;                                          \
        });                                                                   \
    if (it == std::end(m)) throw std::invalid_argument("unknown enum value"); \
    j = it->second;                                                           \
  }                                                                           \
  template <typename BasicJsonType>                                           \
  inline void from_json(const BasicJsonType &j, ENUM_TYPE &e) {               \
    static_assert(std::is_enum<ENUM_TYPE>::value,                             \
                  #ENUM_TYPE " must be an enum!");                            \
    static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;       \
    auto it = std::find_if(                                                   \
        std::begin(m), std::end(m),                                           \
        [&j](const std::pair<ENUM_TYPE, BasicJsonType> &ej_pair) -> bool {    \
          return ej_pair.second == j;                                         \
        });                                                                   \
    if (it == std::end(m)) throw std::invalid_argument("unknown json value"); \
    e = it->first;                                                            \
  }

[nlohmann]

Thanks for sharing! As this is a breaking change, I cannot just change the macro. But nice to see an alternative.