Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45

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

docs/mkdocs/docs/api/basic_json/number_float_t.md

@@ -55,6 +55,10 @@ This implementation does exactly follow this approach, as it uses double precisi
 smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
 and be serialized to `null`.
 
+During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
+`number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for
+example a double-precision number in a binary format when `number_float_t` is `#!cpp float`.
+
 ### Storage
 
 Floating-point number values are stored directly inside a `basic_json` type.

docs/mkdocs/docs/api/basic_json/number_integer_t.md

@@ -47,8 +47,9 @@ With the default values for `NumberIntegerType` (`std::int64_t`), the default va
 
 When the default type is used, the maximal integer number that can be stored is `9223372036854775807` (INT64_MAX) and
 the minimal integer number that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers that are out of
-range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers
-will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [`number_float_t`](number_float_t.md).
+range will yield over/underflow when used in a constructor. During deserialization (from JSON text or any of the binary
+formats), too large or small integer numbers will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md)
+or [`number_float_t`](number_float_t.md).
 
 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are

docs/mkdocs/docs/api/basic_json/number_unsigned_t.md

@@ -48,8 +48,9 @@ With the default values for `NumberUnsignedType` (`std::uint64_t`), the default
 
 When the default type is used, the maximal integer number that can be stored is `18446744073709551615` (UINT64_MAX) and
 the minimal integer number that can be stored is `0`. Integer numbers that are out of range will yield over/underflow
-when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored
-as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_t.md).
+when used in a constructor. During deserialization (from JSON text or any of the binary formats), too large or small
+integer numbers will automatically be stored as [`number_integer_t`](number_integer_t.md) or
+[`number_float_t`](number_float_t.md).
 
 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are

docs/mkdocs/docs/api/macros/index.md

@@ -58,6 +58,8 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_DISABLE_ENUM_SERIALIZATION**](json_disable_enum_serialization.md) - switch off default serialization/deserialization functions for enums
 - [**JSON_DISABLE_TUPLE_REFERENCE_CONVERSION**](json_disable_tuple_reference_conversion.md) - switch off conversion from a one-element tuple of a JSON reference
 - [**JSON_USE_IMPLICIT_CONVERSIONS**](json_use_implicit_conversions.md) - control implicit conversions
+- [**JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS**](json_use_objects_for_enum_keyed_maps.md) - opt in to storing maps with enum
+  keys as objects
 
 ## Comparison behavior
 

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

