Address the cpplint findings of json_view's comparisons

compare.hpp includes <string> (build/include_what_you_use). Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Address the clang-tidy findings of the comparisons
2026-09-29 19:20:30 +00:00 · 2026-09-29 14:03:01 +02:00 · 2026-09-29 14:03:01 +02:00 · 2026-09-29 14:03:00 +02:00 · 2026-09-29 14:02:59 +02:00 · 2026-09-29 14:02:58 +02:00
261 changed files with 20515 additions and 428 deletions
@@ -45,6 +45,23 @@ 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$"
@@ -67,12 +67,13 @@ 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 .
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/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.hpp $INCLUDE_DIR/json_fwd.hpp $INCLUDE_DIR/json_view.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
@@ -20,7 +20,9 @@ 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",
        "include/nlohmann/detail/conversions/to_chars.hpp",
        "include/nlohmann/detail/conversions/to_json.hpp",
@@ -33,6 +35,7 @@ cc_library(
        "include/nlohmann/detail/input/number_parse.hpp",
        "include/nlohmann/detail/input/parser.hpp",
        "include/nlohmann/detail/input/position_t.hpp",
        "include/nlohmann/detail/input/pow5_table.hpp",
        "include/nlohmann/detail/input/string_scan.hpp",
        "include/nlohmann/detail/iterators/internal_iterator.hpp",
        "include/nlohmann/detail/iterators/iter_impl.hpp",
@@ -63,8 +66,26 @@ 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/compare.hpp",
        "include/nlohmann/detail/view/document_data.hpp",
        "include/nlohmann/detail/view/errors.hpp",
        "include/nlohmann/detail/view/input.hpp",
        "include/nlohmann/detail/view/iterator.hpp",
        "include/nlohmann/detail/view/lookup.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/pointer.hpp",
        "include/nlohmann/detail/view/scan.hpp",
        "include/nlohmann/detail/view/serializer.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_view.hpp",
        "include/nlohmann/ordered_map.hpp",
        "include/nlohmann/thirdparty/hedley/hedley.hpp",
        "include/nlohmann/thirdparty/hedley/hedley_undef.hpp",
@@ -77,6 +98,7 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -21,6 +21,7 @@ TESTS_SRCS=$(shell find tests -type f \( -name '*.hpp' -o -name '*.cpp' -o -name
 # the single headers (amalgamated from the source files)
 AMALGAMATED_FILE=single_include/nlohmann/json.hpp
 AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 AMALGAMATED_VIEW_FILE=single_include/nlohmann/json_view.hpp
 ##########################################################################
@@ -29,7 +30,7 @@ AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # main target
 all:
-	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd}.hpp from the include/nlohmann sources"
+	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_view}.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"
@@ -39,6 +40,7 @@ all:
 	@echo "fuzz_testing_bon8 - prepare fuzz testing of the BON8 parser"
 	@echo "fuzz_testing_bson - prepare fuzz testing of the BSON parser"
 	@echo "fuzz_testing_cbor - prepare fuzz testing of the CBOR parser"
 	@echo "fuzz_testing_json_view - prepare fuzz testing of the json_document/json_view parser"
 	@echo "fuzz_testing_msgpack - prepare fuzz testing of the MessagePack parser"
 	@echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser"
 	@echo "pretty - beautify code with Artistic Style"
@@ -96,6 +98,14 @@ fuzz_testing_cbor:
 	find tests/data -size -5k -name *.cbor | xargs -I{} cp "{}" fuzz-testing/testcases
 	@echo "Execute: afl-fuzz -i fuzz-testing/testcases -o fuzz-testing/out fuzz-testing/fuzzer"
 fuzz_testing_json_view:
 	rm -fr fuzz-testing
 	mkdir -p fuzz-testing fuzz-testing/testcases fuzz-testing/out
 	$(MAKE) parse_json_view_fuzzer -C tests CXX=afl-clang++
 	mv tests/parse_json_view_fuzzer fuzz-testing/fuzzer
 	find tests/data/json_tests -size -5k -name *json | xargs -I{} cp "{}" fuzz-testing/testcases
 	@echo "Execute: afl-fuzz -i fuzz-testing/testcases -o fuzz-testing/out fuzz-testing/fuzzer"
 fuzz_testing_msgpack:
 	rm -fr fuzz-testing
 	mkdir -p fuzz-testing fuzz-testing/testcases fuzz-testing/out
@@ -154,14 +164,14 @@ 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) docs/mkdocs/docs/examples/*.cpp
+	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_VIEW_FILE) docs/mkdocs/docs/examples/*.cpp
 # call the Clang-Format on all source files
 pretty_format:
 	for FILE in $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) docs/mkdocs/docs/examples/*.cpp; do echo $$FILE; clang-format -i $$FILE; done
 # create single header files and pretty print
-amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE)
+amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_VIEW_FILE)
 	$(MAKE) pretty
 # call the amalgamation tool for json.hpp
@@ -172,16 +182,23 @@ $(AMALGAMATED_FILE): $(SRCS)
 $(AMALGAMATED_FWD_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_fwd.json -s . --verbose=yes
 # 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
 # check if file single_include/nlohmann/json.hpp has been amalgamated from the nlohmann sources
 # Note: this target is called by Travis
 check-amalgamation:
 	@mv $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~
 	@mv $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_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_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_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)
@@ -222,7 +239,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) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_VIEW_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
@@ -231,11 +248,13 @@ release: include.zip json.tar.xz
 	gpg --armor --detach-sig include.zip
 	gpg --armor --detach-sig $(AMALGAMATED_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_FWD_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
-	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
+	cp $(AMALGAMATED_VIEW_FILE) release_files
-	cd release_files ; shasum -a 256 json.hpp include.zip json.tar.xz > hashes.txt
+	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_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 json.hpp json_view.hpp include.zip json.tar.xz > hashes.txt
 ##########################################################################
@@ -1189,6 +1189,14 @@ 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).
@@ -1395,6 +1403,8 @@ 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 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">
@@ -373,9 +373,10 @@ file(GLOB_RECURSE INDENT_FILES
 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~
+    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_view.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_view.hpp ${include_dir}/json_view.hpp~
    COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
    COMMAND venv_astyle/bin/pip3 --quiet install -r ${CMAKE_SOURCE_DIR}/tools/astyle/requirements.txt
@@ -383,10 +384,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 venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.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 ${include_dir}/json_view.hpp
    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_view.hpp~ ${include_dir}/json_view.hpp
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
    COMMAND for FILE in `find . -name '*.orig'`\; do false \; done
@@ -48,6 +48,7 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -128,7 +128,66 @@ 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::at', 'Method', 'api/basic_json_view/at/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::back', 'Method', 'api/basic_json_view/back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::begin', 'Method', 'api/basic_json_view/begin/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cbegin', 'Method', 'api/basic_json_view/cbegin/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cend', 'Method', 'api/basic_json_view/cend/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::contains', 'Method', 'api/basic_json_view/contains/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::count', 'Method', 'api/basic_json_view/count/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::dump', 'Method', 'api/basic_json_view/dump/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::end', 'Method', 'api/basic_json_view/end/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::find', 'Method', 'api/basic_json_view/find/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::front', 'Method', 'api/basic_json_view/front/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get', 'Method', 'api/basic_json_view/get/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_string', 'Method', 'api/basic_json_view/get_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_to', 'Method', 'api/basic_json_view/get_to/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::items', 'Method', 'api/basic_json_view/items/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::number_format', 'Enum', 'api/basic_json_view/number_format/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_token', 'Method', 'api/basic_json_view/number_token/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::operator<<', 'Operator', 'api/basic_json_view/operator_ltlt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator[]', 'Operator', 'api/basic_json_view/operator[]/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator==', 'Operator', 'api/basic_json_view/operator_eq/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator!=', 'Operator', 'api/basic_json_view/operator_ne/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 ('basic_json_view::type_name', 'Method', 'api/basic_json_view/type_name/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::value', 'Method', 'api/basic_json_view/value/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');
@@ -162,6 +221,8 @@ 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::hash<basic_json>', 'Class', 'api/basic_json/std_hash/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::swap<basic_json>', 'Function', 'api/basic_json/std_swap/index.html');
@@ -191,6 +252,7 @@ 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');
@@ -219,6 +219,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [checked access](../../features/element_access/checked_access.md)
 - [`operator[]`](operator%5B%5D.md) for unchecked access by reference
 - [`value`](value.md) for access with default value
 - [basic_json_view::at](../basic_json_view/at.md) - the same access on a zero-copy view
 ## Version history
@@ -58,6 +58,7 @@ Constant.
 ## See also
 - [front](front.md) to access the first element
 - [basic_json_view::back](../basic_json_view/back.md) - the same access on a zero-copy view
 ## Version history
@@ -37,6 +37,12 @@ Constant.
    --8<-- "examples/begin.output"
    ```
 ## See also
 - [end](end.md) - returns an iterator to one past the last element
 - [basic_json_view::begin](../basic_json_view/begin.md) - the same iteration on a zero-copy view (in document order,
  not sorted by key)
 ## Version history
 - Added in version 1.0.0.
@@ -36,6 +36,11 @@ Constant.
    --8<-- "examples/cbegin.output"
    ```
 ## See also
 - [cend](cend.md) - returns a const iterator to one past the last element
 - [basic_json_view::cbegin](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -36,6 +36,11 @@ Constant.
    --8<-- "examples/cend.output"
    ```
 ## See also
 - [cbegin](cbegin.md) - returns a const iterator to the first element
 - [basic_json_view::cend](../basic_json_view/cend.md) - the same iteration on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -111,6 +111,7 @@ Logarithmic in the size of the JSON object.
 - [find](find.md) find a value in an object
 - [count](count.md) returns the number of occurrences of a key
 - [basic_json_view::contains](../basic_json_view/contains.md) - the same check on a zero-copy view
 ## Version history
@@ -76,6 +76,7 @@ This method always returns `0` when executed on a JSON type that is not an objec
 - [find](find.md) find a value in an object
 - [contains](contains.md) checks whether a key exists
 - [basic_json_view::count](../basic_json_view/count.md) - the same check on a zero-copy view
 ## Version history
@@ -86,6 +86,8 @@ Binary values are serialized as an object containing two keys:
 - [to_string](to_string.md) returns a string representation of a JSON value
 - [operator<<](../operator_ltlt.md) serialize to stream
 - [`basic_json_view::dump`](../basic_json_view/dump.md) the corresponding function of `basic_json_view`, serializing
  directly from a flat index without building a `basic_json` value
 - [Serialization](../../features/serialization.md) - the serialization article
 ## Version history
@@ -60,6 +60,10 @@ itself is empty which is `#!cpp false` in the case of a string.
    --8<-- "examples/empty.output"
    ```
 ## See also
 - [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -37,6 +37,11 @@ Constant.
    --8<-- "examples/end.output"
    ```
 ## See also
 - [begin](begin.md) - returns an iterator to the first element
 - [basic_json_view::end](../basic_json_view/end.md) - the same iteration on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -80,6 +80,7 @@ This method always returns `end()` when executed on a JSON type that is not an o
 - [count](count.md) returns the number of occurrences of a key
 - [contains](contains.md) checks whether a key exists
 - [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view
 ## Version history
@@ -51,6 +51,7 @@ Constant.
 ## See also
 - [back](back.md) to access the last element
 - [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view
 ## Version history
@@ -163,6 +163,8 @@ overload (3).
 - [get_ref](get_ref.md) get a reference to the stored value
 - [operator ValueType](operator_ValueType.md) get a value via implicit conversion
 - [Converting values](../../features/conversions.md) - the type conversions article
 - [basic_json_view::get](../basic_json_view/get.md) - the same conversion on a zero-copy view (many types are
  converted without ever building a `basic_json` value)
 ## Version history
@@ -61,6 +61,8 @@ Constant.
 ## See also
 - [get_ptr()](get_ptr.md) get a pointer value
 - [basic_json_view::get_string](../basic_json_view/get_string.md) - the closest counterpart on a zero-copy view: a
  string without a copy, but as a view rather than a reference to a value that must already exist
 ## Version history
@@ -67,6 +67,7 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 - [get_ref](get_ref.md) get a reference to the stored value
 - [get_ptr](get_ptr.md) get a pointer to the stored value
 - [Converting values](../../features/conversions.md) - the type conversions article
 - [basic_json_view::get_to](../basic_json_view/get_to.md) - the same conversion on a zero-copy view
 ## Version history
@@ -34,6 +34,10 @@ Constant.
    --8<-- "examples/is_array.output"
    ```
 ## See also
 - [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -34,6 +34,10 @@ Constant.
    --8<-- "examples/is_binary.output"
    ```
 ## See also
 - [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 3.8.0.
@@ -34,6 +34,10 @@ Constant.
    --8<-- "examples/is_boolean.output"
    ```
 ## See also
 - [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -69,6 +69,11 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
    --8<-- "examples/is_discarded.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.
@@ -34,6 +34,10 @@ Constant.
    --8<-- "examples/is_null.output"
    ```
 ## See also
 - [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -49,6 +49,7 @@ 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,6 +40,7 @@ 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,6 +40,7 @@ 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,6 +40,7 @@ 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
@@ -34,6 +34,10 @@ Constant.
    --8<-- "examples/is_object.output"
    ```
 ## See also
 - [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -62,6 +62,7 @@ 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
@@ -34,6 +34,10 @@ Constant.
    --8<-- "examples/is_string.output"
    ```
 ## See also
 - [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -57,6 +57,7 @@ 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
@@ -99,6 +99,8 @@ When iterating over an array, `key()` will return the index of the element as st
 - [begin](begin.md) returns an iterator to the first element
 - [end](end.md) returns an iterator to one past the last element
 - [basic_json_view::items](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
  not `#!cpp const auto&`: items are produced on the fly)
 ## Version history
@@ -254,6 +254,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [runtime assertions](../../features/assertions.md)
 - see [`at`](at.md) for access by reference with range checking
 - see [`value`](value.md) for access with default value
 - [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (always
  returns a discarded view instead of assuming undefined behavior)
 ## Version history
@@ -166,6 +166,8 @@ Linear.
 - [operator!=](operator_ne.md) compare for inequality
 - [operator<=>](operator_spaceship.md) comparison: 3-way (C++20)
 - [basic_json_view::operator==](../basic_json_view/operator_eq.md) - the same comparison on a zero-copy view, without
  building a `basic_json` value for it
 ## Version history
@@ -89,6 +89,12 @@ Linear.
    --8<-- "examples/operator__notequal__nullptr_t.output"
    ```
 ## See also
 - [operator==](operator_eq.md) compare for equality
 - [basic_json_view::operator!=](../basic_json_view/operator_ne.md) - the same comparison on a zero-copy view, without
  building a `basic_json` value for it
 ## Version history
 1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove 
@@ -51,6 +51,10 @@ JSON value which is `1` in the case of a string.
    --8<-- "examples/size.output"
    ```
 ## See also
 - [basic_json_view::size](../basic_json_view/size.md) - the same function on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -47,6 +47,10 @@ Constant.
    --8<-- "examples/type.output"
    ```
 ## See also
 - [basic_json_view::type](../basic_json_view/type.md) - the same function on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -52,6 +52,11 @@ Constant.
    --8<-- "examples/type_name.output"
    ```
 ## See also
 - [type](type.md) - return the type of the JSON value
 - [basic_json_view::type_name](../basic_json_view/type_name.md) - the same function on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -181,6 +181,7 @@ changes to any JSON value.
 - see [`at`](at.md) for access by reference with range checking
 - see [`operator[]`](operator%5B%5D.md) for unchecked access by reference
 - [basic_json_view::value](../basic_json_view/value.md) - the same access on a zero-copy view
 ## Version history
@@ -0,0 +1,67 @@
 # <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.
@@ -0,0 +1,58 @@
 # <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.
@@ -0,0 +1,56 @@
 # <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.
@@ -0,0 +1,49 @@
 # <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.
@@ -0,0 +1,50 @@
 # <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.
@@ -0,0 +1,49 @@
 # <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.
@@ -0,0 +1,49 @@
 # <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.
@@ -0,0 +1,139 @@
 # <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.
@@ -0,0 +1,77 @@
 # <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.
@@ -0,0 +1,76 @@
 # <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.
@@ -0,0 +1,50 @@
 # <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.
@@ -0,0 +1,58 @@
 # <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.
@@ -0,0 +1,48 @@
 # <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.
@@ -0,0 +1,132 @@
 # <small>nlohmann::basic_json_view::</small>at
 ```cpp
 // (1)
 basic_json_view at(string_view_t key) const;
 basic_json_view at(const char* key) const;
 basic_json_view at(const string_t& key) const;
 // (2)
 basic_json_view at(size_type idx) const;
 basic_json_view at(int idx) const;
 // (3)
 basic_json_view at(const json_pointer& ptr) const;
 ```
 1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
   [Notes on duplicate keys](operator[].md#notes)).
 2. Returns the array element at index `idx`.
 3. Returns the value a JSON pointer `ptr` refers to, starting at this value.
 ## Parameters
 `key` (in)
 :   object key of the element to access
 `idx` (in)
 :   index of the element to access
 `ptr` (in)
 :   JSON pointer to the element to access
 ## Return value
 1. the value of the first member with key `key`
 2. the element at index `idx`
 3. the value `ptr` resolves to, starting at this value
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 1. The function can throw the following exceptions, both with the same message as the corresponding call to
   [`BasicJsonType::at`](../basic_json/at.md):
    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an object.
    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if no member has key `key`.
 2. The function can throw the following exceptions, both with the same message as the corresponding call to
   [`BasicJsonType::at`](../basic_json/at.md):
    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an array.
    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `#!cpp idx >= size()`.
 3. The function can throw the following exceptions, all with the same message as the corresponding call to
   [`BasicJsonType::at`](../basic_json/at.md):
    - Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr`
      begins with `#!cpp '0'`.
    - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is
      not a number.
    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index in `ptr`
      is out of range.
    - Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is
      `#!cpp "-"` at an array -- `at` never inserts an element, so `#!cpp "-"` is always invalid.
    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a reference token names
      an object member that does not exist.
    - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if `ptr` cannot be resolved
      because a reference token is used on a primitive value.
 None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
   another, in document order, stopping at the first match. Each comparison first checks the key's length --
   already known from the index, without reading the key bytes -- before comparing its content.
 2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
   index (unlike `BasicJsonType`'s array, which is random-access).
 3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level (as 1.) or the index into the array (as 2.).
 ## Notes
 Unlike [`operator[]`](operator[].md), which returns a [discarded](is_discarded.md) view for a missing key or an
 out-of-range index, `at` always throws -- exactly as `BasicJsonType::at` does, and with the same messages, so
 existing error handling written against `BasicJsonType::at` keeps working unchanged when switched to a view. This
 also holds for overload 3: unlike [`operator[]`](operator[].md) with a JSON pointer, which returns a discarded view
 for a missing key or an out-of-range index, `at` throws for those too (`out_of_range.403`/`out_of_range.401`).
 ## Examples
 ??? example "Example: (1)/(2) access specified element with bounds checking"
    The example below reads required fields out of a service configuration with `at`, and shows that the exceptions
    it throws -- for a wrong type and for a missing key -- carry the same messages
    [`BasicJsonType::at`](../basic_json/at.md) would produce for the same JSON text.
    ```cpp
    --8<-- "examples/basic_json_view__at.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__at.output"
    ```
 ??? example "Example: (3) access specified element via JSON pointer with bounds checking"
    The example below shows that `at` with a JSON pointer throws exactly the exceptions, with exactly the messages,
    that [`BasicJsonType::at`](../basic_json/at.md) throws for the same pointer and the same document.
    ```cpp
    --8<-- "examples/basic_json_view__at_json_pointer.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__at_json_pointer.output"
    ```
 ## See also
 - [operator[]](operator[].md) - access specified element (returns a discarded view instead of throwing)
 - [front](front.md), [back](back.md) - access the first or last element
 - [`BasicJsonType::at`](../basic_json/at.md) - the corresponding function of `basic_json`
 - [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,64 @@
 # <small>nlohmann::basic_json_view::</small>back
 ```cpp
 basic_json_view back() const;
 ```
 Returns the last element of an array, the last member value of an object, or the value itself if it is primitive
 (as for [`BasicJsonType::back()`](../basic_json/back.md), a primitive value is a range of one element).
 ## Return value
 The last element or member value. For a primitive value (number, string, boolean), the value itself.
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
 [null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
 This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 Linear in the size of the array or object: unlike [`front()`](front.md), which only ever looks at the first
 element, `back()` has to walk every element to find where they end, since elements are not a fixed size in the
 index.
 ## Notes
 Unlike [`BasicJsonType::back()`](../basic_json/back.md), which has undefined behavior for an empty array or object,
 `back()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and for a
 discarded view, where `BasicJsonType::back()` also throws.
 ## Examples
 ??? example
    The example below reads only the final status of a build log with `back()`. Even though `back()` is linear in
    the number of events (unlike [`front()`](front.md), which is constant), it still avoids building a
    `BasicJsonType` value for the events that are not needed.
    ```cpp
    --8<-- "examples/basic_json_view__back.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__back.output"
    ```
 ## See also
 - [front](front.md) - access the first element
 - [`BasicJsonType::back`](../basic_json/back.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,52 @@
 # <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 by
 navigating into a container with [`operator[]`](operator[].md), [`at`](at.md), [`front`](front.md), [`back`](back.md),
 [`find`](find.md), or iteration.
 ## 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.
@@ -0,0 +1,61 @@
 # <small>nlohmann::basic_json_view::</small>begin
 ```cpp
 iterator begin() const noexcept;
 ```
 Returns an iterator to the first element of an array, or the first member value of an object, in **document order**
 -- the order the values appear in the source text, not sorted by key. A primitive value iterates as a range of one
 element (itself); `#!json null` and a [discarded](is_discarded.md) view iterate as an empty range.
 ## Return value
 Iterator to the first element.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 For an object, iteration visits **every** member, including all occurrences of a duplicate key -- unlike
 [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), [`contains`](contains.md), and [`count`](count.md),
 which all resolve to the *first* member with a given key. See the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]`.
 Because objects are iterated in document order rather than sorted by key, the order seen here can differ from what
 iterating the [`materialize()`](materialize.md)d `BasicJsonType` value would produce: a `#!cpp basic_json` object
 (`std::map`-backed by default) sorts its keys, while a view does not.
 ## Examples
 ??? example
    The example below iterates a log record's members with `begin()`/[`end()`](end.md) and prints them in the order
    they were written. Materializing the record into a `BasicJsonType` object and iterating that would instead print
    the members sorted by key.
    ```cpp
    --8<-- "examples/basic_json_view__begin.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__begin.output"
    ```
 ## See also
 - [end](end.md) - returns an iterator to one past the last element
 - [cbegin](cbegin.md) - returns a const iterator to the first element
 - [items](items.md) - access iterator member functions in range-based for
 - [`BasicJsonType::begin`](../basic_json/begin.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,49 @@
 # <small>nlohmann::basic_json_view::</small>cbegin
 ```cpp
 iterator cbegin() const noexcept;
 ```
 Returns an iterator to the first element, in [document order](begin.md). Equivalent to [`begin()`](begin.md): a view
 is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cbegin()` exists only so
 that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
 ## Return value
 Iterator to the first element; identical to what [`begin()`](begin.md) returns.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below sums many measurements with `std::accumulate`, using `cbegin()`/[`cend()`](cend.md) as the
    range -- the same way it would for any standard container -- without ever materializing the whole array into a
    `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__cbegin.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__cbegin.output"
    ```
 ## See also
 - [begin](begin.md) - returns an iterator to the first element
 - [cend](cend.md) - returns a const iterator to one past the last element
 - [`BasicJsonType::cbegin`](../basic_json/cbegin.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,49 @@
 # <small>nlohmann::basic_json_view::</small>cend
 ```cpp
 iterator cend() const noexcept;
 ```
 Returns an iterator to one past the last element, in [document order](begin.md). Equivalent to [`end()`](end.md): a
 view is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cend()` exists only
 so that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
 ## Return value
 Iterator one past the last element; identical to what [`end()`](end.md) returns.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below checks that every record of a batch is an object with `std::all_of`, using
    [`cbegin()`](cbegin.md)/`cend()` as the range -- the same way it would for any standard container -- before
    materializing any record of the batch.
    ```cpp
    --8<-- "examples/basic_json_view__cend.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__cend.output"
    ```
 ## See also
 - [end](end.md) - returns an iterator to one past the last element
 - [cbegin](cbegin.md) - returns a const iterator to the first element
 - [`BasicJsonType::cend`](../basic_json/cend.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,101 @@
 # <small>nlohmann::basic_json_view::</small>contains
 ```cpp
 // (1)
 bool contains(string_view_t key) const;
 bool contains(const char* key) const;
 bool contains(const string_t& key) const;
 // (2)
 bool contains(const json_pointer& ptr) const;
 ```
 1. Checks whether the value is an object with a member with key `key`.
 2. Checks whether a JSON pointer `ptr` can be resolved, starting at this value.
 ## Parameters
 `key` (in)
 :   key value to check its existence
 `ptr` (in)
 :   JSON pointer to check its existence
 ## Return value
 1. `#!cpp true` if the value is an object and has a member with key `key`, `#!cpp false` otherwise
 2. `#!cpp true` if `ptr` can be resolved to a value starting at this view, `#!cpp false` otherwise
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
   another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
   known from the index, without reading the key bytes -- before comparing its content.
 2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level or the index into the array -- as for [`operator[]`](operator[].md#complexity) and
   [`at`](at.md#complexity) with a JSON pointer.
 ## Notes
 Overload 1 always returns `#!cpp false` when the value is not an object -- including a [discarded](is_discarded.md)
 view.
 !!! info "Postconditions"
    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
    `#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
    throw.
 !!! info "Overload 2 never throws"
    Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
    malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
    an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
    simply make it return `#!cpp false`.
 ## Examples
 ??? example "Example: (1) check with key"
    The example below counts how many of a batch of records carry an optional `retry_of` field, using `contains()`
    to check without ever materializing a single record of the batch.
    ```cpp
    --8<-- "examples/basic_json_view__contains.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__contains.output"
    ```
 ??? example "Example: (2) check with JSON pointer"
    The example below checks an optional, nested field with a JSON pointer, and shows two pointers that
    `#!cpp contains()` resolves to `#!cpp false` without throwing.
    ```cpp
    --8<-- "examples/basic_json_view__contains_json_pointer.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__contains_json_pointer.output"
    ```
 ## See also
 - [find](find.md) - find a value in an object
 - [count](count.md) - returns the number of occurrences of a key
 - [at](at.md), [operator[]](operator[].md) - resolve a JSON pointer and throw, or return a discarded view
 - [`BasicJsonType::contains`](../basic_json/contains.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,66 @@
 # <small>nlohmann::basic_json_view::</small>count
 ```cpp
 size_type count(string_view_t key) const;
 size_type count(const char* key) const;
 size_type count(const string_t& key) const;
 ```
 Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp 0` otherwise.
 ## Parameters
 `key` (in)
 :   key value of the element to count
 ## Return value
 `#!cpp 1` if the value is an object and has a member with key `key`, `#!cpp 0` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
 another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
 known from the index, without reading the key bytes -- before comparing its content.
 ## Notes
 This method always returns `#!cpp 0` when the value is not an object -- including a [discarded](is_discarded.md)
 view.
 Unlike [`BasicJsonType::count()`](../basic_json/count.md), whose return value can in principle exceed `#!cpp 1` for
 an `ObjectType` that allows multiple entries per key, `count()` here never does: it is exactly
 [`contains()`](contains.md) as `#!cpp 0`/`#!cpp 1`. This holds even if the source text has a duplicate key -- see the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]` -- because a `#!cpp count() > 1` result would require
 counting every member with a matching key, not just finding the first one.
 ## Examples
 ??? example
    The example below validates that every transaction of a batch carries a mandatory `amount` field, using
    `count()` before deciding whether to materialize a transaction at all.
    ```cpp
    --8<-- "examples/basic_json_view__count.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__count.output"
    ```
 ## See also
 - [find](find.md) - find a value in an object
 - [contains](contains.md) - checks whether a key exists
 - [`BasicJsonType::count`](../basic_json/count.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,102 @@
 # <small>nlohmann::basic_json_view::</small>dump
 ```cpp
 string_t dump(const int indent = -1,
              const char indent_char = ' ',
              const bool ensure_ascii = false,
              const number_format numbers = number_format::shortest) const;
 ```
 Serializes this value (and its subtree) directly from the flat index, without ever building a `BasicJsonType` value
 first. With the default `#!cpp numbers == number_format::shortest`, the result is the same string
 [`BasicJsonType::dump`](../basic_json/dump.md) would produce for the value
 [`BasicJsonType::parse()`](../basic_json/parse.md) builds from the same source text, called with the same `indent`,
 `indent_char`, and `ensure_ascii` -- except that members of an object appear in document order rather than sorted by
 key, and *every* occurrence of a repeated key is written rather than only the last one (see
 [Notes on duplicate keys](operator[].md#notes)). For a `json_view` (whose `BasicJsonType` is not ordered), this means
 `dump()` can print an object's members in a different order than [`materialize()`](materialize.md)`.dump()` of the
 same subtree.
 ## Parameters
 `indent` (in)
 :   If `indent` is nonnegative, array elements and object members are pretty-printed with that indent level. An
    indent level of `0` only inserts newlines. `-1` (the default) selects the most compact representation.
 `indent_char` (in)
 :   The character used for indentation if `indent` is greater than `0`. The default is ` ` (space).
 `ensure_ascii` (in)
 :   If `ensure_ascii` is `#!cpp true`, all non-ASCII characters in the output are escaped with `\uXXXX` sequences, and
    the result consists of ASCII characters only.
 `numbers` (in)
 :   how to write numbers, see [`number_format`](number_format.md): `shortest` (the default) writes them the way
    [`BasicJsonType::dump`](../basic_json/dump.md) would; `source` copies every number exactly as it appears in the
    source text.
 ## Return value
 string containing the serialization of this value, or `#!cpp "<discarded>"` if the view is
 [discarded](is_discarded.md).
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 May throw `#!cpp std::bad_alloc` if allocating the output string fails. Unlike
 [`BasicJsonType::dump`](../basic_json/dump.md), there is no `error_handler` parameter and no
 [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316): the view only ever holds text the parser
 already validated as UTF-8, so there is nothing to replace or ignore.
 ## Complexity
 Linear in the size of the output text.
 ## Notes
 The walk over the subtree is iterative, so the nesting depth it can write is limited by available memory only, not by
 the call stack -- as for [`materialize()`](materialize.md).
 Strings are escaped by the same rules as [`BasicJsonType::dump`](../basic_json/dump.md). With
 `#!cpp numbers == number_format::shortest`, floats are written with the library's shortest round-trip conversion,
 exactly as [`BasicJsonType::dump`](../basic_json/dump.md) would (e.g. `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`), and
 integers are copied from the source text -- already canonical in JSON, so this matches their shortest form too --
 except that `#!cpp -0` is written as `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it.
 `#!cpp number_format::source` copies every number exactly as written in the source text instead, with no exception
 for `#!cpp -0` -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0.0`, `#!cpp -0`, or all digits of an integer literal with more
 digits than any number type holds (such a literal is itself classified as a float, see
 [What is different](../../features/json_view.md#what-is-different)) -- something `BasicJsonType` cannot do, since
 parsing already reduces every number to its parsed value.
 ## Examples
 ??? example
    The example below forwards a single record out of a larger batch, and re-serializes a configuration file, both
    without ever building a `BasicJsonType` value for the surrounding array or for the parts of it that were not
    needed. It also shows that [`materialize()`](materialize.md)`.dump()` of the configuration sorts its keys, where
    `dump()` on the view keeps the order they appear in the source text.
    ```cpp
    --8<-- "examples/basic_json_view__dump.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__dump.output"
    ```
 ## See also
 - [`number_format`](number_format.md) - how `dump()` writes numbers
 - [operator<<](operator_ltlt.md) - serialize this value to a stream
 - [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to use `BasicJsonType::dump`'s `error_handler`
 - [`BasicJsonType::dump`](../basic_json/dump.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,61 @@
 # <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.
@@ -0,0 +1,54 @@
 # <small>nlohmann::basic_json_view::</small>end
 ```cpp
 iterator end() const noexcept;
 ```
 Returns an iterator to one past the last element of an array, one past the last member value of an object, in
 **document order** -- see [`begin()`](begin.md). A primitive value iterates as a range of one element (itself);
 `#!json null` and a [discarded](is_discarded.md) view iterate as an empty range, so `#!cpp begin() == end()` for
 them.
 ## Return value
 Iterator one past the last element.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `#!cpp iterator` is a forward iterator: unlike `BasicJsonType::iterator`, it cannot be decremented, so there is no
 way to reach the last element by stepping back from `end()`. Use [`back()`](back.md) instead.
 ## Examples
 ??? example
    The example below scans a (possibly large) array of readings for the first one over a threshold, stopping the
    loop at `end()` as soon as one is found. Only the matching reading, if any, is ever materialized.
    ```cpp
    --8<-- "examples/basic_json_view__end.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__end.output"
    ```
 ## See also
 - [begin](begin.md) - returns an iterator to the first element
 - [cend](cend.md) - returns a const iterator to one past the last element
 - [`BasicJsonType::end`](../basic_json/end.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,63 @@
 # <small>nlohmann::basic_json_view::</small>find
 ```cpp
 iterator find(string_view_t key) const;
 iterator find(const char* key) const;
 iterator find(const string_t& key) const;
 ```
 Finds a member with key `key` -- the first one, should the key occur more than once (see
 [Notes on duplicate keys](operator[].md#notes)). If the value is not an object, or no member has this key,
 [`end()`](end.md) is returned.
 ## Parameters
 `key` (in)
 :   key value of the element to search for
 ## Return value
 An iterator to the member with key `key`, or [`end()`](end.md) if there is none or the value is not an object.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
 another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
 known from the index, without reading the key bytes -- before comparing its content.
 ## Notes
 Unlike [`BasicJsonType::find`](../basic_json/find.md), which always returns `#!cpp end()` for a non-object type, this
 also does so for a [discarded](is_discarded.md) view -- there is no separate "invalid" iterator to return.
 ## Examples
 ??? example
    The example below scans a batch of events for those that carry an optional `user_id` field, using `find()`
    instead of [`operator[]`](operator[].md) (which would throw for the events that are not objects at all) or
    [`contains()`](contains.md) followed by a second lookup. Events without a match are never materialized.
    ```cpp
    --8<-- "examples/basic_json_view__find.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__find.output"
    ```
 ## See also
 - [count](count.md) - returns the number of occurrences of a key
 - [contains](contains.md) - checks whether a key exists
 - [`BasicJsonType::find`](../basic_json/find.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,61 @@
 # <small>nlohmann::basic_json_view::</small>front
 ```cpp
 basic_json_view front() const;
 ```
 Returns the first element of an array, the first member value of an object, or the value itself if it is primitive
 (as for [`BasicJsonType::front()`](../basic_json/front.md), a primitive value is a range of one element).
 ## Return value
 The first element or member value. For a primitive value (number, string, boolean), the value itself.
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
 [null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
 This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 Constant.
 ## Notes
 Unlike [`BasicJsonType::front()`](../basic_json/front.md), which has undefined behavior for an empty array or
 object, `front()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and
 for a discarded view, where `BasicJsonType::front()` also throws.
 ## Examples
 ??? example
    The example below reads only the earliest entry of a build log with `front()`, without materializing the rest
    of the (possibly long) log.
    ```cpp
    --8<-- "examples/basic_json_view__front.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__front.output"
    ```
 ## See also
 - [back](back.md) - access the last element
 - [`BasicJsonType::front`](../basic_json/front.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,130 @@
 # <small>nlohmann::basic_json_view::</small>get
 ```cpp
 template<typename T>
 T get() const;
 ```
 Converts the value to `T`.
 For the types below, the conversion works directly on the flat index -- no `BasicJsonType` value is built for it:
 - `#!cpp bool`
 - arithmetic types other than `#!cpp bool` (from a number; from a boolean, as `#!cpp 0`/`#!cpp 1`, exactly as
  [`BasicJsonType::get<T>()`](../basic_json/get.md) converts a boolean)
 - `#!cpp std::nullptr_t`
 - `#!cpp std::basic_string<char, Traits, Alloc>` (including `string_t`) -- a copy of the string
 - [`string_view_t`](index.md#member-types) -- **no copy**: the returned view points into the document's
  [`source()`](../basic_json_document/source.md) text, or, for a string that contains escape sequences, into the
  document's own buffer of decoded strings (see [`get_string()`](get_string.md))
 - `BasicJsonType` -- equivalent to [`materialize()`](materialize.md)
 - `basic_json_view` -- returns `#!cpp *this`
 - `#!cpp std::vector<U, A>` -- element by element, each converted with `#!cpp get<U>()`; `#!cpp
  std::vector<basic_json_view>` keeps a view of every element instead of a value
 - `#!cpp std::map<K, V, C, A>` and `#!cpp std::unordered_map<K, V, H, E, A>`, if `K` is constructible from a `#!cpp
  (const char*, std::size_t)` pair -- member by member, each value converted with `#!cpp get<V>()`; with a repeated
  key, the *last* value is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) (and
  [`materialize()`](materialize.md)) does; `#!cpp std::map<std::string, basic_json_view>` keeps views of the members
  instead of values
 Every other `T` -- `#!cpp std::list`, `#!cpp std::pair`, `#!cpp std::array`, enumerations, user types with a
 `from_json()`, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
 value first (as [`BasicJsonType::parse()`](../basic_json/parse.md) would), and converted from there exactly as
 [`BasicJsonType::get<T>()`](../basic_json/get.md) would convert it.
 ## Template parameters
 `T`
 :   the type to convert the value to
 ## Return value
 the value, converted to `T`
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 - For the directly-converted types listed above (other than `BasicJsonType` and `basic_json_view`, which never
  throw): throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value's type does not
  match `T` -- the same exception, with the same message, that [`BasicJsonType::get<T>()`](../basic_json/get.md)
  throws for the same JSON type and `T`.
 - For `#!cpp std::vector<U, A>`: throws `type_error.302` if the value is not an array; otherwise, whatever converting
  an element to `U` throws.
 - For `#!cpp std::map`/`#!cpp std::unordered_map`: throws `type_error.302` if the value is not an object; otherwise,
  whatever converting a member to the mapped type throws.
 - For every other `T`: whatever [`materialize().get<T>()`](../basic_json/get.md) throws -- typically `type_error.302`,
  or whatever a user-provided `from_json()` throws.
 None of the exceptions thrown directly by this function (the first three bullets above) carry a
 [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no `BasicJsonType` value to point at. An
 exception thrown while converting through `materialize()` (the last bullet) is different: it is thrown by a real
 `BasicJsonType` value, so it **does** carry a `JSON_DIAGNOSTICS` path if `BasicJsonType` was built with it enabled.
 ## Complexity
 - `#!cpp bool`, arithmetic types, `#!cpp std::nullptr_t`, [`string_view_t`](index.md#member-types), `basic_json_view`:
  constant.
 - `#!cpp std::basic_string<char, Traits, Alloc>`: constant, plus one allocation and a copy of the string's bytes.
 - `BasicJsonType`: linear in the size of the subtree, see [`materialize()`](materialize.md).
 - `#!cpp std::vector<U, A>`: linear in the number of elements, times the complexity of converting one element to `U`.
 - `#!cpp std::map`/`#!cpp std::unordered_map`: linear in the number of members for walking them, plus the container's
  own insertion cost per member (logarithmic for `#!cpp std::map`, amortized constant for `#!cpp
  std::unordered_map`), times the complexity of converting one member to the mapped type.
 - every other `T`: linear in the size of the subtree (building the `BasicJsonType` value), plus the complexity of
  [`BasicJsonType::get<T>()`](../basic_json/get.md) on it.
 ## Notes
 !!! info "Floating-point values"
    A floating-point `T` is converted from the same digits the lexer would see during `#!cpp BasicJsonType::parse()`,
    using the same conversion, so the result is bit-for-bit identical to `#!cpp BasicJsonType::parse(text).get<T>()`
    for the same source text.
 !!! info "Duplicate keys"
    `#!cpp std::map`/`#!cpp std::unordered_map` conversions keep the *last* value of a repeated key, like
    [`materialize()`](materialize.md) and [`BasicJsonType::parse()`](../basic_json/parse.md) do. This is the opposite
    of [`operator[]`](operator[].md)/[`at`](at.md)/[`find`](find.md)/[`contains`](contains.md), which resolve to the
    *first* occurrence (see the [Notes on duplicate keys](operator[].md#notes)).
 !!! info "No pointers, references, or implicit conversion"
    Unlike `BasicJsonType`, `basic_json_view` has no stored value anywhere to hand out a pointer or a reference to, so
    it provides neither `#!cpp get_ptr()`, `#!cpp get_ref()`, nor `#!cpp operator ValueType()`.
    [`get_string()`](get_string.md) (equivalently, `#!cpp get<string_view_t>()`) is the zero-copy alternative for
    strings.
 ## Examples
 ??? example
    The example below reads typed fields straight into C++ variables, collects a view of every array element with
    `#!cpp get<std::vector<basic_json_view>>()` instead of a value, and converts a nested object into a user type
    through its `from_json()` -- which runs on a `BasicJsonType` value `materialize()` builds for just that one
    member.
    ```cpp
    --8<-- "examples/basic_json_view__get.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__get.output"
    ```
 ## See also
 - [get_to](get_to.md) - convert and write into a passed value
 - [get_string](get_string.md) - the string, without a copy
 - [number_token](number_token.md) - a number's token text, without a copy
 - [materialize](materialize.md) - build the `BasicJsonType` value of this subtree
 - [`BasicJsonType::get`](../basic_json/get.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,71 @@
 # <small>nlohmann::basic_json_view::</small>get_string
 ```cpp
 string_view_t get_string() const;
 ```
 Returns the string value as a [`string_view_t`](index.md#member-types), without copying it.
 ## Return value
 The string, as a [`string_view_t`](index.md#member-types) that points either into the document's
 [`source()`](../basic_json_document/source.md) text (a string with no escape sequences), or into the document's own
 buffer of decoded strings (a string that contains escape sequences, such as `#!json "\n"` or `#!json "\u00e9"`, which
 had to be decoded once when the document was parsed).
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a string; example:
 `"type must be string, but is array"`.
 This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 Constant.
 ## Notes
 `basic_json_view` has no `BasicJsonType` value stored anywhere, so unlike `BasicJsonType`, it has no `get_ref()` to
 hand out a reference to a stored `string_t`. `get_string()` (equivalently, [`get<string_view_t>()`](get.md)) is the
 zero-copy alternative: [`BasicJsonType::get_ref<const string_t&>()`](../basic_json/get_ref.md) is its closest
 counterpart, except that it returns a view instead of a reference to a value that must already exist.
 The returned [`string_view_t`](index.md#member-types) is valid exactly as long as the view that produced it -- see the
 [validity rules](index.md) of `basic_json_view` -- and, for a string with no escapes, for as long as the document's
 source text.
 ## Examples
 ??? example
    The example below pulls one field out of a JSON text that stands in for a large API response, and shows that no
    `#!cpp std::string` was allocated for it: the returned view still points inside the original buffer. A field that
    contains an escape sequence cannot point into the original text -- it was decoded once into the document's own
    buffer instead -- but still avoids a per-field allocation.
    ```cpp
    --8<-- "examples/basic_json_view__get_string.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__get_string.output"
    ```
 ## See also
 - [get](get.md) - convert the value to a given type (`#!cpp get<string_view_t>()` is equivalent to this function)
 - [number_token](number_token.md) - a number's token text, without a copy
 - [`BasicJsonType::get_ref`](../basic_json/get_ref.md) - the closest counterpart of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,65 @@
 # <small>nlohmann::basic_json_view::</small>get_to
 ```cpp
 template<typename T>
 T& get_to(T& v) const;
 ```
 Converts the value to `T` and assigns it to `v`. Equivalent to
 ```cpp
 v = get<T>();
 return v;
 ```
 ## Template parameters
 `T`
 :   the type to convert the value to
 ## Parameters
 `v` (out)
 :   the variable to store the converted value in
 ## Return value
 `v`, allowing calls to chain
 ## Exception safety
 Strong exception safety: if an exception is thrown, `v` is not modified.
 ## Exceptions
 Whatever [`get<T>()`](get.md) throws for the same value and `T`.
 ## Complexity
 Whatever [`get<T>()`](get.md) has for the same `T`.
 ## Examples
 ??? example
    The example below reads several fields of a service configuration directly into existing variables, then uses
    the returned reference to fold the `#!cpp host`/`#!cpp port` pair into a single string in the same expression.
    ```cpp
    --8<-- "examples/basic_json_view__get_to.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__get_to.output"
    ```
 ## See also
 - [get](get.md) - convert the value to a given type
 - [`BasicJsonType::get_to`](../basic_json/get_to.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,127 @@
 # <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, element
 access, lookup, iteration, conversion, and comparison -- [`get<T>()`](get.md), [`get_string()`](get_string.md),
 [`number_token()`](number_token.md), and [`materialize()`](materialize.md) to build the `BasicJsonType` value of a
 subtree on demand. [`operator[]`](operator%5B%5D.md), [`at`](at.md), [`contains`](contains.md), and
 [`value`](value.md) also accept a [`json_pointer`](../json_pointer/index.md). [`operator==`](operator_eq.md) and
 [`operator!=`](operator_ne.md) compare two views, or a view and a `BasicJsonType` value, without ever building a
 `BasicJsonType` value for a view; no ordering comparison (`#!cpp operator<`) is provided.
 ## 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
 - **iterator**, **const_iterator** - a forward iterator over the elements of an array or the member values of an
  object, in document order; both names refer to the same type, since a view is always read-only
 - **item** - a (key, value) pair produced by [`items()`](items.md)
 - [**number_format**](number_format.md) - how [`dump()`](dump.md) writes numbers
 ## Member functions
 - [(constructor)](basic_json_view.md)
 ### Object inspection
 - [**type**](type.md) - return the type of the value
 - [**type_name**](type_name.md) - return the type as string
 - [**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
 ### Element access
 - [**at**](at.md) - access specified element with bounds checking
 - [**operator[]**](operator[].md) - access specified element
 - [**value**](value.md) - access specified element with default value
 - [**front**](front.md) - access the first element
 - [**back**](back.md) - access the last element
 ### Lookup
 - [**find**](find.md) - find an element in an object
 - [**count**](count.md) - returns the number of occurrences of a key in an object
 - [**contains**](contains.md) - check the existence of an element in an object
 ### Iterators
 - [**begin**](begin.md) - returns an iterator to the first element
 - [**cbegin**](cbegin.md) - returns a const iterator to the first element
 - [**end**](end.md) - returns an iterator to one past the last element
 - [**cend**](cend.md) - returns a const iterator to one past the last element
 - [**items**](items.md) - wrapper to access iterator member functions in range-based for
 ### Capacity
 - [**size**](size.md) - return the number of elements
 - [**empty**](empty.md) - return whether the value has no elements
 ### Conversion
 - [**get**](get.md) - get a value
 - [**get_to**](get_to.md) - get a value and write it to a destination
 - [**get_string**](get_string.md) - get a string value without a copy
 - [**number_token**](number_token.md) - get a number's token text without a copy
 - [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree
 ### Comparison
 - [**operator==**](operator_eq.md) - comparison: equal
 - [**operator!=**](operator_ne.md) - comparison: not equal
 ### Serialization
 - [**dump**](dump.md) - serialize to a JSON-formatted string
 - [**operator<<**](operator_ltlt.md) - serialize to stream
 ### 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.
@@ -0,0 +1,46 @@
 # <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.
@@ -0,0 +1,46 @@
 # <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.
@@ -0,0 +1,45 @@
 # <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.
@@ -0,0 +1,55 @@
 # <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.
@@ -0,0 +1,45 @@
 # <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.
@@ -0,0 +1,47 @@
 # <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.
@@ -0,0 +1,51 @@
 # <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.
@@ -0,0 +1,51 @@
 # <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.
@@ -0,0 +1,45 @@
 # <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.
@@ -0,0 +1,46 @@
 # <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.
@@ -0,0 +1,46 @@
 # <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.
@@ -0,0 +1,45 @@
 # <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.
@@ -0,0 +1,46 @@
 # <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.
@@ -0,0 +1,86 @@
 # <small>nlohmann::basic_json_view::</small>items
 ```cpp
 /* unspecified */ items() const noexcept;
 ```
 Returns a range of [`item`](index.md#member-types) values -- (key, value) pairs -- for use in range-based for loops.
 The key of an array element is its index, converted to a string, as for
 [`BasicJsonType::items()`](../basic_json/items.md).
 The returned type is not part of the public API and may change between versions; use a range-based for loop (see the
 example), or `#!cpp decltype(v.items())` if you need to name it.
 ```cpp
 for (const auto& item : v.items())
 {
    std::cout << "key: " << item.key() << ", value: " << item.value() << '\n';
 }
 ```
 On C++17, `item` also supports [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding):
 ```cpp
 for (const auto [key, value] : v.items())
 {
    std::cout << "key: " << key << ", value: " << value << '\n';
 }
 ```
 Note the `#!cpp const auto` (by value), not `#!cpp const auto&`: unlike `BasicJsonType::items()`, whose elements are
 references into an existing object, a view's `item` is produced on the fly for each step of the iteration, so there
 is nothing for a reference to bind to.
 ## Return value
 A range whose iterators dereference to [`item`](index.md#member-types) and whose `#!cpp begin()`/`#!cpp end()` are
 equivalent to [`basic_json_view::begin()`](begin.md)/[`end()`](end.md), in document order.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`begin()`](begin.md)/[`end()`](end.md), `items()` visits **every** member of an object, including all
 occurrences of a duplicate key -- unlike [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md),
 [`contains`](contains.md), and [`count`](count.md), which resolve to the *first* member with a given key. See the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]`.
 !!! danger "Lifetime issues"
    As for `BasicJsonType::items()`, calling `items()` on a temporary view (or a temporary document) is dangerous:
    the range refers back to the document, so the document must outlive the loop. See
    [#2040](https://github.com/nlohmann/json/issues/2040) for the `BasicJsonType` background.
 ## Examples
 ??? example
    The example below shows a settings object whose source text records every update to a key as a duplicate
    member, in the order they happened. `items()` walks all of them, so the update history is visible, while
    [`operator[]`](operator[].md) only ever sees the *first* one and [`materialize()`](materialize.md) -- like
    [`BasicJsonType::parse()`](../basic_json/parse.md) -- keeps only the *last*.
    ```cpp
    --8<-- "examples/basic_json_view__items.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__items.output"
    ```
 ## See also
 - [begin](begin.md), [end](end.md) - the iterators `items()` is built on
 - [`BasicJsonType::items`](../basic_json/items.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,69 @@
 # <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.
@@ -0,0 +1,51 @@
 # <small>nlohmann::basic_json_view::</small>number_format
 ```cpp
 enum class number_format {
    shortest,
    source
 };
 ```
 This enumeration is used in [`dump`](dump.md) to choose how numbers are written. Two values are differentiated:
 shortest
 :   integers are copied from the source text -- already canonical in JSON -- except that `#!cpp -0` becomes
    `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it; floats are written with the
    library's shortest round-trip conversion, exactly as [`BasicJsonType::dump()`](../basic_json/dump.md) would (e.g.
    `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`)
 source
 :   every number is copied exactly as it appears in the source text -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0`, all
    digits of an integer literal with more digits than any number type holds -- something `BasicJsonType` cannot do,
    since parsing already reduces every number to its parsed value
 ## Examples
 ??? example
    The example below writes back a price list received from a supplier: with `number_format::shortest` (the
    default), a trailing zero and scientific notation are normalized away and a long account number that overflows
    every number type is rounded, the same way `#!cpp materialize().dump()` (or `basic_json::dump()`) would;
    `number_format::source` keeps every number exactly as it was written in the source text instead.
    ```cpp
    --8<-- "examples/basic_json_view__number_format.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__number_format.output"
    ```
 ## See also
 - [dump](dump.md) - serialize to a JSON-formatted string
 - [number_token](number_token.md) - get a single number's token text without dumping the whole value
 - [`BasicJsonType::error_handler_t`](../basic_json/error_handler_t.md) - the analogous enumeration for
  `BasicJsonType::dump`'s decoding-error behavior
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,74 @@
 # <small>nlohmann::basic_json_view::</small>number_token
 ```cpp
 string_view_t number_token() const;
 ```
 Returns the number exactly as it appears in the source text, without parsing or rounding it.
 ## Return value
 The number's token text, as a [`string_view_t`](index.md#member-types) into the document's
 [`source()`](../basic_json_document/source.md) text -- for example `#!cpp "1.50"`, `#!cpp "1E2"`, `#!cpp "-0"`, or an
 integer literal with more digits than any number type holds (such as a 30-digit integer, which [`get<T>()`](get.md)
 and [`materialize()`](materialize.md) can only represent approximately, as a `number_float_t`).
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a number; example:
 `"type must be number, but is string"`.
 This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 Constant.
 ## Notes
 `BasicJsonType` has no counterpart to this function: once a number is parsed into `number_integer_t`,
 `number_unsigned_t`, or `number_float_t`, its original textual form (leading zeros aside, which are already rejected
 by the grammar; trailing zeros in the fraction; the case and sign of the exponent; ...) is gone. `number_token()` is
 useful precisely where that form must survive -- a price or an identifier that must be reproduced exactly, or a
 number too large for any of `BasicJsonType`'s number types to hold without loss.
 The returned [`string_view_t`](index.md#member-types) always points into the document's
 [`source()`](../basic_json_document/source.md) text -- numbers are never decoded into the document's separate string
 buffer -- and is valid exactly as long as that text is, see the [validity rules](index.md) of `basic_json_view`.
 ## Examples
 ??? example
    The example below keeps a price and an order ID exactly as they were written in an incoming order, where
    converting them with [`get<T>()`](get.md) would lose information: the price picks up floating-point rounding, and
    the order ID -- more digits than a 64-bit integer holds -- can only be approximated as a `#!cpp double` once
    `#!cpp materialize()`d.
    ```cpp
    --8<-- "examples/basic_json_view__number_token.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__number_token.output"
    ```
 ## See also
 - [get](get.md) - convert the value to a given type
 - [get_string](get_string.md) - the string, without a copy
 - [`BasicJsonType::number_integer_t`](../basic_json/number_integer_t.md),
  [`number_unsigned_t`](../basic_json/number_unsigned_t.md), [`number_float_t`](../basic_json/number_float_t.md) - the
  number types `#!cpp get<T>()` and `materialize()` convert into
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,156 @@
 # <small>nlohmann::basic_json_view::</small>operator[]
 ```cpp
 // (1)
 basic_json_view operator[](string_view_t key) const;
 basic_json_view operator[](const char* key) const;
 basic_json_view operator[](const string_t& key) const;
 // (2)
 basic_json_view operator[](size_type idx) const;
 basic_json_view operator[](int idx) const;
 // (3)
 basic_json_view operator[](const json_pointer& ptr) const;
 ```
 1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
   the [Notes](#notes) below) -- or a [discarded](is_discarded.md) view if there is no such member.
 2. Returns the array element at index `idx`, or a [discarded](is_discarded.md) view if `idx` is out of range. (The
   `#!cpp int` overload only exists so that an integer literal is not ambiguous between this overload and 1.)
 3. Returns the value a JSON pointer `ptr` refers to, starting at this value, or a [discarded](is_discarded.md) view
   wherever resolving it further is not possible without inserting into or extending the document (see
   [Return value](#return-value) and [Exceptions](#exceptions) below).
 ## Parameters
 `key` (in)
 :   object key of the element to access
 `idx` (in)
 :   index of the element to access
 `ptr` (in)
 :   JSON pointer to the element to access
 ## Return value
 1. the value of the first member with key `key`, or a discarded view if `#!cpp is_object()` is `#!cpp false` or no
   member has this key
 2. the element at index `idx`, or a discarded view if `#!cpp is_array()` is `#!cpp false` or `#!cpp idx >= size()`
 3. the value `ptr` resolves to, starting at this value, or a discarded view for exactly the reference tokens where the
   **const** overload of [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) invokes undefined behavior for
   the same pointer and the same document: an object member that does not exist, or an array index that is out of
   range
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 1. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the value is not an object --
   the same exception, with the same message, that the **const** overload of
   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for a string argument on a non-object value.
 2. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the value is not an array --
   the same exception, with the same message, that the **const** overload of
   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for a numeric argument on a non-array value.
 3. Throws the same exceptions, with the same messages, that the **const** overload of
   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for the same pointer and the same document:
    - [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is `#!cpp "-"`
      at an array.
    - [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token cannot be
      resolved because it is used on a primitive value.
    - [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr` begins
      with `#!cpp '0'`.
    - [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is not a
      number.
 None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
   another, in document order, stopping at the first match. Each comparison first checks the key's length --
   already known from the index, without reading the key bytes -- before comparing its content, so a key of a
   different length than `key` is rejected without touching the source text.
 2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
   index (unlike `BasicJsonType`'s array, which is random-access).
 3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level (as 1.) or the index into the array (as 2.).
 ## Notes
 Unlike `BasicJsonType::operator[]`, which is undefined behavior (guarded by a
 [runtime assertion](../../features/assertions.md)) for a missing key on a **const** value, this operator always
 returns a safe, testable result: a [discarded](is_discarded.md) view, which is `#!cpp false` in a boolean context.
 There is also no non-const overload that inserts a missing key or extends an array -- a view never modifies the
 document.
 !!! info "Duplicate keys"
    If the source text has an object with a duplicate key, `#!cpp operator[]` (and [`at`](at.md), [`find`](find.md),
    [`contains`](contains.md), [`count`](count.md)) all resolve to the *first* member with that key, because a
    lookup can stop as soon as it finds a match. This is different from
    [`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which replay every
    member in order and so end up keeping the *last* value for a repeated key -- there is no reason for them to stop
    early. [`begin()`](begin.md)/[`end()`](end.md) and [`items()`](items.md) iterate over *all* members, including
    duplicates, in document order. See the example below and [`size()`](size.md#notes).
 !!! info "JSON pointer resolution"
    Overload 3 walks `ptr` one reference token at a time, starting at this value, the same way [`at`](at.md) and
    [`contains`](contains.md) do. It only ever returns a discarded view where the **const** overload of
    `BasicJsonType::operator[]` would be undefined behavior for the same pointer -- a missing object member or an
    out-of-range array index -- and still throws for every other way `ptr` can fail to resolve. See
    [`at`](at.md#exceptions) for the checked version, which throws in every case instead, and
    [`contains`](contains.md) for a version that never throws.
 ## Examples
 ??? example "Example: (1)/(2) access specified element"
    The example below reads a couple of fields out of a batch of user records without ever materializing a full
    `BasicJsonType` value for the batch. `operator[]` is used both to look up an optional object member and to index
    into an array -- in both cases, a missing value comes back as a discarded view that can be tested with a plain
    `#!cpp if`, instead of relying on undefined behavior.
    ```cpp
    --8<-- "examples/basic_json_view__operator[].cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__operator[].output"
    ```
 ??? example "Example: (3) access specified element via JSON pointer"
    The example below reaches straight into one deeply nested field of a large document with a single JSON pointer,
    without ever building a tree for the rest of it, and shows the discarded-view and throwing outcomes of a pointer
    that cannot be fully resolved.
    ```cpp
    --8<-- "examples/basic_json_view__operator[]_json_pointer.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__operator[]_json_pointer.output"
    ```
 ## See also
 - [at](at.md) - access specified element with bounds checking (throws instead of returning a discarded view)
 - [front](front.md), [back](back.md) - access the first or last element
 - [find](find.md), [contains](contains.md) - look up a member without throwing
 - [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) - the corresponding function of `basic_json`
 - [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,46 @@
 # <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.
@@ -0,0 +1,107 @@
 # <small>nlohmann::basic_json_view::</small>operator==
 ```cpp
 // (1)
 bool operator==(const basic_json_view& lhs, const basic_json_view& rhs);
 // (2)
 bool operator==(const basic_json_view& lhs, const BasicJsonType& rhs);
 bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs);
 ```
 1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](../basic_json/parse.md) would
   produce for `lhs` and `rhs` are equal, according to `BasicJsonType`'s [`operator==`](../basic_json/operator_eq.md).
 2. Compares a view and a `BasicJsonType` value for equality, in either order: whether the value `parse()` would
   produce for the view and the other operand are equal, according to `BasicJsonType`'s
   [`operator==`](../basic_json/operator_eq.md).
 Neither overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers
 compare by value across their types (`#!cpp 1 == 1.0`), and an object compares by its members, with duplicate keys
 resolved exactly as `parse()` resolves them -- the last value, at the position of the first occurrence of the key.
 ## Parameters
 `lhs` (in)
 :   first value to consider
 `rhs` (in)
 :   second value to consider
 ## Return value
 whether the values `lhs` and `rhs` are equal
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a
 view refers to.
 ## Exceptions
 May throw `#!cpp std::bad_alloc`. Unlike the other comparison and most other `basic_json_view` functions,
 `operator==` is not `#!cpp noexcept`: resolving an object's members needs a temporary array to sort them by key (see
 [Complexity](#complexity) below), and that allocation can fail.
 ## Complexity
 Linear in the size of the compared values: every number, string, array element, and object member is visited at most
 once, and the walk is iterative, so the nesting depth it can compare is limited by available memory only, not by the
 call stack (as for [`materialize()`](materialize.md)). Resolving an object's members takes an additional O(n log n)
 in the number of members at that level, since they are sorted by key to detect and resolve duplicates before being
 compared. Two arrays of different [`size()`](size.md) are rejected without visiting either one's elements.
 ## Notes
 Only a single number, boolean, or `#!cpp null` value is ever materialized into a `BasicJsonType`, to reuse its
 `operator==` -- for numbers, so that values written differently in the source text but equal in value (e.g. an
 integer and a floating-point literal) still compare equal, following the same rules `BasicJsonType` does for special
 values such as `#!cpp NaN`. Constructing one of these scalars never allocates. Strings are compared directly, without
 allocating, either from the source text on both sides or, for overload 2, against `BasicJsonType`'s own string.
 Arrays and objects are never materialized at all; only their elements or members are visited, one pair at a time.
 !!! info "How objects are compared"
    For a [`json_view`](../json_view.md) (`BasicJsonType::object_t` is `#!cpp std::map`), members are compared by
    key, regardless of the order they appear in the source text. For an
    [`ordered_json_view`](../ordered_json_view.md) (`object_t` is `ordered_map`), they are compared in the order
    they occur, so the very same two objects with their members reordered can compare equal as `json_view`s but not
    as `ordered_json_view`s. This is exactly how [`json`](../json.md) and [`ordered_json`](../ordered_json.md)
    compare, see ["Comparing different `basic_json` specializations"](../basic_json/operator_eq.md#notes).
 !!! info "Discarded views"
    A [discarded](is_discarded.md) view compares the same way a discarded `BasicJsonType` value does, which is
    governed by
    [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../macros/json_use_legacy_discarded_value_comparison.md): by
    default, a discarded view is never equal to anything, not even another discarded view.
 No ordering comparison (`#!cpp operator<`) is provided for `basic_json_view`; [`materialize()`](materialize.md) is
 the way to get a `BasicJsonType` value that supports it.
 ## Examples
 ??? example
    The example below checks whether a newly received configuration differs from the previous one, and whether a
    received document matches what a test expects -- directly on views, without ever materializing a `BasicJsonType`
    value for either side.
    ```cpp
    --8<-- "examples/basic_json_view__operator_eq.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__operator_eq.output"
    ```
 ## See also
 - [operator!=](operator_ne.md) - compare for inequality
 - [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
 - [`BasicJsonType::operator==`](../basic_json/operator_eq.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,74 @@
 # <small>nlohmann::basic_json_view::</small>operator<<
 ```cpp
 std::ostream& operator<<(std::ostream& o, const basic_json_view& v);
 ```
 Not available when [`JSON_NO_IO`](../macros/json_no_io.md) is defined.
 Serializes the given view `v` to the output stream `o`, using [`dump`](dump.md) -- exactly as
 `#!cpp operator<<(std::ostream&, const basic_json&)` does for a `basic_json` value.
 - The indentation of the output can be controlled with the member variable `width` of the output stream `o`. For
  instance, using the manipulator `std::setw(4)` on `o` sets the indentation level to `4`, and the serialization
  result is the same as calling `#!cpp v.dump(4)`. A `width` of `0` or less (the default) selects the most compact
  representation, as `#!cpp v.dump(-1)` does.
 - The indentation character can be controlled with the member variable `fill` of the output stream `o`. For instance,
  the manipulator `std::setfill('\t')` sets indentation to use a tab character rather than the default space
  character.
 - As for `basic_json`, `o`'s `width` is reset to `0` after this call, whether or not it was greater than `0` before.
 Numbers are always written as `#!cpp v.dump()` writes them by default, i.e. as with
 [`number_format::shortest`](number_format.md); there is no way to select `#!cpp number_format::source` through the
 stream.
 ## Parameters
 `o` (in, out)
 :   stream to write to
 `v` (in)
 :   view to serialize
 ## Return value
 the stream `o`
 ## Exceptions
 May throw `#!cpp std::bad_alloc`, propagated from [`dump`](dump.md#exceptions). Unlike
 `#!cpp operator<<(std::ostream&, const basic_json&)`, there is no UTF-8 decoding step that could throw
 [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316), and no `error_handler` to choose between --
 see the [Exceptions](dump.md#exceptions) of `dump`.
 ## Complexity
 Linear, as [`dump`](dump.md#complexity).
 ## Examples
 ??? example
    The example below writes one record out of a larger batch straight to a log stream -- compact for a one-line
    entry, and pretty-printed with `std::setw`/`std::setfill` for a readable dump -- without ever building a
    `BasicJsonType` value for the record, or for the rest of the batch.
    ```cpp
    --8<-- "examples/basic_json_view__operator_ltlt.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__operator_ltlt.output"
    ```
 ## See also
 - [dump](dump.md) - serialize to a JSON-formatted string
 - [`operator<<(std::ostream&)`](../operator_ltlt.md) - the corresponding operator for `basic_json`
 - [`JSON_NO_IO`](../macros/json_no_io.md) - switch off functions relying on certain C++ I/O headers
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,82 @@
 # <small>nlohmann::basic_json_view::</small>operator!=
 ```cpp
 // (1)
 bool operator!=(const basic_json_view& lhs, const basic_json_view& rhs);
 // (2)
 bool operator!=(const basic_json_view& lhs, const BasicJsonType& rhs);
 bool operator!=(const BasicJsonType& lhs, const basic_json_view& rhs);
 ```
 1. Compares two views for inequality. Returns `#!cpp !(lhs == rhs)`, see [operator==](operator_eq.md).
 2. Compares a view and a `BasicJsonType` value for inequality, in either order. Returns `#!cpp !(lhs == rhs)` (or,
   for the reversed order, `#!cpp !(rhs == lhs)`), see [operator==](operator_eq.md).
 Since `operator!=` is defined as the negation of [`operator==`](operator_eq.md), it follows the same rules for
 special cases: for instance, since a [discarded](is_discarded.md) view is never equal to anything by default (see
 [operator=='s Notes](operator_eq.md#notes)), it is never *unequal* to anything either -- `#!cpp discarded != discarded`
 is also `#!cpp false`, exactly as for a discarded `BasicJsonType` value.
 ## Parameters
 `lhs` (in)
 :   first value to consider
 `rhs` (in)
 :   second value to consider
 ## Return value
 whether the values `lhs` and `rhs` are not equal
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a
 view refers to.
 ## Exceptions
 May throw `#!cpp std::bad_alloc`, propagated from [`operator==`](operator_eq.md#exceptions). Unlike most other
 `basic_json_view` functions, `operator!=` is not `#!cpp noexcept`.
 ## Complexity
 Linear, as [`operator==`](operator_eq.md#complexity).
 ## Notes
 See the [Notes](operator_eq.md#notes) of `operator==` -- in particular for how an object's members are compared
 (order matters for [`ordered_json_view`](../ordered_json_view.md) but not for [`json_view`](../json_view.md)) and
 for how discarded views compare.
 No ordering comparison (`#!cpp operator<`) is provided for `basic_json_view`; [`materialize()`](materialize.md) is
 the way to get a `BasicJsonType` value that supports it.
 ## Examples
 ??? example
    The example below asserts, as a test would, that a received document differs from an unwanted value, and shows
    that -- as for [`json`](../json.md)/[`ordered_json`](../ordered_json.md) -- reordering an object's members is
    detected as a difference for an `ordered_json_view` but not for a `json_view`.
    ```cpp
    --8<-- "examples/basic_json_view__operator_ne.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__operator_ne.output"
    ```
 ## See also
 - [operator==](operator_eq.md) - compare for equality
 - [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
 - [`BasicJsonType::operator!=`](../basic_json/operator_ne.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -0,0 +1,66 @@
 # <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.
 If the source text has an object with a duplicate key, every occurrence counts towards its `size()` -- unlike
 [`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which keeps only the last
 value for a repeated key. This means `#!cpp v.size()` can be larger than `#!cpp v.materialize().size()`. See the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]` for why lookups and iteration disagree on how many
 members there are.
 ## 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.
@@ -0,0 +1,55 @@
 # <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.
@@ -0,0 +1,53 @@
 # <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.
@@ -0,0 +1,63 @@
 # <small>nlohmann::basic_json_view::</small>type_name
 ```cpp
 const char* type_name() const noexcept;
 ```
 Returns the type name as string to be used in error messages -- usually to indicate that a function was called on a
 wrong JSON type. Identical to [`BasicJsonType::type_name()`](../basic_json/type_name.md), including the extra
 `#!cpp "discarded"` return value for a [discarded](is_discarded.md) view (`BasicJsonType::type_name()` produces the
 same string for a discarded `BasicJsonType` value).
 ## Return value
 a string representation of the type ([`value_t`](../basic_json/value_t.md)):
 | Value type                                         | return value  |
 |-----------------------------------------------------|---------------|
 | `#!json null`                                        | `"null"`      |
 | boolean                                              | `"boolean"`   |
 | string                                               | `"string"`    |
 | number (integer, unsigned integer, floating-point)   | `"number"`    |
 | object                                               | `"object"`    |
 | array                                                | `"array"`     |
 | discarded                                            | `"discarded"` |
 `type_name()` never returns `#!cpp "binary"`, since a JSON text has no binary values (see
 [`is_binary()`](is_binary.md)); it also never returns `#!cpp "invalid"`, since a view's `#!cpp kind` always comes
 from a value the parser actually produced.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below reports why some parsed messages were rejected, using only `type_name()` -- no
    `BasicJsonType` value is ever built for the ones that are wrong, and the message text matches what
    [`BasicJsonType::type_name()`](../basic_json/type_name.md) would produce for the same value.
    ```cpp
    --8<-- "examples/basic_json_view__type_name.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_name.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::type_name`](../basic_json/type_name.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
--- a/Show More
+++ b/Show More