Document new Xcode and GCC versions in the supported compilers table

Versions taken from the CI logs of this PR (Xcode 26.1.1-26.6) and from the gcc:16 image (same digest as gcc:16.2.0 and gcc:latest). Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Replace retired macOS 14 runner and test all available Xcode versions
2026-10-05 14:10:31 +00:00 · 2026-10-05 07:45:19 +02:00 · 2026-10-04 18:10:59 +02:00 · 2026-10-04 17:54:05 +02:00 · 2026-10-04 17:53:29 +02:00
182 changed files with 10267 additions and 13027 deletions
@@ -45,23 +45,6 @@ labels:
 - label: "aspect: binary formats"
  title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|bon8|binary format)"
 - label: "aspect: json_view"
  files:
    - "include/nlohmann/json_view\\.hpp"
    - "include/nlohmann/detail/view/.*"
    - "single_include/nlohmann/json_view\\.hpp"
    - "tests/src/unit-json_view.*"
    - "tests/src/fuzzer-parse_json_view\\.cpp"
    - "tools/amalgamate/config_json_view\\.json"
    - "docs/mkdocs/docs/features/json_view\\.md"
    - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
    - "docs/mkdocs/docs/api/(ordered_)?json_(document|view)\\.md"
    - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(document|view)).*"
    - "tests/benchmarks/src/benchmarks_view\\.cpp"
 - label: "aspect: json_view"
  title: "(?i)(json_view|json_document|zero-copy)"
 - label: "python"
  files:
    - "\\.py$"
@@ -118,15 +118,12 @@ jobs:
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
          cp include/nlohmann/json_literals.hpp $INCLUDE_DIR/json_literals.hpp
          # the configuration of json_view.hpp comes with the pull request until
          # it is on develop; the tool itself is still develop's
          python3 $TOOL_DIR/amalgamate.py -c $MAIN_DIR/tools/amalgamate/config_json_view.json -s .
          # the header list of the Bazel "json" target must match the files in include/
          cmake -P cmake/scripts/gen_bazel_build_file.cmake
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
-            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp $INCLUDE_DIR/json_view.hpp
+            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp
          # fail loudly if a directory is renamed or removed: find would only warn
          # about the missing path and silently drop its files from the check
@@ -17,11 +17,11 @@ permissions:
  contents: read
 jobs:
-  macos-14:
+  macos-15:
-    runs-on: macos-14 # https://github.com/actions/runner-images/blob/main/images/macos/macos-14-Readme.md
+    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
    strategy:
      matrix:
-        xcode: ['15.0.1', '15.1', '15.2', '15.3', '15.4']
+        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1', '26.1.1', '26.2', '26.3']
    env:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
@@ -36,11 +36,11 @@ jobs:
      - name: Test
        run: cd build ; ctest -j 10 --output-on-failure
-  macos-15:
+  macos-26:
-    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
+    runs-on: macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-arm64-Readme.md
    strategy:
      matrix:
-        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1']
+        xcode: ['26.4.1', '26.5', '26.6']
    env:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
@@ -209,7 +209,7 @@ jobs:
    strategy:
      matrix:
        # older GCC docker images (4, 5, 6) fail to check out code
-        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
+        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', '16', 'latest']
    container: gcc:${{ matrix.compiler }}
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -20,7 +20,6 @@ cc_library(
    hdrs = [
        "include/nlohmann/adl_serializer.hpp",
        "include/nlohmann/byte_container_with_subtype.hpp",
        "include/nlohmann/detail/abi_config.hpp",
        "include/nlohmann/detail/abi_macros.hpp",
        "include/nlohmann/detail/bit_ops.hpp",
        "include/nlohmann/detail/conversions/from_json.hpp",
@@ -66,21 +65,9 @@ cc_library(
        "include/nlohmann/detail/string_escape.hpp",
        "include/nlohmann/detail/string_utils.hpp",
        "include/nlohmann/detail/value_t.hpp",
        "include/nlohmann/detail/view/builder.hpp",
        "include/nlohmann/detail/view/document_data.hpp",
        "include/nlohmann/detail/view/errors.hpp",
        "include/nlohmann/detail/view/input.hpp",
        "include/nlohmann/detail/view/macro_scope.hpp",
        "include/nlohmann/detail/view/macro_unscope.hpp",
        "include/nlohmann/detail/view/materialize.hpp",
        "include/nlohmann/detail/view/node.hpp",
        "include/nlohmann/detail/view/number.hpp",
        "include/nlohmann/detail/view/scan.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_literals.hpp",
        "include/nlohmann/json_view.hpp",
        "include/nlohmann/ordered_map.hpp",
        "include/nlohmann/thirdparty/hedley/hedley.hpp",
        "include/nlohmann/thirdparty/hedley/hedley_undef.hpp",
@@ -93,7 +80,6 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -23,7 +23,6 @@ AMALGAMATED_FILE=single_include/nlohmann/json.hpp
 AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # json_literals.hpp only includes <nlohmann/json.hpp>, so it is copied verbatim
 AMALGAMATED_LITERALS_FILE=single_include/nlohmann/json_literals.hpp
 AMALGAMATED_VIEW_FILE=single_include/nlohmann/json_view.hpp
 # the header with the argument-counting macros generated by tools/macro_builder
 MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
@@ -35,7 +34,7 @@ MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
 # main target
 all:
-	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals,_view}.hpp from the include/nlohmann sources"
+	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals}.hpp from the include/nlohmann sources"
 	@echo "BUILD.bazel - regenerate the Bazel BUILD file from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
 	@echo "check-amalgamation - check whether sources have been amalgamated and BUILD.bazel is up to date"
@@ -88,10 +87,10 @@ install_astyle:
 # call the Artistic Style pretty printer on all source files
 pretty: install_astyle
-	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
+	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
 # create single header files and pretty print
-amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE)
+amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE)
 	$(MAKE) pretty
 # call the amalgamation tool for json.hpp
@@ -106,9 +105,6 @@ $(AMALGAMATED_FWD_FILE): $(SRCS)
 $(AMALGAMATED_LITERALS_FILE): include/nlohmann/json_literals.hpp
 	cp include/nlohmann/json_literals.hpp $(AMALGAMATED_LITERALS_FILE)
 # call the amalgamation tool for json_view.hpp (keeps including json.hpp)
 $(AMALGAMATED_VIEW_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
 natvis:
 	python3 tools/generate_natvis/generate_natvis.py .
@@ -133,16 +129,13 @@ check-amalgamation:
 	@mv $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~
 	@mv $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~
 	@mv $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_LITERALS_FILE)~
 	@mv $(AMALGAMATED_VIEW_FILE) $(AMALGAMATED_VIEW_FILE)~
 	@$(MAKE) amalgamate
 	@diff $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE) ; false)
 	@diff $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE) ; false)
 	@diff $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_LITERALS_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_LITERALS_FILE)~ $(AMALGAMATED_LITERALS_FILE) ; false)
 	@diff $(AMALGAMATED_VIEW_FILE) $(AMALGAMATED_VIEW_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_VIEW_FILE)~ $(AMALGAMATED_VIEW_FILE) ; false)
 	@mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE)
 	@mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE)
 	@mv $(AMALGAMATED_LITERALS_FILE)~ $(AMALGAMATED_LITERALS_FILE)
 	@mv $(AMALGAMATED_VIEW_FILE)~ $(AMALGAMATED_VIEW_FILE)
 	@mv BUILD.bazel BUILD.bazel~
 	@$(MAKE) BUILD.bazel
 	@diff BUILD.bazel BUILD.bazel~ || (echo "===================================================================\n  BUILD.bazel is out of date! Please run 'make BUILD.bazel'.\n===================================================================" ; mv BUILD.bazel~ BUILD.bazel ; false)
@@ -188,7 +181,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz
@@ -198,13 +191,11 @@ release: include.zip json.tar.xz
 	gpg --armor --detach-sig $(AMALGAMATED_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_FWD_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_LITERALS_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_VIEW_FILE)
 	gpg --armor --detach-sig json.tar.xz
 	cp $(AMALGAMATED_FILE) release_files
 	cp $(AMALGAMATED_FWD_FILE) release_files
 	cp $(AMALGAMATED_LITERALS_FILE) release_files