@@ -0,0 +1,139 @@
+# JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
+
+```cpp
+#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS /* value */
+```
+
+When defined to `1`, maps whose keys are enums (such as `std::map<E, T>` or `std::unordered_map<E, T>`) are stored as
+JSON objects, using the enum's own conversion for the keys. By default, they are stored as arrays of `[key, value]`
+pairs.
+
+## Default definition
+
+The default value is `0` (disabled — existing behavior is preserved).
+
+```cpp
+#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
+```
+
+## Notes
+
+!!! note "Background"
+
+    JSON object keys are strings, so a map is only stored as an object if its keys can be converted to a string type.
+    Enums are not, even if [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps them to strings, so a
+    map with enum keys becomes an array of `[key, value]` pairs:
+
+    ```json
+    [["stopped", "aa"], ["completed", "bb"]]
+    ```
+
+    With this macro, the same map becomes an object
+    (see [#4378](https://github.com/nlohmann/json/issues/4378)):
+
+    ```json
+    {"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
+    object. For the latter, each key is converted to the enum with its `from_json` function, e.g., the one defined by
+    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md). Data written without the macro can therefore
+    still be read after enabling it.
+
+!!! warning "Keys must serialize to distinct strings"
+
+    Each key is converted with the enum's `to_json` function. If a key is not converted to a string (for instance, an
+    enum without [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md), which is stored as an integer, or an
+    enumerator mapped to `nullptr`), [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) is thrown.
+    If two keys are converted to the same string (for instance, because
+    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps an unlisted enumerator to the first entry),
+    [`type_error.318`](../../home/exceptions.md#jsonexceptiontype_error318) is thrown. In both cases, the target value
+    is not changed.
+
+!!! warning "Opt-in only"
+
+    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no effect.
+
+!!! note "ABI compatibility"
+
+    The value of this macro is encoded in the [namespace](../../features/namespace.md) (tag `_ekmo`), resulting in
+    distinct symbol names. Translation units compiled with and without it can therefore be linked into the same program
+    without One Definition Rule (ODR) violations, but they cannot exchange instances of library types.
+
+## Examples
+
+??? example "Default behavior (macro not defined)"
+
+    Without the macro, a map with enum keys is stored as an array of pairs:
+
+    ```cpp
+    #include <map>
+    #include <nlohmann/json.hpp>
+
+    using json = nlohmann::json;
+
+    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
+
+    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
+        {TS_STOPPED, "stopped"},
+        {TS_RUNNING, "running"},
+        {TS_COMPLETED, "completed"},
+    })
+
+    int main()
+    {
+        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
+
+        json j = m;
+        // j is [["stopped","aa"],["completed","bb"]]
+    }
+    ```
+
+??? example "Objects for enum-keyed maps (macro defined to 1)"
+
+    With the macro, the same map is stored as an object:
+
+    ```cpp
+    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
+    #include <map>
+    #include <nlohmann/json.hpp>
+
+    using json = nlohmann::json;
+
+    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
+
+    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
+        {TS_STOPPED, "stopped"},
+        {TS_RUNNING, "running"},
+        {TS_COMPLETED, "completed"},
+    })
+
+    int main()
+    {
+        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
+
+        json j = m;
+        // j is {"completed":"bb","stopped":"aa"}
+
+        auto m2 = j.get<std::map<TaskState, std::string>>();
+        // m2 == m
+    }
+    ```
+
+## See also
+
+- [Specializing enum conversion](../../features/enum_conversion.md)
+- [**NLOHMANN_JSON_SERIALIZE_ENUM**](nlohmann_json_serialize_enum.md) - serialize/deserialize an enum
+- [**NLOHMANN_JSON_SERIALIZE_ENUM_STRICT**](nlohmann_json_serialize_enum_strict.md) - serialize/deserialize an enum with
+  exceptions
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/macros/nlohmann_json_serialize_enum.md

@@ -41,6 +41,9 @@ inline void from_json(const BasicJsonType& j, type& e);
       conversion. Select this default pair carefully. See example 1 below.
     - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
       list will be returned when converting to or from JSON. See example 2 below.
+    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
+      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
+      with the converted keys. Such maps can be read from both forms.
 
 ## Examples
 
@@ -80,6 +83,7 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](./nlohmann_json_serialize_enum_strict.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
+- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)
 
 ## Version history
 

docs/mkdocs/docs/api/macros/nlohmann_json_serialize_enum_strict.md

@@ -44,6 +44,9 @@ inline void from_json(const BasicJsonType& j, type& e);
       `"enum value out of range for <type>"`.
     - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
       list will be returned when converting to or from JSON. See example 2 below.
+    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
+      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
+      with the converted keys. Such maps can be read from both forms.
 
 ## Examples
 
@@ -99,6 +102,7 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM`](./nlohmann_json_serialize_enum.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
+- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)
 
 ## Version history
 

docs/mkdocs/docs/features/binary_formats/cbor.md

@@ -168,9 +168,9 @@ The library maps CBOR types to JSON value types as follows:
 !!! warning "Negative integer overflow"
 
     CBOR negative integers (major type 1) are decoded as `-1 - n`. If the encoded magnitude `n` is too large for the
-    result to fit into `number_integer_t` (`std::int64_t` by default), parsing fails with a
-    [`parse_error.112`](../../home/exceptions.md#jsonexceptionparse_error112) exception rather than overflowing
-    silently.
+    result to fit into `number_integer_t` (`std::int64_t` by default), the result is stored as `number_float_t`, like
+    a too small integer in JSON text. For example, `-18446744073709551616` (`0x3B` followed by eight `0xFF` bytes) is
+    stored as `-1.8446744073709552e+19`.
 
 !!! warning "Object keys"
 

docs/mkdocs/docs/features/enum_conversion.md

@@ -58,6 +58,23 @@ assert(jPi.get<TaskState>() == TS_INVALID );
     --8<-- "examples/nlohmann_json_serialize_enum.output"
     ```
 
+## Maps with enum keys
+
+By default, maps with enum keys, such as `std::map<TaskState, std::string>`, are stored as arrays of `[key, value]`
+pairs, because JSON object keys must be strings. Define
+[`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) before including the
+library to store them as objects, with the keys converted by the enum's `to_json()` function:
+
+```cpp
+std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
+
+json j = m;
+// default:                                   [["stopped","aa"],["completed","bb"]]
+// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS: {"completed":"bb","stopped":"aa"}
+```
+
+Either form can be read back, with or without the macro.
+
 ## Notes
 
 Just as in [Arbitrary Type Conversions](arbitrary_types.md) above,

docs/mkdocs/docs/features/macros.md

