Keep multimaps with enum keys as arrays of pairs

With JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS, is_enum_keyed_map also matched
std::multimap and std::unordered_multimap. Storing them as objects throws
type_error.318 as soon as a key occurs twice, which is the normal case for
a multimap, so such values could no longer be serialized at all once the
macro was enabled, although they are stored losslessly as arrays of
[key, value] pairs without it.

Exclude maps with non-unique keys from is_enum_keyed_map. They are
detected by insert(value_type) returning an iterator rather than a
pair<iterator, bool>. Map-like types without such an insert() are still
treated as before.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md

@@ -35,6 +35,11 @@ The default value is `0` (disabled — existing behavior is preserved).
     {"completed": "bb", "stopped": "aa"}
     ```
 
+!!! note "Maps with non-unique keys"
+
+    Maps that allow duplicate keys, such as `std::multimap<E, T>` or `std::unordered_multimap<E, T>`, are not affected
+    by the macro and are still stored as arrays of `[key, value]` pairs, as an object cannot hold duplicate keys.
+
 !!! note "Reading"
 
     Reading is not affected by the macro: a map with enum keys can always be read from both an array of pairs and an

include/nlohmann/detail/meta/type_traits.hpp

@@ -400,6 +400,12 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
     : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
 
+template<typename T>
+using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
+
+template<typename T>
+using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
+
 // a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
 // JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 template<typename T, typename = void>
@@ -410,8 +416,12 @@ struct is_enum_keyed_map <
     T, enable_if_t < is_detected<mapped_type_t, T>::value&&
     is_detected<key_type_t, T>::value >>
 {
+    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
+    // are excluded, because an object cannot hold duplicate keys; they are
+    // detected by insert() returning an iterator instead of a pair<iterator, bool>
     // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value;
+    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
+                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
 };
 
 template<typename BasicJsonType, typename ConstructibleObjectType,

single_include/nlohmann/json.hpp

@@ -4421,6 +4421,12 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
     : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
 
+template<typename T>
+using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
+
+template<typename T>
+using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
+
 // a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
 // JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 template<typename T, typename = void>
@@ -4431,8 +4437,12 @@ struct is_enum_keyed_map <
     T, enable_if_t < is_detected<mapped_type_t, T>::value&&
     is_detected<key_type_t, T>::value >>
 {
+    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
+    // are excluded, because an object cannot hold duplicate keys; they are
+    // detected by insert() returning an iterator instead of a pair<iterator, bool>
     // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value;
+    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
+                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
 };
 
 template<typename BasicJsonType, typename ConstructibleObjectType,

tests/src/unit-enum_keyed_maps.cpp

@@ -198,6 +198,14 @@ TEST_CASE("JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS")
         CHECK(json(int_keys) == json::parse("[[1,2]]"));
     }
 
+    SECTION("maps with non-unique keys are still stored as arrays of pairs")
+    {
+        const std::multimap<TaskState, int> mm = {{TS_STOPPED, 1}, {TS_STOPPED, 2}};
+        const std::unordered_multimap<TaskState, int, enum_hash> umm = {{TS_RUNNING, 3}, {TS_RUNNING, 3}};
+        CHECK(json(mm) == json::parse(R"([["stopped",1],["stopped",2]])"));
+        CHECK(json(umm) == json::parse(R"([["running",3],["running",3]])"));
+    }
+
     SECTION("keys that do not serialize to strings")
     {
         const std::map<TaskState, int> null_key = {{TS_INVALID, 1}};