-	cp $(AMALGAMATED_VIEW_FILE) release_files
+	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc $(AMALGAMATED_VIEW_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	cd release_files ; shasum -a 256 $$(find . -type f -not -name '*.asc' | sed 's|^\./||' | sort) > hashes.txt
@@ -1187,14 +1187,6 @@ binary.set_subtype(0x10);
 auto cbor = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
 ```
 ### Zero-copy views
 Header `<nlohmann/json_view.hpp>` adds `json_document`/`json_view`, a read-only, non-owning way to look at a parsed
 JSON text: parsing builds a flat index (16 bytes per value) instead of a tree, strings and numbers stay in the source
 text, and `materialize()` builds a `json` value for a subtree only when you actually need one. See
 [Zero-copy JSON views](https://json.nlohmann.me/features/json_view/) for the details, including which inputs are
 borrowed and which are copied.
 ## Customers
 The library is used in multiple projects, applications, operating systems, etc. The list below is not exhaustive, but the result of an internet search. If you know further customers of the library, please let me know, see [contact](#contact).
@@ -1401,8 +1393,7 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
- The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+- The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
 - The view's parser (`<nlohmann/json_view.hpp>`) contains techniques and code adapted from [yyjson](https://github.com/ibireme/yyjson) by YaoYuan, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above): table-driven decoding of `\u` escapes and fixed-offset unrolled checks.
 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">
@@ -396,11 +396,10 @@ list(FILTER INDENT_FILES EXCLUDE REGEX "/tests/thirdparty/|/tests/abi/include/nl
 set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
 set(tool_dir ${PROJECT_SOURCE_DIR}/tools/amalgamate)
 add_custom_target(ci_test_amalgamation
-    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~
+    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~
    COMMAND cp ${include_dir}/json.hpp ${include_dir}/json.hpp~
    COMMAND cp ${include_dir}/json_fwd.hpp ${include_dir}/json_fwd.hpp~
    COMMAND cp ${include_dir}/json_literals.hpp ${include_dir}/json_literals.hpp~
    COMMAND cp ${include_dir}/json_view.hpp ${include_dir}/json_view.hpp~
    COMMAND cp ${PROJECT_SOURCE_DIR}/BUILD.bazel ${PROJECT_SOURCE_DIR}/BUILD.bazel~
    COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
@@ -410,14 +409,12 @@ add_custom_target(ci_test_amalgamation
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json.json -s .
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_fwd.json -s .
    COMMAND cp ${PROJECT_SOURCE_DIR}/include/nlohmann/json_literals.hpp ${include_dir}/json_literals.hpp
-    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_view.json -s .
+    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_view.hpp
    COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake
    COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
    COMMAND diff ${include_dir}/json_fwd.hpp~ ${include_dir}/json_fwd.hpp
    COMMAND diff ${include_dir}/json_literals.hpp~ ${include_dir}/json_literals.hpp
    COMMAND diff ${include_dir}/json_view.hpp~ ${include_dir}/json_view.hpp
    COMMAND diff ${PROJECT_SOURCE_DIR}/BUILD.bazel~ ${PROJECT_SOURCE_DIR}/BUILD.bazel
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
@@ -48,7 +48,6 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -132,43 +132,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_ubjson', 'Func
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::value', 'Method', 'api/basic_json/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::value_t', 'Enum', 'api/basic_json/value_t/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::~basic_json', 'Method', 'api/basic_json/~basic_json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document', 'Class', 'api/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::basic_json_document', 'Constructor', 'api/basic_json_document/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::accept', 'Function', 'api/basic_json_document/accept/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::is_discarded', 'Method', 'api/basic_json_document/is_discarded/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::memory_usage', 'Method', 'api/basic_json_document/memory_usage/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::node_count', 'Method', 'api/basic_json_document/node_count/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::owns_source', 'Method', 'api/basic_json_document/owns_source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::parse', 'Function', 'api/basic_json_document/parse/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::parse_copy', 'Function', 'api/basic_json_document/parse_copy/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::read', 'Method', 'api/basic_json_document/read/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::root', 'Method', 'api/basic_json_document/root/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::shrink_to_fit', 'Method', 'api/basic_json_document/shrink_to_fit/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::source', 'Method', 'api/basic_json_document/source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view', 'Class', 'api/basic_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::basic_json_view', 'Constructor', 'api/basic_json_view/basic_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::empty', 'Method', 'api/basic_json_view/empty/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_array', 'Method', 'api/basic_json_view/is_array/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_binary', 'Method', 'api/basic_json_view/is_binary/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_boolean', 'Method', 'api/basic_json_view/is_boolean/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_discarded', 'Method', 'api/basic_json_view/is_discarded/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_null', 'Method', 'api/basic_json_view/is_null/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number', 'Method', 'api/basic_json_view/is_number/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_float', 'Method', 'api/basic_json_view/is_number_float/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_integer', 'Method', 'api/basic_json_view/is_number_integer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_unsigned', 'Method', 'api/basic_json_view/is_number_unsigned/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_object', 'Method', 'api/basic_json_view/is_object/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_primitive', 'Method', 'api/basic_json_view/is_primitive/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_string', 'Method', 'api/basic_json_view/is_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_structured', 'Method', 'api/basic_json_view/is_structured/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::materialize', 'Method', 'api/basic_json_view/materialize/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator bool', 'Method', 'api/basic_json_view/operator_bool/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::size', 'Method', 'api/basic_json_view/size/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::source_offset', 'Method', 'api/basic_json_view/source_offset/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type', 'Method', 'api/basic_json_view/type/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json', 'Class', 'api/json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_document', 'Class', 'api/json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_view', 'Class', 'api/json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer', 'Class', 'api/json_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::back', 'Method', 'api/json_pointer/back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::empty', 'Method', 'api/json_pointer/empty/index.html');
@@ -206,8 +170,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('operator""_json_pointer', 'Li
 INSERT INTO searchIndex(name, type, path) VALUES ('operator<<', 'Operator', 'api/operator_ltlt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('operator>>', 'Operator', 'api/operator_gtgt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json', 'Class', 'api/ordered_json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_document', 'Class', 'api/ordered_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_view', 'Class', 'api/ordered_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_map', 'Class', 'api/ordered_map/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::formatter<basic_json>', 'Class', 'api/basic_json/std_formatter/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::hash<basic_json>', 'Class', 'api/basic_json/std_hash/index.html');
@@ -238,7 +200,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Iterators', 'Guide', 'feature
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON Merge Patch', 'Guide', 'features/merge_patch/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON Patch and Diff', 'Guide', 'features/json_patch/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON Pointer', 'Guide', 'features/json_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Zero-copy JSON views', 'Guide', 'features/json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('nlohmann Namespace', 'Guide', 'features/namespace/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Types', 'Guide', 'features/types/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Types: Number Handling', 'Guide', 'features/types/number_handling/index.html');
@@ -64,7 +64,6 @@ itself is empty which is `#!cpp false` in the case of a string.
 - [size](size.md) returns the number of elements
 - [clear](clear.md) clears the content and resets the value to the default value
 - [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
 - [type](type.md) returns the type of the JSON value
 - [array_t](array_t.md) the type used to store JSON arrays
 - [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 ## Version history
@@ -39,7 +39,6 @@ Constant.
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [binary_t](binary_t.md) the type used to store binary values
 - [get_binary](get_binary.md) returns a reference to the stored binary value
 - [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 ## Version history
@@ -38,7 +38,6 @@ Constant.
 - [boolean_t](boolean_t.md) the type used to store JSON booleans
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 ## Version history
@@ -85,11 +85,6 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
    --8<-- "examples/is_discarded__parse.output"
    ```
 ## See also
 - [basic_json_view::is_discarded](../basic_json_view/is_discarded.md) - the corresponding check on a zero-copy view,
  which is `#!cpp true` if the view refers to no value
 ## Version history
 - Added in version 1.0.0.
@@ -40,7 +40,6 @@ Constant.
 - [is_object](is_object.md) checks whether the JSON value is an object
 - [type](type.md) returns the type of the JSON value
 - [value_t](value_t.md) the enumeration of JSON types
 - [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 ## Version history
@@ -49,7 +49,6 @@ constexpr bool is_number() const noexcept
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number](../basic_json_view/is_number.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [basic_json_view::is_number_float](../basic_json_view/is_number_float.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number_integer](../basic_json_view/is_number_integer.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number_unsigned](../basic_json_view/is_number_unsigned.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
 - [type](type.md) returns the type of the JSON value
 - [object_t](object_t.md) the type used to store JSON objects
 - [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 ## Version history
@@ -62,7 +62,6 @@ This library extends primitive types to binary types, because binary types are r
 - [is_boolean()](is_boolean.md) returns whether the JSON value is a boolean
 - [is_number()](is_number.md) returns whether the JSON value is a number
 - [is_binary()](is_binary.md) returns whether the JSON value is a binary array
 - [basic_json_view::is_primitive](../basic_json_view/is_primitive.md) - the same check on a zero-copy view
 ## Version history
@@ -39,7 +39,6 @@ Constant.
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [type](type.md) returns the type of the JSON value
 - [string_t](string_t.md) the type used to store JSON strings
 - [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 ## Version history
@@ -57,7 +57,6 @@ Note that though strings are containers in C++, they are treated as primitive va
 - [is_primitive()](is_primitive.md) returns whether JSON value is primitive
 - [is_array()](is_array.md) returns whether the value is an array
 - [is_object()](is_object.md) returns whether the value is an object
 - [basic_json_view::is_structured](../basic_json_view/is_structured.md) - the same check on a zero-copy view
 ## Version history
@@ -23,10 +23,9 @@ type to use.
 ## Template parameters
 `NumberFloatType`
-:   the type to store floating-point numbers. The parser converts `#!cpp float`, `#!cpp double`, and a
+:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp long double` that is IEEE 754 binary64 itself and other `#!cpp long double` formats with
+    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    `#!cpp std::from_chars` or `#!cpp std::strtold`, and serialization falls back to `#!cpp std::snprintf`, so the
+    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    type must be `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
    because they have no encoding for `#!cpp long double`. See
    [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
@@ -56,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.
@@ -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
+range will yield over/underflow when used in a constructor. During deserialization (from JSON text or any of the binary
-will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [`number_float_t`](number_float_t.md).
+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
@@ -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
+when used in a constructor. During deserialization (from JSON text or any of the binary formats), too large or small
-as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_t.md).
+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
@@ -55,7 +55,6 @@ JSON value which is `1` in the case of a string.
 - [empty](empty.md) checks whether the JSON value has no elements
 - [max_size](max_size.md) returns the maximum possible number of elements
 - [basic_json_view::size](../basic_json_view/size.md) - the same function on a zero-copy view
 ## Version history
@@ -52,7 +52,6 @@ Constant.
 - [operator value_t](operator_value_t.md) implicit conversion operator equivalent to this named member function
 - [type_name](type_name.md) returns the type as a string, for use in error messages
 - [value_t](value_t.md) the enumeration of JSON types
 - [basic_json_view::type](../basic_json_view/type.md) - the same function on a zero-copy view
 ## Version history
@@ -1,67 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>accept
 ```cpp
 template<typename InputType>
 static bool accept(InputType&& input,
                   const bool ignore_comments = false,
                   const bool ignore_trailing_commas = false);
 ```
 Checks whether the input is valid JSON, accepting and rejecting exactly what
 [`BasicJsonType::accept()`](../basic_json/accept.md) does, with the same options. Unlike [`parse()`](parse.md), this
 function never throws an exception for invalid input, and the returned `#!cpp bool` is the only result -- no document
 is returned.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to check.
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Return value
 Whether the input is valid JSON.
 ## Exception safety
 Strong guarantee: this function itself never throws for an invalid input; it can only throw what allocating the
 input's own copy (for inputs that are always read into a buffer) throws.
 ## Complexity
 Linear in the length of the input.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__accept.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__accept.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [`BasicJsonType::accept`](../basic_json/accept.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,58 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>basic_json_document
 ```cpp
 // (1)
 basic_json_document() = default;
 // (2)
 basic_json_document(basic_json_document&& other) noexcept = default;
 // (3)
 basic_json_document(const basic_json_document&) = delete;
 ```
 1. Creates an empty (discarded) document: [`root()`](root.md) returns a discarded view, and
   [`is_discarded()`](is_discarded.md) is `#!cpp true`.
 2. Move constructor. Takes over `other`'s index and, if owned, its text; `other` is left as an empty document. Views
   taken from `other` before the move remain valid, because the index is heap-allocated independently of the
   `basic_json_document` object.
 3. `basic_json_document` is move-only. Copying is disabled because it would either duplicate a potentially large index
   and text, or leave two documents claiming to borrow the same buffer.
 ## Parameters
 `other` (in)
 :   another document to move the index and text from
 ## Exception safety
 No-throw guarantee: the default and move constructors never throw exceptions.
 ## Complexity
 Constant, for the default and move constructors.
 ## Examples
 ??? example
    The example below shows the default constructor and demonstrates that `basic_json_document` is move-only.
    ```cpp
    --8<-- "examples/basic_json_document__basic_json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__basic_json_document.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [is_discarded](is_discarded.md) - return whether the last parse failed
 ## Version history
 - Added in version 3.13.0.
@@ -1,56 +0,0 @@
 # <small>nlohmann::</small>basic_json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType>
 class basic_json_document;
 ```
 A parsed JSON text, held as a flat index of its values
 ([16 bytes per value](../../home/architecture.md#node-index-of-json-views)) instead of a tree of `BasicJsonType` values.
 Strings and numbers stay in the source text; only strings that contain escapes are decoded, into one buffer owned by
 the document. [`basic_json_view`](../basic_json_view/index.md) is a read-only handle to one value of a
 `basic_json_document`; [`materialize()`](../basic_json_view/materialize.md) turns a subtree back into the
 `BasicJsonType` value that [`BasicJsonType::parse()`](../basic_json/parse.md) would have produced for it.
 A document may **borrow** the text it was parsed from (the caller's buffer must then outlive the document) or **own**
 it (a copy, or an rvalue `#!cpp std::string` that was moved in); see [`owns_source`](owns_source.md). `basic_json_document`
 is move-only: copying a document would either duplicate a potentially large index and text, or leave two documents
 claiming to borrow the same buffer, so it is disabled.
 ## Template parameters
 `BasicJsonType`
 :   a specialization of [`basic_json`](../basic_json/index.md), for instance [`json`](../json.md) or
    [`ordered_json`](../ordered_json.md). Only 64-bit `number_integer_t`/`number_unsigned_t` types are supported; this
    is checked with a `static_assert`.
 ## Specializations
 - [**json_document**](../json_document.md) - documents of the default specialization [`json`](../json.md)
 - [**ordered_json_document**](../ordered_json_document.md) - documents of [`ordered_json`](../ordered_json.md)
 ## Member types
 - **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 ## Member functions
 - [(constructor)](basic_json_document.md)
 - [**parse**](parse.md) (_static_) - deserialize from a compatible input, borrowing or owning it as appropriate
 - [**parse_copy**](parse_copy.md) (_static_) - deserialize a copy of a compatible input
 - [**accept**](accept.md) (_static_) - check whether the input is valid JSON
 - [**read**](read.md) - (re-)parse into this document, reusing its memory
 - [**root**](root.md) - the view of the root value
 - [**is_discarded**](is_discarded.md) - return whether the last parse failed
 - [**source**](source.md) - the parsed text
 - [**owns_source**](owns_source.md) - return whether the document holds its own copy of the text
 - [**node_count**](node_count.md) - the number of index entries (values plus object keys)
 - [**memory_usage**](memory_usage.md) - the number of bytes held by the document
 - [**shrink_to_fit**](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>is_discarded
 ```cpp
 bool is_discarded() const noexcept;
 ```
 Returns whether the document holds no value, either because it was default-constructed or because the last call to
 [`parse()`](parse.md), [`parse_copy()`](parse_copy.md), or [`read()`](read.md) failed with `allow_exceptions` set to
 `#!cpp false`.
 ## Return value
 `#!cpp true` if the document is discarded, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 When the document is discarded, [`root()`](root.md) returns a discarded view (its
 [`is_discarded()`](../basic_json_view/is_discarded.md) is also `#!cpp true`).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__is_discarded.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__is_discarded.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [is_discarded (basic_json_view)](../basic_json_view/is_discarded.md) - return whether a view is invalid
 ## Version history
 - Added in version 3.13.0.
@@ -1,50 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>memory_usage
 ```cpp
 std::size_t memory_usage() const noexcept;
 ```
 Returns the number of bytes held by the document: the node index, the decoded-string buffer (for strings that
 contain escapes), and, for an owned document, its copy of the source text.
 ## Return value
 The number of bytes the document holds, `0` for a [discarded](is_discarded.md) document.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 The exact value depends on the platform, the allocator, and the library's own layout, and may change between
 versions; do not rely on it being a specific number, and do not compare it across different builds or platforms.
 Compare it for the same document over time, or between documents built with the same binary, instead -- for instance
 to observe the effect of [`shrink_to_fit()`](shrink_to_fit.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__memory_usage.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__memory_usage.output"
    ```
 ## See also
 - [node_count](node_count.md) - the number of index entries
 - [shrink_to_fit](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>node_count
 ```cpp
 std::size_t node_count() const noexcept;
 ```
 Returns the number of entries in the document's flat index.
 ## Return value
 The number of index entries: one per value (of any type, at any nesting depth) plus one per object key. `0` for a
 [discarded](is_discarded.md) document.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 Each index entry is [16 bytes](../../home/architecture.md#node-index-of-json-views), so `#!cpp node_count() * 16` is
 the size of the index itself (part, but not all, of [`memory_usage()`](memory_usage.md), which also counts decoded
 strings and, for an owned document, the text).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__node_count.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__node_count.output"
    ```
 ## See also
 - [memory_usage](memory_usage.md) - the number of bytes held by the document
 - [shrink_to_fit](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>owns_source
 ```cpp
 bool owns_source() const noexcept;
 ```
 Returns whether the document holds its own copy of the parsed text, as opposed to borrowing the caller's buffer.
 ## Return value
 `#!cpp true` if the document owns the text returned by [`source()`](source.md), `#!cpp false` if it borrows it (or if
 the document is [discarded](is_discarded.md)).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 See the ownership table on [`parse`](parse.md#notes) for which inputs are borrowed and which are owned. A borrowed
 document (`#!cpp owns_source() == false`) is only valid while the buffer it was parsed from is still alive.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__owns_source.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__owns_source.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [parse_copy](parse_copy.md) - deserialize a copy of a compatible input, always owned
 - [source](source.md) - the parsed text
 ## Version history
 - Added in version 3.13.0.
@@ -1,139 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>parse
 ```cpp
 // (1)
 template<typename InputType>
 static basic_json_document parse(InputType&& input,
                                 const bool allow_exceptions = true,
                                 const bool ignore_comments = false,
                                 const bool ignore_trailing_commas = false);
 // (2)
 template<typename IteratorType>
 static basic_json_document parse(IteratorType first, IteratorType last,
                                 const bool allow_exceptions = true,
                                 const bool ignore_comments = false,
                                 const bool ignore_trailing_commas = false);
 ```
 1. Deserialize from a compatible input, borrowing or owning it depending on its value category and type (see Notes).
 2. Deserialize from a pair of input iterators.
 Both overloads accept exactly what [`BasicJsonType::parse()`](../basic_json/parse.md) accepts, with the same
 `ignore_comments`/`ignore_trailing_commas` options, but build a [`basic_json_document`](index.md) (a flat index into
 the input) instead of a tree of `BasicJsonType` values.
 ## Template parameters
 `InputType`
 :   A compatible input, for instance:
    - a `#!cpp std::string`, `#!cpp std::string_view`, or a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
    - a container for which `#!cpp obj.data()` and `#!cpp obj.size()` give contiguous single-byte access, e.g.
      `#!cpp std::vector<char>` or `#!cpp std::vector<std::uint8_t>`
    - an `#!cpp std::istream` object, or anything else [`BasicJsonType::parse()`](../basic_json/parse.md) accepts
 `IteratorType`
 :   a compatible iterator type, for instance a pair of pointers such as `ptr` and `ptr + len`, or a pair of
    `#!cpp std::string::iterator`
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 `first` (in)
 :   iterator to the start of a character range
 `last` (in)
 :   iterator to the end of a character range
 ## Return value
 The parsed document. If `allow_exceptions` is `#!cpp false` and the input is not valid JSON, the returned document is
 discarded; see [`is_discarded`](is_discarded.md).
 ## Exceptions
 Throws the same exception [`BasicJsonType::parse()`](../basic_json/parse.md) throws for the same input and options --
 the same exception id, message, and position -- because on a failing input the library's own parser is run on the
 same bytes to produce the diagnostic. Additionally throws
 [`out_of_range.416`](../../home/exceptions.md#jsonexceptionout_of_range416) if the input is 4 GiB or larger, a size
 [`BasicJsonType::parse()`](../basic_json/parse.md) does not reject.
 ## Complexity
 Linear in the length of the input.
 ## Notes
 **Ownership.** Whether the document borrows `input` or owns a copy of it depends on its value category and type:
 | `input`                                                                             | ownership                                                    |
 |--------------------------------------------------------------------------------------|--------------------------------------------------------------|
 | lvalue byte container (`std::string`, `std::vector<char>`, ...), `std::string_view`, C string, character array | **borrowed** -- `input` must outlive the document |
 | rvalue `#!cpp std::string`                                                            | **owned**, moved in without a copy                            |
 | rvalue byte container other than `#!cpp std::string`                                  | **owned**, copied                                             |
 | stream, wide string, or anything else read through the general input adapter          | **owned**, read into a buffer (a stream is read to its end)   |
 For overload (2), a pair of pointers to single-byte integers (e.g. `#!cpp const char*`, `#!cpp std::uint8_t*`) is
 borrowed. From C++20 on, so is any other contiguous iterator over single bytes, such as
 `#!cpp std::vector<char>::iterator` or `#!cpp std::string::const_iterator`. Before C++20 these iterators cannot be
 told apart from other class-type iterators, so their range is read into an owned buffer, as is any non-contiguous
 range (e.g. of a `#!cpp std::list<char>`).
 See [`owns_source`](owns_source.md) to check which happened after a call, and the
 [feature page](../../features/json_view.md) for the reasoning.
 **Numbers.** As for [`BasicJsonType::parse()`](../basic_json/parse.md), an integer literal too large for the 64-bit
 integer type becomes a floating-point value.
 ## Examples
 ??? example "Example: (1) borrowed vs. owned input, and errors identical to `BasicJsonType::parse()`"
    ```cpp
    --8<-- "examples/basic_json_document__parse.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse.output"
    ```
 ??? example "Example: (2) parse an iterator range (no NUL terminator required)"
    ```cpp
    --8<-- "examples/basic_json_document__parse_iterator_pair.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse_iterator_pair.output"
    ```
 ## See also
 - [parse_copy](parse_copy.md) - deserialize a copy of a compatible input
 - [accept](accept.md) - check whether the input is valid JSON
 - [read](read.md) - (re-)parse into this document, reusing its memory
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [`BasicJsonType::parse`](../basic_json/parse.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,77 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>parse_copy
 ```cpp
 template<typename InputType>
 static basic_json_document parse_copy(InputType&& input,
                                      const bool allow_exceptions = true,
                                      const bool ignore_comments = false,
                                      const bool ignore_trailing_commas = false);
 ```
 Deserialize from a compatible input, always taking the document's own copy of it, regardless of the value category or
 type of `input`. Unlike [`parse()`](parse.md), the returned document never depends on `input` staying alive.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Return value
 The parsed document, with [`owns_source()`](owns_source.md) `#!cpp true`. If `allow_exceptions` is `#!cpp false` and
 the input is not valid JSON, the returned document is discarded; see [`is_discarded`](is_discarded.md).
 ## Exceptions
 Same as [`parse`](parse.md#exceptions).
 ## Complexity
 Linear in the length of the input.
 ## Notes
 `parse_copy()` accepts and rejects exactly what [`parse()`](parse.md) does, and classifies numbers the same way; it
 only differs in that the input is always copied rather than sometimes borrowed. Prefer [`parse()`](parse.md) when the
 input's lifetime already covers the document's, since it avoids the copy for borrowed inputs.
 ## Examples
 ??? example
    The example below returns a document from a function whose local buffer would otherwise not outlive it.
    ```cpp
    --8<-- "examples/basic_json_document__parse_copy.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse_copy.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input, borrowing it where possible
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 ## Version history
 - Added in version 3.13.0.
@@ -1,76 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>read
 ```cpp
 template<typename InputType>
 void read(InputType&& input,
         const bool allow_exceptions = true,
         const bool ignore_comments = false,
         const bool ignore_trailing_commas = false);
 ```
 (Re-)parses `input` into `#!cpp *this`, discarding the document's previous value and reusing its memory (the node
 index, the decoded-string buffer, and, if applicable, the owned copy of the text) rather than allocating a fresh
 document. [`parse()`](parse.md) is implemented in terms of this function, applied to a default-constructed document.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Exceptions
 Same as [`parse`](parse.md#exceptions).
 ## Complexity
 Linear in the length of the input.
 ## Notes
 Every view taken from `#!cpp *this` before the call -- including the previous [`root()`](root.md) -- is invalidated,
 whether or not the new parse succeeds; take fresh views from [`root()`](root.md) afterward.
 `input` is borrowed or owned by the same rules as [`parse()`](parse.md#notes); a document can borrow on one call and
 own on the next, since ownership is decided freshly each time.
 ## Examples
 ??? example
    The example below parses a sequence of messages into the same document, reusing its memory instead of allocating
    a new document for each one.
    ```cpp
    --8<-- "examples/basic_json_document__read.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__read.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [root](root.md) - the view of the root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,50 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>root
 ```cpp
 view_type root() const noexcept;
 ```
 Returns a view of the root value of the document.
 ## Return value
 A [`view_type`](index.md#member-types) (i.e. `#!cpp basic_json_view<BasicJsonType>`) for the root value, or a
 discarded view if the document is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `root()` is a cheap handle into the document's index, not a copy of anything; call it as often as needed. The
 returned view is valid under the same conditions as any other view of the document -- see
 [Object inspection](../basic_json_view/index.md) -- in particular, it is invalidated by the next
 [`read()`](read.md) or [`shrink_to_fit()`](shrink_to_fit.md) on this document.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__root.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__root.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the last parse failed
 - [materialize](../basic_json_view/materialize.md) - build the `BasicJsonType` value of a subtree
 ## Version history
 - Added in version 3.13.0.
@@ -1,58 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>shrink_to_fit
 ```cpp
 void shrink_to_fit();
 ```
 Releases capacity that is no longer needed, both of the node index and of the buffer for decoded strings (strings that
 contained escape sequences), e.g. after [`read()`](read.md) replaced a large document with a much smaller one. Like
 `#!cpp std::vector::shrink_to_fit()`, this is a non-binding request: the library may keep more capacity than strictly
 necessary.
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes to the document.
 ## Exceptions
 May throw `#!cpp std::bad_alloc` if the reallocation fails; on exception, the document is unchanged.
 ## Complexity
 Linear in [`node_count()`](node_count.md) plus the length of the decoded strings.
 ## Notes
 !!! warning "Invalidates views"
    Unlike moving the document, `shrink_to_fit()` **invalidates every view taken from this document before the
    call**, including a previously obtained [`root()`](root.md): the node index is moved into a new, smaller
    allocation, and the old one is freed. Take a fresh view from [`root()`](root.md) after calling this function.
 This is unlike `#!cpp std::vector::shrink_to_fit()`, which promises nothing about validity but in practice often
 leaves iterators alone when it did not need to reallocate; here, an implementation that avoids a reallocation when
 possible would be an internal optimization only, not a guarantee to rely on.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__shrink_to_fit.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__shrink_to_fit.output"
    ```
 ## See also
 - [node_count](node_count.md) - the number of index entries
 - [memory_usage](memory_usage.md) - the number of bytes held by the document
 - [root](root.md) - the view of the root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,48 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>source
 ```cpp
 view_type::string_view_t source() const noexcept;
 ```
 Returns the parsed text, whether it is borrowed from the caller or owned by the document.
 ## Return value
 A `#!cpp string_view_t` (`#!cpp std::string_view` on C++17 and newer) over the parsed text, or an empty one if the
 document is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 For a borrowed document, `source()` points directly into the caller's buffer, so it is only valid while that buffer
 is; see [`owns_source`](owns_source.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__source.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__source.output"
    ```
 ## See also
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [source_offset](../basic_json_view/source_offset.md) - byte offset of a value in the source text
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>basic_json_view
 ```cpp
 basic_json_view() noexcept = default;
 ```
 Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::discarded`,
 [`is_discarded()`](is_discarded.md) is `#!cpp true`, and `#!cpp explicit operator bool()` is `#!cpp false`.
 This is the only constructor a caller can use directly. Every other view is obtained from a
 [`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or (once
 element access is added) from navigating into a container.
 ## Exception safety
 No-throw guarantee: this constructor never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `basic_json_view` is trivially copyable (it holds two pointers), so a default-constructed view can be used as a
 placeholder for "no value yet" and later be assigned a real view.
 ## Examples
 ??? example
    The example below shows the default constructor and that a `basic_json_view` is a small, copyable handle.
    ```cpp
    --8<-- "examples/basic_json_view__basic_json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__basic_json_view.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the view is invalid
 - [operator bool](operator_bool.md) - return whether the view refers to a value
 - [root](../basic_json_document/root.md) - the view of a document's root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,61 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>empty
 ```cpp
 bool empty() const noexcept;
 ```
 Checks whether [`size()`](size.md) is `0`, as [`BasicJsonType::empty()`](../basic_json/empty.md) would for the same
 value.
 ## Return value
 The return value depends on the type and is defined as follows:
 | Value type          | return value    |
 |----------------------|-----------------|
 | null                  | `#!cpp true`     |
 | discarded             | `#!cpp true`     |
 | boolean               | `#!cpp false`    |
 | string                | `#!cpp false`    |
 | number                | `#!cpp false`    |
 | object                | `#!cpp object_t::empty()` |
 | array                 | `#!cpp array_t::empty()`  |
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::empty()`](../basic_json/empty.md), this does not return whether a string value is empty -- it
 is `#!cpp false` for any string, regardless of its length.
 ## Examples
 ??? example
    The example below uses [`size()`](size.md) and `empty()` to decide whether a parsed message is worth acting on,
    without materializing it into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__size_empty.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__size_empty.output"
    ```
 ## See also
 - [size](size.md) - return the number of elements
 - [`BasicJsonType::empty`](../basic_json/empty.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,82 +0,0 @@
 # <small>nlohmann::</small>basic_json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType>
 class basic_json_view;
 ```
 A read-only handle to one value of a [`basic_json_document`](../basic_json_document/index.md): two pointers (a pointer
 to the document and a pointer into its index), trivially copyable. A view is valid as long as
 - the document is alive,
 - the document has not been re-parsed with [`read()`](../basic_json_document/read.md) (or
  [`parse()`](../basic_json_document/parse.md) into it) or shrunk with
  [`shrink_to_fit()`](../basic_json_document/shrink_to_fit.md) since the view was taken, and
 - if the document borrows its source text, that text is still alive.
 Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
 `basic_json_document` object.
 `basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, and
 [`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand. It does not (yet) provide
 element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or comparison.
 ## Template parameters
 `BasicJsonType`
 :   a specialization of [`basic_json`](../basic_json/index.md), matching the
    [`basic_json_document`](../basic_json_document/index.md) the view was taken from.
 ## Specializations
 - [**json_view**](../json_view.md) - views of a [`json_document`](../json_document.md)
 - [**ordered_json_view**](../ordered_json_view.md) - views of an [`ordered_json_document`](../ordered_json_document.md)
 ## Member types
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **string_t**, **number_integer_t**, **number_unsigned_t**, **number_float_t**, **json_pointer** - the corresponding
  member types of `BasicJsonType`
 - **size_type** - `#!cpp std::size_t`
 - **string_view_t** - `#!cpp std::string_view` on C++17 and newer, a minimal internal substitute otherwise
 ## Member functions
 - [(constructor)](basic_json_view.md)
 ### Object inspection
 - [**type**](type.md) - return the type of the value
 - [**is_null**](is_null.md) - return whether the value is null
 - [**is_boolean**](is_boolean.md) - return whether the value is a boolean
 - [**is_number**](is_number.md) - return whether the value is a number
 - [**is_number_integer**](is_number_integer.md) - return whether the value is an integer number
 - [**is_number_unsigned**](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [**is_number_float**](is_number_float.md) - return whether the value is a floating-point number
 - [**is_string**](is_string.md) - return whether the value is a string
 - [**is_array**](is_array.md) - return whether the value is an array
 - [**is_object**](is_object.md) - return whether the value is an object
 - [**is_binary**](is_binary.md) - return whether the value is a binary array (always `#!cpp false`)
 - [**is_primitive**](is_primitive.md) - return whether the type is primitive
 - [**is_structured**](is_structured.md) - return whether the type is structured
 - [**is_discarded**](is_discarded.md) - return whether the view is invalid
 - [**operator bool**](operator_bool.md) - return whether the view refers to a value
 ### Capacity
 - [**size**](size.md) - return the number of elements
 - [**empty**](empty.md) - return whether the value has no elements
 ### Conversion
 - [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree
 ### Source access
 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_array
 ```cpp
 bool is_array() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an array.
 ## Return value
 `#!cpp true` if the type is an array, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_array`](../basic_json/is_array.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_binary
 ```cpp
 bool is_binary() const noexcept;
 ```
 This function always returns `#!cpp false`: a JSON text has no binary values, so a view can never refer to one. The
 function exists for interface parity with [`BasicJsonType::is_binary`](../basic_json/is_binary.md).
 ## Return value
 `#!cpp false`, always.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_binary`](../basic_json/is_binary.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_boolean
 ```cpp
 bool is_boolean() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a boolean.
 ## Return value
 `#!cpp true` if the type is a boolean, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_boolean`](../basic_json/is_boolean.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,55 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_discarded
 ```cpp
 bool is_discarded() const noexcept;
 ```
 Returns whether this view is invalid, i.e. does not refer to a value. This is the case for a default-constructed
 view (see [(constructor)](basic_json_view.md)), and for [`root()`](../basic_json_document/root.md) of a document
 that is itself [discarded](../basic_json_document/is_discarded.md) -- in particular, the root of a failed
 [`parse()`](../basic_json_document/parse.md) with `allow_exceptions` set to `#!cpp false`.
 ## Return value
 `#!cpp true` if the view is discarded, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `#!cpp v.is_discarded()` and `#!cpp !static_cast<bool>(v)` are equivalent; use whichever reads better at the call
 site.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [operator bool](operator_bool.md) - return whether the view refers to a value
 - [(constructor)](basic_json_view.md) - the default constructor creates a discarded view
 - [is_discarded (basic_json_document)](../basic_json_document/is_discarded.md) - return whether the last parse failed
 - [`BasicJsonType::is_discarded`](../basic_json/is_discarded.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_null
 ```cpp
 bool is_null() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is `#!json null`.
 ## Return value
 `#!cpp true` if the type is `#!json null`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_null`](../basic_json/is_null.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,47 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number
 ```cpp
 bool is_number() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a number, i.e. an integer, unsigned integer, or floating-point value. It is defined as `#!cpp is_number_integer() || is_number_float()`.
 ## Return value
 `#!cpp true` if the type is a number, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
 - [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [is_number_float](is_number_float.md) - return whether the value is a floating-point number
 - [`BasicJsonType::is_number`](../basic_json/is_number.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_float
 ```cpp
 bool is_number_float() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a floating-point number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_float`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::parse`](../basic_json/parse.md), an integer literal that does not fit into the 64-bit
 integer type is classified as a floating-point number, so `is_number_float()` can be `#!cpp true` even for an
 integer-looking token in the source text.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number](is_number.md) - return whether the value is a number
 - [`BasicJsonType::is_number_float`](../basic_json/is_number_float.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_integer
 ```cpp
 bool is_number_integer() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an integer or unsigned integer number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_integer` or `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md), this includes unsigned integer
 values; use [`is_number_unsigned`](is_number_unsigned.md) to test for those specifically.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number](is_number.md) - return whether the value is a number
 - [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_unsigned
 ```cpp
 bool is_number_unsigned() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an unsigned integer number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
 - [`BasicJsonType::is_number_unsigned`](../basic_json/is_number_unsigned.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_object
 ```cpp
 bool is_object() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an object.
 ## Return value
 `#!cpp true` if the type is an object, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_object`](../basic_json/is_object.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_primitive
 ```cpp
 bool is_primitive() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is primitive, i.e. `#!json null`, a boolean, a number, or a string. It is defined as `#!cpp is_null() || is_string() || is_boolean() || is_number()`.
 ## Return value
 `#!cpp true` if the type is primitive, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured (the complement of this function, for a
  non-discarded view)
 - [`BasicJsonType::is_primitive`](../basic_json/is_primitive.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_string
 ```cpp
 bool is_string() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a string.
 ## Return value
 `#!cpp true` if the type is a string, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [source_offset](source_offset.md) - byte offset of this value in the document's source text
 - [`BasicJsonType::is_string`](../basic_json/is_string.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_structured
 ```cpp
 bool is_structured() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is structured, i.e. an array or an object. It is defined as `#!cpp is_array() || is_object()`.
 ## Return value
 `#!cpp true` if the type is structured, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_primitive](is_primitive.md) - return whether the type is primitive
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_structured`](../basic_json/is_structured.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,69 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>materialize
 ```cpp
 BasicJsonType materialize() const;
 ```
 Builds the `BasicJsonType` value of this subtree: the value [`BasicJsonType::parse()`](../basic_json/parse.md) would
 have produced for the same source text, allocated for the first time by this call.
 ## Return value
 The `BasicJsonType` value of this subtree, or a discarded `BasicJsonType` value (`#!cpp BasicJsonType(value_t::discarded)`)
 if the view is [discarded](is_discarded.md).
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes to the view or the document it refers to (nothing
 about either is mutated by this function).
 ## Exceptions
 May throw `#!cpp std::bad_alloc` (via `BasicJsonType`'s allocator) if constructing the result fails.
 ## Complexity
 Linear in the size of the subtree.
 ## Notes
 `materialize()` replays the subtree through the same SAX builder [`BasicJsonType::parse()`](../basic_json/parse.md)
 uses internally, so the result matches it exactly -- including, for an object, that a repeated key keeps only its
 last value. The replay is iterative, so it is not limited by the call stack the way a naive recursive conversion
 would be; the JSON nesting depth is limited only by available memory, as for `BasicJsonType::parse()` itself.
 Unlike parsing with [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) enabled, the values
 produced by `materialize()` do not carry source positions: there is no lexer run during the replay to record them.
 Calling `materialize()` on the same view repeatedly builds a new, independent `BasicJsonType` value each time; it
 never caches the result.
 ## Examples
 ??? example
    The example below skips messages that are not useful -- a discarded value, or an empty array -- using only
    [`is_array()`](is_array.md) and [`empty()`](empty.md), and calls `materialize()` only for the messages that are
    actually used, so no `BasicJsonType` value (and none of its per-element allocations) is ever built for the
    skipped ones.
    ```cpp
    --8<-- "examples/basic_json_view__materialize.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__materialize.output"
    ```
 ## See also
 - [root](../basic_json_document/root.md) - the view of a document's root value
 - [`BasicJsonType::parse`](../basic_json/parse.md) - build a `BasicJsonType` value directly from a JSON text
 - [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) - source positions on parsed values (not
  produced by `materialize()`)
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>operator bool
 ```cpp
 explicit operator bool() const noexcept;
 ```
 Returns whether this view refers to a value, i.e. the negation of [`is_discarded()`](is_discarded.md). Being
 `#!cpp explicit`, this conversion is only considered in a boolean context (`#!cpp if (v)`, `#!cpp !v`, `#!cpp v &&
 ...`), not for implicit conversions to other types.
 ## Return value
 `#!cpp true` if the view refers to a value, `#!cpp false` if it is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the view is invalid
 ## Version history
 - Added in version 3.13.0.
@@ -1,60 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>size
 ```cpp
 size_type size() const noexcept;
 ```
 Returns the number of elements, as [`BasicJsonType::size()`](../basic_json/size.md) would for the same value.
 ## Return value
 The return value depends on the type and is defined as follows:
 | Value type          | return value                |
 |----------------------|-----------------------------|
 | null                  | `0`                          |
 | discarded             | `0`                          |
 | boolean               | `1`                          |
 | string                | `1`                          |
 | number                | `1`                          |
 | object                | number of key/value pairs    |
 | array                 | number of elements           |
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant: for an object or array, the element count is stored in the index, not counted on demand.
 ## Notes
 As for [`BasicJsonType::size()`](../basic_json/size.md), this does not return the length of a string value -- it is
 `1` for a string, regardless of its length.
 ## Examples
 ??? example
    The example below uses `size()` and [`empty()`](empty.md) to decide whether a parsed message is worth acting on,
    without materializing it into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__size_empty.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__size_empty.output"
    ```
 ## See also
 - [empty](empty.md) - return whether the value has no elements
 - [`BasicJsonType::size`](../basic_json/size.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,55 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>source_offset
 ```cpp
 std::size_t source_offset() const noexcept;
 ```
 Returns the byte offset of this value in the document's [`source()`](../basic_json_document/source.md) text, without
 materializing anything.
 ## Return value
 - For a string with no escapes, a number, `#!json true`/`#!json false`/`#!json null`, an array, or an object: the
  byte offset of the first byte of the value's token (for a string: the first byte after the opening quote) in
  [`source()`](../basic_json_document/source.md).
 - `#!cpp static_cast<std::size_t>(-1)` for a [discarded](is_discarded.md) view, and for a string that contains
  escapes -- such a string was decoded once into the document's own buffer, so there is no single byte range in
  `source()` left to point at.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 This is a raw offset, not a length: the API does not (yet) expose how many bytes the token occupies in the source
 text, so `source_offset()` alone is enough to report *where* a value came from (for an error message, for syntax
 highlighting, ...) but not to slice its exact text back out of [`source()`](../basic_json_document/source.md) for a
 string, whose token length is not the same as its decoded [`size()`](size.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_view__source_offset.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__source_offset.output"
    ```
 ## See also
 - [source](../basic_json_document/source.md) - the parsed text
 - [is_string](is_string.md) - return whether the value is a string
 ## Version history
 - Added in version 3.13.0.
@@ -1,53 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>type
 ```cpp
 value_t type() const noexcept;
 ```
 Returns the type of the value this view refers to, as a value from the [`value_t`](../basic_json/value_t.md)
 enumeration -- the same enumeration [`BasicJsonType::type()`](../basic_json/type.md) uses.
 ## Return value
 The type of the value; `#!cpp value_t::discarded` for a [discarded](is_discarded.md) view.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 Unlike [`BasicJsonType::type()`](../basic_json/type.md), this function can never return `#!cpp value_t::binary`: a
 JSON text has no binary values, so `type()` only distinguishes the eight ordinary JSON value types (plus
 `#!cpp discarded`).
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_null](is_null.md), [is_boolean](is_boolean.md), [is_number](is_number.md), [is_string](is_string.md),
  [is_array](is_array.md), [is_object](is_object.md) - type-specific predicates built on `type()`
 - [`BasicJsonType::type`](../basic_json/type.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,35 +0,0 @@
 # <small>nlohmann::</small>json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using json_document = basic_json_document<json>;
 ```
 This type is a [`basic_json_document`](basic_json_document/index.md) of the default [`json`](json.md)
 specialization.
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::json_document`.
    ```cpp
    --8<-- "examples/json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/json_document.output"
    ```
 ## See also
 - [json_view](json_view.md) - a view of a value of a `json_document`
 - [ordered_json_document](ordered_json_document.md) - the corresponding document for `ordered_json`
 ## Version history
 Since version 3.13.0.
@@ -1,34 +0,0 @@
 # <small>nlohmann::</small>json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using json_view = basic_json_view<json>;
 ```
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a [`json_document`](json_document.md).
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::json_view`.
    ```cpp
    --8<-- "examples/json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/json_view.output"
    ```
 ## See also
 - [json_document](json_document.md) - the document type this view refers into
 - [ordered_json_view](ordered_json_view.md) - the corresponding view for `ordered_json_document`
 ## Version history
 Since version 3.13.0.
@@ -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
@@ -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.
@@ -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
@@ -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
@@ -1,38 +0,0 @@
 # <small>nlohmann::</small>ordered_json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using ordered_json_document = basic_json_document<ordered_json>;
 ```
 This type is a [`basic_json_document`](basic_json_document/index.md) of the [`ordered_json`](ordered_json.md)
 specialization: [`materialize()`](basic_json_view/materialize.md) on one of its views preserves the insertion order
 of object keys, instead of sorting them like [`json_document`](json_document.md) does.
 ## Examples
 ??? example
    The example below demonstrates how `ordered_json_document` preserves the insertion order of object keys when
    materializing.
    ```cpp
    --8<-- "examples/ordered_json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/ordered_json_document.output"
    ```
 ## See also
 - [ordered_json_view](ordered_json_view.md) - a view of a value of an `ordered_json_document`
 - [json_document](json_document.md) - the corresponding document for the default `json` specialization
 - [Object Order](../features/object_order.md)
 ## Version history
 Since version 3.13.0.
@@ -1,35 +0,0 @@
 # <small>nlohmann::</small>ordered_json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using ordered_json_view = basic_json_view<ordered_json>;
 ```
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
 [`ordered_json_document`](ordered_json_document.md).
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::ordered_json_view`.
    ```cpp
    --8<-- "examples/ordered_json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/ordered_json_view.output"
    ```
 ## See also
 - [ordered_json_document](ordered_json_document.md) - the document type this view refers into
 - [json_view](json_view.md) - the corresponding view for `json_document`
 ## Version history
 Since version 3.13.0.
@@ -21,17 +21,18 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | Compiler                                     | Architecture | Operating System                  | CI        |
        |----------------------------------------------|--------------|-----------------------------------|-----------|
        | AppleClang 15.0.0.15000040; Xcode 15.0.1     | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 15.0.0.15000100; Xcode 15.1       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 15.0.0.15000100; Xcode 15.2       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 15.0.0.15000309; Xcode 15.3       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 15.0.0.15000309; Xcode 15.4       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16         | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16.1       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16.2       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000013; Xcode 16.3       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000013; Xcode 16.4       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000319; Xcode 26.0.1     | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000404; Xcode 26.1.1     | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
        | AppleClang 17.0.0.17000603; Xcode 26.2       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
        | AppleClang 17.0.0.17000604; Xcode 26.3       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
        | AppleClang 21.0.0.21000099; Xcode 26.4.1     | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
        | AppleClang 21.0.0.21000101; Xcode 26.5       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
        | AppleClang 21.0.0.21000101; Xcode 26.6       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
        | Clang 3.4.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 3.5.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 3.6.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
@@ -89,7 +90,7 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | GNU 13.3.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 14.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 15.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | GNU 16.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 16.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 16.1.0                                   | arm64        | Ubuntu 24.04                      | GitHub    |
        | icpc (ICC) 2021.10.0 20230609                | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
        | icpx (Intel oneAPI DPC++/C++) 2025.3.2       | x86_64       | Ubuntu 24.04 LTS                  | GitHub    |
@@ -1,19 +0,0 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // accept() behaves exactly like basic_json::accept(): the same inputs are
    // accepted or rejected, with the same ignore_comments/ignore_trailing_commas
    // options
    std::cout << json_document::accept(R"({"a": 1})") << '\n';
    std::cout << json_document::accept(R"({"a": 1,})") << '\n'; // trailing comma: rejected by default
    std::cout << json_document::accept(R"({"a": 1,})", false, true) << '\n'; // ignore_trailing_commas
    std::cout << (json_document::accept(R"({"a": 1})") == nlohmann::json::accept(R"({"a": 1})")) << '\n';
 }
@@ -1,4 +0,0 @@
 true
 false
 true
 true
@@ -1,23 +0,0 @@
 #include <iostream>
 #include <utility>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // the default constructor creates an empty (discarded) document
    json_document empty;
    std::cout << empty.is_discarded() << '\n';
    // json_document is move-only: parse() itself returns by value (moved out),
    // and a document can be moved again, e.g. into a container
    json_document doc = json_document::parse(R"({"a": 1})");
    json_document moved = std::move(doc);
    std::cout << moved.root().is_object() << '\n';
    // copying is disabled at compile time:
    // json_document another = moved; // does not compile
 }
@@ -1,2 +0,0 @@
 true
 true
@@ -1,19 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // with allow_exceptions == false, a parse error produces a discarded
    // document instead of throwing -- exactly like basic_json::parse()
    json_document doc = json_document::parse(R"({"a": )", /* allow_exceptions */ false);
    std::cout << doc.is_discarded() << '\n';
    std::cout << doc.root().is_discarded() << '\n';
    // a successful parse is never discarded
    json_document ok = json_document::parse(R"({"a": 1})", false);
    std::cout << ok.is_discarded() << '\n';
 }
@@ -1,3 +0,0 @@
 true
 true
 false
@@ -1,28 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // long enough that copying it needs a real (heap) allocation, so the
    // comparison below does not depend on the standard library's small
    // string optimization threshold
    const std::string text = std::string(200, ' ') + "[1, 2, 3, 4, 5]";
    // memory_usage() is not portable across platforms/allocators/compilers, so
    // compare it relatively instead of printing the raw byte count
    json_document borrowed = json_document::parse(text);
    json_document owned = json_document::parse_copy(text);
    // the owned document additionally stores its own copy of the source text
    std::cout << (owned.memory_usage() > borrowed.memory_usage()) << '\n';
    // a document with more values needs a larger index
    json_document small = json_document::parse(std::string("[1]"));
    json_document large = json_document::parse(std::string("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"));
    std::cout << (large.memory_usage() > small.memory_usage()) << '\n';
 }
@@ -1,2 +0,0 @@
 true
 true
@@ -1,15 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    // node_count() is the size of the flat index: one 16-byte node per value,
    // plus one per object key (values and keys are all the index stores)
    json_document scalar = json_document::parse("42");
    std::cout << scalar.node_count() << '\n';
    json_document doc = json_document::parse(R"({"a": 1, "b": [1, 2]})");
    std::cout << doc.node_count() << '\n';
 }
@@ -1,2 +0,0 @@
 1
 7
@@ -1,24 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    std::string text = R"({"a": 1})";
    // borrowed: the document only points into `text`; `text` must outlive it
    json_document borrowed = json_document::parse(text);
    std::cout << borrowed.owns_source() << '\n';
    // owned: parse_copy() always takes its own copy
    json_document copied = json_document::parse_copy(text);
    std::cout << copied.owns_source() << '\n';
    // owned: an rvalue std::string is moved in, not copied, but still owned
    json_document moved_in = json_document::parse(std::string(text));
    std::cout << moved_in.owns_source() << '\n';
 }
@@ -1,3 +0,0 @@
 false
 true
 true
@@ -1,33 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json.hpp>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // an lvalue std::string is BORROWED: the document only stores a pointer
    // into `text`, so `text` must outlive `borrowed`
    std::string text = R"({"count": 3})";
    json_document borrowed = json_document::parse(text);
    std::cout << borrowed.owns_source() << '\n'; // false
    // an rvalue std::string is MOVED into the document -- no copy of the text
    json_document owned = json_document::parse(std::string(R"({"count": 3})"));
    std::cout << owned.owns_source() << '\n'; // true
    // errors are identical to basic_json::parse: same exception id, message,
    // and position, because the library parser runs on the same bytes on a
    // failing input
    try
    {
        static_cast<void>(json_document::parse(R"({"count": )"));
    }
    catch (const nlohmann::json::parse_error& e)
    {
        std::cout << e.id << '\n';
    }
 }
@@ -1,3 +0,0 @@
 false
 true
 101
@@ -1,22 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 json_document parse_from_temporary_buffer()
 {
    char buffer[] = R"({"a": 1})";
    // parse() would borrow `buffer`, which is about to go out of scope;
    // parse_copy() takes its own copy instead, so the returned document does
    // not depend on `buffer` afterward
    return json_document::parse_copy(buffer);
 }
 int main()
 {
    std::cout << std::boolalpha;
    json_document doc = parse_from_temporary_buffer();
    std::cout << doc.owns_source() << '\n';
    std::cout << doc.root().is_object() << '\n';
 }
@@ -1,2 +0,0 @@
 true
 true
@@ -1,22 +0,0 @@
 #include <iostream>
 #include <vector>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // a JSON value embedded in a larger, non-null-terminated buffer (e.g. a
    // slice received over the network)
    std::vector<char> buffer = {'[', '1', ',', '2', ']', 'j', 'u', 'n', 'k'};
    // a pointer pair is BORROWED, exactly like a byte container lvalue: the
    // document points into the buffer. (From C++20 on, std::vector<char>
    // iterators are borrowed as well; before, they are copied.)
    const char* first = buffer.data();
    json_document doc = json_document::parse(first, first + 5);
    std::cout << doc.root().is_array() << ' ' << doc.root().size() << '\n';
    std::cout << doc.owns_source() << '\n'; // false: borrowed
 }
@@ -1,2 +0,0 @@
 true 2
 false
@@ -1,31 +0,0 @@
 #include <iostream>
 #include <string>
 #include <vector>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    std::vector<std::string> messages =
    {
        R"({"id": 1})", R"({"id": 2, "tag": "x"})", R"({"id": 3})"
    };
    // parse into the same document over and over: its node index and decode
    // buffer are reused instead of being freed and reallocated for each message
    json_document doc;
    std::size_t total = 0;
    for (const auto& msg : messages)
    {
        doc.read(msg);
        total += doc.root().size();
    }
    std::cout << total << '\n';
    // read() can also change what kind of input is owned/borrowed between calls
    doc.read(std::string(R"({"owned": true})"));
    std::cout << doc.owns_source() << '\n';
 }
@@ -1,2 +0,0 @@
 4
 true
@@ -1,19 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    json_document doc = json_document::parse(R"({"greeting": "hi"})");
    std::cout << doc.root().is_object() << '\n';
    // root() is a cheap handle, not a copy: repeated calls observe the same value
    std::cout << (doc.root().type() == doc.root().type()) << '\n';
    // the root of a failed parse (allow_exceptions == false) is discarded
    json_document failed = json_document::parse("{", false);
    std::cout << failed.root().is_discarded() << '\n';
 }
@@ -1,3 +0,0 @@
 true
 true
 true
@@ -1,44 +0,0 @@
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    // build a large array (many nodes), then read a small one into the same
    // document: the index grown for the large input is still allocated
    std::ostringstream big;
    big << '[';
    for (int i = 0; i < 500; ++i)
    {
        if (i != 0)
        {
            big << ',';
        }
        big << i;
    }
    big << ']';
    json_document doc;
    doc.read(big.str());
    const std::size_t big_nodes = doc.node_count();
    doc.read(std::string("[1]"));
    std::cout << (doc.node_count() < big_nodes) << '\n'; // far fewer live nodes now
    const std::size_t before = doc.memory_usage();
    // shrink_to_fit() moves the index into a block sized for what is actually
    // used. This INVALIDATES every view taken from this document before the
    // call (they point into the old, now-freed block) -- take fresh ones from
    // root() afterward.
    doc.shrink_to_fit();
    const std::size_t after = doc.memory_usage();
    std::cout << (after <= before) << '\n';
    // a freshly taken view is valid and correct
    std::cout << doc.root().is_array() << ' ' << doc.root().size() << '\n';
 }
@@ -1,3 +0,0 @@
 true
 true
 true 1
@@ -1,20 +0,0 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json_view.hpp>
 using json_document = nlohmann::json_document;
 int main()
 {
    std::cout << std::boolalpha;
    std::string text = R"({"a": 1})";
    json_document doc = json_document::parse(text);
    // source() is the parsed text, whether borrowed or owned
    std::cout << (doc.source().size() == text.size()) << '\n';
    std::cout << std::string(doc.source().data(), doc.source().size()) << '\n';
    // for a borrowed document, source() points right into the caller's buffer
    std::cout << (doc.source().data() == text.data()) << '\n';
 }
@@ -1,3 +0,0 @@
 true
 {"a": 1}
 true
@@ -1,17 +0,0 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 int main()
 {
    std::cout << std::boolalpha;
    // the default constructor is the only public one: it creates an invalid
    // (discarded) view, useful as a "no value yet" placeholder
    nlohmann::json_view v;
    std::cout << static_cast<bool>(v) << ' ' << v.is_discarded() << '\n';
    // views are trivially copyable handles (two pointers); the document owns
    // the actual data
    nlohmann::json_view copy = v;
    std::cout << static_cast<bool>(copy) << '\n';
 }
@@ -1,2 +0,0 @@
 false true
 false
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	1faf93bb39	Document new Xcode and GCC versions in the supported compilers table Versions taken from the CI logs of this PR (Xcode 26.1.1-26.6) and from the gcc:16 image (same digest as gcc:16.2.0 and gcc:latest). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-05 07:45:19 +02:00
Niels Lohmann	fe90fa5cda	Replace retired macOS 14 runner and test all available Xcode versions GitHub retires the macos-14 image on 2026-11-02 (brownouts from 2026-10-05). Xcode 15 is not available on any remaining hosted runner, so drop the macos-14 job and its documented compilers. Also test the Xcode versions that the images provide but CI did not use (26.1.1-26.3 on macos-15, 26.4.1-26.6 on a new macos-26 job), and pin GCC 16 explicitly next to gcc:latest. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 18:10:59 +02:00
Niels LohmannandMuhammad Amir bin Mohamad Ghazaly	8c1f60a45e	Store maps with enum keys as objects (opt-in) (#5600 ) * Store maps with enum keys as objects (opt-in) Maps with enum keys, such as std::map<E, T>, are stored as arrays of [key, value] pairs, because enums are not convertible to the string type of object keys - even if NLOHMANN_JSON_SERIALIZE_ENUM maps them to strings (#4378). The new JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS macro stores them as objects instead, converting each key with the enum's to_json. It applies to any map-like type with enum keys (std::map with any comparator, std::unordered_map, ...). A key that does not convert to a string throws type_error.302, and two keys converting to the same string throw the new type_error.318, rather than losing an entry. The macro changes the output of inline functions, so it is part of the ABI tag (_ekmo). Reading needs no macro: std::map and std::unordered_map with enum keys are now also read from objects, converting each key with the enum's from_json. That input was rejected before, and arrays of pairs are still read, so data written either way can be read. This supersedes #4531, which first proposed storing these maps as objects. Co-authored-by: Muhammad Amir bin Mohamad Ghazaly <amirghaz@umich.edu> Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 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> * Move the default enum-keyed map tests out of unit-conversions.cpp The Windows clang 20.1.8 job (MinGW, Debug) failed to link test-conversions_cpp17 with "relocation truncated to fit: IMAGE_REL_AMD64_REL32 against .rdata": the object file of unit-conversions.cpp was already close to the limit, and the new "maps with enum keys" test case pushed it over. windows.yml asks to keep these objects small by splitting test files. Move the test case unchanged into unit-enum_keyed_maps_default.cpp, with the three enums it needs. It still honors a -D flag for JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS, as before. unit-conversions.cpp is back to its state on develop. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Build the enum-keyed map test object instead of parsing it ci_test_diagnostic_positions failed in unit-enum_keyed_maps_default.cpp: with JSON_DIAGNOSTIC_POSITIONS, a parsed value adds its byte range to the exception message ("(bytes 0-7) type must be array, but is object"), so the exact-message checks did not match. Build the object in memory, like unit-custom-array-type.cpp does. Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me> Co-authored-by: Muhammad Amir bin Mohamad Ghazaly <amirghaz@umich.edu>	2026-10-04 17:54:05 +02:00
Niels Lohmann	6b4b825af2	Handle numbers that do not fit narrow number types in the binary readers (#5607 ) * Handle numbers that do not fit narrow number types in the binary readers With custom number types narrower than the values in a binary document, for example basic_json<..., std::int32_t, std::uint32_t, float>, every binary reader (CBOR, MessagePack, UBJSON, BJData, BSON, BON8) passed the decoded number to the SAX interface with an implicit conversion: the integer 5000000000 silently became 705032704, and a finite double such as 1e300 became infinity. The lexer handles the same values in JSON text: an integer that fits neither integer type is stored as number_float_t, and a finite number that overflows number_float_t is rejected with out_of_range.406. Pass every number read from binary input through three helpers that apply the lexer's rules: - emit_signed(): number_integer_t, else number_unsigned_t for a non-negative value, else number_float_t - emit_unsigned(): number_unsigned_t, else number_float_t - emit_float(): out_of_range.406 if a finite value overflows number_float_t; infinity and NaN are passed on For consistency, a CBOR negative integer below the range of number_integer_t is now stored as number_float_t, like a too small integer in JSON text, instead of being rejected with parse_error.112. With the default number types, this is the only change in behavior. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Fix MSVC and clang 3.5 in the narrow number type test MSVC types 3000000000 and 5000000000 as unsigned long, so json(-3000000000) triggered C4146 (unary minus on an unsigned type), which /WX turns into an error. Use LL literals, as elsewhere in the tests. clang 3.5 cannot convert the lambdas in the braced initializer of the format table to function pointers. Use named functions instead. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Check integer-to-float fallbacks for overflow in the binary readers emit_signed, emit_unsigned, and the CBOR negative integer fallback now pass their number_float_t fallback through emit_float, so a value that overflows number_float_t is rejected with out_of_range.406 like a floating-point value, instead of silently becoming infinity. This only matters for a number_float_t that cannot represent 2^64, such as a half-precision type. The CBOR value -1 - n is computed as long double so that emit_float sees a finite value. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Use the input_format member instead of passing the format to binary_reader helpers The helpers (get_number, get_to, get_string, get_binary, get_bytes, emit_signed, emit_unsigned, emit_float, unexpect_eof, exception_message) are members of binary_reader, which already stores the format it was constructed with, so the parameter was redundant. Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 17:53:29 +02:00