@@ -198,6 +198,13 @@ default.
 
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).
 
+## `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`
+
+When defined to `1`, maps with enum keys (e.g., `std::map<E, T>`) are stored as objects, using the enum's conversion for
+the keys, instead of arrays of `[key, value]` pairs. It is switched off (`0`) by default.
+
+See [full documentation of `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md).
+
 ## `JSON_USE_SIMDUTF`
 
 When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the

docs/mkdocs/docs/features/namespace.md

@@ -21,6 +21,8 @@ The complete default namespace name is derived as follows:
     - [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md) defined non-zero appends `_psp`.
     - [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) defined non-zero appends `_snul`.
     - [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md) defined non-zero appends `_sbu8`.
+    - [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) defined non-zero
+      appends `_ekmo`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
   underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
   below.

docs/mkdocs/docs/features/parsing/error_recovery.md

@@ -75,7 +75,7 @@ If the item is complete, but cannot be passed on as it is, it is replaced, and p
 |---------------------------------------------------------------------|-------------------------|-------------------------------------------------------------------------|
 | tag                                                                 | CBOR                    | ignored                                                                 |
 | simple value other than `false`, `true`, and `null`, like undefined | CBOR                    | `#!json null`                                                           |
-| negative integer below the range of `number_integer_t`              | CBOR                    | the nearest floating-point number                                       |
+| number too large for a custom `number_float_t`, like `float`        | all                     | infinity                                                                |
 | character (`C`) that is not ASCII                                   | BJData, UBJSON          | U+FFFD                                                                  |
 | invalid high-precision number (`H`)                                 | BJData, UBJSON          | the longest valid beginning is kept, as for JSON text, or `#!json null` |
 | high-precision number too large                                     | BJData, UBJSON          | passed as infinity, together with its text                              |

docs/mkdocs/docs/home/exceptions.md

@@ -331,9 +331,6 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
     [json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1
     ```
     ```
-    [json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow
-    ```
-    ```
     [json.exception.parse_error.112] parse error at byte 5: syntax error while parsing BSON document: document size 6 does not match the number of bytes read (5)
     ```
 
@@ -599,6 +596,9 @@ During implicit or explicit value conversion, the JSON type must be compatible w
     [json.exception.type_error.302] type must be string, but is object
     ```
 
+This exception is also thrown with [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)
+if a key of a map with enum keys is not converted to a string, for instance, because the enum is stored as an integer.
+
 ### json.exception.type_error.303
 
 To retrieve a reference to a value stored in a `basic_json` object with `get_ref`, the type of the reference must match the value type. For instance, for a JSON array, the `ReferenceType` must be `array_t &`.
@@ -791,6 +791,19 @@ The dynamic type of the object cannot be represented in the requested serializat
 
     Encapsulate the JSON value in an object. That is, instead of serializing `#!json true`, serialize `#!json {"value": true}`
 
+### json.exception.type_error.318
+
+With [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md), a map with enum
+keys is stored as an object. This exception is thrown if two of its keys are converted to the same string, so one of the
+entries would be lost. This happens, for instance, if [`NLOHMANN_JSON_SERIALIZE_ENUM`](../api/macros/nlohmann_json_serialize_enum.md)
+does not list an enumerator and it is therefore converted like the first listed one.
+
+!!! failure "Example message"
+
+    ```
+    [json.exception.type_error.318] duplicate object key 'red'
+    ```
+
 ## Out of range
 
 This exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for instance, in the case of array indices or nonexisting object keys.
@@ -863,13 +876,18 @@ The JSON Patch operations 'remove' and 'add' cannot be applied to the root eleme
 
 ### json.exception.out_of_range.406
 
-A parsed number could not be stored as without changing it to NaN or INF.
+A parsed number could not be stored without changing it to NaN or INF. For the binary formats, this happens when a
+finite floating-point number does not fit into [`number_float_t`](../api/basic_json/number_float_t.md), for example a
+double-precision number when `number_float_t` is `#!cpp float`.
 
-!!! failure "Example message"
+!!! failure "Example messages"
 
     ```
     number overflow parsing '10E1000'
     ```
+    ```
+    [json.exception.out_of_range.406] syntax error while parsing CBOR value: number overflow
+    ```
 
 ### json.exception.out_of_range.407
 

docs/mkdocs/mkdocs.yml

@@ -314,6 +314,7 @@ nav:
           - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
           - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
           - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
+          - 'JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS': api/macros/json_use_objects_for_enum_keyed_maps.md
           - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
           - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
           - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md