Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
766ca3164d | ||
|
|
f1b26e20c6 | ||
|
|
619fafc087 | ||
|
|
a2cc727dd5 | ||
|
|
75e7198260 | ||
|
|
73aea7ce54 | ||
|
|
5187b6ecc7 | ||
|
|
8001ed67b9 | ||
|
|
af2e1c73c1 | ||
|
|
4c75628374 | ||
|
|
44b1e7b2b9 | ||
|
|
71ec3b4306 |
No files matched your search
+1
-1
@@ -66,7 +66,7 @@ labels:
|
||||
- "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp"
|
||||
- "tests/benchmarks/json_view/.*"
|
||||
- "tools/amalgamate/config_json_view\\.json"
|
||||
- "docs/mkdocs/docs/features/json_view/.*"
|
||||
- "docs/mkdocs/docs/features/json_view\\.md"
|
||||
- "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
|
||||
- "docs/mkdocs/docs/api/(ordered_)?json_(editable_)?(document|view)\\.md"
|
||||
- "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(editable_)?(document|view)).*"
|
||||
|
||||
@@ -28,7 +28,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -22,7 +22,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -46,7 +46,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -115,7 +115,9 @@ 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 configuration of json_view.hpp comes with the pull request until
|
||||
# it is on develop; the tool itself is still develop's
|
||||
python3 $TOOL_DIR/amalgamate.py -c $MAIN_DIR/tools/amalgamate/config_json_view.json -s .
|
||||
|
||||
# the header list of the Bazel "json" target must match the files in include/
|
||||
cmake -P cmake/scripts/gen_bazel_build_file.cmake
|
||||
|
||||
@@ -20,7 +20,7 @@ jobs:
|
||||
timeout-minutes: 30
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@ jobs:
|
||||
runs-on: ubuntu-22.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -27,7 +27,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -20,7 +20,7 @@ jobs:
|
||||
pull-requests: write
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -21,7 +21,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -31,7 +31,7 @@ jobs:
|
||||
security-events: write
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -54,7 +54,7 @@ jobs:
|
||||
timeout-minutes: 60
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -23,7 +23,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -37,7 +37,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -40,7 +40,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -36,7 +36,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -38,7 +38,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Check that Meson and pkg-config offer the CMake options
|
||||
run: make check_build_options
|
||||
- name: Install Meson
|
||||
@@ -80,7 +80,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -92,7 +92,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -112,7 +112,7 @@ jobs:
|
||||
target: [ci_test_single_header, ci_cppcheck, ci_cpplint, ci_reproducible_tests, ci_non_git_tests, ci_offline_testdata, ci_reuse_compliance, ci_test_valgrind]
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -123,7 +123,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -142,7 +142,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -168,7 +168,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -178,7 +178,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -244,7 +244,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: CXX=g++-${{ matrix.compiler }} cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -262,7 +262,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -279,7 +279,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Disable filesystem support (std::filesystem is unusable) for clang 7 / 8 / 9 / 10
|
||||
run: echo "JSON_FORCED_GLOBAL_COMPILE_OPTIONS=-DJSON_HAS_FILESYSTEM=0;-DJSON_HAS_EXPERIMENTAL_FILESYSTEM=0" >> "$GITHUB_ENV"
|
||||
if: ${{ matrix.compiler == '7' || matrix.compiler == '8' || matrix.compiler == '9' || matrix.compiler == '10' }}
|
||||
@@ -299,7 +299,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -319,7 +319,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build with libc++
|
||||
@@ -346,7 +346,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -362,16 +362,13 @@ jobs:
|
||||
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
|
||||
with:
|
||||
persist-credentials: false
|
||||
# get-cmake extracts the Ninja zip with the system unzip, which the Clang
|
||||
# image lacks; other Clang jobs get away with it by hitting the cache.
|
||||
- name: Install unzip (Clang)
|
||||
if: matrix.container == 'silkeh/clang:latest'
|
||||
run: apt-get update ; apt-get install -y unzip
|
||||
# The module test uses `import std;`, which needs CMake 4.5 or newer.
|
||||
- name: Get CMake 4.5+ and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
# The module test uses `import std;`, which needs CMake's experimental
|
||||
# import-std support. Its opt-in token is CMake-version-specific, so pin
|
||||
# CMake to the version whose token is set in tests/module_cpp20/CMakeLists.txt.
|
||||
- name: Get pinned CMake and ninja
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
with:
|
||||
cmakeVersion: '^4.5.0'
|
||||
cmakeVersion: 4.3.4
|
||||
# Clang: the std library module is provided by libc++ (the image's libstdc++
|
||||
# ships none), and the image's libc++ module manifest has a broken relative
|
||||
# path — repoint it at the real module sources.
|
||||
@@ -395,7 +392,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -412,7 +409,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -426,7 +423,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DJSON_CI=On
|
||||
- name: Build
|
||||
@@ -436,7 +433,7 @@ jobs:
|
||||
runs-on: ubuntu-26.04
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -446,7 +443,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Run CMake
|
||||
run: cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=$EMSDK/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -GNinja
|
||||
- name: Build
|
||||
@@ -459,7 +456,7 @@ jobs:
|
||||
target: [ci_test_examples, ci_test_build_documentation, ci_test_documentation_mermaid]
|
||||
steps:
|
||||
- name: Harden Runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@46b06cea07f9e64621fdf066ba77ac6915163d43 # v2.22.3
|
||||
with:
|
||||
egress-policy: audit
|
||||
|
||||
@@ -487,7 +484,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Check that the job runs natively on arm64
|
||||
run: uname -m && test "$(uname -m)" = aarch64
|
||||
- name: Run CMake
|
||||
|
||||
@@ -90,7 +90,7 @@ jobs:
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Get latest CMake and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
- name: Set extra CXX_FLAGS for latest std_version
|
||||
# /wd5285 silences C5285 emitted by the bundled third-party doctest.h, which
|
||||
# specializes std::tuple (newly diagnosed by the VS2026 v145 toolset)
|
||||
@@ -212,11 +212,13 @@ jobs:
|
||||
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
|
||||
with:
|
||||
persist-credentials: false
|
||||
# The module test uses `import std;`, which needs CMake 4.5 or newer.
|
||||
- name: Get CMake 4.5+ and ninja
|
||||
uses: lukka/get-cmake@16e8153a8b4918849d92aad131befe67a3705daa # v4.5.0
|
||||
# The module test uses `import std;`, which needs CMake's experimental
|
||||
# import-std support. Its opt-in token is CMake-version-specific, so pin
|
||||
# CMake to the version whose token is set in tests/module_cpp20/CMakeLists.txt.
|
||||
- name: Get pinned CMake and ninja
|
||||
uses: lukka/get-cmake@f86dd60acae0d132056913e248bdabf0e0580b7a # v4.4.5
|
||||
with:
|
||||
cmakeVersion: '^4.5.0'
|
||||
cmakeVersion: 4.3.4
|
||||
# CMAKE_CXX_FLAGS replaces CMake's MSVC defaults (which include /EHsc), and
|
||||
# ci_module_cpp20 forwards it to the module build, so list /EHsc explicitly
|
||||
- name: Run CMake (Debug)
|
||||
|
||||
+3
-2
@@ -20,7 +20,7 @@
|
||||
|
||||
# fuzzers
|
||||
/tests/corpus_*
|
||||
/tests/*_fuzzer
|
||||
/tests/parse_*_fuzzer
|
||||
|
||||
# documentation
|
||||
/docs/docset/JSON_for_Modern_C++.docset/
|
||||
@@ -47,10 +47,11 @@ nlohmann_json.spdx
|
||||
# Bazel-related
|
||||
MODULE.bazel.lock
|
||||
|
||||
# backups left by `make check-amalgamation` if it is interrupted
|
||||
# backups left by `make check-amalgamation` or the ci_test_amalgamation target if they are interrupted
|
||||
/BUILD.bazel~
|
||||
/nlohmann_json.natvis~
|
||||
/single_include/nlohmann/*.hpp~
|
||||
/venv_astyle/
|
||||
|
||||
# release outputs of `make release`
|
||||
/include.zip
|
||||
|
||||
@@ -28,7 +28,6 @@ The [GitHub Actions](https://docs.github.com/en/actions) workflows that build, t
|
||||
- `publish_documentation.yml` — build and publish the documentation on pushes to the `develop` branch that touch the documentation sources (or the files it embeds).
|
||||
- `check_docs_links.yml` — check the links of the documentation weekly, as external links can break without any change in this repository.
|
||||
- `cancel_closed_pr_runs.yml` — cancel unfinished workflow runs of a pull request once it is closed or merged.
|
||||
- `json_view_benchmarks.yml` — compare the performance of `json_view` with other JSON libraries on GitHub-hosted x86-64 and AArch64 Linux runners, on demand or when a pull request gets the label "benchmark".
|
||||
|
||||
Further documentation:
|
||||
|
||||
|
||||
@@ -215,7 +215,7 @@ release: include.zip json.tar.xz
|
||||
|
||||
# clean up
|
||||
clean:
|
||||
rm -fr *.dSYM tests/*.dSYM tests/*_fuzzer
|
||||
rm -fr *.dSYM tests/*.dSYM tests/parse_*_fuzzer
|
||||
rm -fr cmake-build-benchmarks cmake-build-pvs-studio release_files
|
||||
$(MAKE) clean -Cdocs
|
||||
|
||||
|
||||
@@ -165,8 +165,7 @@ std::ifstream f("example.json");
|
||||
json data = json::parse(f);
|
||||
```
|
||||
|
||||
If using modules (enabled with `NLOHMANN_JSON_BUILD_MODULES`; `import std;` needs CMake 4.5 or newer, see the
|
||||
[modules documentation](https://json.nlohmann.me/features/modules/)), this example becomes:
|
||||
If using modules (enabled with `NLOHMANN_JSON_BUILD_MODULES`), this example becomes:
|
||||
```cpp
|
||||
import std;
|
||||
import nlohmann.json;
|
||||
@@ -1383,7 +1382,6 @@ Use your favorite [**package manager**](https://json.nlohmann.me/integration/pac
|
||||
- [**build2**](https://json.nlohmann.me/integration/package_managers/#build2) `nlohmann-json`
|
||||
- <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/CPM.png" height="20"> [**cpm.cmake**](https://json.nlohmann.me/integration/package_managers/#cpmcmake) `gh:nlohmann/json`
|
||||
- <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/xmake.svg" height="20"> [**xmake**](https://json.nlohmann.me/integration/package_managers/#xmake) `nlohmann_json`
|
||||
- <img src="https://raw.githubusercontent.com/nlohmann/json/refs/heads/develop/docs/mkdocs/docs/images/package_managers/nix.svg" height="20"> [**Nix**](https://json.nlohmann.me/integration/package_managers/#nix) `nlohmann_json`
|
||||
|
||||
The library is part of many package managers. See the [**documentation**](https://json.nlohmann.me/integration/package_managers/) for detailed descriptions and examples.
|
||||
|
||||
|
||||
@@ -406,6 +406,61 @@ add_custom_target(ci_test_clang_sanitizer
|
||||
COMMENT "Compile and test with sanitizers"
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
# Check if header is amalgamated and sources are properly indented.
|
||||
###############################################################################
|
||||
|
||||
# Same file set as .github/workflows/check_amalgamation.yml, so this CMake target (which can be run locally) is held
|
||||
# to the same standard as the workflow (which runs for pull requests and for pushes to develop/master/release/*).
|
||||
file(GLOB_RECURSE INDENT_FILES
|
||||
${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.hpp
|
||||
${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.cpp
|
||||
${PROJECT_SOURCE_DIR}/docs/mkdocs/docs/examples/*.cu
|
||||
${PROJECT_SOURCE_DIR}/include/*.hpp
|
||||
${PROJECT_SOURCE_DIR}/include/*.cpp
|
||||
${PROJECT_SOURCE_DIR}/include/*.cu
|
||||
${PROJECT_SOURCE_DIR}/tests/*.hpp
|
||||
${PROJECT_SOURCE_DIR}/tests/*.cpp
|
||||
${PROJECT_SOURCE_DIR}/tests/*.cu
|
||||
)
|
||||
list(FILTER INDENT_FILES EXCLUDE REGEX "/tests/thirdparty/|/tests/abi/include/nlohmann/")
|
||||
|
||||
set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
|
||||
set(tool_dir ${PROJECT_SOURCE_DIR}/tools/amalgamate)
|
||||
add_custom_target(ci_test_amalgamation
|
||||
COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~
|
||||
COMMAND cp ${include_dir}/json.hpp ${include_dir}/json.hpp~
|
||||
COMMAND cp ${include_dir}/json_fwd.hpp ${include_dir}/json_fwd.hpp~
|
||||
COMMAND cp ${include_dir}/json_literals.hpp ${include_dir}/json_literals.hpp~
|
||||
COMMAND cp ${include_dir}/json_view.hpp ${include_dir}/json_view.hpp~
|
||||
COMMAND cp ${PROJECT_SOURCE_DIR}/BUILD.bazel ${PROJECT_SOURCE_DIR}/BUILD.bazel~
|
||||
|
||||
COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
|
||||
COMMAND venv_astyle/bin/pip3 --quiet install -r ${CMAKE_SOURCE_DIR}/tools/astyle/requirements.txt
|
||||
COMMAND venv_astyle/bin/astyle --version
|
||||
|
||||
COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json.json -s .
|
||||
COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_fwd.json -s .
|
||||
COMMAND cp ${PROJECT_SOURCE_DIR}/include/nlohmann/json_literals.hpp ${include_dir}/json_literals.hpp
|
||||
COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_view.json -s .
|
||||
COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_literals.hpp ${include_dir}/json_view.hpp
|
||||
COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake
|
||||
|
||||
COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
|
||||
COMMAND diff ${include_dir}/json_fwd.hpp~ ${include_dir}/json_fwd.hpp
|
||||
COMMAND diff ${include_dir}/json_literals.hpp~ ${include_dir}/json_literals.hpp
|
||||
COMMAND diff ${include_dir}/json_view.hpp~ ${include_dir}/json_view.hpp
|
||||
COMMAND diff ${PROJECT_SOURCE_DIR}/BUILD.bazel~ ${PROJECT_SOURCE_DIR}/BUILD.bazel
|
||||
|
||||
COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
|
||||
COMMAND for FILE in `find . -name '*.orig'`\; do false \; done
|
||||
|
||||
COMMAND rm -f ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~ ${PROJECT_SOURCE_DIR}/BUILD.bazel~
|
||||
|
||||
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
|
||||
COMMENT "Check amalgamation, formatting, and BUILD.bazel"
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
# Build and test using the amalgamated header
|
||||
###############################################################################
|
||||
@@ -637,6 +692,19 @@ else()
|
||||
)
|
||||
endif()
|
||||
|
||||
###############################################################################
|
||||
# Benchmarks
|
||||
###############################################################################
|
||||
|
||||
add_custom_target(ci_benchmarks
|
||||
COMMAND ${CMAKE_COMMAND}
|
||||
-DCMAKE_BUILD_TYPE=Release -GNinja
|
||||
-S${PROJECT_SOURCE_DIR}/tests/benchmarks -B${PROJECT_BINARY_DIR}/build_benchmarks
|
||||
COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_benchmarks --target json_benchmarks
|
||||
COMMAND cd ${PROJECT_BINARY_DIR}/build_benchmarks && ./json_benchmarks
|
||||
COMMENT "Run benchmarks"
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
# CMake flags
|
||||
###############################################################################
|
||||
@@ -897,3 +965,12 @@ add_custom_target(ci_test_documentation_mermaid
|
||||
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs
|
||||
COMMENT "Check the Mermaid diagrams of the documentation"
|
||||
)
|
||||
|
||||
###############################################################################
|
||||
# Clean up all generated files.
|
||||
###############################################################################
|
||||
|
||||
add_custom_target(ci_clean
|
||||
COMMAND rm -fr ${PROJECT_BINARY_DIR}/build_* ${PROJECT_BINARY_DIR}/cmake-3.5.0 ${PROJECT_BINARY_DIR}/cmake-3.31.6 ${PROJECT_BINARY_DIR}/cmake-4.0.0 ${JSON_CMAKE_FLAG_BUILD_DIRS} ${single_binaries}
|
||||
COMMENT "Clean generated directories"
|
||||
)
|
||||
@@ -1 +1 @@
|
||||
semgrep==1.185.0
|
||||
semgrep==1.184.0
|
||||
@@ -265,9 +265,7 @@ basic_json(basic_json&& other) noexcept;
|
||||
4. Depends on the called constructor. For types directly supported by the library (i.e., all types for which no
|
||||
`to_json()` function was provided), a strong guarantee holds: if an exception is thrown, there are no changes to any
|
||||
JSON value.
|
||||
5. Strong guarantee: if an exception is thrown, there are no changes to any JSON value. Values that are moved into
|
||||
`init` (e.g., `a` in `#!cpp json::object({std::move(a), 5})`) are moved when the initializer list is created,
|
||||
before the constructor runs, and stay moved-from if it throws.
|
||||
5. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
6. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
7. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
8. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
|
||||
@@ -58,9 +58,7 @@ is not UTF-8 encoded and `error_handler` is set to `strict`
|
||||
|
||||
## Complexity
|
||||
|
||||
Linear in the size of the result. With an `indent`, every line starts with up to `indent` characters per nesting level,
|
||||
so the result can be larger than the value by a factor of its nesting depth (see
|
||||
[Parsing untrusted input](../../features/parsing/untrusted_input.md#nesting-depth)).
|
||||
Linear.
|
||||
|
||||
## Notes
|
||||
|
||||
|
||||
@@ -26,12 +26,10 @@ void erase(const size_type idx);
|
||||
|
||||
If called on a primitive type other than `#!json null`, the resulting JSON value will be `#!json null`.
|
||||
|
||||
2. Remove an element range specified by `[first; last)` from a JSON value. For arrays and objects, the iterator `first`
|
||||
does not need to be dereferenceable if `first == last`: erasing an empty range is a no-op.
|
||||
2. Remove an element range specified by `[first; last)` from a JSON value. The iterator `first` does not need to be
|
||||
dereferenceable if `first == last`: erasing an empty range is a no-op.
|
||||
|
||||
If called on a primitive type other than `#!json null`, the range must be `[begin(); end())`, and the resulting JSON
|
||||
value will be `#!json null`. Any other range, including the empty ranges `[begin(); begin())` and
|
||||
`[end(); end())`, throws [`invalid_iterator.204`](../../home/exceptions.md#jsonexceptioninvalid_iterator204).
|
||||
If called on a primitive type other than `#!json null`, the resulting JSON value will be `#!json null`.
|
||||
|
||||
3. Removes an element from a JSON object by key.
|
||||
|
||||
@@ -95,8 +93,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
|
||||
- Throws [`invalid_iterator.203`](../../home/exceptions.md#jsonexceptioninvalid_iterator203) if called on iterators
|
||||
which does not belong to the current JSON value; example: `"iterators do not fit current value"`
|
||||
- Throws [`invalid_iterator.204`](../../home/exceptions.md#jsonexceptioninvalid_iterator204) if called on a
|
||||
primitive type with invalid iterators (i.e., if `first != begin()` or `last != end()`, which includes the empty
|
||||
ranges `[begin(); begin())` and `[end(); end())`); example: `"iterators out of range"`
|
||||
primitive type with invalid iterators (i.e., if `first != begin()` and `last != end()`); example: `"iterators out
|
||||
of range"`
|
||||
3. The function can throw the following exceptions:
|
||||
- Throws [`type_error.307`](../../home/exceptions.md#jsonexceptiontype_error307) when called on a type other than
|
||||
JSON object; example: `"cannot use erase() with null"`
|
||||
|
||||
@@ -18,8 +18,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
|
||||
|
||||
## Complexity
|
||||
|
||||
Linear in the size of the result. Every key repeats the path of its value, so the keys can be larger than the value by a
|
||||
factor of its nesting depth (see [Parsing untrusted input](../../features/parsing/untrusted_input.md#nesting-depth)).
|
||||
Linear in the size of the JSON value.
|
||||
|
||||
## Notes
|
||||
|
||||
|
||||
@@ -69,10 +69,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
|
||||
|
||||
## Exceptions
|
||||
|
||||
- Throws [parse_error.110](../../home/exceptions.md#jsonexceptionparse_error110) if the given input ends prematurely,
|
||||
if the end of the file was not reached when `strict` was set to true, or if a string at the end of the value is not
|
||||
terminated by 0xFF although a byte follows it (also when `strict` is false: the byte that ends the string is
|
||||
taken from the input, so the next value would be lost)
|
||||
- Throws [parse_error.110](../../home/exceptions.md#jsonexceptionparse_error110) if the given input ends prematurely or
|
||||
the end of the file was not reached when `strict` was set to true
|
||||
- Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if a parse error occurs, for instance
|
||||
an invalid byte, a string that is not valid UTF-8, or an object key that is not a string
|
||||
|
||||
|
||||
@@ -18,9 +18,7 @@ JSON object value
|
||||
|
||||
## Exception safety
|
||||
|
||||
Strong guarantee: if an exception is thrown, there are no changes in the JSON value. Values that are moved into `init`
|
||||
(e.g., `a` in `#!cpp json::object({std::move(a), 5})`) are moved when the initializer list is created, before this
|
||||
function runs, and stay moved-from if it throws.
|
||||
Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
|
||||
|
||||
## Exceptions
|
||||
|
||||
|
||||
@@ -2,21 +2,12 @@
|
||||
|
||||
```cpp
|
||||
namespace std {
|
||||
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2) noexcept(
|
||||
is_nothrow_move_constructible<nlohmann::basic_json>::value &&
|
||||
is_nothrow_move_assignable<nlohmann::basic_json>::value
|
||||
);
|
||||
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2);
|
||||
}
|
||||
```
|
||||
|
||||
Exchanges the values of two JSON objects.
|
||||
|
||||
This specialization is only provided before C++20, which no longer allows specializing function templates in
|
||||
namespace `std`. With C++20 (and in generic code with any standard), use the idiom `#!cpp using std::swap; swap(j1, j2);`: it finds
|
||||
the [`swap`](swap.md) friend function (overload 2) by argument-dependent lookup. A qualified `#!cpp std::swap(j1, j2)`
|
||||
still compiles with C++20, but uses the generic `std::swap`, which swaps by three moves instead of exchanging the
|
||||
contents.
|
||||
|
||||
## Parameters
|
||||
|
||||
`j1` (in, out)
|
||||
@@ -27,9 +18,7 @@ contents.
|
||||
|
||||
## Exception safety
|
||||
|
||||
No-throw guarantee if the `noexcept` condition above holds: it holds unless moving the
|
||||
[`json_base_class_t`](json_base_class_t.md) can throw. With the default base class, this function never throws
|
||||
exceptions.
|
||||
No-throw guarantee: this function never throws exceptions.
|
||||
|
||||
## Complexity
|
||||
|
||||
@@ -68,4 +57,3 @@ void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2)
|
||||
|
||||
- Added in version 1.0.0.
|
||||
- Extended for arbitrary basic_json types in version 3.10.5.
|
||||
- Not provided with C++20 since version 3.9.0.
|
||||
@@ -75,12 +75,8 @@ void swap(typename binary_t::container_type& other);
|
||||
|
||||
## Exception safety
|
||||
|
||||
1. No-throw guarantee if the `noexcept` condition above holds: it holds unless moving the
|
||||
[`json_base_class_t`](json_base_class_t.md) can throw (moving the type tag and the stored value never throws).
|
||||
With the default base class, this function never throws exceptions.
|
||||
2. No-throw guarantee if the `noexcept` condition above holds: it holds unless moving the
|
||||
[`json_base_class_t`](json_base_class_t.md) can throw (moving the type tag and the stored value never throws).
|
||||
With the default base class, this function never throws exceptions.
|
||||
1. No-throw guarantee: this function never throws exceptions.
|
||||
2. No-throw guarantee: this function never throws exceptions.
|
||||
3. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
4. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
5. Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
|
||||
@@ -89,8 +85,8 @@ void swap(typename binary_t::container_type& other);
|
||||
|
||||
## Exceptions
|
||||
|
||||
1. Throws only what moving the [`json_base_class_t`](json_base_class_t.md) throws; nothing with the default base class.
|
||||
2. Throws only what moving the [`json_base_class_t`](json_base_class_t.md) throws; nothing with the default base class.
|
||||
1. No-throw guarantee: this function never throws exceptions.
|
||||
2. No-throw guarantee: this function never throws exceptions.
|
||||
3. Throws [`type_error.310`](../../home/exceptions.md#jsonexceptiontype_error310) if called on JSON values other than
|
||||
arrays; example: `"cannot use swap(array_t&) with boolean"`
|
||||
4. Throws [`type_error.310`](../../home/exceptions.md#jsonexceptiontype_error310) if called on JSON values other than
|
||||
|
||||
@@ -57,8 +57,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
|
||||
## Exceptions
|
||||
|
||||
- Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
|
||||
is false, and `j` contains a non-empty array, object, or binary value. Scalars and empty arrays, objects, or binary
|
||||
values do not throw.
|
||||
is false, and `j` contains a non-empty array, object, or binary value.
|
||||
- Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
|
||||
not valid UTF-8 and `error_handler` is `strict` (the default only if
|
||||
[`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
|
||||
|
||||
@@ -26,8 +26,7 @@ The function can throw the following exceptions:
|
||||
- Throws [`type_error.314`](../../home/exceptions.md#jsonexceptiontype_error314) if value is not an object
|
||||
- Throws [`type_error.315`](../../home/exceptions.md#jsonexceptiontype_error315) if object values are not primitive
|
||||
- Throws [`type_error.313`](../../home/exceptions.md#jsonexceptiontype_error313) if a key (JSON pointer) leads to a
|
||||
conflicting nesting, for example if a key with a value other than `#!json null` is a prefix of another key (as `/a`
|
||||
and `/a/b`), in whichever order the keys come; example: `"invalid value to unflatten"`
|
||||
conflicting nesting; example: `"invalid value to unflatten"`
|
||||
- Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in a key begins
|
||||
with '0'; example: `"array index '01' must not begin with '0'"`
|
||||
- Throws [`parse_error.107`](../../home/exceptions.md#jsonexceptionparse_error107) if a key is not empty and does not
|
||||
@@ -91,6 +90,3 @@ Apart from these three cases, for a JSON value `j`, the following is always true
|
||||
- Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
|
||||
[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is
|
||||
not a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
|
||||
- Throws [`type_error.313`](../../home/exceptions.md#jsonexceptiontype_error313) for a key that is a prefix of an
|
||||
earlier key in version 3.13.0; before, an object type that keeps the insertion order (such as
|
||||
[`ordered_json`](../ordered_json.md)) silently replaced the nested value.
|
||||
@@ -66,8 +66,7 @@ has `erase`; calling it on a read-only `basic_json_document` fails to compile (`
|
||||
[`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`),
|
||||
[`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number),
|
||||
[`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or
|
||||
[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token, or the token
|
||||
`#!cpp "-"`, which never names an existing element); otherwise (an
|
||||
[`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token); otherwise (an
|
||||
object, or a primitive value the pointer's parent resolves to) throws what 1. throws.
|
||||
|
||||
Overloads 1. and 2. also throw [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202)
|
||||
|
||||
@@ -100,8 +100,7 @@ points apply to every edit:
|
||||
[`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the
|
||||
document, allocated on demand.
|
||||
- **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view
|
||||
sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. Such a
|
||||
view can still be edited: the edit changes only that detached value, never anything reachable from `root()`. An edit
|
||||
sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit
|
||||
of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a
|
||||
different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even
|
||||
as further edits happen (earlier buffers of edited text are kept alive, not overwritten).
|
||||
|
||||
@@ -164,9 +164,7 @@ general.
|
||||
The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a
|
||||
scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent
|
||||
originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a
|
||||
one-node scalar. This also holds when `target` is no longer part of the document (an edit erased or replaced it, or
|
||||
a value that contains it): if the container that `target` was in still uses its parsed layout, it switches to links
|
||||
(otherwise nothing steps over `target` any more), and only the dropped values change.
|
||||
one-node scalar.
|
||||
|
||||
## Examples
|
||||
|
||||
|
||||
@@ -62,9 +62,10 @@ view.
|
||||
|
||||
!!! info "Overload 2 never throws"
|
||||
|
||||
Like [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), 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`.
|
||||
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
|
||||
|
||||
|
||||
@@ -27,10 +27,9 @@ for (const auto [key, value] : v.items())
|
||||
}
|
||||
```
|
||||
|
||||
Taking `item` by value (`#!cpp const auto`) is recommended: 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 and is
|
||||
cheap to copy. A `#!cpp const auto&` (as in the first snippet) also works, as it binds to that temporary, but a
|
||||
non-const `#!cpp auto&` does not compile.
|
||||
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
|
||||
|
||||
|
||||
@@ -7,10 +7,6 @@ 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);
|
||||
|
||||
// (3)
|
||||
template<view_mode M>
|
||||
bool operator==(const basic_json_view& lhs, const basic_json_view<BasicJsonType, M>& rhs);
|
||||
```
|
||||
|
||||
1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](../basic_json/parse.md) would
|
||||
@@ -18,12 +14,8 @@ bool operator==(const basic_json_view& lhs, const basic_json_view<BasicJsonType,
|
||||
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).
|
||||
3. Like overload 1, for two views of the same `BasicJsonType` but of different [view modes](../view_mode.md), in
|
||||
either order: a view of a read-only document (such as a [`json_view`](../json_view.md)) and a view of an editable
|
||||
document (such as a [`json_editable_view`](../json_editable_view.md)). This overload only takes part in overload
|
||||
resolution if `M` is not the mode of `lhs`.
|
||||
|
||||
No overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers
|
||||
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.
|
||||
This is not what [`operator[]`](operator[].md) and the other lookups return for a duplicate key: they find the *first*
|
||||
|
||||
@@ -7,17 +7,11 @@ 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);
|
||||
|
||||
// (3)
|
||||
template<view_mode M>
|
||||
bool operator!=(const basic_json_view& lhs, const basic_json_view<BasicJsonType, M>& 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).
|
||||
3. Compares a read-only and an editable view of the same `BasicJsonType` for inequality, in either order. Returns
|
||||
`#!cpp !(lhs == rhs)`, 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
|
||||
|
||||
@@ -15,10 +15,6 @@ materializing anything.
|
||||
- `#!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.
|
||||
- `#!cpp static_cast<std::size_t>(-1)` in an [editable document](../json_editable_document.md) for a value written
|
||||
by an edit ([`set`](../basic_json_document/set.md), [`push_back`](../basic_json_document/push_back.md),
|
||||
[`insert`](../basic_json_document/insert.md)), and for an array or object whose elements an edit added or removed.
|
||||
The values an edit did not touch keep their offsets.
|
||||
|
||||
## Exception safety
|
||||
|
||||
|
||||
@@ -8,9 +8,8 @@ using json_editable_document = basic_json_document<json, view_mode::editable>;
|
||||
|
||||
This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the default
|
||||
[`json`](json.md) specialization: in addition to everything [`json_document`](json_document.md) offers,
|
||||
[`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md),
|
||||
[`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md) change values after parsing,
|
||||
without ever rewriting the source text — see [Edits](basic_json_document/index.md#edits) and
|
||||
[`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) change values after
|
||||
parsing, without ever rewriting the source text — see [Edits](basic_json_document/index.md#edits) and
|
||||
[Editing a document](../features/json_view/editing.md).
|
||||
|
||||
## Examples
|
||||
|
||||
@@ -9,8 +9,7 @@ using json_editable_view = basic_json_view<json, view_mode::editable>;
|
||||
This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a
|
||||
[`json_editable_document`](json_editable_document.md). It offers the same read-only interface as
|
||||
[`json_view`](json_view.md); what is different is what it can be a view *of* — a value that
|
||||
[`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md),
|
||||
[`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md) can change, with every view
|
||||
[`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) can change, with every view
|
||||
still referring to it seeing the change, see [Edits](basic_json_document/index.md#edits).
|
||||
|
||||
## Examples
|
||||
|
||||
@@ -47,9 +47,11 @@ Therefore, assertions can be switched off by defining `NDEBUG`.
|
||||
}
|
||||
```
|
||||
|
||||
The assertion `#!cpp it != m_data.m_value.object->end()` fails in `#!cpp operator[]`.
|
||||
The exact diagnostic format, source filename, and line number depend on the platform,
|
||||
library version, and whether the single-header or multi-header version is used.
|
||||
Output:
|
||||
|
||||
```
|
||||
Assertion failed: (m_value.object->find(key) != m_value.object->end()), function operator[], file json.hpp, line 2144.
|
||||
```
|
||||
|
||||
??? example "Example: user-defined behavior"
|
||||
|
||||
|
||||
@@ -27,7 +27,7 @@ comparison of two [`json_view`](../basic_json_view/index.md) documents has a fix
|
||||
and does not depend on it either.
|
||||
|
||||
The call stack that these operations need grows with the limit: roughly *a few kilobytes plus a cost per level times the
|
||||
limit*, where the cost per level is up to about 1.8 KiB in an unoptimized and up to about 0.5 KiB in an optimized build
|
||||
limit*, where the cost per level is up to about 2.3 KiB in an unoptimized and up to about 0.5 KiB in an optimized build
|
||||
(see [Stack needed](#stack-needed)). The default of `128` levels is tuned for threads with ordinary stacks of a few
|
||||
hundred kilobytes or more. Set a lower limit if your threads have small stacks (RTOS tasks, fibers, threads of the musl
|
||||
C
|
||||
@@ -67,7 +67,7 @@ When the macro is not defined, the library defines it to its default value.
|
||||
the levels that are descended into are counted, so the count never exceeds the limit, not even when user code (a
|
||||
copy constructor of a custom base class, say) copies a value while a copy is going on. A byte holds `255` at
|
||||
most, and the limit stays below that, so that the count cannot wrap around. (More levels would hardly be
|
||||
useful: `254` levels need up to 448 KiB of stack in an unoptimized build already, twice as much as the
|
||||
useful: `254` levels need up to 576 KiB of stack in an unoptimized build already, twice as much as the
|
||||
default.)
|
||||
|
||||
### Stack needed
|
||||
@@ -83,7 +83,7 @@ Unoptimized (`-O0`):
|
||||
|
||||
| Operation | limit 16 | limit 32 | limit 64 | limit 128 | limit 254 |
|
||||
|---|---:|---:|---:|---:|---:|
|
||||
| `dump()` and `dump(indent)`, `operator<<` | 16 / 16 | 16 / 16 | 32 / 32 | 48 / 48 | 96 / 96 |
|
||||
| `dump()` and `dump(indent)`, `operator<<` | 48 / 32 | 80 / 64 | 144 / 128 | 288 / 256 | 576 / 512 |
|
||||
| copy construction and assignment | 32 / 16 | 48 / 32 | 112 / 80 | 224 / 144 | 432 / 304 |
|
||||
| `==` | 16 / 16 | 16 / 16 | 16 / 16 | 48 / 32 | 96 / 48 |
|
||||
| `<=>` (C++20) | 16 / 16 | 16 / 16 | 32 / 32 | 64 / 64 | 144 / 128 |
|
||||
@@ -123,24 +123,23 @@ The rule of thumb is
|
||||
|
||||
> stack needed ≈ a few KiB + cost per level × limit
|
||||
|
||||
with a cost per level of up to 1.8 KiB (conversion to another `basic_json` type at `-O0` with Clang; 1.3 KiB with
|
||||
GCC), 1.7 KiB for copying and merging (1.3 KiB with GCC), 0.4 KiB for `dump`, and 0.1 to 0.5 KiB for most other
|
||||
operations at `-O0`; and 0.5 KiB or less at `-O2`. The numbers come from the difference between the limits `128` and
|
||||
`254` in the tables, so they are rough: other compilers, other targets (the frames of x86-64 code are about as large),
|
||||
other standard libraries, `JSON_DIAGNOSTICS`, and sanitizers change them. Measure with your own tool chain (see the
|
||||
example below) rather than relying on the tables. The stack that your own code and the operating system need comes on
|
||||
top of these numbers.
|
||||
with a cost per level of up to 2.3 KiB (`dump` at `-O0` with Clang; 2.1 KiB with GCC), 1.7 KiB for copying and merging
|
||||
(1.3 KiB with GCC), and 0.1 to 0.5 KiB for most other operations at `-O0`; and 0.5 KiB or less at `-O2`. The numbers
|
||||
come from the difference between the limits `128` and `254` in the tables, so they are rough: other compilers,
|
||||
other targets (the frames of x86-64 code are about as large), other standard libraries, `JSON_DIAGNOSTICS`, and
|
||||
sanitizers change them. Measure with your own tool chain (see the example below) rather than relying on the tables.
|
||||
The stack that your own code and the operating system need comes on top of these numbers.
|
||||
|
||||
Which limit to choose, for the stack that you can spare for the library (the largest limit of those measured
|
||||
for which the slowest operation needs at most that much):
|
||||
|
||||
| Stack for the library | optimized (`-O2`) | unoptimized (`-O0`) |
|
||||
|---|---:|---:|
|
||||
| 32 KiB | 64 | 16 |
|
||||
| 64 KiB | 128 | 32 |
|
||||
| 128 KiB (the default stack of threads on musl) | 254 | 64 |
|
||||
| 256 KiB | 254 | 128 |
|
||||
| 512 KiB | 254 | 254 |
|
||||
| 32 KiB | 64 | 0 |
|
||||
| 64 KiB | 128 | 16 |
|
||||
| 128 KiB (the default stack of threads on musl) | 254 | 32 |
|
||||
| 256 KiB | 254 | 64 |
|
||||
| 512 KiB | 254 | 128 |
|
||||
| 1 MiB or more | 254 | 254 |
|
||||
|
||||
### Speed
|
||||
|
||||
@@ -171,7 +171,7 @@ See the examples below for the concrete generated code.
|
||||
|
||||
The macro is equivalent to:
|
||||
|
||||
```cpp hl_lines="22 23 24 25 26 27 28"
|
||||
```cpp hl_lines="22 22 23 24 25 26 27 28"
|
||||
--8<-- "examples/nlohmann_define_type_intrusive_only_serialize_explicit.cpp"
|
||||
```
|
||||
|
||||
|
||||
@@ -69,7 +69,7 @@ For further information please refer to the corresponding macros without `WITH_N
|
||||
|
||||
The macro is equivalent to:
|
||||
|
||||
```cpp hl_lines="16 17 18 19 20 21 22 23 24 25 26 27 28 29 30"
|
||||
```cpp hl_lines="16 17 18 19 20 21 22 23 24 25 26 27 28"
|
||||
--8<-- "examples/nlohmann_define_type_non_intrusive_with_names_explicit.cpp"
|
||||
```
|
||||
|
||||
|
||||
@@ -89,21 +89,19 @@ This differs from `#!cpp std::map`, where the same operations are O(log n).
|
||||
!!! warning "Quadratic cost of building large objects"
|
||||
|
||||
Because every insertion scans all elements inserted so far, building an object of `n` distinct keys costs
|
||||
**O(n²)** in total. This applies to filling an [`ordered_json`](ordered_json.md) object key by key (with
|
||||
`operator[]`, `emplace`, or `insert`) and, for now, to reading one with a binary reader such as
|
||||
[`from_cbor`](basic_json/from_cbor.md) ([#6104](https://github.com/nlohmann/json/issues/6104)). Parsing JSON text
|
||||
is not affected: the parser finds the keys of an object with many members in a hash table and takes linear time.
|
||||
**O(n²)** in total. This applies to filling an [`ordered_json`](ordered_json.md) object key by key as well as to
|
||||
parsing one, since the parser inserts each key as it is read.
|
||||
|
||||
The cost is negligible for the object sizes typically found in configuration files or API payloads, but it grows
|
||||
steeply for machine-generated objects with many thousands of keys. Measured with Apple clang 21, `-O2 -DNDEBUG`,
|
||||
arm64, for a flat object of `n` keys (best of seven runs):
|
||||
steeply for machine-generated objects with many thousands of keys. Measured with `-O2 -DNDEBUG` for parsing a flat
|
||||
object of `n` keys, relative to `#!cpp nlohmann::json` (which uses `#!cpp std::map`):
|
||||
|
||||
| `n` | `json::parse` | `ordered_json::parse` | `ordered_json`, key by key | `ordered_json::from_cbor` |
|
||||
|--------|---------------|-----------------------|----------------------------|---------------------------|
|
||||
| 2000 | 0.3 ms | 0.1 ms | 4.5 ms | 4.4 ms |
|
||||
| 4000 | 0.5 ms | 0.2 ms | 17.1 ms | 16.8 ms |
|
||||
| 8000 | 0.9 ms | 0.3 ms | 67.0 ms | 66.8 ms |
|
||||
| 16 000 | 2.0 ms | 0.7 ms | 282.4 ms | 282.4 ms |
|
||||
| `n` | `json` | `ordered_json` | factor |
|
||||
|--------|--------|----------------|--------|
|
||||
| 2000 | 0.7 ms | 3.6 ms | 5× |
|
||||
| 4000 | 0.8 ms | 14.0 ms | 19× |
|
||||
| 8000 | 1.6 ms | 67.8 ms | 43× |
|
||||
| 16 000 | 3.3 ms | 181.6 ms | 54× |
|
||||
|
||||
If key order matters for objects of that size, consider a container with a lookup index, such as
|
||||
[`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map)
|
||||
|
||||
@@ -18,10 +18,6 @@ before including the `json.hpp` header.
|
||||
|
||||
## Function with runtime assertions
|
||||
|
||||
The examples below identify the failing assertion and the function containing it.
|
||||
The exact diagnostic format, source filename, and line number depend on the platform,
|
||||
library version, and whether the single-header or multi-header version is used.
|
||||
|
||||
### Unchecked access to a const value
|
||||
|
||||
Function [`operator[]`](../api/basic_json/operator%5B%5D.md) implements unchecked access for arrays and objects. Whereas
|
||||
@@ -50,7 +46,11 @@ See also the documentation on [element access](element_access/index.md).
|
||||
}
|
||||
```
|
||||
|
||||
The assertion `#!cpp it != m_data.m_value.object->end()` fails in `#!cpp operator[]`.
|
||||
Output:
|
||||
|
||||
```
|
||||
Assertion failed: (it != m_data.m_value.object->end()), function operator[], file json.hpp, line 28795.
|
||||
```
|
||||
|
||||
??? example "Example 2: Invalid array index in a JSON pointer"
|
||||
|
||||
@@ -69,7 +69,11 @@ See also the documentation on [element access](element_access/index.md).
|
||||
}
|
||||
```
|
||||
|
||||
The assertion `#!cpp idx < ptr->m_data.m_value.array->size()` fails in `#!cpp get_unchecked`.
|
||||
Output:
|
||||
|
||||
```
|
||||
Assertion failed: (idx < m_data.m_value.array->size()), function operator[], file json.hpp, line 28758.
|
||||
```
|
||||
|
||||
### Constructing from an uninitialized iterator range
|
||||
|
||||
@@ -92,7 +96,11 @@ uninitialized iterator is undefined behavior and yields a runtime assertion.
|
||||
}
|
||||
```
|
||||
|
||||
The assertion `#!cpp first.m_object != nullptr` fails in `#!cpp basic_json`.
|
||||
Output:
|
||||
|
||||
```
|
||||
Assertion failed: (m_object != nullptr), function operator++, file iter_impl.hpp, line 368.
|
||||
```
|
||||
|
||||
### Operations on uninitialized iterators
|
||||
|
||||
@@ -115,7 +123,11 @@ behavior and yields a runtime assertion.
|
||||
}
|
||||
```
|
||||
|
||||
The assertion `#!cpp m_object != nullptr` fails in `#!cpp operator++`.
|
||||
Output:
|
||||
|
||||
```
|
||||
Assertion failed: (m_object != nullptr), function operator++, file iter_impl.hpp, line 368.
|
||||
```
|
||||
|
||||
## Changes
|
||||
|
||||
|
||||
@@ -181,10 +181,7 @@ of the message are reported as [parse_error.110](../../home/exceptions.md#jsonex
|
||||
arrays and objects with up to four elements that are terminated by 0xFE, unsorted object keys, or a 0xFF after a
|
||||
string that would also end without it, are accepted. A second 0xFF is not a terminator but an empty string.
|
||||
|
||||
Strings must be valid UTF-8, and a string at the very end of a message must be terminated by 0xFF. This also
|
||||
holds when `strict` is false and more data follows the value: the byte that would end the string belongs to the
|
||||
next value, and reading it would remove it from the input, so the missing 0xFF is reported as
|
||||
[parse_error.110](../../home/exceptions.md#jsonexceptionparse_error110).
|
||||
Strings must be valid UTF-8, and a string at the very end of a message must be terminated by 0xFF.
|
||||
|
||||
Duplicate object keys are accepted; the last value wins (`ordered_json` keeps the position of the first occurrence).
|
||||
The specification does not say how to treat them; the HikoGUI reference decoder keeps the first value.
|
||||
|
||||
@@ -9,19 +9,7 @@ Importing the module instead of including the header reduces the compile time of
|
||||
## Requirements
|
||||
The `nlohmann.json` module requires that the build system is configured to build and resolve modules when imported. Obviously, as modules were introduced in C++20, this feature can only be used in C++20 and subsequent versions.
|
||||
|
||||
To enable building the `nlohmann.json` module (which is not done by default), set the CMake option
|
||||
[`NLOHMANN_JSON_BUILD_MODULES`](../integration/cmake.md#nlohmann_json_build_modules) and link the
|
||||
`nlohmann_json_modules` target.
|
||||
|
||||
With CMake, building the module needs:
|
||||
|
||||
- CMake 3.28 or newer, and
|
||||
- a generator that scans for modules: Ninja (1.11 or newer), Ninja Multi-Config, or Visual Studio 2022 or newer.
|
||||
|
||||
The example below also uses `import std;`. CMake supports it without experimental opt-in since version 4.5, and then
|
||||
only with the Ninja generators and these toolchains: Clang 18.1.2 or newer (with libc++ or libstdc++), MSVC toolset 14.36
|
||||
(Visual Studio 17.6) or newer, and GCC 15 or newer (GCC 16 on macOS). With older CMake versions, `import std;` needs
|
||||
CMake's version-specific experimental opt-in.
|
||||
To enable building the `nlohmann.json` module (which is not done by default), the macro `NLOHMANN_JSON_BUILD_MODULES` must be passed to the build system.
|
||||
|
||||
## Example
|
||||
When using modules rather than headers, the previous example for creating a `json` object through a JSON file, would instead be:
|
||||
@@ -79,7 +67,7 @@ and should not be used directly:
|
||||
|
||||
## Known issues
|
||||
|
||||
C++20 modules support is exercised in CI with CMake 4.5 and `import std;` against current GCC and Clang on Ubuntu, and the default MSVC toolset on Windows Server 2022 — there is no documented minimum compiler version, unlike feature-test-macro-gated features such as [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md).
|
||||
C++20 modules support is exercised in CI against current GCC and Clang on Ubuntu, and the default MSVC toolset on Windows Server 2022 — there is no documented minimum compiler version, unlike feature-test-macro-gated features such as [`JSON_HAS_RANGES`](../api/macros/json_has_ranges.md).
|
||||
|
||||
!!! info "Known compiler issues"
|
||||
|
||||
|
||||
@@ -64,13 +64,13 @@ stack for the nesting.)
|
||||
|
||||
The call stack still needs room for the levels that are recursed into, and the default limit assumes a stack of ordinary
|
||||
size. The stack that an operation needs is roughly proportional to the limit; with the default of 128 levels, the most
|
||||
demanding operations (copying a value and converting it to another `basic_json` type, in an unoptimized build) needed
|
||||
up to 224 KiB, and an optimized build needed 48 KiB or less, in measurements on macOS with arm64. The most demanding
|
||||
operation needed this much stack at the limits `0`, `32`, `128`, and `254`:
|
||||
demanding operation (`dump` in an unoptimized build) needed up to 288 KiB, and an optimized build needed 48 KiB or less,
|
||||
in measurements on macOS with arm64. The most demanding operation needed this much stack at the limits `0`, `32`,
|
||||
`128`, and `254`:
|
||||
|
||||
| Stack needed, in KiB | limit 0 | limit 32 | limit 128 (default) | limit 254 |
|
||||
|---|---:|---:|---:|---:|
|
||||
| unoptimized build (`-O0`) | 16 or less | 64 | 224 | 448 |
|
||||
| unoptimized build (`-O0`) | 16 or less | 80 | 288 | 576 |
|
||||
| optimized build (`-O2`) | 16 or less | 16 or less | 48 | 112 |
|
||||
|
||||
A thread with a smaller stack (a task of a real-time operating system, a fiber, or a thread of the musl C library, whose
|
||||
@@ -81,20 +81,6 @@ result. See the [documentation of the macro](../../api/macros/json_recursion_dep
|
||||
the speed, and the rules for choosing a value. Destroying a value (its destructor) recurses over the same number of
|
||||
levels and then continues without the call stack, and needs 32 KiB or less at every limit.
|
||||
|
||||
!!! warning "Indented output and flattened keys grow with the depth"
|
||||
|
||||
Some results are larger than the value by a factor of its nesting depth.
|
||||
[`dump`](../../api/basic_json/dump.md) with an `indent` of `n` (and likewise `operator<<` with `std::setw(n)` and
|
||||
[`basic_json_view::dump`](../../api/basic_json_view/dump.md)) writes up to `n` characters per nesting level in
|
||||
front of every line, and [`flatten`](../../api/basic_json/flatten.md) repeats the path of every value in its key.
|
||||
For the 80,001-byte array `[1,[1,...[1,1]...]]` with 20,000 levels, `dump(1)` returns 600 MB, `dump(4)` 2.4 GB,
|
||||
and the keys of `flatten()` hold 400 MB. A compact `dump()` without indentation stays the size of the value. If you
|
||||
pretty-print, log, or flatten untrusted input, limit its nesting depth while parsing, for example with a
|
||||
[parser callback](parser_callbacks.md#recipe-max-nesting-depth-via-a-callback): with a limit of `d`, every line has
|
||||
at most `n * d` indentation characters, and every flattened key has at most `d` reference tokens.
|
||||
[`JSON_RECURSION_DEPTH_LIMIT`](../../api/macros/json_recursion_depth_limit.md) does not help here: it changes only
|
||||
how much of the call stack a walk uses, never its result, and it does not limit the depth that `parse()` accepts.
|
||||
|
||||
## Input size
|
||||
|
||||
The library does not limit the overall size of a JSON text; a value nested or wide enough will use memory
|
||||
@@ -182,20 +168,6 @@ values for a repeated key ends up in the parsed object. If your application must
|
||||
silently resolving them one way or another, see the
|
||||
[parser callback recipe for rejecting duplicate keys](parser_callbacks.md#recipe-rejecting-duplicate-object-keys).
|
||||
|
||||
## Objects with many keys in `ordered_json`
|
||||
|
||||
[`ordered_json`](../../api/ordered_json.md) keeps the members of an object in a vector in insertion order
|
||||
([`ordered_map`](../../api/ordered_map.md)) and finds a key by searching all members. Parsing JSON text into an
|
||||
`ordered_json` avoids that search for objects with many keys and takes linear time. The binary readers
|
||||
([`from_cbor`](../../api/basic_json/from_cbor.md), [`from_msgpack`](../../api/basic_json/from_msgpack.md),
|
||||
[`from_ubjson`](../../api/basic_json/from_ubjson.md), [`from_bjdata`](../../api/basic_json/from_bjdata.md),
|
||||
[`from_bson`](../../api/basic_json/from_bson.md), and [`from_bon8`](../../api/basic_json/from_bon8.md)) do not yet:
|
||||
reading an object of `n` keys into an `ordered_json` costs time proportional to `n²`. A flat object of 40,000 keys
|
||||
(about 300 KB of CBOR) takes about 1.3 s, against a few milliseconds as JSON text or into a `json`
|
||||
([#6104](https://github.com/nlohmann/json/issues/6104)). `json` is not affected. If you read untrusted binary input
|
||||
into `ordered_json`, bound the input size more tightly, read it into a `json`, or reject objects with many keys in a
|
||||
[SAX handler](sax_interface.md).
|
||||
|
||||
## Numbers
|
||||
|
||||
A number whose value cannot be represented — for instance `1E1000`, which overflows `double` — is rejected while
|
||||
@@ -227,11 +199,9 @@ indices (or the pointer as a whole) before using them, or use [`at`](../../api/b
|
||||
|
||||
- Wrap parsing in a `#!cpp try`/`#!cpp catch` block, or use `allow_exceptions=false`/`accept()` if your environment
|
||||
cannot use exceptions; never let `JSON_NOEXCEPTION`'s `abort()` be the first time you think about error handling.
|
||||
- If the input's nesting depth matters to you (for example because you pretty-print, log, or flatten it), enforce your
|
||||
own limit with a [parser callback](parser_callbacks.md#recipe-max-nesting-depth-via-a-callback) or a
|
||||
- If the input's nesting depth matters to you, enforce your own limit with a
|
||||
[parser callback](parser_callbacks.md#recipe-max-nesting-depth-via-a-callback) or a
|
||||
[SAX handler](sax_interface.md); the library bounds the call stack but not memory use.
|
||||
- If you read untrusted binary input into `ordered_json`, mind that objects with many keys are
|
||||
[slow to read](#objects-with-many-keys-in-ordered_json).
|
||||
- Bound the size of the input itself before parsing, independent of the library's own bounded allocations for binary
|
||||
format lengths.
|
||||
- Decide up front how you want a string with invalid UTF-8 — from any source, not only parsing — to be serialized
|
||||
|
||||
@@ -98,7 +98,7 @@ serialization fails by default. The fourth argument of `dump` selects an
|
||||
|
||||
## Using `std::format`, `std::print`, and `fmt`
|
||||
|
||||
Since version 3.13.0, JSON values can be formatted directly with C++20's
|
||||
Since version 3.12.0, JSON values can be formatted directly with C++20's
|
||||
[`std::format`](https://en.cppreference.com/w/cpp/utility/format/format) whenever the standard library provides the
|
||||
`<format>` header (controlled by [`JSON_HAS_STD_FORMAT`](../api/macros/json_has_std_format.md)). This is enabled by the
|
||||
[`std::formatter<basic_json>`](../api/basic_json/std_formatter.md) specialization, which also makes JSON values work with
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# Recipes for Common Types
|
||||
|
||||
The library converts the standard containers, strings, numbers, tuples, `std::optional` (since version 3.12.0), and
|
||||
`std::filesystem::path` (since version 3.10.5), the last two with C++17, out of the box, and your own types once you write conversion functions or use
|
||||
The library converts the standard containers, strings, numbers, tuples, `std::optional`, and `std::filesystem::path`
|
||||
(the last two since version 3.12.0, C++17) out of the box, and your own types once you write conversion functions or use
|
||||
the macros (see [Arbitrary type conversions](arbitrary_types.md)). It deliberately does **not** convert smart pointers,
|
||||
`std::variant`, `std::chrono` types, or class hierarchies, because there is more than one reasonable JSON
|
||||
representation for each of them. This page shows a representation for each that you can copy and adapt.
|
||||
|
||||
@@ -102,7 +102,7 @@ the result of an internet search. If you know further customers of the library,
|
||||
|
||||
- [**Apple iOS and macOS**](https://www.apple.com/macos), a family of operating systems developed by Apple, including iOS for mobile devices and macOS for desktop computers
|
||||
- [**Chromium**](https://chromium.googlesource.com/chromium/src/+/main/third_party/nlohmann_json/), the open-source browser project that Google Chrome, Microsoft Edge, and many other browsers are built on, where the library is used as data container for on-device model execution
|
||||
- [**Google Fuchsia**](https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/scripts/prebuilts/swiftshader/build_config), an open-source operating system developed by Google, designed to be secure, updatable, and adaptable across various devices, where the library is used indirectly through bundled dependencies such as SwiftShader's debugger support and cppdap
|
||||
- [**Google Fuchsia**](https://fuchsia.googlesource.com/third_party/json/), an open-source operating system developed by Google, designed to be secure, updatable, and adaptable across various devices
|
||||
- [**LG webOS**](https://github.com/webosose/com.webos.service.camera), a Linux-based operating system used in LG smart TVs, signage, and embedded devices
|
||||
- [**Microsoft Azure Linux**](https://github.com/microsoft/azurelinux), a Linux distribution developed by Microsoft for Azure infrastructure and edge workloads
|
||||
- [**OpenHarmony**](https://github.com/openharmony/third_party_json), an open-source operating system for smart devices and the foundation of HarmonyOS
|
||||
@@ -174,7 +174,7 @@ the result of an internet search. If you know further customers of the library,
|
||||
- [**NVIDIA Instant NGP**](https://github.com/NVlabs/instant-ngp/blob/master/src/nerf_loader.cu), an implementation of instant neural graphics primitives for rapid scene reconstruction
|
||||
- [**NVIDIA TensorRT**](https://github.com/NVIDIA/TensorRT), an SDK for high-performance deep learning inference, including its TensorRT-LLM extension for large language models
|
||||
- [**NVIDIA TensorRT-LLM**](https://github.com/NVIDIA/TensorRT-LLM/blob/main/cpp/tensorrt_llm/common/safetensors.cpp), a toolkit for optimizing and serving large language model inference on GPUs
|
||||
- [**ONNX Runtime**](https://onnxruntime.ai), a cross-platform inference and training accelerator for machine learning models
|
||||
- [**ONNX Runtime**](https://github.com/microsoft/onnxruntime), a cross-platform inference and training accelerator for machine learning models
|
||||
- [**OpenVINO**](https://github.com/openvinotoolkit/openvino), Intel's toolkit for optimizing and deploying deep learning inference across CPUs, GPUs, and NPUs
|
||||
- [**PaddleOCR**](https://github.com/PaddlePaddle/PaddleOCR/blob/main/deploy/cpp_infer/src/modules/text_detection/result.cc), an optical character recognition toolkit that turns documents and images into structured data
|
||||
- [**PaddlePaddle**](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/ap/src/axpr/anf_expr.cc), a deep learning framework for distributed training and inference
|
||||
@@ -216,7 +216,7 @@ the result of an internet search. If you know further customers of the library,
|
||||
- [**Check Point**](https://www.checkpoint.com/about-us/copyright-and-trademarks/), a cybersecurity company specializing in threat prevention and network security solutions, offering a range of products designed to protect enterprises from cyber threats and ensure data integrity
|
||||
- [**EasyEffects**](https://github.com/wwmm/easyeffects/blob/master/src/presets_manager.hpp), an audio effects processor for PipeWire offering limiting, compression and equalization
|
||||
- [**espanso**](https://github.com/espanso/espanso/blob/dev/espanso-ui/src/win32/native.cpp), a cross-platform text expander
|
||||
- [**Karabiner-Elements**](https://github.com/pqrs-org/Karabiner-Elements/blob/main/src/share/json_utility.hpp), a keyboard customizer for macOS
|
||||
- [**Karabiner-Elements**](https://github.com/pqrs-org/Karabiner-Elements/blob/main/src/share/app_icon.hpp), a keyboard customizer for macOS
|
||||
- [**MacType**](https://github.com/snowie2000/mactype/blob/directwrite/settings.h), a font rendering engine for Windows
|
||||
- [**magicplan**](https://help.magicplan.app/acknowledgments), a mobile application for creating floor plans and interior designs using augmented reality
|
||||
- [**Microsoft Office for Mac**](https://officecdnmac.microsoft.com/pr/legal/mac/OfficeforMacAttributions.html), a suite of productivity applications developed by Microsoft for macOS, including tools for word processing, spreadsheets, and presentations
|
||||
|
||||
@@ -140,8 +140,6 @@ Exceptions have ids 1xx.
|
||||
|
||||
This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member `byte` indicates the error position.
|
||||
|
||||
The message ends with the last read token (`last read: '...'`), with control characters written as `<U+XXXX>`. A token of more than 8192 characters is shown by its first and its last 4096 characters, separated by `...`.
|
||||
|
||||
!!! failure "Example message"
|
||||
|
||||
Input ended prematurely:
|
||||
@@ -987,9 +985,7 @@ contains other characters (e.g., `1a`), or `-` where it cannot be used.
|
||||
|
||||
The JSON Patch operations 'remove' and 'move' cannot be applied to the root element of the JSON value. The exception is
|
||||
also thrown when the parent or a reference token of an empty JSON Pointer is requested, for instance by
|
||||
[`front`](../api/json_pointer/front.md), [`back`](../api/json_pointer/back.md),
|
||||
[`pop_front`](../api/json_pointer/pop_front.md), or [`pop_back`](../api/json_pointer/pop_back.md), and when
|
||||
[`basic_json_document::erase`](../api/basic_json_document/erase.md) is called with an empty JSON Pointer.
|
||||
[`back`](../api/json_pointer/back.md) or [`pop_back`](../api/json_pointer/pop_back.md).
|
||||
|
||||
!!! failure "Example message"
|
||||
|
||||
@@ -1265,9 +1261,9 @@ A JSON Patch operation 'test' failed. The unsuccessful operation is also printed
|
||||
### json.exception.other_error.502
|
||||
|
||||
[`to_ubjson`](../api/basic_json/to_ubjson.md) and [`to_bjdata`](../api/basic_json/to_bjdata.md) were called with
|
||||
`use_type = true` but `use_size = false`, and the value contains a non-empty array, object, or binary value (with
|
||||
BJData Draft 3, any binary value, including an empty one). UBJSON requires a size marker (`#`) after a type marker
|
||||
(`$`); scalars and empty arrays or objects do not throw.
|
||||
`use_type = true` but `use_size = false`, and the value contains a non-empty array or object (or, with BJData Draft 3,
|
||||
any binary value). UBJSON requires a size marker (`#`) after a type marker (`$`); scalars and empty arrays or objects
|
||||
do not throw.
|
||||
|
||||
!!! failure "Example message"
|
||||
|
||||
|
||||
@@ -1,187 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) -->
|
||||
|
||||
<svg
|
||||
width="535"
|
||||
height="535"
|
||||
viewBox="0 0 501.56251 501.56249"
|
||||
id="svg2"
|
||||
version="1.1"
|
||||
inkscape:version="1.3.2 (091e20ef0f, 2023-11-25)"
|
||||
sodipodi:docname="nix-snowflake-colours.svg"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:xlink="http://www.w3.org/1999/xlink"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/">
|
||||
<defs
|
||||
id="defs4">
|
||||
<linearGradient
|
||||
inkscape:collect="always"
|
||||
id="linearGradient5562">
|
||||
<stop
|
||||
style="stop-color:#699ad7;stop-opacity:1"
|
||||
offset="0"
|
||||
id="stop5564" />
|
||||
<stop
|
||||
id="stop5566"
|
||||
offset="0.24345198"
|
||||
style="stop-color:#7eb1dd;stop-opacity:1" />
|
||||
<stop
|
||||
style="stop-color:#7ebae4;stop-opacity:1"
|
||||
offset="1"
|
||||
id="stop5568" />
|
||||
</linearGradient>
|
||||
<linearGradient
|
||||
inkscape:collect="always"
|
||||
id="linearGradient5053">
|
||||
<stop
|
||||
style="stop-color:#415e9a;stop-opacity:1"
|
||||
offset="0"
|
||||
id="stop5055" />
|
||||
<stop
|
||||
id="stop5057"
|
||||
offset="0.23168644"
|
||||
style="stop-color:#4a6baf;stop-opacity:1" />
|
||||
<stop
|
||||
style="stop-color:#5277c3;stop-opacity:1"
|
||||
offset="1"
|
||||
id="stop5059" />
|
||||
</linearGradient>
|
||||
<linearGradient
|
||||
inkscape:collect="always"
|
||||
xlink:href="#linearGradient5562"
|
||||
id="linearGradient4328"
|
||||
gradientUnits="userSpaceOnUse"
|
||||
gradientTransform="translate(70.650339,-1055.1511)"
|
||||
x1="200.59668"
|
||||
y1="351.41116"
|
||||
x2="290.08701"
|
||||
y2="506.18814" />
|
||||
<linearGradient
|
||||
inkscape:collect="always"
|
||||
xlink:href="#linearGradient5053"
|
||||
id="linearGradient4330"
|
||||
gradientUnits="userSpaceOnUse"
|
||||
gradientTransform="translate(864.69589,-1491.3405)"
|
||||
x1="-584.19934"
|
||||
y1="782.33563"
|
||||
x2="-496.29703"
|
||||
y2="937.71399" />
|
||||
</defs>
|
||||
<sodipodi:namedview
|
||||
id="base"
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1.0"
|
||||
inkscape:pageopacity="0.0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:zoom="0.70904368"
|
||||
inkscape:cx="99.429699"
|
||||
inkscape:cy="195.33352"
|
||||
inkscape:document-units="px"
|
||||
inkscape:current-layer="layer3"
|
||||
showgrid="false"
|
||||
inkscape:window-width="1920"
|
||||
inkscape:window-height="1050"
|
||||
inkscape:window-x="1920"
|
||||
inkscape:window-y="30"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:snap-global="true"
|
||||
fit-margin-top="0"
|
||||
fit-margin-left="0"
|
||||
fit-margin-right="0"
|
||||
fit-margin-bottom="0"
|
||||
inkscape:showpageshadow="2"
|
||||
inkscape:pagecheckerboard="0"
|
||||
inkscape:deskcolor="#d1d1d1" />
|
||||
<metadata
|
||||
id="metadata7">
|
||||
<rdf:RDF>
|
||||
<cc:Work
|
||||
rdf:about="">
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
|
||||
</cc:Work>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<g
|
||||
inkscape:groupmode="layer"
|
||||
id="layer3"
|
||||
inkscape:label="gradient-logo"
|
||||
style="display:inline;opacity:1"
|
||||
transform="translate(-156.41121,933.30685)">
|
||||
<g
|
||||
id="g2"
|
||||
transform="matrix(0.99994059,0,0,0.99994059,-0.06321798,33.188377)"
|
||||
style="stroke-width:1.00006">
|
||||
<path
|
||||
sodipodi:nodetypes="cccccccccc"
|
||||
inkscape:connector-curvature="0"
|
||||
id="path3336-6"
|
||||
d="m 309.54892,-710.38827 122.19683,211.67512 -56.15706,0.5268 -32.6236,-56.8692 -32.85645,56.5653 -27.90237,-0.011 -14.29086,-24.6896 46.81047,-80.4901 -33.22946,-57.8257 z"
|
||||
style="opacity:1;fill:url(#linearGradient4328);fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:3.00018;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
|
||||
<use
|
||||
height="100%"
|
||||
width="100%"
|
||||
transform="rotate(60,407.11155,-715.78724)"
|
||||
id="use3439-6"
|
||||
inkscape:transform-center-y="151.59082"
|
||||
inkscape:transform-center-x="124.43045"
|
||||
xlink:href="#path3336-6"
|
||||
y="0"
|
||||
x="0"
|
||||
style="stroke-width:1.00006" />
|
||||
<use
|
||||
height="100%"
|
||||
width="100%"
|
||||
transform="rotate(-60,407.31177,-715.70016)"
|
||||
id="use3445-0"
|
||||
inkscape:transform-center-y="75.573958"
|
||||
inkscape:transform-center-x="-168.20651"
|
||||
xlink:href="#path3336-6"
|
||||
y="0"
|
||||
x="0"
|
||||
style="stroke-width:1.00006" />
|
||||
<use
|
||||
height="100%"
|
||||
width="100%"
|
||||
transform="rotate(180,407.41868,-715.7565)"
|
||||
id="use3449-5"
|
||||
inkscape:transform-center-y="-139.94592"
|
||||
inkscape:transform-center-x="59.669705"
|
||||
xlink:href="#path3336-6"
|
||||
y="0"
|
||||
x="0"
|
||||
style="stroke-width:1.00006" />
|
||||
<path
|
||||
style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:url(#linearGradient4330);fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:3.00018;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
|
||||
d="m 309.54892,-710.38827 122.19683,211.67512 -56.15706,0.5268 -32.6236,-56.8692 -32.85645,56.5653 -27.90237,-0.011 -14.29086,-24.6896 46.81047,-80.4901 -33.22946,-57.8256 z"
|
||||
id="path4260-0"
|
||||
inkscape:connector-curvature="0"
|
||||
sodipodi:nodetypes="cccccccccc" />
|
||||
<use
|
||||
height="100%"
|
||||
width="100%"
|
||||
transform="rotate(120,407.33916,-716.08356)"
|
||||
id="use4354-5"
|
||||
xlink:href="#path4260-0"
|
||||
y="0"
|
||||
x="0"
|
||||
style="display:inline;stroke-width:1.00006" />
|
||||
<use
|
||||
height="100%"
|
||||
width="100%"
|
||||
transform="rotate(-120,407.28823,-715.86995)"
|
||||
id="use4362-2"
|
||||
xlink:href="#path4260-0"
|
||||
y="0"
|
||||
x="0"
|
||||
style="display:inline;stroke-width:1.00006" />
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 6.4 KiB |
@@ -269,9 +269,6 @@ target_link_libraries(myproject PRIVATE nlohmann_json_modules)
|
||||
target_compile_definitions(myproject PRIVATE NLOHMANN_JSON_BUILD_MODULES)
|
||||
```
|
||||
|
||||
If `main.cpp` also uses `import std;`, the project needs CMake 4.5 or newer and a Ninja generator; see
|
||||
[Modules](../features/modules.md#requirements) for the supported toolchains.
|
||||
|
||||
## See also
|
||||
|
||||
- [Macros](../api/macros/index.md) - reference of all macros
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
cmake_minimum_required(VERSION 3.15)
|
||||
project(json_example)
|
||||
|
||||
find_package(nlohmann_json CONFIG REQUIRED)
|
||||
|
||||
add_executable(json_example example.cpp)
|
||||
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
|
||||
@@ -1,10 +0,0 @@
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
using nlohmann::json;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::cout << std::setw(4) << json::meta() << std::endl;
|
||||
}
|
||||
@@ -14,8 +14,7 @@
|
||||
{: style="height:1em"} [**Conda**](#conda) `nlohmann_json`  
|
||||
{: style="height:1em"} [**MacPorts**](#macports) `nlohmann-json`<br>
|
||||
{: style="height:1em"} [**CPM.cmake**](#cpmcmake) `gh:nlohmann/json`  
|
||||
{: style="height:1em"} [**xmake**](#xmake) `nlohmann_json`  
|
||||
{: style="height:1em"} [**Nix**](#nix) `nlohmann_json`
|
||||
{: style="height:1em"} [**xmake**](#xmake) `nlohmann_json`
|
||||
</p>
|
||||
|
||||
## Running example
|
||||
@@ -907,56 +906,6 @@ CPMAddPackage("gh:nlohmann/json@3.12.0")
|
||||
|
||||
* * *
|
||||
|
||||
## Nix
|
||||
|
||||
!!! abstract "Summary"
|
||||
|
||||
package: [**`nlohmann_json`**](https://search.nixos.org/packages?channel=unstable&show=nlohmann_json&query=nlohmann_json)
|
||||
|
||||
- :octicons-tag-24: Available versions: current version of each Nixpkgs channel (may lag behind the latest release)
|
||||
- :octicons-rocket-24: The package is maintained by the Nixpkgs community and updated after releases.
|
||||
- :octicons-file-24: File issues at the [Nixpkgs issue tracker](https://github.com/NixOS/nixpkgs/issues)
|
||||
- :octicons-question-24: [Nix website](https://nixos.org)
|
||||
|
||||
If you are using [Nix](https://nixos.org) or [NixOS](https://nixos.org/manual/nixos/stable/), the library is available
|
||||
as the [nlohmann_json](https://search.nixos.org/packages?channel=unstable&show=nlohmann_json&query=nlohmann_json)
|
||||
package in [Nixpkgs](https://github.com/NixOS/nixpkgs). To try it in a temporary shell, execute
|
||||
|
||||
```shell
|
||||
nix-shell -p nlohmann_json
|
||||
```
|
||||
|
||||
On NixOS, the package can be installed system-wide by adding it to `configuration.nix`:
|
||||
|
||||
```nix
|
||||
environment.systemPackages = [ pkgs.nlohmann_json ];
|
||||
```
|
||||
|
||||
??? example "Example: CMake"
|
||||
|
||||
1. Create the following files:
|
||||
|
||||
```cpp title="example.cpp"
|
||||
--8<-- "integration/nix/example.cpp"
|
||||
```
|
||||
|
||||
```cmake title="CMakeLists.txt"
|
||||
--8<-- "integration/nix/CMakeLists.txt"
|
||||
```
|
||||
|
||||
2. Enter a shell that provides the package, CMake, and a C++ compiler:
|
||||
|
||||
```sh
|
||||
nix-shell -p nlohmann_json cmake
|
||||
```
|
||||
|
||||
3. Compile the code:
|
||||
|
||||
```sh
|
||||
cmake -S . -B build
|
||||
cmake --build build
|
||||
```
|
||||
|
||||
## Other package managers
|
||||
|
||||
The library is also contained in many other package repositories; [Repology](https://repology.org/project/nlohmann-json/versions) tracks the packaged
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
wheel==0.48.0
|
||||
|
||||
mkdocs==1.6.1 # documentation framework
|
||||
mkdocs-git-revision-date-localized-plugin==1.7.0 # plugin "git-revision-date-localized"
|
||||
mkdocs-material==9.8.1 # theme for mkdocs
|
||||
mkdocs-git-revision-date-localized-plugin==1.6.3 # plugin "git-revision-date-localized"
|
||||
mkdocs-material==9.8.0 # theme for mkdocs
|
||||
mkdocs-material-extensions==1.3.1 # extensions
|
||||
mkdocs-minify-plugin==0.8.0 # plugin "minify"
|
||||
mkdocs-redirects==1.2.3 # plugin "redirects"
|
||||
|
||||
+4
-4
@@ -6,7 +6,7 @@
|
||||
"": {
|
||||
"name": "check-mermaid",
|
||||
"dependencies": {
|
||||
"jsdom": "31.0.1",
|
||||
"jsdom": "31.0.0",
|
||||
"mermaid": "12.3.0"
|
||||
}
|
||||
},
|
||||
@@ -1109,9 +1109,9 @@
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/jsdom": {
|
||||
"version": "31.0.1",
|
||||
"resolved": "https://registry.npmjs.org/jsdom/-/jsdom-31.0.1.tgz",
|
||||
"integrity": "sha512-CbhJL8ZQg3eKswxSZth4QO9tW0jPIhmR0vtSXQSbKSfWbwIT6hoRc17wdHIVTQ43KI0mdV5iTJr3281IDgVZ5g==",
|
||||
"version": "31.0.0",
|
||||
"resolved": "https://registry.npmjs.org/jsdom/-/jsdom-31.0.0.tgz",
|
||||
"integrity": "sha512-xAkhD9z1eyFC5+QUi9K24CaZJgdCQ2GOGLW1GdVDoQvkp/AxEH9TQ0pAplPOlIiV92hfcgnFOADZypbjgbBT6Q==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@exodus/bytes": "^1.16.0",
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
"description": "Validate the Mermaid diagrams of the documentation (see check_mermaid.mjs)",
|
||||
"type": "module",
|
||||
"dependencies": {
|
||||
"jsdom": "31.0.1",
|
||||
"jsdom": "31.0.0",
|
||||
"mermaid": "12.3.0"
|
||||
}
|
||||
}
|
||||
@@ -48,11 +48,10 @@ namespace detail
|
||||
{
|
||||
|
||||
/*!
|
||||
@brief implements binary to decimal floating-point conversion: the shortest
|
||||
digits of Zmij (see zmij.hpp) for IEEE 754 binary64 numbers, and the Grisu2
|
||||
algorithm for all other formats.
|
||||
@brief implements the Grisu2 algorithm for binary to decimal floating-point
|
||||
conversion.
|
||||
|
||||
The Grisu2 implementation is a slightly modified version of the reference
|
||||
This implementation is a slightly modified version of the reference
|
||||
implementation which may be obtained from
|
||||
http://florian.loitsch.com/publications (bench.tar.gz).
|
||||
|
||||
|
||||
@@ -88,9 +88,8 @@ JSON_INLINE_VARIABLE constexpr std::size_t max_valueless_container_size = 1 << 2
|
||||
|
||||
The limit @ref max_valueless_container_size applies to each container on its
|
||||
own, so on its own it lets 9 bytes announce 1048576 values, and every further
|
||||
8 bytes (a row of an optimized array of arrays) another 1048576. The elements
|
||||
of all containers of a valueless type in one input are therefore added up, and
|
||||
the sum must stay below this base
|
||||
8 bytes (a row of an optimized array of arrays) another 1048576. The elements of all containers of a valueless type
|
||||
in one input are therefore added up, and the sum must stay below this base
|
||||
plus @ref valueless_elements_per_byte for every byte read so far. The base is
|
||||
the per-container limit, so a container that was accepted on its own before
|
||||
the sum was introduced is still accepted at the start of an input.
|
||||
@@ -300,17 +299,6 @@ class binary_reader
|
||||
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
||||
}
|
||||
|
||||
// BON8: a string ends at the first byte that cannot continue it. If
|
||||
// that byte follows the value, the reader has already taken it from
|
||||
// the input and holds it in bon8_pushback. Without the end-of-input
|
||||
// check below it would be dropped, and the next read would start
|
||||
// behind it, so report the missing 0xFF instead.
|
||||
if (result && !strict && input_format == input_format_t::bon8 && bon8_pushback_size != 0)
|
||||
{
|
||||
get_bon8();
|
||||
return last_byte_error(exception_id::unexpected_end_of_input, "string at the end of the value is not terminated by 0xFF", "value", "");
|
||||
}
|
||||
|
||||
// strict mode: next byte must be EOF
|
||||
if (result && strict)
|
||||
{
|
||||
@@ -1927,21 +1915,6 @@ class binary_reader
|
||||
return result;
|
||||
}
|
||||
|
||||
/*!
|
||||
@brief move past a value of @a size bytes, starting with @a head, that a
|
||||
bulk run reads, as get() and get_number() would
|
||||
|
||||
Called before the value is passed on, so that an error reported while
|
||||
passing it on (see @ref emit_float) has the position and the last byte
|
||||
that reading the value byte by byte gives.
|
||||
*/
|
||||
void bulk_advance(const std::size_t size, const unsigned char head)
|
||||
{
|
||||
ia.bulk_skip(size);
|
||||
chars_read += size;
|
||||
current = head;
|
||||
}
|
||||
|
||||
/*!
|
||||
@brief read the integers, floats, booleans, and nulls that follow in a
|
||||
definite-length array, without the per-element bookkeeping of
|
||||
@@ -1967,70 +1940,71 @@ class binary_reader
|
||||
{
|
||||
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
|
||||
const unsigned char head = data[0];
|
||||
std::size_t size = 0;
|
||||
bool accepted = false;
|
||||
switch (head)
|
||||
{
|
||||
case 0x18:
|
||||
bulk_advance(2, head);
|
||||
size = 2;
|
||||
accepted = emit_unsigned(data[1]);
|
||||
break;
|
||||
case 0x19:
|
||||
bulk_advance(3, head);
|
||||
size = 3;
|
||||
accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
|
||||
break;
|
||||
case 0x1A:
|
||||
bulk_advance(5, head);
|
||||
size = 5;
|
||||
accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
|
||||
break;
|
||||
case 0x1B:
|
||||
bulk_advance(9, head);
|
||||
size = 9;
|
||||
accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
|
||||
break;
|
||||
case 0x38:
|
||||
bulk_advance(2, head);
|
||||
size = 2;
|
||||
accepted = emit_cbor_negative_integer(data[1]);
|
||||
break;
|
||||
case 0x39:
|
||||
bulk_advance(3, head);
|
||||
size = 3;
|
||||
accepted = emit_cbor_negative_integer(load_big_endian<std::uint16_t>(data + 1));
|
||||
break;
|
||||
case 0x3A:
|
||||
bulk_advance(5, head);
|
||||
size = 5;
|
||||
accepted = emit_cbor_negative_integer(load_big_endian<std::uint32_t>(data + 1));
|
||||
break;
|
||||
case 0x3B:
|
||||
bulk_advance(9, head);
|
||||
size = 9;
|
||||
accepted = emit_cbor_negative_integer(load_big_endian<std::uint64_t>(data + 1));
|
||||
break;
|
||||
case 0xF4:
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->boolean(false);
|
||||
break;
|
||||
case 0xF5:
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->boolean(true);
|
||||
break;
|
||||
case 0xF6:
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->null();
|
||||
break;
|
||||
case 0xFA:
|
||||
bulk_advance(5, head);
|
||||
size = 5;
|
||||
accepted = emit_float(load_big_endian<float>(data + 1));
|
||||
break;
|
||||
case 0xFB:
|
||||
bulk_advance(9, head);
|
||||
size = 9;
|
||||
accepted = emit_float(load_big_endian<double>(data + 1));
|
||||
break;
|
||||
default:
|
||||
if (head <= 0x17)
|
||||
{
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
|
||||
}
|
||||
else if (head >= 0x20 && head <= 0x37)
|
||||
{
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - head));
|
||||
}
|
||||
else
|
||||
@@ -2040,6 +2014,10 @@ class binary_reader
|
||||
}
|
||||
break;
|
||||
}
|
||||
// as if read by get() and get_number(): current is the head byte
|
||||
ia.bulk_skip(size);
|
||||
chars_read += size;
|
||||
current = head;
|
||||
--remaining;
|
||||
if (JSON_HEDLEY_UNLIKELY(!accepted))
|
||||
{
|
||||
@@ -2877,72 +2855,73 @@ class binary_reader
|
||||
{
|
||||
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
|
||||
const unsigned char head = data[0];
|
||||
std::size_t size = 0;
|
||||
bool accepted = false;
|
||||
switch (head)
|
||||
{
|
||||
case 0xC0: // nil
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->null();
|
||||
break;
|
||||
case 0xC2: // false
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->boolean(false);
|
||||
break;
|
||||
case 0xC3: // true
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->boolean(true);
|
||||
break;
|
||||
case 0xCA: // float 32
|
||||
bulk_advance(5, head);
|
||||
size = 5;
|
||||
accepted = emit_float(load_big_endian<float>(data + 1));
|
||||
break;
|
||||
case 0xCB: // float 64
|
||||
bulk_advance(9, head);
|
||||
size = 9;
|
||||
accepted = emit_float(load_big_endian<double>(data + 1));
|
||||
break;
|
||||
case 0xCC: // uint 8
|
||||
bulk_advance(2, head);
|
||||
size = 2;
|
||||
accepted = emit_unsigned(data[1]);
|
||||
break;
|
||||
case 0xCD: // uint 16
|
||||
bulk_advance(3, head);
|
||||
size = 3;
|
||||
accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
|
||||
break;
|
||||
case 0xCE: // uint 32
|
||||
bulk_advance(5, head);
|
||||
size = 5;
|
||||
accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
|
||||
break;
|
||||
case 0xCF: // uint 64
|
||||
bulk_advance(9, head);
|
||||
size = 9;
|
||||
accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
|
||||
break;
|
||||
case 0xD0: // int 8
|
||||
bulk_advance(2, head);
|
||||
size = 2;
|
||||
accepted = emit_signed(static_cast<std::int8_t>(data[1]));
|
||||
break;
|
||||
case 0xD1: // int 16
|
||||
bulk_advance(3, head);
|
||||
size = 3;
|
||||
accepted = emit_signed(load_big_endian<std::int16_t>(data + 1));
|
||||
break;
|
||||
case 0xD2: // int 32
|
||||
bulk_advance(5, head);
|
||||
size = 5;
|
||||
accepted = emit_signed(load_big_endian<std::int32_t>(data + 1));
|
||||
break;
|
||||
case 0xD3: // int 64
|
||||
bulk_advance(9, head);
|
||||
size = 9;
|
||||
accepted = emit_signed(load_big_endian<std::int64_t>(data + 1));
|
||||
break;
|
||||
default:
|
||||
if (head <= 0x7F)
|
||||
{
|
||||
// positive fixint
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
|
||||
}
|
||||
else if (head >= 0xE0)
|
||||
{
|
||||
// negative fixint
|
||||
bulk_advance(1, head);
|
||||
size = 1;
|
||||
accepted = sax->number_integer(static_cast<std::int8_t>(head));
|
||||
}
|
||||
else
|
||||
@@ -2952,6 +2931,10 @@ class binary_reader
|
||||
}
|
||||
break;
|
||||
}
|
||||
// as if read by get() and get_number(): current is the last byte
|
||||
ia.bulk_skip(size);
|
||||
chars_read += size;
|
||||
current = data[size - 1];
|
||||
--remaining;
|
||||
if (JSON_HEDLEY_UNLIKELY(!accepted))
|
||||
{
|
||||
@@ -3855,7 +3838,6 @@ class binary_reader
|
||||
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
|
||||
// UBJSON stores numbers big-endian, BJData little-endian
|
||||
const bool swap = is_little_endian != (input_format == input_format_t::bjdata);
|
||||
const std::size_t start = chars_read;
|
||||
std::size_t read = 0;
|
||||
bool accepted = true;
|
||||
while (read < count && accepted)
|
||||
@@ -3867,39 +3849,16 @@ class binary_reader
|
||||
byte_swap(number);
|
||||
}
|
||||
++read;
|
||||
// where passing the value on can report an error (see
|
||||
// emit_float), the position is that after the value, as if it
|
||||
// was read by get_number()
|
||||
set_chars_read(start + (read * size), std::integral_constant<bool, may_overflow_number_float<NumberType>()> {});
|
||||
accepted = emit_ubjson_number(number);
|
||||
}
|
||||
// get_number() does not change current
|
||||
// as if read by get_number(): current is the last byte read
|
||||
ia.bulk_skip(read * size);
|
||||
chars_read = start + (read * size);
|
||||
chars_read += read * size;
|
||||
current = data[(read * size) - 1];
|
||||
remaining -= read;
|
||||
return accepted;
|
||||
}
|
||||
|
||||
/*!
|
||||
@brief whether a value of type @a NumberType can be finite and still
|
||||
overflow number_float_t, which @ref emit_float reports as an error
|
||||
|
||||
False for the default number types, so that the loop in @ref
|
||||
parse_ubjson_typed_run need not track the position per value.
|
||||
*/
|
||||
template<typename NumberType>
|
||||
static constexpr bool may_overflow_number_float() noexcept
|
||||
{
|
||||
return static_cast<long double>((std::numeric_limits<number_float_t>::max)()) < static_cast<long double>((std::numeric_limits<NumberType>::max)());
|
||||
}
|
||||
|
||||
void set_chars_read(const std::size_t position, std::true_type /*track*/) noexcept
|
||||
{
|
||||
chars_read = position;
|
||||
}
|
||||
|
||||
void set_chars_read(const std::size_t /*position*/, std::false_type /*track*/) const noexcept {}
|
||||
|
||||
template<typename NumberType, enable_if_t<std::is_floating_point<NumberType>::value, int> = 0>
|
||||
bool emit_ubjson_number(const NumberType number)
|
||||
{
|
||||
@@ -4125,10 +4084,6 @@ class binary_reader
|
||||
auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
|
||||
const auto result_number = number_lexer.scan();
|
||||
const auto number_string = number_lexer.get_token_string();
|
||||
// the number as the lexer read it, for SAX number_float(): unlike
|
||||
// get_token_string(), which is meant for error messages and shortens
|
||||
// long tokens, it is complete; the next scan() replaces it
|
||||
const string_t number_text = number_lexer.get_string();
|
||||
const auto result_remainder = number_lexer.scan();
|
||||
|
||||
using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
|
||||
@@ -4155,7 +4110,10 @@ class binary_reader
|
||||
number_string,
|
||||
out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", number_string, '\''), nullptr));
|
||||
}
|
||||
return sax->number_float(parsed_float, number_text);
|
||||
// number_string is a std::string, while the SAX interface takes a
|
||||
// string_t; convert explicitly, as the two are only implicitly
|
||||
// convertible for some string types
|
||||
return sax->number_float(parsed_float, string_t(number_string.data(), number_string.size()));
|
||||
}
|
||||
case token_type::uninitialized:
|
||||
case token_type::literal_true:
|
||||
|
||||
@@ -110,164 +110,87 @@ inline const char* empty_input_message() noexcept
|
||||
return "attempting to parse an empty input; check that your input string or stream contains the expected JSON";
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// input adapters //
|
||||
////////////////////
|
||||
|
||||
#ifndef JSON_NO_IO
|
||||
/*!
|
||||
@brief the characters of the last read token, kept for error messages
|
||||
|
||||
A growable array of characters for the part of a token that an input adapter
|
||||
copied out of its window, or that the lexer copies while it scans input it
|
||||
cannot read again: unlike std::vector::push_back(), appending a character
|
||||
takes no reference to a local, and is a few instructions when there is room.
|
||||
|
||||
The token is only needed for error messages, which show its first head()
|
||||
characters and its last head() characters (see lexer::get_token_string). The
|
||||
buffer therefore keeps the first head() and at least the last tail()
|
||||
characters: when it is full and holds more than limit() characters, it drops
|
||||
the characters in between instead of growing. That happens where it would
|
||||
otherwise reallocate, so appending stays as cheap as before, and a long string
|
||||
or a long run of whitespace read from a stream is not kept a second time.
|
||||
copied out of its window: unlike std::vector<char>::push_back(), appending a
|
||||
character takes no reference to a local, and is a few instructions when there
|
||||
is room.
|
||||
*/
|
||||
template<typename CharType>
|
||||
class token_text_buffer
|
||||
class token_carry_buffer
|
||||
{
|
||||
public:
|
||||
static constexpr std::size_t head() noexcept
|
||||
{
|
||||
return 4096;
|
||||
}
|
||||
/// a little more than head(), as the last character may be handed back
|
||||
static constexpr std::size_t tail() noexcept
|
||||
{
|
||||
return head() + 16;
|
||||
}
|
||||
static constexpr std::size_t limit() noexcept
|
||||
{
|
||||
return head() + (2 * tail());
|
||||
}
|
||||
|
||||
token_text_buffer() = default;
|
||||
token_text_buffer(const token_text_buffer&) = delete;
|
||||
token_text_buffer& operator=(const token_text_buffer&) = delete;
|
||||
token_text_buffer(token_text_buffer&& rhs) noexcept
|
||||
token_carry_buffer() = default;
|
||||
token_carry_buffer(const token_carry_buffer&) = delete;
|
||||
token_carry_buffer& operator=(const token_carry_buffer&) = delete;
|
||||
token_carry_buffer(token_carry_buffer&& rhs) noexcept
|
||||
: m_data(std::move(rhs.m_data)), m_end(rhs.m_end), m_capacity_end(rhs.m_capacity_end)
|
||||
{
|
||||
rhs.m_end = rhs.m_capacity_end = nullptr;
|
||||
}
|
||||
token_text_buffer& operator=(token_text_buffer&& rhs) noexcept
|
||||
{
|
||||
m_data = std::move(rhs.m_data);
|
||||
m_end = rhs.m_end;
|
||||
m_capacity_end = rhs.m_capacity_end;
|
||||
rhs.m_end = rhs.m_capacity_end = nullptr;
|
||||
return *this;
|
||||
}
|
||||
~token_text_buffer() = default;
|
||||
token_carry_buffer& operator=(token_carry_buffer&&) = delete;
|
||||
~token_carry_buffer() = default;
|
||||
|
||||
void clear() noexcept
|
||||
{
|
||||
m_end = m_data.get();
|
||||
}
|
||||
|
||||
bool empty() const noexcept
|
||||
{
|
||||
return m_end == m_data.get();
|
||||
}
|
||||
|
||||
void push_back(CharType c)
|
||||
void push_back(char c)
|
||||
{
|
||||
if (JSON_HEDLEY_UNLIKELY(m_end == m_capacity_end))
|
||||
{
|
||||
make_room(1);
|
||||
grow(1);
|
||||
}
|
||||
*m_end++ = c;
|
||||
}
|
||||
|
||||
/// drop the last character
|
||||
void pop_back() noexcept
|
||||
{
|
||||
JSON_ASSERT(!empty());
|
||||
--m_end;
|
||||
}
|
||||
|
||||
void append(const CharType* first, const CharType* last)
|
||||
void append(const char* first, const char* last)
|
||||
{
|
||||
const auto n = static_cast<std::size_t>(last - first);
|
||||
const auto room = static_cast<std::size_t>(m_capacity_end - m_end);
|
||||
if (JSON_HEDLEY_UNLIKELY(n > room))
|
||||
if (n > room)
|
||||
{
|
||||
append_long(first, n);
|
||||
return;
|
||||
grow(n);
|
||||
}
|
||||
if (n != 0)
|
||||
{
|
||||
std::memcpy(m_end, first, n * sizeof(CharType));
|
||||
std::memcpy(m_end, first, n);
|
||||
}
|
||||
m_end += n;
|
||||
}
|
||||
|
||||
/// replace the contents of @a out
|
||||
void copy_to(std::vector<CharType>& out) const
|
||||
void copy_to(std::vector<char>& out) const
|
||||
{
|
||||
out.assign(m_data.get(), m_end);
|
||||
}
|
||||
|
||||
private:
|
||||
/// append @a n characters that do not fit, in pieces of at most tail()
|
||||
/// characters, so that dropping the middle keeps the last tail() of them
|
||||
JSON_HEDLEY_NEVER_INLINE void append_long(const CharType* first, std::size_t n)
|
||||
/// make room for @a extra more characters
|
||||
JSON_HEDLEY_NEVER_INLINE void grow(std::size_t extra)
|
||||
{
|
||||
while (n != 0)
|
||||
const auto size = static_cast<std::size_t>(m_end - m_data.get());
|
||||
const auto capacity = static_cast<std::size_t>(m_capacity_end - m_data.get());
|
||||
const std::size_t new_capacity = (std::max)(capacity < 32 ? static_cast<std::size_t>(32) : 2 * capacity, size + extra);
|
||||
std::unique_ptr<char[]> data(new char[new_capacity]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
if (size != 0)
|
||||
{
|
||||
const std::size_t piece = n < tail() ? n : tail();
|
||||
make_room(piece);
|
||||
std::memcpy(m_end, first, piece * sizeof(CharType));
|
||||
m_end += piece;
|
||||
first += piece;
|
||||
n -= piece;
|
||||
std::memcpy(data.get(), m_data.get(), size);
|
||||
}
|
||||
m_data = std::move(data);
|
||||
m_end = m_data.get() + size;
|
||||
m_capacity_end = m_data.get() + new_capacity;
|
||||
}
|
||||
|
||||
/// make room for @a extra (at most tail()) more characters: drop the
|
||||
/// middle of a long token instead of growing beyond limit()
|
||||
JSON_HEDLEY_NEVER_INLINE void make_room(std::size_t extra)
|
||||
{
|
||||
// nothing is allocated before the first character
|
||||
std::size_t size = m_data ? static_cast<std::size_t>(m_end - m_data.get()) : 0;
|
||||
if (size + extra > limit() && size > head() + tail())
|
||||
{
|
||||
std::memmove(m_data.get() + head(), m_end - tail(), tail() * sizeof(CharType));
|
||||
m_end = m_data.get() + head() + tail();
|
||||
size = head() + tail();
|
||||
}
|
||||
const std::size_t capacity = m_data ? static_cast<std::size_t>(m_capacity_end - m_data.get()) : 0;
|
||||
if (size + extra > capacity)
|
||||
{
|
||||
// never more than limit(): from there on, the middle is dropped
|
||||
const std::size_t doubled = capacity < 32 ? static_cast<std::size_t>(32) : 2 * capacity;
|
||||
const std::size_t new_capacity = (std::max)(doubled < limit() ? doubled : limit(), size + extra);
|
||||
std::unique_ptr<CharType[]> data(new CharType[new_capacity]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
if (size != 0)
|
||||
{
|
||||
std::memcpy(data.get(), m_data.get(), size * sizeof(CharType));
|
||||
}
|
||||
m_data = std::move(data);
|
||||
m_end = m_data.get() + size;
|
||||
m_capacity_end = m_data.get() + new_capacity;
|
||||
}
|
||||
}
|
||||
|
||||
std::unique_ptr<CharType[]> m_data{}; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,readability-redundant-member-init)
|
||||
CharType* m_end = nullptr;
|
||||
CharType* m_capacity_end = nullptr;
|
||||
std::unique_ptr<char[]> m_data{}; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,readability-redundant-member-init)
|
||||
char* m_end = nullptr;
|
||||
char* m_capacity_end = nullptr;
|
||||
};
|
||||
|
||||
/// the part of a token that an input adapter copied out of its window
|
||||
using token_carry_buffer = token_text_buffer<char>;
|
||||
|
||||
////////////////////
|
||||
// input adapters //
|
||||
////////////////////
|
||||
|
||||
#ifndef JSON_NO_IO
|
||||
/*!
|
||||
Input adapter for stdio file access. The file is locked for the lifetime of the
|
||||
adapter and read with the unlocked stdio functions (see
|
||||
|
||||
@@ -215,19 +215,6 @@ template<typename ArrayType>
|
||||
inline void reserve_array(ArrayType& /*arr*/, std::size_t /*len*/, priority_tag<0> /*unused*/)
|
||||
{}
|
||||
|
||||
/// reserve capacity for @a count elements in array @a arr, where @a count is
|
||||
/// at most reserve_cap() already (see json_sax_dom_error_state::reserve_count)
|
||||
template<typename ArrayType>
|
||||
auto reserve_array_capped(ArrayType& arr, std::size_t count, priority_tag<1> /*unused*/)
|
||||
-> decltype(arr.reserve(count), void())
|
||||
{
|
||||
arr.reserve(count);
|
||||
}
|
||||
|
||||
template<typename ArrayType>
|
||||
inline void reserve_array_capped(ArrayType& /*arr*/, std::size_t /*count*/, priority_tag<0> /*unused*/)
|
||||
{}
|
||||
|
||||
/*!
|
||||
@brief reports an object or array whose announced size exceeds max_size()
|
||||
|
||||
@@ -470,35 +457,32 @@ class json_sax_dom_error_state
|
||||
announces more than what is left of that is given what is left, and
|
||||
grows as its elements arrive. Without the position of the input (the
|
||||
parser is not driven by a binary_reader that is running) nothing is
|
||||
bounded but reserve_cap() for each array.
|
||||
bounded but the cap of reserve_array().
|
||||
|
||||
The common case, an array whose reservation is no more than the credit
|
||||
left, costs a comparison and a subtraction. An array is charged what is
|
||||
reserved for it, at most reserve_cap() elements, not what it announces, so
|
||||
an array of more elements does not take credit from the arrays nested in
|
||||
it.
|
||||
The common case, an array that announces no more than the credit left,
|
||||
costs a comparison and a subtraction. It is charged what it announces, which
|
||||
for an array of more than reserve_cap() elements is more than reserve_array()
|
||||
reserves for it, which its own elements refill as they are read.
|
||||
*/
|
||||
std::size_t reserve_count(const std::size_t len) noexcept
|
||||
{
|
||||
const std::size_t count = (std::min)(len, reserve_cap());
|
||||
if (JSON_HEDLEY_LIKELY(count <= reserve_credit))
|
||||
if (JSON_HEDLEY_LIKELY(len <= reserve_credit))
|
||||
{
|
||||
reserve_credit -= count;
|
||||
return count;
|
||||
reserve_credit -= len;
|
||||
return len;
|
||||
}
|
||||
return reserve_count_slowly(count);
|
||||
return reserve_count_slowly(len);
|
||||
}
|
||||
|
||||
private:
|
||||
/// @a count is at most reserve_cap()
|
||||
JSON_HEDLEY_NEVER_INLINE
|
||||
std::size_t reserve_count_slowly(std::size_t count) noexcept
|
||||
std::size_t reserve_count_slowly(const std::size_t len) noexcept
|
||||
{
|
||||
constexpr std::size_t max_size = (std::numeric_limits<std::size_t>::max)();
|
||||
if (input_position == nullptr)
|
||||
{
|
||||
reserve_credit = max_size;
|
||||
return count;
|
||||
return len;
|
||||
}
|
||||
|
||||
// refill the credit with 'reserved_elements_per_byte' for every
|
||||
@@ -516,6 +500,7 @@ class json_sax_dom_error_state
|
||||
credit_position = position;
|
||||
}
|
||||
|
||||
std::size_t count = (std::min)(len, reserve_cap());
|
||||
count = (std::min)(count, reserve_credit);
|
||||
reserve_credit -= count;
|
||||
return count;
|
||||
@@ -1361,7 +1346,7 @@ class json_sax_dom_parser : public json_sax_dom_error_state
|
||||
|
||||
if (len != detail::unknown_size())
|
||||
{
|
||||
reserve_array_capped(*ref->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
|
||||
reserve_array(*ref->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1709,7 +1694,7 @@ class json_sax_dom_binary_parser : public json_sax_dom_error_state
|
||||
|
||||
if (len != detail::unknown_size())
|
||||
{
|
||||
reserve_array_capped(*ref_stack.back()->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
|
||||
reserve_array(*ref_stack.back()->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
|
||||
}
|
||||
|
||||
return true;
|
||||
@@ -2001,7 +1986,7 @@ class json_sax_dom_callback_parser : public json_sax_dom_error_state
|
||||
|
||||
if (len != detail::unknown_size())
|
||||
{
|
||||
reserve_array_capped(*ref_stack.back()->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
|
||||
reserve_array(*ref_stack.back()->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -494,10 +494,7 @@ class lexer : public lexer_base<BasicJsonType>
|
||||
/// streaming adapter: capture the characters
|
||||
void bulk_track_token(const char* data, std::size_t n, std::false_type /*lazy*/)
|
||||
{
|
||||
for (std::size_t i = 0; i < n; ++i)
|
||||
{
|
||||
token_string.push_back(static_cast<char_type>(data[i]));
|
||||
}
|
||||
token_string.insert(token_string.end(), data, data + n);
|
||||
}
|
||||
|
||||
/// streaming input: no bulk fast path
|
||||
@@ -2240,28 +2237,15 @@ scan_number_done:
|
||||
const std::size_t stop = ia.get_consumed_count() - (pending_real_unget ? 1u : 0u);
|
||||
if (JSON_HEDLEY_LIKELY(stop >= token_string_start))
|
||||
{
|
||||
// only the beginning and the end of a long token are shown (see
|
||||
// get_token_string), so copy only these
|
||||
constexpr std::size_t head = token_text_buffer<char_type>::head();
|
||||
constexpr std::size_t tail = token_text_buffer<char_type>::tail();
|
||||
if (stop - token_string_start > head + tail)
|
||||
{
|
||||
ia.copy_consumed_range(token_string_start, token_string_start + head, out);
|
||||
ia.copy_consumed_range(stop - tail, stop, out);
|
||||
}
|
||||
else
|
||||
{
|
||||
ia.copy_consumed_range(token_string_start, stop, out);
|
||||
}
|
||||
ia.copy_consumed_range(token_string_start, stop, out);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/// streaming adapter: the token was copied eagerly while scanning
|
||||
const std::vector<char_type>& collect_token_chars(std::vector<char_type>& out, std::false_type /*lazy*/) const
|
||||
const std::vector<char_type>& collect_token_chars(std::vector<char_type>& /*out*/, std::false_type /*lazy*/) const
|
||||
{
|
||||
token_string.copy_to(out);
|
||||
return out;
|
||||
return token_string;
|
||||
}
|
||||
|
||||
/// return the last read token (for errors only). Will never contain EOF
|
||||
@@ -2272,32 +2256,10 @@ scan_number_done:
|
||||
std::vector<char_type> reconstructed;
|
||||
const std::vector<char_type>& chars = collect_token_chars(reconstructed, std::integral_constant<bool, lazy_token_string> {});
|
||||
|
||||
// a long token is shown by its first and its last head() characters;
|
||||
// the buffers that keep it while it is read keep no more than these
|
||||
// and a few more (see token_text_buffer)
|
||||
constexpr std::size_t shown = token_text_buffer<char_type>::head();
|
||||
// escape control characters
|
||||
std::string result;
|
||||
if (chars.size() > 2 * shown)
|
||||
for (const auto c : chars)
|
||||
{
|
||||
append_escaped(result, chars.begin(), chars.begin() + static_cast<std::ptrdiff_t>(shown));
|
||||
result += "...";
|
||||
append_escaped(result, chars.end() - static_cast<std::ptrdiff_t>(shown), chars.end());
|
||||
}
|
||||
else
|
||||
{
|
||||
append_escaped(result, chars.begin(), chars.end());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private:
|
||||
/// append the characters [first, last) to @a result, escaping control characters
|
||||
template<typename Iterator>
|
||||
static void append_escaped(std::string& result, Iterator first, Iterator last)
|
||||
{
|
||||
for (; first != last; ++first)
|
||||
{
|
||||
const auto c = *first;
|
||||
if (static_cast<unsigned char>(c) <= '\x1F')
|
||||
{
|
||||
// escape control characters
|
||||
@@ -2311,9 +2273,9 @@ scan_number_done:
|
||||
result.push_back(static_cast<std::string::value_type>(c));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
return result;
|
||||
}
|
||||
|
||||
/// return syntax error message
|
||||
JSON_HEDLEY_RETURNS_NON_NULL
|
||||
@@ -2563,7 +2525,7 @@ scan_number_done:
|
||||
|
||||
/// raw input token string for error messages; only populated for streaming
|
||||
/// adapters (seekable adapters reconstruct it lazily via token_string_start)
|
||||
token_text_buffer<char_type> token_string {};
|
||||
std::vector<char_type> token_string {};
|
||||
|
||||
/// start offset of the current token within the input, used to reconstruct
|
||||
/// the last read token on error for seekable adapters (see collect_token_chars)
|
||||
|
||||
@@ -257,7 +257,7 @@ struct ieee_binary_format<53> // binary64
|
||||
|
||||
These formats (float, double, and long double where it is binary64, e.g.
|
||||
with MSVC or on Apple arm64) are converted by parse_float_native(). The
|
||||
predicate is the one the serializer uses to choose to_chars() over snprintf.
|
||||
predicate is the one the serializer uses to choose Grisu2.
|
||||
*/
|
||||
template<typename FloatType>
|
||||
struct has_native_float_format
|
||||
|
||||
@@ -108,9 +108,7 @@ class json_reverse_iterator : public std::reverse_iterator<Base>
|
||||
/// access to successor
|
||||
reference operator[](difference_type n) const
|
||||
{
|
||||
// the element n positions after *this is the one n + 1 positions before base();
|
||||
// Base::operator[] then reports invalid_iterator.208 for object iterators
|
||||
return this->base()[-n - 1];
|
||||
return *(this->operator+(n));
|
||||
}
|
||||
|
||||
/// return the key of an object iterator
|
||||
|
||||
@@ -852,6 +852,139 @@ class json_pointer
|
||||
}
|
||||
|
||||
private:
|
||||
/*!
|
||||
@brief the pointer prefixes of a flattened object that denote arrays
|
||||
|
||||
@ref unflatten creates arrays exactly below the prefixes that have a
|
||||
reference token 0 among their children, and objects everywhere else.
|
||||
Deciding this up front keeps the result independent of the order in which
|
||||
the flattened object is iterated, which is unspecified for some object
|
||||
types.
|
||||
|
||||
A prefix is identified by the text of the key it is the beginning of:
|
||||
escaping is unambiguous, so equal prefixes of valid keys are equal texts.
|
||||
The set refers to the keys, which must outlive it.
|
||||
*/
|
||||
class array_prefix_set
|
||||
{
|
||||
public:
|
||||
void insert(const char* data, std::size_t size)
|
||||
{
|
||||
// flattened objects are usually sorted, so most keys that have a
|
||||
// 0 yield the prefix of the previous one
|
||||
if (last_data != nullptr && last_size == size && std::memcmp(last_data, data, size) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
last_data = data;
|
||||
last_size = size;
|
||||
|
||||
if (table.empty())
|
||||
{
|
||||
table.resize(16);
|
||||
}
|
||||
const std::size_t hash = hash_of(data, size);
|
||||
const std::size_t mask = table.size() - 1;
|
||||
std::size_t i = hash & mask;
|
||||
while (table[i].data != nullptr)
|
||||
{
|
||||
if (table[i].hash == hash && table[i].size == size && std::memcmp(table[i].data, data, size) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
i = (i + 1) & mask;
|
||||
}
|
||||
table[i] = slot(hash, data, size);
|
||||
|
||||
// keep the load factor below 1/2
|
||||
if (++used * 2 > table.size())
|
||||
{
|
||||
grow();
|
||||
}
|
||||
}
|
||||
|
||||
bool empty() const noexcept
|
||||
{
|
||||
return used == 0;
|
||||
}
|
||||
|
||||
bool contains(const char* data, std::size_t size) const noexcept
|
||||
{
|
||||
if (used == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const std::size_t hash = hash_of(data, size);
|
||||
const std::size_t mask = table.size() - 1;
|
||||
for (std::size_t i = hash & mask; table[i].data != nullptr; i = (i + 1) & mask)
|
||||
{
|
||||
if (table[i].hash == hash && table[i].size == size && std::memcmp(table[i].data, data, size) == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
struct slot
|
||||
{
|
||||
slot() noexcept = default;
|
||||
|
||||
slot(std::size_t h, const char* d, std::size_t s) noexcept
|
||||
: hash(h), data(d), size(s)
|
||||
{}
|
||||
|
||||
std::size_t hash = 0;
|
||||
const char* data = nullptr; // nullptr: the slot is empty
|
||||
std::size_t size = 0;
|
||||
};
|
||||
|
||||
static std::size_t hash_of(const char* data, std::size_t size) noexcept
|
||||
{
|
||||
std::uint64_t h = 0x9E3779B97F4A7C15ULL ^ size;
|
||||
std::size_t i = 0;
|
||||
for (; i + 8 <= size; i += 8)
|
||||
{
|
||||
std::uint64_t w = 0;
|
||||
std::memcpy(&w, data + i, 8);
|
||||
h = (h ^ w) * 0x100000001B3ULL;
|
||||
h ^= h >> 32u;
|
||||
}
|
||||
std::uint64_t w = 0;
|
||||
if (i < size)
|
||||
{
|
||||
std::memcpy(&w, data + i, size - i);
|
||||
}
|
||||
h = (h ^ w) * 0x9E3779B97F4A7C15ULL;
|
||||
return detail::conditional_static_cast<std::size_t>(h ^ (h >> 29u));
|
||||
}
|
||||
|
||||
void grow()
|
||||
{
|
||||
std::vector<slot> old(table.size() * 2);
|
||||
old.swap(table);
|
||||
const std::size_t mask = table.size() - 1;
|
||||
for (const auto& s : old)
|
||||
{
|
||||
if (s.data != nullptr)
|
||||
{
|
||||
std::size_t i = s.hash & mask;
|
||||
while (table[i].data != nullptr)
|
||||
{
|
||||
i = (i + 1) & mask;
|
||||
}
|
||||
table[i] = s;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<slot> table{};
|
||||
std::size_t used = 0;
|
||||
const char* last_data = nullptr;
|
||||
std::size_t last_size = 0;
|
||||
};
|
||||
|
||||
/// @brief the length of the longest common prefix of the first @a limit bytes of @a a and @a b
|
||||
static std::size_t common_prefix_length(const char* a, const char* b, const std::size_t limit) noexcept
|
||||
{
|
||||
@@ -874,355 +1007,6 @@ class json_pointer
|
||||
return i;
|
||||
}
|
||||
|
||||
/*!
|
||||
@brief the prefixes of a flattened object that are marked as arrays, for
|
||||
prefixes that are not short
|
||||
|
||||
A prefix is identified by the tokens it consists of: a node of a tree
|
||||
stands for the prefix of its parent followed by a token, and is looked up
|
||||
by its parent and the text of the token. The node of a prefix is found by
|
||||
walking the tokens of the key from the root, so identifying all prefixes
|
||||
of a key together costs one pass over the key, however long the prefixes
|
||||
are, and no prefix is ever compared byte by byte as a whole. The nodes
|
||||
along the key that was walked last are kept, and the walk of the next key
|
||||
starts below the beginning it has in common with that key. The tree refers
|
||||
to the keys, which must outlive it.
|
||||
*/
|
||||
class prefix_tree
|
||||
{
|
||||
public:
|
||||
/// @brief set the seed of the hash function, before anything is added
|
||||
void reseed(const std::uint64_t seed_value) noexcept
|
||||
{
|
||||
seed = seed_value;
|
||||
}
|
||||
|
||||
/// @brief mark the first @a prefix_size bytes of the key of @a key_size bytes at @a data
|
||||
void mark(const char* data, std::size_t key_size, std::size_t prefix_size)
|
||||
{
|
||||
nodes[walk(data, key_size, prefix_size)].marked = true;
|
||||
any_marked = true;
|
||||
}
|
||||
|
||||
bool is_marked(const char* data, std::size_t key_size, std::size_t prefix_size)
|
||||
{
|
||||
return any_marked && nodes[walk(data, key_size, prefix_size)].marked;
|
||||
}
|
||||
|
||||
bool empty() const noexcept
|
||||
{
|
||||
return !any_marked;
|
||||
}
|
||||
|
||||
/// @brief the hash of the first @a size bytes at @a data, for the seed @a seed_value
|
||||
static std::size_t hash_bytes(const char* data, std::size_t size, const std::uint64_t seed_value) noexcept
|
||||
{
|
||||
std::uint64_t h = seed_value ^ size;
|
||||
std::size_t i = 0;
|
||||
for (; i + 8 <= size; i += 8)
|
||||
{
|
||||
std::uint64_t w = 0;
|
||||
std::memcpy(&w, data + i, 8);
|
||||
h = (h ^ w) * 0x100000001B3ULL;
|
||||
h ^= h >> 32u;
|
||||
}
|
||||
std::uint64_t w = 0;
|
||||
if (i < size)
|
||||
{
|
||||
std::memcpy(&w, data + i, size - i);
|
||||
}
|
||||
h = (h ^ w) * 0x9E3779B97F4A7C15ULL;
|
||||
return detail::conditional_static_cast<std::size_t>(h ^ (h >> 29u));
|
||||
}
|
||||
|
||||
private:
|
||||
struct node
|
||||
{
|
||||
std::size_t parent = 0;
|
||||
std::size_t hash = 0;
|
||||
const char* token = nullptr;
|
||||
std::size_t token_size = 0;
|
||||
bool marked = false;
|
||||
};
|
||||
|
||||
/// @brief a slot of the hash table; the index of a node, 0 if the slot is empty
|
||||
struct bucket
|
||||
{
|
||||
std::size_t index = 0;
|
||||
};
|
||||
|
||||
/// @brief the node after a token of the key that was walked last, and where the token ends
|
||||
struct step
|
||||
{
|
||||
std::size_t node = 0;
|
||||
std::size_t end = 0;
|
||||
};
|
||||
|
||||
/// @brief the index of the node of the prefix that ends at the slash (or the end) at @a prefix_size
|
||||
std::size_t walk(const char* data, std::size_t key_size, std::size_t prefix_size)
|
||||
{
|
||||
if (nodes.empty())
|
||||
{
|
||||
nodes.emplace_back();
|
||||
table.resize(16);
|
||||
chain.emplace_back();
|
||||
}
|
||||
|
||||
if (data != last_key)
|
||||
{
|
||||
// keep the nodes within the beginning that this key has in common
|
||||
// with the key they were found for; a prefix that ends inside a
|
||||
// token of this key is not one of its prefixes
|
||||
const std::size_t same = common_prefix_length(data, last_key, (std::min)(key_size, last_key_size));
|
||||
std::size_t keep = chain.size();
|
||||
while (keep > 1 && (chain[keep - 1].end > same || (chain[keep - 1].end == same && same < key_size && data[same] != '/')))
|
||||
{
|
||||
--keep;
|
||||
}
|
||||
chain.resize(keep);
|
||||
last_key = data;
|
||||
last_key_size = key_size;
|
||||
}
|
||||
|
||||
// walk the tokens that are not walked yet
|
||||
while (chain.back().end < prefix_size && chain.back().end < key_size)
|
||||
{
|
||||
const std::size_t start = chain.back().end + 1;
|
||||
const void* const slash = std::memchr(data + start, '/', key_size - start);
|
||||
const std::size_t end = slash == nullptr ? key_size : static_cast<std::size_t>(static_cast<const char*>(slash) - data);
|
||||
step next;
|
||||
next.node = child(chain.back().node, data + start, end - start);
|
||||
next.end = end;
|
||||
chain.push_back(next);
|
||||
}
|
||||
|
||||
if (chain.back().end == prefix_size)
|
||||
{
|
||||
return chain.back().node;
|
||||
}
|
||||
// an earlier call walked further
|
||||
const auto it = std::lower_bound(chain.begin(), chain.end(), prefix_size, [](const step & s, std::size_t size)
|
||||
{
|
||||
return s.end < size;
|
||||
});
|
||||
return it->node;
|
||||
}
|
||||
|
||||
std::size_t slot_of(std::size_t parent, std::size_t hash) const noexcept
|
||||
{
|
||||
std::uint64_t x = static_cast<std::uint64_t>(hash) ^ (static_cast<std::uint64_t>(parent) * 0x9E3779B97F4A7C15ULL);
|
||||
x ^= x >> 32u;
|
||||
x *= 0xD6E8FEB86659FD93ULL;
|
||||
x ^= x >> 32u;
|
||||
return static_cast<std::size_t>(x) & (table.size() - 1);
|
||||
}
|
||||
|
||||
/// @brief the node of the prefix of the node @a parent followed by the token, which is added if it is not there
|
||||
std::size_t child(std::size_t parent, const char* token, std::size_t token_size)
|
||||
{
|
||||
const std::size_t hash = hash_bytes(token, token_size, seed);
|
||||
std::size_t i = slot_of(parent, hash);
|
||||
while (table[i].index != 0)
|
||||
{
|
||||
const node& n = nodes[table[i].index];
|
||||
if (n.parent == parent && n.hash == hash && n.token_size == token_size && std::memcmp(n.token, token, token_size) == 0)
|
||||
{
|
||||
return table[i].index;
|
||||
}
|
||||
i = (i + 1) & (table.size() - 1);
|
||||
}
|
||||
|
||||
node created;
|
||||
created.parent = parent;
|
||||
created.hash = hash;
|
||||
created.token = token;
|
||||
created.token_size = token_size;
|
||||
nodes.push_back(created);
|
||||
table[i].index = nodes.size() - 1;
|
||||
|
||||
// keep the load factor below 1/2
|
||||
if (nodes.size() * 2 > table.size())
|
||||
{
|
||||
std::vector<bucket> old(table.size() * 2);
|
||||
old.swap(table);
|
||||
for (std::size_t k = 1; k < nodes.size(); ++k)
|
||||
{
|
||||
std::size_t j = slot_of(nodes[k].parent, nodes[k].hash);
|
||||
while (table[j].index != 0)
|
||||
{
|
||||
j = (j + 1) & (table.size() - 1);
|
||||
}
|
||||
table[j].index = k;
|
||||
}
|
||||
}
|
||||
return nodes.size() - 1;
|
||||
}
|
||||
|
||||
std::uint64_t seed = 0;
|
||||
/// @brief the nodes; the first is the root, the empty prefix
|
||||
std::vector<node> nodes{};
|
||||
/// @brief the nodes (not the root) in a hash table
|
||||
std::vector<bucket> table{};
|
||||
/// @brief the root, and the node after each token of the key that was walked last
|
||||
std::vector<step> chain{};
|
||||
const char* last_key = nullptr;
|
||||
std::size_t last_key_size = 0;
|
||||
bool any_marked = false;
|
||||
};
|
||||
|
||||
/*!
|
||||
@brief the pointer prefixes of a flattened object that denote arrays
|
||||
|
||||
@ref unflatten creates arrays exactly below the prefixes that have a
|
||||
reference token 0 among their children, and objects everywhere else.
|
||||
Deciding this up front keeps the result independent of the order in which
|
||||
the flattened object is iterated, which is unspecified for some object
|
||||
types.
|
||||
|
||||
A prefix is identified by the text of the key it is the beginning of:
|
||||
escaping is unambiguous, so equal prefixes of valid keys are equal texts.
|
||||
The set refers to the keys, which must outlive it. Short prefixes are
|
||||
kept in a hash table and compared as texts, which costs at most the length
|
||||
of the bound. Longer prefixes are kept in a @ref prefix_tree, because
|
||||
hashing and comparing every one of the prefixes of a key with many tokens
|
||||
from its beginning would take quadratic time.
|
||||
|
||||
The hash function depends on a seed that is derived from the address of a
|
||||
local variable, which address space layout randomization changes between
|
||||
processes, so keys cannot be crafted to collide in advance; the result
|
||||
does not depend on the seed. Where the addresses are not randomized, or
|
||||
when the seed is known, keys can collide: k short prefixes then cost
|
||||
k^2 / 2 comparisons of fewer than 64 bytes each. The long prefixes are not
|
||||
hashed as a whole.
|
||||
*/
|
||||
class array_prefix_set
|
||||
{
|
||||
public:
|
||||
/// @brief choose the seed of the hash function, before anything is added: it is derived from the address that is passed
|
||||
void reseed(const void* address) noexcept
|
||||
{
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast,hicpp-use-auto,modernize-use-auto): the address is only a source of entropy
|
||||
std::uint64_t x = reinterpret_cast<std::uintptr_t>(address);
|
||||
x ^= 0x9E3779B97F4A7C15ULL;
|
||||
x *= 0xBF58476D1CE4E5B9ULL;
|
||||
seed = x ^ (x >> 31u);
|
||||
tree.reseed(seed);
|
||||
}
|
||||
|
||||
/// @brief add the first @a prefix_size bytes of the key of @a key_size bytes at @a data
|
||||
void insert(const char* data, std::size_t key_size, std::size_t prefix_size)
|
||||
{
|
||||
if (prefix_size >= short_limit)
|
||||
{
|
||||
tree.mark(data, key_size, prefix_size);
|
||||
return;
|
||||
}
|
||||
|
||||
// flattened objects are usually sorted, so most keys that have a
|
||||
// 0 yield the prefix of the previous one
|
||||
if (last_data != nullptr && last_size == prefix_size && std::memcmp(last_data, data, prefix_size) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
last_data = data;
|
||||
last_size = prefix_size;
|
||||
|
||||
const std::size_t hash = prefix_tree::hash_bytes(data, prefix_size, seed);
|
||||
if (table.empty())
|
||||
{
|
||||
table.resize(16);
|
||||
}
|
||||
const std::size_t mask = table.size() - 1;
|
||||
std::size_t i = hash & mask;
|
||||
while (table[i].data != nullptr)
|
||||
{
|
||||
if (table[i].hash == hash && table[i].size == prefix_size && std::memcmp(table[i].data, data, prefix_size) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
i = (i + 1) & mask;
|
||||
}
|
||||
table[i] = slot(hash, data, prefix_size);
|
||||
|
||||
// keep the load factor below 1/2
|
||||
if (++used * 2 > table.size())
|
||||
{
|
||||
grow();
|
||||
}
|
||||
}
|
||||
|
||||
bool empty() const noexcept
|
||||
{
|
||||
return used == 0 && tree.empty();
|
||||
}
|
||||
|
||||
/// @brief whether the first @a prefix_size bytes of the key of @a key_size bytes at @a data were added
|
||||
bool contains(const char* data, std::size_t key_size, std::size_t prefix_size)
|
||||
{
|
||||
if (prefix_size >= short_limit)
|
||||
{
|
||||
return tree.is_marked(data, key_size, prefix_size);
|
||||
}
|
||||
if (used == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const std::size_t hash = prefix_tree::hash_bytes(data, prefix_size, seed);
|
||||
const std::size_t mask = table.size() - 1;
|
||||
for (std::size_t i = hash & mask; table[i].data != nullptr; i = (i + 1) & mask)
|
||||
{
|
||||
if (table[i].hash == hash && table[i].size == prefix_size && std::memcmp(table[i].data, data, prefix_size) == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
/// @brief prefixes of fewer bytes are kept in the hash table
|
||||
static constexpr std::size_t short_limit = 64;
|
||||
|
||||
struct slot
|
||||
{
|
||||
slot() noexcept = default;
|
||||
|
||||
slot(std::size_t h, const char* d, std::size_t s) noexcept
|
||||
: hash(h), data(d), size(s)
|
||||
{}
|
||||
|
||||
std::size_t hash = 0;
|
||||
const char* data = nullptr; // nullptr: the slot is empty
|
||||
std::size_t size = 0;
|
||||
};
|
||||
|
||||
void grow()
|
||||
{
|
||||
std::vector<slot> old(table.size() * 2);
|
||||
old.swap(table);
|
||||
const std::size_t mask = table.size() - 1;
|
||||
for (const auto& s : old)
|
||||
{
|
||||
if (s.data != nullptr)
|
||||
{
|
||||
std::size_t i = s.hash & mask;
|
||||
while (table[i].data != nullptr)
|
||||
{
|
||||
i = (i + 1) & mask;
|
||||
}
|
||||
table[i] = s;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::uint64_t seed = 0;
|
||||
prefix_tree tree{};
|
||||
std::vector<slot> table{};
|
||||
std::size_t used = 0;
|
||||
const char* last_data = nullptr;
|
||||
std::size_t last_size = 0;
|
||||
};
|
||||
|
||||
/*!
|
||||
@brief check that @a key is a valid JSON pointer, and add the prefixes of
|
||||
it that denote arrays to @a arrays
|
||||
@@ -1268,7 +1052,7 @@ class json_pointer
|
||||
// a token 0 makes the pointer before it an array
|
||||
if (i - begin == 1 && data[begin] == '0')
|
||||
{
|
||||
arrays.insert(data, size, begin - 1);
|
||||
arrays.insert(data, begin - 1);
|
||||
}
|
||||
begin = i + 1;
|
||||
}
|
||||
@@ -2311,7 +2095,6 @@ class json_pointer
|
||||
// token 0 among their children; the values below them are arrays,
|
||||
// all others are objects (see array_prefix_set)
|
||||
array_prefix_set arrays;
|
||||
arrays.reseed(&arrays);
|
||||
const string_t* previous_key = nullptr;
|
||||
for (const auto& element : *value.m_data.m_value.object)
|
||||
{
|
||||
@@ -2403,7 +2186,7 @@ class json_pointer
|
||||
case detail::value_t::null:
|
||||
{
|
||||
// a first child 0 makes the value an array without a look-up
|
||||
if ((token_size == 1 && data[pos + 1] == '0') || arrays.contains(data, key.size(), pos))
|
||||
if ((token_size == 1 && data[pos + 1] == '0') || arrays.contains(data, pos))
|
||||
{
|
||||
// some reference token below this position is 0, so the
|
||||
// value is an array
|
||||
@@ -2455,19 +2238,6 @@ class json_pointer
|
||||
pos = end;
|
||||
}
|
||||
|
||||
if (JSON_HEDLEY_UNLIKELY(!current->is_null()))
|
||||
{
|
||||
// the key is a prefix of an earlier key (only possible if the
|
||||
// object type does not sort its keys), so the value is the
|
||||
// array or object built for that key: a null leaves it as it
|
||||
// is (as when the shorter key comes first), any other value
|
||||
// conflicts with it
|
||||
if (element.second.is_null())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
JSON_THROW(detail::type_error::create(detail::exception_id::unflatten_invalid_value, "invalid value to unflatten", &result));
|
||||
}
|
||||
*current = element.second;
|
||||
}
|
||||
|
||||
|
||||
@@ -230,16 +230,6 @@
|
||||
// detail/recursion_depth_limit.hpp. Like JSON_NO_THREAD_LOCAL it is neither part
|
||||
// of the ABI tag nor undefined at the end of json.hpp.
|
||||
|
||||
// forced inlining of the serializer's helpers only in optimized builds: at -O0,
|
||||
// GCC and Clang give every inlined copy its own stack slots, which made the
|
||||
// recursive frame of serializer::dump_container() about 2.3 KB (MSVC does not
|
||||
// expand __forceinline at /Ob0, so it keeps it)
|
||||
#if defined(__OPTIMIZE__) || defined(_MSC_VER)
|
||||
#define JSON_INTERNAL_SERIALIZER_INLINE JSON_HEDLEY_ALWAYS_INLINE
|
||||
#else
|
||||
#define JSON_INTERNAL_SERIALIZER_INLINE inline
|
||||
#endif
|
||||
|
||||
// allow disabling exceptions
|
||||
#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
|
||||
#define JSON_THROW(exception) throw exception
|
||||
|
||||
@@ -11,7 +11,6 @@
|
||||
// clean up
|
||||
#undef JSON_ASSERT
|
||||
#undef JSON_INTERNAL_CATCH
|
||||
#undef JSON_INTERNAL_SERIALIZER_INLINE
|
||||
#undef JSON_THROW
|
||||
#undef JSON_PRIVATE_UNLESS_TESTED
|
||||
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
||||
|
||||
@@ -915,7 +915,7 @@ class binary_writer
|
||||
JSON_THROW(out_of_range::create(exception_id::subtype_out_of_range, concat("subtype ", std::to_string(subtype), " is too large for ", what, " (max 255)"), &j));
|
||||
}
|
||||
|
||||
/// @throw other_error.502 always
|
||||
/// @throw other_error.407 always
|
||||
JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE
|
||||
static void throw_size_marker_required(const BasicJsonType& j)
|
||||
{
|
||||
|
||||
@@ -265,7 +265,7 @@ class serializer
|
||||
for a container; writing them from here spares each the entry and exit of
|
||||
that function.
|
||||
*/
|
||||
JSON_INTERNAL_SERIALIZER_INLINE void dump_element(const BasicJsonType& val,
|
||||
JSON_HEDLEY_ALWAYS_INLINE void dump_element(const BasicJsonType& val,
|
||||
const std::size_t current_indent,
|
||||
const std::size_t depth)
|
||||
{
|
||||
@@ -636,7 +636,7 @@ class serializer
|
||||
put_literal("\"subtype\": ");
|
||||
if (binary.has_subtype())
|
||||
{
|
||||
dump_subtype(binary.subtype());
|
||||
dump_integer(binary.subtype());
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -662,7 +662,7 @@ class serializer
|
||||
put_literal("],\"subtype\":");
|
||||
if (binary.has_subtype())
|
||||
{
|
||||
dump_subtype(binary.subtype());
|
||||
dump_integer(binary.subtype());
|
||||
put_char('}');
|
||||
}
|
||||
else
|
||||
@@ -971,7 +971,7 @@ class serializer
|
||||
}
|
||||
|
||||
/// write out the bytes pending in @ref string_buffer and reset @a bytes
|
||||
JSON_INTERNAL_SERIALIZER_INLINE void emit_pending(std::size_t& bytes)
|
||||
JSON_HEDLEY_ALWAYS_INLINE void emit_pending(std::size_t& bytes)
|
||||
{
|
||||
if (bytes != 0)
|
||||
{
|
||||
@@ -983,7 +983,7 @@ class serializer
|
||||
/// write buffer and reset index if fewer than 13 bytes are left, as this
|
||||
/// is the maximal number of bytes to be written ("\uxxxx\uxxxx\0") for one
|
||||
/// code point
|
||||
JSON_INTERNAL_SERIALIZER_INLINE void reserve_string_buffer(std::size_t& bytes)
|
||||
JSON_HEDLEY_ALWAYS_INLINE void reserve_string_buffer(std::size_t& bytes)
|
||||
{
|
||||
if (string_buffer.size() - bytes < 13)
|
||||
{
|
||||
@@ -1344,7 +1344,7 @@ class serializer
|
||||
inlining both into the pretty-printing loops once @ref dump_escaped
|
||||
has grown, which made indented output up to 13% slower
|
||||
*/
|
||||
JSON_INTERNAL_SERIALIZER_INLINE void put_indent(std::size_t indent)
|
||||
JSON_HEDLEY_ALWAYS_INLINE void put_indent(std::size_t indent)
|
||||
{
|
||||
// closing braces at the outermost level ask for no indentation at all
|
||||
if (indent == 0)
|
||||
@@ -1398,7 +1398,7 @@ class serializer
|
||||
its room and four stores of the indentation, see @ref put_short_literal_indent.
|
||||
*/
|
||||
template<std::size_t N>
|
||||
JSON_INTERNAL_SERIALIZER_INLINE void put_literal_indent(const char (&s)[N], const std::size_t indent) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
JSON_HEDLEY_ALWAYS_INLINE void put_literal_indent(const char (&s)[N], const std::size_t indent) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
{
|
||||
if (JSON_HEDLEY_LIKELY(put_short_literal_indent(s, indent)))
|
||||
{
|
||||
@@ -1418,7 +1418,7 @@ class serializer
|
||||
@a indent is wider or the write buffer lacks the room.
|
||||
*/
|
||||
template<std::size_t N>
|
||||
JSON_INTERNAL_SERIALIZER_INLINE bool put_short_literal_indent(const char (&s)[N], const std::size_t indent) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
JSON_HEDLEY_ALWAYS_INLINE bool put_short_literal_indent(const char (&s)[N], const std::size_t indent) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
{
|
||||
constexpr std::size_t length = N - 1;
|
||||
if (indent > 32 || write_buffer_pos + length + 32 > write_buffer.size())
|
||||
@@ -1445,7 +1445,7 @@ class serializer
|
||||
write-through path for oversized runs.
|
||||
*/
|
||||
template<std::size_t N>
|
||||
JSON_INTERNAL_SERIALIZER_INLINE void put_literal(const char (&s)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
JSON_HEDLEY_ALWAYS_INLINE void put_literal(const char (&s)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
||||
{
|
||||
static_assert(N >= 2, "put_literal expects a non-empty string literal");
|
||||
// the array bound counts the terminating NUL, which is not written
|
||||
@@ -1571,7 +1571,7 @@ class serializer
|
||||
{
|
||||
return n_digits + 3;
|
||||
}
|
||||
x = static_cast<number_magnitude_t>(x / 10000u);
|
||||
x = x / 10000u;
|
||||
n_digits += 4;
|
||||
}
|
||||
}
|
||||
@@ -1883,40 +1883,6 @@ class serializer
|
||||
write_buffer_pos = pos;
|
||||
}
|
||||
|
||||
/*!
|
||||
@brief dump the subtype of a binary value
|
||||
|
||||
The subtype is a std::uint64_t, whatever the number types are. @ref
|
||||
dump_integer converts its argument to the magnitude type of
|
||||
number_unsigned_t, so it writes the subtype only if that type has at least
|
||||
64 bits; otherwise (it would truncate the subtype) the digits are written
|
||||
one by one.
|
||||
|
||||
@param[in] subtype the subtype to dump
|
||||
*/
|
||||
void dump_subtype(std::uint64_t subtype)
|
||||
{
|
||||
dump_subtype(subtype, std::integral_constant<bool, magnitude_has_at_least_64_bits> {});
|
||||
}
|
||||
|
||||
void dump_subtype(std::uint64_t subtype, std::true_type /*magnitude has at least 64 bits*/)
|
||||
{
|
||||
dump_integer(subtype);
|
||||
}
|
||||
|
||||
void dump_subtype(std::uint64_t subtype, std::false_type /*magnitude has less than 64 bits*/)
|
||||
{
|
||||
std::array<char, 20> digits{{}}; // 2^64 - 1 has 20 digits
|
||||
std::size_t start = digits.size();
|
||||
do
|
||||
{
|
||||
digits[--start] = static_cast<char>('0' + (subtype % 10));
|
||||
subtype /= 10;
|
||||
}
|
||||
while (subtype != 0);
|
||||
put_string(digits, start, digits.size());
|
||||
}
|
||||
|
||||
/*!
|
||||
@brief dump an integer
|
||||
|
||||
@@ -2067,9 +2033,8 @@ class serializer
|
||||
}
|
||||
|
||||
// If number_float_t is an IEEE-754 single or double precision number,
|
||||
// use to_chars() to produce short numbers which are guaranteed to
|
||||
// round-trip, using strtof and strtod, resp. (the shortest digits of
|
||||
// Zmij for binary64, the Grisu2 algorithm for binary32).
|
||||
// use the Grisu2 algorithm to produce short numbers which are
|
||||
// guaranteed to round-trip, using strtof and strtod, resp.
|
||||
//
|
||||
// NB: The test below works if <long double> == <double>.
|
||||
static constexpr bool is_ieee_single_or_double
|
||||
@@ -2171,11 +2136,6 @@ class serializer
|
||||
static constexpr bool magnitude_has_at_most_64_bits = std::numeric_limits<number_magnitude_t>::is_specialized
|
||||
&& std::numeric_limits<number_magnitude_t>::digits <= 64;
|
||||
|
||||
/// whether every std::uint64_t fits number_magnitude_t (then dump_integer
|
||||
/// can write a binary subtype)
|
||||
static constexpr bool magnitude_has_at_least_64_bits = std::numeric_limits<number_magnitude_t>::is_specialized
|
||||
&& std::numeric_limits<number_magnitude_t>::digits >= 64;
|
||||
|
||||
/// whether @a x fits 64 bits: always if number_magnitude_t has at most
|
||||
/// 64 bits (selected by type, as the comparison would be reported as
|
||||
/// always true), else compared
|
||||
@@ -2201,7 +2161,7 @@ class serializer
|
||||
number_magnitude_t remove_sign(number_integer_t x) noexcept
|
||||
{
|
||||
JSON_ASSERT(x < 0);
|
||||
return static_cast<number_magnitude_t>(static_cast<number_magnitude_t>(-(x + 1)) + 1);
|
||||
return static_cast<number_magnitude_t>(-(x + 1)) + 1;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
@@ -384,22 +384,9 @@ class editor
|
||||
// for the container is linear in the size of the document, so
|
||||
// links (which are marked in the slot) avoid it.
|
||||
node* const p = parent_known ? parent : find_parent(m_doc, slot);
|
||||
if (p != nullptr)
|
||||
if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0))
|
||||
{
|
||||
if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)
|
||||
{
|
||||
block_of(m_doc, p, 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// the slot is no longer part of the document, but the
|
||||
// (dropped) container it is in may still step over it
|
||||
node* const q = find_layout_parent(m_doc, slot);
|
||||
if (q != nullptr)
|
||||
{
|
||||
block_of(m_doc, q, 0);
|
||||
}
|
||||
block_of(m_doc, p, 0);
|
||||
}
|
||||
}
|
||||
*slot = e.scalar;
|
||||
|
||||
@@ -194,9 +194,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
|
||||
h->len = n->len;
|
||||
h->next = static_cast<std::uint32_t>(used);
|
||||
node* o = h + 1;
|
||||
// (the bound on o keeps the copy inside the block even if the elements
|
||||
// disagreed with the element count)
|
||||
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;)
|
||||
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;)
|
||||
{
|
||||
if (object)
|
||||
{
|
||||
@@ -278,41 +276,6 @@ inline node* find_parent(const document_data& d, const node* target)
|
||||
}
|
||||
}
|
||||
|
||||
/// The container whose contiguous layout (in the parsed index, or in a new
|
||||
/// value) steps over `target`, also when an edit dropped the container or a
|
||||
/// value that encloses it; nullptr if there is none, or if the container no
|
||||
/// longer walks that layout (its elements moved). An edit never gives a node a
|
||||
/// larger extent than it was parsed or encoded with (a scalar is one node, an
|
||||
/// assigned array/object keeps the extent of the slot), so the containers whose
|
||||
/// extent covers `target` are its original ancestors: the nearest one before it
|
||||
/// is its original parent. The root of a new value that is the element sequence
|
||||
/// of another container is walked by that container (which find_parent() finds
|
||||
/// while it still uses the sequence), not by itself.
|
||||
inline node* find_layout_parent(const document_data& d, const node* target)
|
||||
{
|
||||
const std::less<const node*> lt{};
|
||||
const node* lo = d.nodes;
|
||||
if (lt(target, lo) || !lt(target, d.nodes + d.node_count))
|
||||
{
|
||||
auto it = d.edits->regions.upper_bound(target);
|
||||
if (it == d.edits->regions.begin())
|
||||
{
|
||||
return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value)
|
||||
}
|
||||
--it;
|
||||
lo = it->second != nullptr ? it->first + 1 : it->first;
|
||||
}
|
||||
for (const node* c = target; c != lo;)
|
||||
{
|
||||
--c;
|
||||
if (is_container(*c) && lt(target, c + c->next))
|
||||
{
|
||||
return (c->flags & node_flags::moved) == 0 ? const_cast<node*>(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
} // namespace view
|
||||
} // namespace detail
|
||||
NLOHMANN_JSON_NAMESPACE_END
|
||||
@@ -849,7 +849,7 @@ class basic_json_view
|
||||
return !navigation::editable() || m_doc->edits == nullptr;
|
||||
}
|
||||
|
||||
/// the member of this object with @a key (the first one if the key occurs more than once), or nullptr
|
||||
/// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
|
||||
NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
|
||||
{
|
||||
return find_key(key, std::integral_constant<bool, is_editable> {});
|
||||
|
||||
+1
-1
@@ -50,7 +50,6 @@
|
||||
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
|
||||
#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
|
||||
#undef JSON_HEDLEY_END_C_DECLS
|
||||
#undef JSON_HEDLEY_FALL_THROUGH
|
||||
#undef JSON_HEDLEY_FLAGS
|
||||
#undef JSON_HEDLEY_FLAGS_CAST
|
||||
#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
|
||||
@@ -159,3 +158,4 @@
|
||||
#undef JSON_HEDLEY_WARNING
|
||||
#undef JSON_HEDLEY_WARN_UNUSED_RESULT
|
||||
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
|
||||
#undef JSON_HEDLEY_FALL_THROUGH
|
||||
Generated
+264
-720
File diff suppressed because it is too large.
Load diff
Generated
+4
-54
@@ -5564,9 +5564,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
|
||||
h->len = n->len;
|
||||
h->next = static_cast<std::uint32_t>(used);
|
||||
node* o = h + 1;
|
||||
// (the bound on o keeps the copy inside the block even if the elements
|
||||
// disagreed with the element count)
|
||||
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;)
|
||||
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;)
|
||||
{
|
||||
if (object)
|
||||
{
|
||||
@@ -5648,41 +5646,6 @@ inline node* find_parent(const document_data& d, const node* target)
|
||||
}
|
||||
}
|
||||
|
||||
/// The container whose contiguous layout (in the parsed index, or in a new
|
||||
/// value) steps over `target`, also when an edit dropped the container or a
|
||||
/// value that encloses it; nullptr if there is none, or if the container no
|
||||
/// longer walks that layout (its elements moved). An edit never gives a node a
|
||||
/// larger extent than it was parsed or encoded with (a scalar is one node, an
|
||||
/// assigned array/object keeps the extent of the slot), so the containers whose
|
||||
/// extent covers `target` are its original ancestors: the nearest one before it
|
||||
/// is its original parent. The root of a new value that is the element sequence
|
||||
/// of another container is walked by that container (which find_parent() finds
|
||||
/// while it still uses the sequence), not by itself.
|
||||
inline node* find_layout_parent(const document_data& d, const node* target)
|
||||
{
|
||||
const std::less<const node*> lt{};
|
||||
const node* lo = d.nodes;
|
||||
if (lt(target, lo) || !lt(target, d.nodes + d.node_count))
|
||||
{
|
||||
auto it = d.edits->regions.upper_bound(target);
|
||||
if (it == d.edits->regions.begin())
|
||||
{
|
||||
return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value)
|
||||
}
|
||||
--it;
|
||||
lo = it->second != nullptr ? it->first + 1 : it->first;
|
||||
}
|
||||
for (const node* c = target; c != lo;)
|
||||
{
|
||||
--c;
|
||||
if (is_container(*c) && lt(target, c + c->next))
|
||||
{
|
||||
return (c->flags & node_flags::moved) == 0 ? const_cast<node*>(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
} // namespace view
|
||||
} // namespace detail
|
||||
NLOHMANN_JSON_NAMESPACE_END
|
||||
@@ -6559,22 +6522,9 @@ class editor
|
||||
// for the container is linear in the size of the document, so
|
||||
// links (which are marked in the slot) avoid it.
|
||||
node* const p = parent_known ? parent : find_parent(m_doc, slot);
|
||||
if (p != nullptr)
|
||||
if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0))
|
||||
{
|
||||
if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0)
|
||||
{
|
||||
block_of(m_doc, p, 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// the slot is no longer part of the document, but the
|
||||
// (dropped) container it is in may still step over it
|
||||
node* const q = find_layout_parent(m_doc, slot);
|
||||
if (q != nullptr)
|
||||
{
|
||||
block_of(m_doc, q, 0);
|
||||
}
|
||||
block_of(m_doc, p, 0);
|
||||
}
|
||||
}
|
||||
*slot = e.scalar;
|
||||
@@ -11066,7 +11016,7 @@ class basic_json_view
|
||||
return !navigation::editable() || m_doc->edits == nullptr;
|
||||
}
|
||||
|
||||
/// the member of this object with @a key (the first one if the key occurs more than once), or nullptr
|
||||
/// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
|
||||
NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
|
||||
{
|
||||
return find_key(key, std::integral_constant<bool, is_editable> {});
|
||||
|
||||
@@ -1,12 +1,5 @@
|
||||
cmake_minimum_required(VERSION 3.13...4.0)
|
||||
|
||||
# The unit tests use no C++ modules. Without this, CMake 4.5 scans the C++20 and
|
||||
# newer test targets and builds a `std` module for them, compiling the standard
|
||||
# library's module sources with the test warning flags (which fails with
|
||||
# -Werror) or failing to configure when the libc++ module sources are missing.
|
||||
# The module test in tests/module_cpp20 is a separate project and unaffected.
|
||||
set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
|
||||
|
||||
option(JSON_Valgrind "Execute test suite with Valgrind." OFF)
|
||||
option(JSON_FastTests "Skip expensive/slow tests." OFF)
|
||||
option(JSON_TestSimdutf "Build the unit tests against the simdutf UTF-8 validation backend." OFF)
|
||||
@@ -445,7 +438,8 @@ json_test_add_test_for(src/unit-stream-bulk-scan.cpp
|
||||
# with other values of JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE: 1 (the smallest),
|
||||
# 1000000 (so large that the budget cannot be reached), and the largest value of
|
||||
# a 64-bit integer (which saturates the limit already at the first byte, and is
|
||||
# clamped to the largest std::size_t where that has 32 bits)
|
||||
# clamped to the largest std::size_t where that has 32 bits). The file does not
|
||||
# mention JSON_HAS_CPP_<n>, so only C++11 is built unless the standards are forced
|
||||
json_test_set_test_options(test-ubjson_valueless_rate_1
|
||||
COMPILE_DEFINITIONS JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=1
|
||||
)
|
||||
|
||||
@@ -1,6 +1,11 @@
|
||||
# `import std;` (used by main.cpp) is supported without experimental opt-in
|
||||
# since CMake 4.5: it is available to every target that scans for C++ modules.
|
||||
cmake_minimum_required(VERSION 4.5)
|
||||
cmake_minimum_required(VERSION 3.30)
|
||||
|
||||
# `import std;` (used by main.cpp) needs CMake's experimental C++ import-std
|
||||
# support. The accepted token is CMake-version-specific; this value matches the
|
||||
# CMake version pinned in the ci_module_cpp20 CI jobs (4.3.x). If that pin is
|
||||
# bumped, this token must be updated to match (configuration fails loudly
|
||||
# otherwise).
|
||||
set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD "451f2fe2-a8a2-47c3-bc32-94786d8fc91b")
|
||||
|
||||
project(json_test CXX)
|
||||
|
||||
@@ -8,6 +13,7 @@ project(json_test CXX)
|
||||
set(CMAKE_CXX_STANDARD 23)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
set(CMAKE_CXX_MODULE_STD ON)
|
||||
|
||||
set(NLOHMANN_JSON_BUILD_MODULES ON CACHE BOOL "Enable nlohmann.json module support")
|
||||
|
||||
|
||||
@@ -17,8 +17,8 @@ using namespace nlohmann::literals;
|
||||
// Standard-library facilities are pulled in via `import std;` rather than
|
||||
// textual `#include`s: mixing `import` with textual standard headers does not
|
||||
// compile under GCC's C++20 modules implementation, whereas `import std;` works
|
||||
// across GCC, Clang, and MSVC. This requires C++23 and CMake 4.5 or newer;
|
||||
// see CMakeLists.txt.
|
||||
// across GCC, Clang, and MSVC. This requires C++23 and CMake's (experimental)
|
||||
// import-std support; see CMakeLists.txt.
|
||||
int main()
|
||||
{
|
||||
// basic_json / json: parsing and value access
|
||||
|
||||
@@ -6,13 +6,6 @@
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#define JSON_TESTS_PRIVATE
|
||||
@@ -22,7 +15,6 @@ using nlohmann::json;
|
||||
#include <functional>
|
||||
#include <limits>
|
||||
#include <valarray>
|
||||
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
|
||||
#if JSON_HAS_RANGES
|
||||
#include <ranges>
|
||||
#endif
|
||||
|
||||
@@ -14,7 +14,6 @@ using nlohmann::json;
|
||||
#include <cmath>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
@@ -368,125 +367,3 @@ TEST_CASE("Binary formats with narrow number types")
|
||||
CHECK(format.decode(format.encode(json(1e300)), false).is_discarded());
|
||||
}
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
// records the SAX events of narrow_json, including the arguments of parse_error
|
||||
struct narrow_event_recorder
|
||||
{
|
||||
using number_integer_t = narrow_json::number_integer_t;
|
||||
using number_unsigned_t = narrow_json::number_unsigned_t;
|
||||
using number_float_t = narrow_json::number_float_t;
|
||||
using string_t = narrow_json::string_t;
|
||||
using binary_t = narrow_json::binary_t;
|
||||
|
||||
bool null()
|
||||
{
|
||||
events.emplace_back("null");
|
||||
return true;
|
||||
}
|
||||
bool boolean(bool val)
|
||||
{
|
||||
events.emplace_back(val ? "true" : "false");
|
||||
return true;
|
||||
}
|
||||
bool number_integer(number_integer_t val)
|
||||
{
|
||||
events.push_back(std::to_string(val));
|
||||
return true;
|
||||
}
|
||||
bool number_unsigned(number_unsigned_t val)
|
||||
{
|
||||
events.push_back(std::to_string(val));
|
||||
return true;
|
||||
}
|
||||
bool number_float(number_float_t val, const string_t& /*unused*/)
|
||||
{
|
||||
events.push_back(std::to_string(val));
|
||||
return true;
|
||||
}
|
||||
bool string(string_t& val)
|
||||
{
|
||||
events.push_back(val);
|
||||
return true;
|
||||
}
|
||||
bool binary(binary_t& /*unused*/)
|
||||
{
|
||||
events.emplace_back("binary");
|
||||
return true;
|
||||
}
|
||||
bool start_object(std::size_t /*unused*/)
|
||||
{
|
||||
events.emplace_back("{");
|
||||
return true;
|
||||
}
|
||||
bool key(string_t& val)
|
||||
{
|
||||
events.push_back(val);
|
||||
return true;
|
||||
}
|
||||
bool end_object()
|
||||
{
|
||||
events.emplace_back("}");
|
||||
return true;
|
||||
}
|
||||
bool start_array(std::size_t /*unused*/)
|
||||
{
|
||||
events.emplace_back("[");
|
||||
return true;
|
||||
}
|
||||
bool end_array()
|
||||
{
|
||||
events.emplace_back("]");
|
||||
return true;
|
||||
}
|
||||
bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex)
|
||||
{
|
||||
events.push_back("parse_error(" + std::to_string(position) + ", " + last_token + ", " + ex.what() + ")");
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
|
||||
};
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("Binary formats with narrow number types from contiguous and non-contiguous input")
|
||||
{
|
||||
// contiguous input reads runs of numbers in one loop; a number that
|
||||
// overflows number_float_t must be reported with the same position and
|
||||
// last byte as when the input is read byte by byte
|
||||
const json values = {1, 70000, -70000, 1.5, 2.5, 1e300, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5};
|
||||
const json doubles = {1.5, 2.5, 3.5, 1e300, 4.5, 5.5, 6.5, 7.5, 8.5};
|
||||
|
||||
struct binary_input
|
||||
{
|
||||
const char* name;
|
||||
json::input_format_t format;
|
||||
bytes data;
|
||||
};
|
||||
const std::vector<binary_input> inputs =
|
||||
{
|
||||
{"CBOR", json::input_format_t::cbor, json::to_cbor(values)},
|
||||
{"CBOR doubles", json::input_format_t::cbor, json::to_cbor(doubles)},
|
||||
{"MessagePack", json::input_format_t::msgpack, json::to_msgpack(values)},
|
||||
{"MessagePack doubles", json::input_format_t::msgpack, json::to_msgpack(doubles)},
|
||||
{"UBJSON", json::input_format_t::ubjson, json::to_ubjson(values, true)},
|
||||
{"UBJSON typed doubles", json::input_format_t::ubjson, json::to_ubjson(doubles, true, true)},
|
||||
{"BJData", json::input_format_t::bjdata, json::to_bjdata(values, true)},
|
||||
{"BJData typed doubles", json::input_format_t::bjdata, json::to_bjdata(doubles, true, true)},
|
||||
};
|
||||
|
||||
for (const auto& input : inputs)
|
||||
{
|
||||
const std::string name = input.name;
|
||||
CAPTURE(name)
|
||||
const std::list<std::uint8_t> bytewise(input.data.begin(), input.data.end());
|
||||
narrow_event_recorder from_contiguous;
|
||||
narrow_event_recorder from_bytewise;
|
||||
CHECK_FALSE(narrow_json::sax_parse(input.data, &from_contiguous, input.format));
|
||||
CHECK_FALSE(narrow_json::sax_parse(bytewise.begin(), bytewise.end(), &from_bytewise, input.format));
|
||||
CHECK(from_contiguous.events == from_bytewise.events);
|
||||
REQUIRE(!from_contiguous.events.empty());
|
||||
CHECK(from_contiguous.events.back().find("out_of_range.406") != std::string::npos);
|
||||
}
|
||||
}
|
||||
@@ -1278,25 +1278,6 @@ TEST_CASE("BJData")
|
||||
CHECK(j.dump() == "3.141592653589793");
|
||||
}
|
||||
|
||||
SECTION("long floating-point number")
|
||||
{
|
||||
// the SAX parser receives the number text as it is in the
|
||||
// input, also when it is longer than the part of a token
|
||||
// that error messages show
|
||||
const std::vector<std::size_t> lengths = {8192, 8193, 10000};
|
||||
for (const auto length : lengths)
|
||||
{
|
||||
CAPTURE(length)
|
||||
const std::string number = "1." + std::string(length - 2, '3');
|
||||
std::vector<std::uint8_t> vec = {'H', 'I', static_cast<std::uint8_t>(length & 0xFF), static_cast<std::uint8_t>(length >> 8)};
|
||||
vec.insert(vec.end(), number.begin(), number.end());
|
||||
SaxEventLogger logger;
|
||||
CHECK(json::sax_parse(vec, &logger, json::input_format_t::bjdata));
|
||||
CHECK(logger.events == std::vector<std::string>({"number_float(" + number + ")"}));
|
||||
CHECK(json::from_bjdata(vec).is_number_float());
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("errors")
|
||||
{
|
||||
// error while parsing length
|
||||
|
||||
+3
-15
@@ -608,26 +608,14 @@ TEST_CASE("BON8")
|
||||
CHECK_THROWS_WITH_AS(_ = json::from_bon8(vec), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing BON8 value: expected end of input; last byte: 0x90", json::parse_error&);
|
||||
CHECK(json::from_bon8(vec, true, false).is_discarded());
|
||||
|
||||
// the byte after a string that ends a container: without strict, the
|
||||
// missing 0xFF is reported, as the byte has been taken from the input
|
||||
// the byte after a string that ends a container
|
||||
const bytes vec2 = {0x81, 'a', 0x90};
|
||||
CHECK_THROWS_WITH_AS(_ = json::from_bon8(vec2, false), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing BON8 value: string at the end of the value is not terminated by 0xFF; last byte: 0x90", json::parse_error&);
|
||||
CHECK(json::from_bon8(vec2, false, false).is_discarded());
|
||||
CHECK(json::from_bon8(vec2, false) == json({"a"}));
|
||||
CHECK_THROWS_WITH_AS(_ = json::from_bon8(vec2), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing BON8 value: expected end of input; last byte: 0x90", json::parse_error&);
|
||||
|
||||
const bytes vec3 = {0x81, 'a', 0xC2, 0x00};
|
||||
CHECK_THROWS_WITH_AS(_ = json::from_bon8(vec3, false), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing BON8 value: string at the end of the value is not terminated by 0xFF; last byte: 0xC2", json::parse_error&);
|
||||
CHECK(json::from_bon8(vec3, false) == json({"a"}));
|
||||
CHECK_THROWS_WITH_AS(_ = json::from_bon8(vec3), "[json.exception.parse_error.110] parse error at byte 3: syntax error while parsing BON8 value: expected end of input; last byte: 0xC2", json::parse_error&);
|
||||
|
||||
// with a terminated string, strict = false leaves the next value in the stream
|
||||
std::istringstream terminated(std::string("\x61\xFF\x90", 3));
|
||||
CHECK(json::from_bon8(terminated, false) == "a");
|
||||
CHECK((terminated.tellg() == 2));
|
||||
CHECK(json::from_bon8(terminated, false) == 0);
|
||||
|
||||
// without the terminator, the next value would be lost
|
||||
std::istringstream unterminated(std::string("\x61\x90", 2));
|
||||
CHECK_THROWS_WITH_AS(_ = json::from_bon8(unterminated, false), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing BON8 value: string at the end of the value is not terminated by 0xFF; last byte: 0x90", json::parse_error&);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2898,33 +2898,6 @@ TEST_CASE("CBOR - open arrays reserve only what the input has backed")
|
||||
CHECK(j.back() == 2);
|
||||
}
|
||||
|
||||
SECTION("an array that announces more than 16384 elements is charged what it is reserved")
|
||||
{
|
||||
// an array of 20000 elements (header 9A 00 00 4E 20) and three nested
|
||||
// arrays of 16384: the four reservations of 16384 add up to the credit
|
||||
// of 65,536. Charged the 20000 it announces, the outer array would
|
||||
// leave the innermost one less than it announces
|
||||
std::vector<std::uint8_t> input = {0x9A, 0x00, 0x00, 0x4E, 0x20};
|
||||
const auto nested = utils::repeated({0x99, 0x40, 0x00}, 3);
|
||||
input.insert(input.end(), nested.begin(), nested.end());
|
||||
|
||||
json result;
|
||||
dom_parser parser(result, false);
|
||||
CHECK_FALSE(json::sax_parse(input, &parser, json::input_format_t::cbor));
|
||||
const json* node = &result;
|
||||
for (int level = 0; level < 4; ++level)
|
||||
{
|
||||
CAPTURE(level)
|
||||
REQUIRE(node->is_array());
|
||||
CHECK(node->get_ref<const json::array_t&>().capacity() == 16384);
|
||||
if (level < 3)
|
||||
{
|
||||
REQUIRE(node->size() == 1);
|
||||
node = &node->front();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("a DOM parser that a parse has finished with is not bounded by the input of that parse")
|
||||
{
|
||||
// the DOM parser learns where the reader counts its characters, and
|
||||
|
||||
@@ -12,7 +12,6 @@
|
||||
#include <nlohmann/json.hpp>
|
||||
using nlohmann::json;
|
||||
|
||||
#include <algorithm> // min
|
||||
#include <array> // array
|
||||
#include <cctype> // toupper
|
||||
#include <cstdint> // uint32_t, uint64_t
|
||||
@@ -2234,125 +2233,3 @@ TEST_CASE("serialization of short strings")
|
||||
CHECK(json("caf\xC3\xA9").dump() == "\"caf\xC3\xA9\"");
|
||||
CHECK(json("caf\xC3\xA9").dump(-1, ' ', true) == "\"caf\\u00e9\"");
|
||||
}
|
||||
|
||||
TEST_CASE("token_text_buffer keeps the beginning and the end of a long token")
|
||||
{
|
||||
using buffer_t = nlohmann::detail::token_text_buffer<char>;
|
||||
constexpr std::size_t head = buffer_t::head();
|
||||
constexpr std::size_t tail = buffer_t::tail();
|
||||
|
||||
// the characters 0, 1, ..., 250, 0, 1, ...
|
||||
const auto at = [](std::size_t i)
|
||||
{
|
||||
return static_cast<char>(i % 251);
|
||||
};
|
||||
// whether out holds the first head and the last tail characters of a
|
||||
// token of n characters (and maybe more characters of its middle)
|
||||
const auto keeps_ends = [&](const std::vector<char>& out, std::size_t n)
|
||||
{
|
||||
if (out.size() < head + tail || out.size() > buffer_t::limit())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (std::size_t i = 0; i < head; ++i)
|
||||
{
|
||||
if (out[i] != at(i))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (std::size_t i = 0; i < tail; ++i)
|
||||
{
|
||||
if (out[out.size() - tail + i] != at(n - tail + i))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
SECTION("a short token is kept as it is")
|
||||
{
|
||||
buffer_t buffer;
|
||||
CHECK(buffer.empty());
|
||||
for (std::size_t i = 0; i < head + tail; ++i)
|
||||
{
|
||||
buffer.push_back(at(i));
|
||||
}
|
||||
std::vector<char> out;
|
||||
buffer.copy_to(out);
|
||||
REQUIRE(out.size() == head + tail);
|
||||
bool same = true;
|
||||
for (std::size_t i = 0; i < out.size(); ++i)
|
||||
{
|
||||
same = same && out[i] == at(i);
|
||||
}
|
||||
CHECK(same);
|
||||
}
|
||||
|
||||
SECTION("characters added one by one")
|
||||
{
|
||||
for (const std::size_t n :
|
||||
{
|
||||
head + tail + 1, buffer_t::limit(), buffer_t::limit() + 1, static_cast<std::size_t>(100000)
|
||||
})
|
||||
{
|
||||
CAPTURE(n)
|
||||
buffer_t buffer;
|
||||
for (std::size_t i = 0; i < n; ++i)
|
||||
{
|
||||
buffer.push_back(at(i));
|
||||
}
|
||||
std::vector<char> out;
|
||||
buffer.copy_to(out);
|
||||
CHECK(keeps_ends(out, n));
|
||||
|
||||
// the last character can be handed back
|
||||
buffer.pop_back();
|
||||
buffer.copy_to(out);
|
||||
CHECK(keeps_ends(out, n - 1));
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("characters added in pieces of different sizes")
|
||||
{
|
||||
std::vector<char> input(200000);
|
||||
for (std::size_t i = 0; i < input.size(); ++i)
|
||||
{
|
||||
input[i] = at(i);
|
||||
}
|
||||
for (const std::size_t piece :
|
||||
{
|
||||
static_cast<std::size_t>(1), static_cast<std::size_t>(100), tail - 1, tail, tail + 1, static_cast<std::size_t>(65536), input.size()
|
||||
})
|
||||
{
|
||||
CAPTURE(piece)
|
||||
buffer_t buffer;
|
||||
for (std::size_t pos = 0; pos < input.size(); pos += piece)
|
||||
{
|
||||
const std::size_t n = (std::min)(piece, input.size() - pos);
|
||||
// false positive: append() on an empty buffer allocates in append_long() before writing
|
||||
// @infer-ignore NULLPTR_DEREFERENCE
|
||||
buffer.append(input.data() + pos, input.data() + pos + n);
|
||||
}
|
||||
std::vector<char> out;
|
||||
buffer.copy_to(out);
|
||||
CHECK(keeps_ends(out, input.size()));
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("clear starts a new token")
|
||||
{
|
||||
buffer_t buffer;
|
||||
for (std::size_t i = 0; i < 100000; ++i)
|
||||
{
|
||||
buffer.push_back('x');
|
||||
}
|
||||
buffer.clear();
|
||||
CHECK(buffer.empty());
|
||||
buffer.push_back('a');
|
||||
std::vector<char> out;
|
||||
buffer.copy_to(out);
|
||||
CHECK(out == std::vector<char> {'a'});
|
||||
}
|
||||
}
|
||||
@@ -6,13 +6,6 @@
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
// capture whether JSON_STRICT_NUL_HANDLING was enabled on the command line
|
||||
@@ -524,7 +517,6 @@ TEST_CASE("parser class")
|
||||
CHECK(json::accept(u"[1]"));
|
||||
CHECK(json::parse(U"[1]") == json({1}));
|
||||
CHECK(json::accept(U"[1]"));
|
||||
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
|
||||
#if defined(__cpp_char8_t)
|
||||
CHECK(json::parse(u8"[1]") == json({1}));
|
||||
CHECK(json::accept(u8"[1]"));
|
||||
@@ -2510,7 +2502,7 @@ TEST_CASE("text of float tokens")
|
||||
std::vector<std::string> result;
|
||||
std::copy_if(events.begin(), events.end(), std::back_inserter(result), [](const std::string & e)
|
||||
{
|
||||
return e.compare(0, 13, "number_float(") == 0; // NOLINT(modernize-use-starts-ends-with): C++11
|
||||
return e.compare(0, 13, "number_float(") == 0;
|
||||
});
|
||||
return result;
|
||||
};
|
||||
@@ -3111,7 +3103,7 @@ TEST_CASE("object keys are delivered decoded and validated")
|
||||
std::vector<std::string> keys;
|
||||
for (const auto& e : l.events)
|
||||
{
|
||||
if (e.compare(0, 4, "key(") == 0) // NOLINT(modernize-use-starts-ends-with): C++11
|
||||
if (e.compare(0, 4, "key(") == 0)
|
||||
{
|
||||
keys.push_back(e.substr(4, e.size() - 5));
|
||||
}
|
||||
@@ -3277,116 +3269,3 @@ TEST_CASE("a plain function is accepted as parser callback for containers")
|
||||
CHECK((nlohmann::detail::can_compare_ne<std::string::const_iterator, std::string::const_iterator>::value));
|
||||
CHECK((nlohmann::detail::can_compare_ne<const char*, const char*>::value));
|
||||
}
|
||||
|
||||
#if !defined(JSON_NOEXCEPTION)
|
||||
TEST_CASE("parse error message of a long token")
|
||||
{
|
||||
// the message of a parse error shows the last read token; a long token is
|
||||
// shown by its first and its last 4096 characters, and the message is the
|
||||
// same for every kind of input
|
||||
const auto message = [](const std::string & text, int kind) -> std::string
|
||||
{
|
||||
json _;
|
||||
try
|
||||
{
|
||||
if (kind == 0)
|
||||
{
|
||||
_ = json::parse(text);
|
||||
}
|
||||
else if (kind == 1)
|
||||
{
|
||||
std::istringstream stream(text);
|
||||
_ = json::parse(stream);
|
||||
}
|
||||
else if (kind == 2)
|
||||
{
|
||||
FILE* const file = std::tmpfile(); // NOLINT(cppcoreguidelines-owning-memory)
|
||||
REQUIRE(file != nullptr);
|
||||
CHECK(std::fwrite(text.data(), 1, text.size(), file) == text.size());
|
||||
CHECK(std::fseek(file, 0, SEEK_SET) == 0);
|
||||
try
|
||||
{
|
||||
_ = json::parse(file);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
std::fclose(file); // NOLINT(cert-err33-c,cppcoreguidelines-owning-memory)
|
||||
throw;
|
||||
}
|
||||
std::fclose(file); // NOLINT(cert-err33-c,cppcoreguidelines-owning-memory)
|
||||
}
|
||||
else
|
||||
{
|
||||
const std::list<char> chars(text.begin(), text.end());
|
||||
_ = json::parse(chars.begin(), chars.end());
|
||||
}
|
||||
}
|
||||
catch (const json::parse_error& e)
|
||||
{
|
||||
return e.what();
|
||||
}
|
||||
return "no error";
|
||||
};
|
||||
|
||||
SECTION("a short token is shown completely")
|
||||
{
|
||||
const std::string text = "[\"" + std::string(8000, 'a') + "\x01\"]";
|
||||
const std::string expected = "last read: '\"" + std::string(8000, 'a') + "<U+0001>'";
|
||||
for (int kind = 0; kind < 4; ++kind)
|
||||
{
|
||||
CAPTURE(kind)
|
||||
const std::string m = message(text, kind);
|
||||
CHECK(m.size() > expected.size());
|
||||
CHECK(m.compare(m.size() - expected.size(), expected.size(), expected) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("a long string")
|
||||
{
|
||||
const std::string text = "[\"" + std::string(100000, 'a') + "b\x01\"]";
|
||||
// the token is '"', 100,000 times 'a', 'b', and the control character
|
||||
const std::string expected = "last read: '\"" + std::string(4095, 'a') + "..." + std::string(4094, 'a') + "b<U+0001>'";
|
||||
for (int kind = 0; kind < 4; ++kind)
|
||||
{
|
||||
CAPTURE(kind)
|
||||
const std::string m = message(text, kind);
|
||||
CHECK(m.size() > expected.size());
|
||||
CHECK(m.compare(m.size() - expected.size(), expected.size(), expected) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("a long run of whitespace after a number")
|
||||
{
|
||||
// the token begins with the number and ends with the invalid character
|
||||
const std::string text = "[1," + std::string(100000, '\n') + "?]";
|
||||
std::string expected = "last read: '1,";
|
||||
for (int i = 0; i < 4094; ++i)
|
||||
{
|
||||
expected += "<U+000A>";
|
||||
}
|
||||
expected += "...";
|
||||
for (int i = 0; i < 4095; ++i)
|
||||
{
|
||||
expected += "<U+000A>";
|
||||
}
|
||||
expected += "?'";
|
||||
for (int kind = 0; kind < 4; ++kind)
|
||||
{
|
||||
CAPTURE(kind)
|
||||
const std::string m = message(text, kind);
|
||||
CHECK(m.size() > expected.size());
|
||||
CHECK(m.compare(m.size() - expected.size(), expected.size(), expected) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("valid input with a long run of whitespace")
|
||||
{
|
||||
const std::string text = "1" + std::string(100000, ' ');
|
||||
for (int kind = 0; kind < 4; ++kind)
|
||||
{
|
||||
CAPTURE(kind)
|
||||
CHECK(message(text, kind) == "no error");
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -6,13 +6,6 @@
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
@@ -24,7 +17,6 @@
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
|
||||
#if JSON_HAS_THREE_WAY_COMPARISON
|
||||
#include <compare>
|
||||
#endif
|
||||
@@ -491,25 +483,3 @@ TEST_CASE("custom number types: 32-bit integers in the binary formats")
|
||||
CHECK(json32::to_msgpack(values) == nlohmann::json::to_msgpack(values64));
|
||||
CHECK(json32::to_ubjson(values) == nlohmann::json::to_ubjson(values64));
|
||||
}
|
||||
|
||||
TEST_CASE("custom number types: binary subtypes wider than the integer types")
|
||||
{
|
||||
// the subtype of a binary value is a std::uint64_t, whatever the number types are
|
||||
using json8 = nlohmann::json::with_integers_t<std::int8_t, std::uint8_t>;
|
||||
using json16 = nlohmann::json::with_integers_t<std::int16_t, std::uint16_t>;
|
||||
using json32 = nlohmann::json::with_integers_t<std::int32_t, std::uint32_t>;
|
||||
const std::uint64_t max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
|
||||
|
||||
CHECK(json8::binary({1}, 300).dump() == "{\"bytes\":[1],\"subtype\":300}");
|
||||
CHECK(json8::binary({200}, 255).dump() == "{\"bytes\":[200],\"subtype\":255}");
|
||||
CHECK(json16::binary({1}, 65543).dump() == "{\"bytes\":[1],\"subtype\":65543}");
|
||||
CHECK(json32::binary({1}, 4294967301u).dump() == "{\"bytes\":[1],\"subtype\":4294967301}");
|
||||
CHECK(json32::binary({1}, max_uint64).dump() == "{\"bytes\":[1],\"subtype\":18446744073709551615}");
|
||||
CHECK(json32::binary({1}, 0).dump() == "{\"bytes\":[1],\"subtype\":0}");
|
||||
CHECK(json32::binary({1}, 4294967301u).dump(1) == "{\n \"bytes\": [1],\n \"subtype\": 4294967301\n}");
|
||||
CHECK(json8::binary({1}).dump() == "{\"bytes\":[1],\"subtype\":null}");
|
||||
|
||||
// unchanged for the default number types
|
||||
CHECK(nlohmann::json::binary({1}, 4294967301u).dump() == "{\"bytes\":[1],\"subtype\":4294967301}");
|
||||
CHECK(nlohmann::json::binary({1}, max_uint64).dump(1) == "{\n \"bytes\": [1],\n \"subtype\": 18446744073709551615\n}");
|
||||
}
|
||||
@@ -830,13 +830,13 @@ TEST_CASE("iterators 2")
|
||||
{
|
||||
{
|
||||
auto it = j_object.rbegin();
|
||||
CHECK_THROWS_WITH_AS(it[0], "[json.exception.invalid_iterator.208] cannot use operator[] for object iterators", json::invalid_iterator&);
|
||||
CHECK_THROWS_WITH_AS(it[1], "[json.exception.invalid_iterator.208] cannot use operator[] for object iterators", json::invalid_iterator&);
|
||||
CHECK_THROWS_WITH_AS(it[0], "[json.exception.invalid_iterator.209] cannot use offsets with object iterators", json::invalid_iterator&);
|
||||
CHECK_THROWS_WITH_AS(it[1], "[json.exception.invalid_iterator.209] cannot use offsets with object iterators", json::invalid_iterator&);
|
||||
}
|
||||
{
|
||||
auto it = j_object.crbegin();
|
||||
CHECK_THROWS_WITH_AS(it[0], "[json.exception.invalid_iterator.208] cannot use operator[] for object iterators", json::invalid_iterator&);
|
||||
CHECK_THROWS_WITH_AS(it[1], "[json.exception.invalid_iterator.208] cannot use operator[] for object iterators", json::invalid_iterator&);
|
||||
CHECK_THROWS_WITH_AS(it[0], "[json.exception.invalid_iterator.209] cannot use offsets with object iterators", json::invalid_iterator&);
|
||||
CHECK_THROWS_WITH_AS(it[1], "[json.exception.invalid_iterator.209] cannot use offsets with object iterators", json::invalid_iterator&);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -850,7 +850,6 @@ TEST_CASE("iterators 2")
|
||||
CHECK(it[3] == json(3));
|
||||
CHECK(it[4] == json(2));
|
||||
CHECK(it[5] == json(1));
|
||||
CHECK((j_array.rbegin() + 2)[1] == json(3));
|
||||
}
|
||||
{
|
||||
auto it = j_array.crbegin();
|
||||
@@ -860,7 +859,6 @@ TEST_CASE("iterators 2")
|
||||
CHECK(it[3] == json(3));
|
||||
CHECK(it[4] == json(2));
|
||||
CHECK(it[5] == json(1));
|
||||
CHECK((j_array.crbegin() + 2)[3] == json(1));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -890,11 +888,6 @@ TEST_CASE("iterators 2")
|
||||
CHECK(it[0] == json(42));
|
||||
CHECK_THROWS_WITH_AS(it[1], "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
|
||||
}
|
||||
CHECK(json(1).rbegin()[0] == json(1));
|
||||
CHECK_THROWS_WITH_AS(json(1).rbegin()[1], "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
|
||||
|
||||
CHECK(json(1).crbegin()[0] == json(1));
|
||||
CHECK_THROWS_WITH_AS(json(1).crbegin()[1], "[json.exception.invalid_iterator.214] cannot get value", json::invalid_iterator&);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,10 +23,8 @@ using nlohmann::json;
|
||||
using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
|
||||
#endif
|
||||
|
||||
#include <algorithm>
|
||||
#include <cerrno>
|
||||
#include <cstdlib>
|
||||
#include <ctime>
|
||||
#include <limits>
|
||||
#include <map>
|
||||
#include <random>
|
||||
@@ -1240,34 +1238,6 @@ TEST_CASE("flatten of structured values")
|
||||
CHECK(flat_object.unflatten() == nlohmann::ordered_json::parse(R"({"b": {"1": 2}})"));
|
||||
}
|
||||
|
||||
#if !defined(JSON_NOEXCEPTION)
|
||||
SECTION("unflatten with a key that is a prefix of an earlier key")
|
||||
{
|
||||
// json visits the shorter key first; ordered_json may see it last
|
||||
CHECK_THROWS_WITH_AS(nlohmann::ordered_json::parse(R"({"/a/b":2,"/a":1})").unflatten(),
|
||||
"[json.exception.type_error.313] invalid value to unflatten", nlohmann::ordered_json::type_error&);
|
||||
CHECK_THROWS_WITH_AS(nlohmann::ordered_json::parse(R"({"/a/0/b":1,"/a/0":2})").unflatten(),
|
||||
"[json.exception.type_error.313] invalid value to unflatten", nlohmann::ordered_json::type_error&);
|
||||
CHECK_THROWS_WITH_AS(nlohmann::ordered_json::parse(R"({"/x":1,"":2})").unflatten(),
|
||||
"[json.exception.type_error.313] invalid value to unflatten", nlohmann::ordered_json::type_error&);
|
||||
|
||||
// the same members in the other order
|
||||
CHECK_THROWS_WITH_AS(nlohmann::ordered_json::parse(R"({"/a":1,"/a/b":2})").unflatten(),
|
||||
"[json.exception.type_error.313] invalid value to unflatten", nlohmann::ordered_json::type_error&);
|
||||
CHECK_THROWS_WITH_AS(json::parse(R"({"/a/b":2,"/a":1})").unflatten(),
|
||||
"[json.exception.type_error.313] invalid value to unflatten", json::type_error&);
|
||||
}
|
||||
#endif
|
||||
|
||||
SECTION("unflatten with a null at a key that is a prefix of another key")
|
||||
{
|
||||
// the null keeps the container, whichever key comes first
|
||||
CHECK(nlohmann::ordered_json::parse(R"({"/a/b":2,"/a":null})").unflatten() == nlohmann::ordered_json::parse(R"({"a":{"b":2}})"));
|
||||
CHECK(nlohmann::ordered_json::parse(R"({"/a":null,"/a/b":2})").unflatten() == nlohmann::ordered_json::parse(R"({"a":{"b":2}})"));
|
||||
CHECK(nlohmann::ordered_json::parse(R"({"/a/0":1,"/a":null})").unflatten() == nlohmann::ordered_json::parse(R"({"a":[1]})"));
|
||||
CHECK(json::parse(R"({"/a/b":2,"/a":null})").unflatten() == json::parse(R"({"a":{"b":2}})"));
|
||||
}
|
||||
|
||||
#if !defined(JSON_NOEXCEPTION)
|
||||
SECTION("an object with the key \"0\" next to a non-index key does not round-trip")
|
||||
{
|
||||
@@ -1590,294 +1560,3 @@ TEST_CASE("JSON patch with moves and copies")
|
||||
CHECK_THROWS_AS(inplace.patch_inplace(json::parse(R"([{"op":"move","from":"","path":""}])")), json::out_of_range&);
|
||||
CHECK(inplace == doc);
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
// the keys of a shape of flattened objects with long keys; `zero` is the
|
||||
// token that is repeated `m` times
|
||||
// 0: one key, 1: one `zero` followed by tokens 1, 2: the token 1 followed by
|
||||
// tokens `zero`, 3 and 4: two keys with a long prefix, apart from other keys,
|
||||
// 5: the same for two long branches, 6: more of the keys of 3
|
||||
std::vector<std::string> shape_keys(const int shape, const std::size_t m, const std::string& zero)
|
||||
{
|
||||
std::string repeated;
|
||||
for (std::size_t i = 0; i < m; ++i)
|
||||
{
|
||||
repeated += "/" + zero;
|
||||
}
|
||||
std::vector<std::string> keys;
|
||||
switch (shape)
|
||||
{
|
||||
case 0:
|
||||
keys.push_back(repeated);
|
||||
break;
|
||||
case 1:
|
||||
{
|
||||
std::string key = "/" + zero;
|
||||
for (std::size_t i = 1; i < m; ++i)
|
||||
{
|
||||
key += "/1";
|
||||
}
|
||||
keys.push_back(key);
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
std::string key = "/1";
|
||||
for (std::size_t i = 1; i < m; ++i)
|
||||
{
|
||||
key += "/" + zero;
|
||||
}
|
||||
keys.push_back(key);
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
case 4:
|
||||
keys = {repeated + "/a0", "/10", repeated + "/a1", "/11"};
|
||||
break;
|
||||
case 5:
|
||||
keys = {"/x" + repeated + "/a0", "/y" + repeated + "/a0", "/x" + repeated + "/a1", "/y" + repeated + "/a1"};
|
||||
break;
|
||||
case 6:
|
||||
for (int j = 0; j < 4; ++j)
|
||||
{
|
||||
keys.push_back(repeated + "/a" + std::to_string(j));
|
||||
keys.push_back("/1" + std::to_string(j));
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return keys;
|
||||
}
|
||||
|
||||
// the best of `runs` times in seconds that std::clock() measures to unflatten the keys,
|
||||
// which an ordered_json holds in the order they are given (shape 4 uses a
|
||||
// json, which sorts them)
|
||||
double unflatten_cpu_time(const int shape, const std::size_t m, const int runs, const std::string& zero)
|
||||
{
|
||||
const std::vector<std::string> keys = shape_keys(shape, m, zero);
|
||||
nlohmann::ordered_json ordered = nlohmann::ordered_json::object();
|
||||
json sorted = json::object();
|
||||
for (const auto& key : keys)
|
||||
{
|
||||
ordered[key] = 1;
|
||||
sorted[key] = 1;
|
||||
}
|
||||
|
||||
double best = 1e30;
|
||||
for (int i = 0; i < runs; ++i)
|
||||
{
|
||||
const std::clock_t start = std::clock();
|
||||
if (shape == 4)
|
||||
{
|
||||
const json nested = sorted.unflatten();
|
||||
}
|
||||
else
|
||||
{
|
||||
const nlohmann::ordered_json nested = ordered.unflatten();
|
||||
}
|
||||
best = (std::min)(best, static_cast<double>(std::clock() - start) / static_cast<double>(CLOCKS_PER_SEC));
|
||||
}
|
||||
return best;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("unflatten of keys with many reference tokens")
|
||||
{
|
||||
using nlohmann::ordered_json;
|
||||
|
||||
SECTION("which prefixes become arrays")
|
||||
{
|
||||
// sorted keys that share a long beginning
|
||||
CHECK(json({{"/x/y/q/1", 5}, {"/x/y/w/0", 4}, {"/x/y/w/1", 3}, {"/x/y/z/0", 1}, {"/x/y/z/1", 2}}).unflatten() ==
|
||||
json::parse(R"({"x":{"y":{"q":{"1":5},"w":[4,3],"z":[1,2]}}})"));
|
||||
|
||||
// prefixes that differ in the position of a slash only
|
||||
CHECK(json({{"/a/0/x", 1}, {"/a/1/y", 3}, {"/ab/1", 2}}).unflatten() ==
|
||||
json::parse(R"({"a":[{"x":1},{"y":3}],"ab":{"1":2}})"));
|
||||
CHECK(json({{"/a/b/1", 1}, {"/ab/0", 2}}).unflatten() ==
|
||||
json::parse(R"({"a":{"b":{"1":1}},"ab":[2]})"));
|
||||
|
||||
// tokens longer than one word, escapes, and a token 0 below a token 1
|
||||
const std::string t = "token_with_more_than_eight_bytes";
|
||||
CHECK(json({{"/" + t + "/1/b/0", 1}, {"/" + t + "/0", 2}, {"/" + t + "/2/a~1b", 3}}).unflatten() ==
|
||||
json::parse(R"({"token_with_more_than_eight_bytes":[2,{"b":[1]},{"a/b":3}]})"));
|
||||
|
||||
// prefixes of more than 64 bytes, that share a long beginning
|
||||
std::string deep;
|
||||
json expected = {{"a", {1, 2}}, {"b", {{"1", 3}}}, {"c", {{"1", {{"x", {4}}}}}}};
|
||||
for (int i = 0; i < 30; ++i)
|
||||
{
|
||||
deep += "/seg";
|
||||
expected = {{"seg", expected}};
|
||||
}
|
||||
CHECK(json({{deep + "/c/1/x/0", 4}, {deep + "/a/1", 2}, {deep + "/b/1", 3}, {deep + "/a/0", 1}}).unflatten() == expected);
|
||||
CHECK(json(ordered_json({{deep + "/c/1/x/0", 4}, {deep + "/a/1", 2}, {deep + "/b/1", 3}, {deep + "/a/0", 1}}).unflatten()) == expected);
|
||||
CHECK(json(ordered_json({{deep + "/a/1", 2}, {deep + "/a/0", 1}, {deep + "/b/1", 3}, {deep + "/c/1/x/0", 4}}).unflatten()) == expected);
|
||||
|
||||
// prefixes of every length around the limit up to which they are hashed directly
|
||||
for (std::size_t length = 40; length < 90; ++length)
|
||||
{
|
||||
const std::string name(length, 'x');
|
||||
const json flat = {{"/" + name + "/a/0", 1}, {"/" + name + "/a/1", 2}, {"/" + name + "/b/1", 3}, {"/" + name + "/c/1/0", 4}};
|
||||
CHECK(flat.unflatten() == json({{name, {{"a", {1, 2}}, {"b", {{"1", 3}}}, {"c", {{"1", {4}}}}}}}));
|
||||
}
|
||||
|
||||
// only the parent of a token 0 is an array, however deep the key is
|
||||
CHECK(json({{"/0/1/1/1", 1}}).unflatten() == json::parse(R"([{"1":{"1":{"1":1}}}])"));
|
||||
CHECK(json({{"/1/1/1/0", 1}}).unflatten() == json::parse(R"({"1":{"1":{"1":[1]}}})"));
|
||||
CHECK(json({{"/1/0/1/0", 1}}).unflatten() == json::parse(R"({"1":[{"1":[1]}]})"));
|
||||
}
|
||||
|
||||
SECTION("the result does not depend on the order of the keys")
|
||||
{
|
||||
// random documents without empty containers and without the key "0" in
|
||||
// an object: flatten() and unflatten() are inverse to each other
|
||||
std::mt19937 gen(20261110); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
|
||||
const std::vector<std::string> names = {"a", "b", "ab", "1", "2", "10", "a/b", "a~b", "token_with_more_than_eight_bytes", "x"};
|
||||
|
||||
struct builder
|
||||
{
|
||||
std::mt19937& gen;
|
||||
const std::vector<std::string>& names;
|
||||
|
||||
json operator()(int depth) const
|
||||
{
|
||||
const int kind = std::uniform_int_distribution<int>(0, 9)(gen);
|
||||
if (depth == 0 || kind < 3)
|
||||
{
|
||||
return kind;
|
||||
}
|
||||
json result = kind < 6 ? json::array() : json::object();
|
||||
const int size = std::uniform_int_distribution<int>(1, 4)(gen);
|
||||
for (int i = 0; i < size; ++i)
|
||||
{
|
||||
if (kind < 6)
|
||||
{
|
||||
result.push_back((*this)(depth - 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
result[names[std::uniform_int_distribution<std::size_t>(0, names.size() - 1)(gen)]] = (*this)(depth - 1);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
};
|
||||
const builder build{gen, names};
|
||||
|
||||
for (int round = 0; round < 200; ++round)
|
||||
{
|
||||
const json doc = build(6);
|
||||
const json flat = doc.flatten();
|
||||
CHECK(flat.unflatten() == doc);
|
||||
|
||||
// the same entries in shuffled order, in an object that keeps it
|
||||
std::vector<std::pair<std::string, json>> entries;
|
||||
for (const auto& el : flat.items())
|
||||
{
|
||||
entries.emplace_back(el.key(), el.value());
|
||||
}
|
||||
std::shuffle(entries.begin(), entries.end(), gen);
|
||||
ordered_json shuffled = ordered_json::object();
|
||||
for (const auto& e : entries)
|
||||
{
|
||||
shuffled[e.first] = e.second;
|
||||
}
|
||||
CHECK(json(shuffled.unflatten()) == doc);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("keys with long prefixes, in every order")
|
||||
{
|
||||
// prefixes of more than 64 bytes that share a long beginning, and
|
||||
// continue with tokens that start the same way
|
||||
std::string deep;
|
||||
for (int i = 0; i < 30; ++i)
|
||||
{
|
||||
deep += "/seg";
|
||||
}
|
||||
const std::string other = deep.substr(0, 70) + "/x" + deep.substr(70);
|
||||
std::vector<std::string> keys = {deep + "/a/0", deep + "/ab/1", deep + "/ab/x", deep + "/abc/0/y/0", other + "/b/1/0", deep + "/abc/1"};
|
||||
std::sort(keys.begin(), keys.end());
|
||||
|
||||
// the result for the keys in sorted order, which json iterates in
|
||||
json sorted = json::object();
|
||||
for (const auto& key : keys)
|
||||
{
|
||||
sorted[key] = 1;
|
||||
}
|
||||
const json expected = sorted.unflatten();
|
||||
CHECK(expected.is_object());
|
||||
|
||||
// ordered_json iterates in the order the keys were added
|
||||
std::vector<std::size_t> order(keys.size());
|
||||
for (std::size_t i = 0; i < order.size(); ++i)
|
||||
{
|
||||
order[i] = i;
|
||||
}
|
||||
std::size_t permutations = 0;
|
||||
bool all_equal = true;
|
||||
do
|
||||
{
|
||||
nlohmann::ordered_json flat = nlohmann::ordered_json::object();
|
||||
for (const auto i : order)
|
||||
{
|
||||
flat[keys[i]] = 1;
|
||||
}
|
||||
all_equal = all_equal && json(flat.unflatten()) == expected;
|
||||
++permutations;
|
||||
}
|
||||
while (std::next_permutation(order.begin(), order.end()));
|
||||
CHECK(permutations == 720);
|
||||
CHECK(all_equal);
|
||||
}
|
||||
|
||||
SECTION("time is linear in the number of tokens")
|
||||
{
|
||||
// A bound in seconds would depend on the machine. Instead, the time is
|
||||
// compared with the time for the same keys with the token 0 replaced by
|
||||
// a token that is not a number: there is no array, so no prefix is
|
||||
// looked up. The ratio is 1 to 3 for a linear algorithm, and between
|
||||
// 12 and 100 when looking up a prefix takes time proportional to its
|
||||
// length. The time that std::clock() measures is mostly the time of the
|
||||
// processor, which a busy machine does not inflate (on MSVC, it is the
|
||||
// time that has passed), and the best of two or three runs counts.
|
||||
for (int shape = 0; shape < 7; ++shape)
|
||||
{
|
||||
// the shapes with several keys, in an order that does not sort them,
|
||||
// need more tokens to be slow enough to tell
|
||||
const bool many = shape == 3 || shape == 5 || shape == 6;
|
||||
const std::size_t m = many ? 40000 : 10000;
|
||||
const int runs = many ? 2 : 3;
|
||||
|
||||
// a busy machine may spoil one comparison, hardly two
|
||||
bool linear = false;
|
||||
double t_array = 0;
|
||||
double t_object = 0;
|
||||
for (int attempt = 0; attempt < 2 && !linear; ++attempt)
|
||||
{
|
||||
t_array = unflatten_cpu_time(shape, m, runs, "0");
|
||||
t_object = (std::max)(unflatten_cpu_time(shape, m, runs, "a"), 1e-3);
|
||||
linear = t_array < 6 * t_object;
|
||||
}
|
||||
CAPTURE(shape)
|
||||
CAPTURE(t_array)
|
||||
CAPTURE(t_object)
|
||||
CHECK(linear);
|
||||
}
|
||||
|
||||
// the nesting is as expected: an array exactly below each token 0
|
||||
const json nested_deep = json::object({{shape_keys(0, 1000, "0")[0], 1}}).unflatten();
|
||||
std::size_t depth = 0;
|
||||
for (const json* p = &nested_deep; p->is_array(); p = &p->back())
|
||||
{
|
||||
++depth;
|
||||
}
|
||||
CHECK(depth == 1000);
|
||||
const json nested_ones = json::object({{shape_keys(1, 1000, "0")[0], 1}}).unflatten();
|
||||
CHECK(nested_ones.is_array());
|
||||
CHECK(nested_ones.back().is_object());
|
||||
}
|
||||
}
|
||||
@@ -6,13 +6,6 @@
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
@@ -279,7 +272,6 @@ struct generator
|
||||
TEST_CASE("json_view string_ref")
|
||||
{
|
||||
// std::string_view in C++17, a stand-in with the same members before
|
||||
// JSON_HAS_CPP_17 (do not remove; see note at top of file)
|
||||
using nlohmann::detail::view::string_ref;
|
||||
const std::string text = "abc";
|
||||
const string_ref r(text);
|
||||
@@ -953,7 +945,7 @@ TEST_CASE("json_view document_data::holds() (the debug check of read())")
|
||||
|
||||
SECTION("current edit buffer")
|
||||
{
|
||||
d->edits.reset(new document_data::edit_state()); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-unique)
|
||||
d->edits.reset(new document_data::edit_state()); // NOLINT(cppcoreguidelines-owning-memory)
|
||||
CHECK(!d->holds(other.data(), other.size()));
|
||||
d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-owning-memory)
|
||||
d->edits->text_cap = 16;
|
||||
|
||||
@@ -589,76 +589,6 @@ TEST_CASE("json_view edits: a container that was added is replaced by a scalar")
|
||||
CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})"));
|
||||
}
|
||||
|
||||
TEST_CASE("json_view edits: a scalar replaces an array or object that is no longer part of the document")
|
||||
{
|
||||
// the dropped container that the array/object is in still steps over its
|
||||
// parsed extent: that container switches to links first, as a live one does
|
||||
SECTION("members of an erased object")
|
||||
{
|
||||
json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, [2]], "b": 3, "e": []}, "q": 0})");
|
||||
const json_editable_view p = d.root()["p"];
|
||||
const json_editable_view a = p["a"];
|
||||
d.erase(d.root(), "p");
|
||||
d.set(a[1], 5);
|
||||
CHECK(p.dump() == R"({"a":[1,5],"b":3,"e":[]})");
|
||||
d.set(a, 5);
|
||||
CHECK(p.size() == 3);
|
||||
CHECK(p.dump() == R"({"a":5,"b":3,"e":[]})");
|
||||
d.push_back(p["e"], 6);
|
||||
CHECK(p.dump() == R"({"a":5,"b":3,"e":[6]})");
|
||||
CHECK(d.root().dump() == R"({"q":0})");
|
||||
}
|
||||
|
||||
SECTION("an array whose elements moved")
|
||||
{
|
||||
json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, 2], "b": 3}, "q": 0})");
|
||||
const json_editable_view p = d.root()["p"];
|
||||
const json_editable_view a = p["a"];
|
||||
d.erase(d.root(), "p");
|
||||
d.push_back(a, 4); // (the extent of a stays)
|
||||
d.set(a, 5);
|
||||
CHECK(p.dump() == R"({"a":5,"b":3})");
|
||||
CHECK(d.root().dump() == R"({"q":0})");
|
||||
}
|
||||
|
||||
SECTION("an element of an erased array, which grows afterwards")
|
||||
{
|
||||
json_editable_document d = json_editable_document::parse(R"({"p": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "q": 0})");
|
||||
const json_editable_view p = d.root()["p"];
|
||||
d.erase(d.root(), "p");
|
||||
d.set(p[0], 5);
|
||||
d.push_back(p, 1);
|
||||
CHECK(p.dump() == "[5,1]");
|
||||
CHECK(d.root().dump() == R"({"q":0})");
|
||||
}
|
||||
|
||||
SECTION("values in an erased new value")
|
||||
{
|
||||
json_editable_document d = json_editable_document::parse("[0]");
|
||||
const json_editable_view x = d.push_back(d.root(), json::parse("[[[1, 2]], 3]"));
|
||||
const json_editable_view y = x[0];
|
||||
d.erase(d.root(), 1);
|
||||
d.set(y[0], 5);
|
||||
CHECK(x.dump() == "[[5],3]");
|
||||
d.set(y, 5);
|
||||
CHECK(x.dump() == "[5,3]");
|
||||
CHECK(d.root().dump() == "[0]");
|
||||
}
|
||||
|
||||
SECTION("values in the elements that an array had before it was replaced")
|
||||
{
|
||||
json_editable_document d = json_editable_document::parse("[0]");
|
||||
d.set(d.root()[0], json::parse("[[[1, 2]]]"));
|
||||
const json_editable_view y = d.root()[0][0];
|
||||
d.set(d.root()[0], json::array({3}));
|
||||
d.set(y[0], 5);
|
||||
CHECK(y.dump() == "[5]");
|
||||
d.set(y, 5);
|
||||
CHECK(y.dump() == "5");
|
||||
CHECK(d.root().dump() == "[[3]]");
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(JSON_NOEXCEPTION)
|
||||
TEST_CASE("json_view edits: the size of a text arena")
|
||||
{
|
||||
|
||||
@@ -6,13 +6,6 @@
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
@@ -355,7 +348,6 @@ static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<unsigned c
|
||||
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<wchar_t>::value, "wchar_t is refused");
|
||||
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char16_t>::value, "char16_t is refused");
|
||||
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char32_t>::value, "char32_t is refused");
|
||||
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
|
||||
#if defined(__cpp_char8_t)
|
||||
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char8_t>::value, "char8_t is refused");
|
||||
#endif
|
||||
|
||||
@@ -6,13 +6,6 @@
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
@@ -30,11 +23,8 @@ using nlohmann::json;
|
||||
#include <valarray>
|
||||
#include <vector>
|
||||
|
||||
// JSON_HAS_CPP_17 (do not remove; see note at top of file)
|
||||
#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
|
||||
// libstdc++ 8 needs -lstdc++fs for std::filesystem (GCC bug 90050), which clang on such a
|
||||
// libstdc++ does not get from the test options
|
||||
#if __has_include(<filesystem>) && (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 9)
|
||||
#if __has_include(<filesystem>)
|
||||
#include <filesystem>
|
||||
#define TO_JSON_RVALUE_HAS_FS 1
|
||||
#endif
|
||||
@@ -254,7 +244,6 @@ TEST_CASE("to_json from rvalue containers")
|
||||
SECTION("std::filesystem::path rvalue is still a string")
|
||||
{
|
||||
CHECK(json(std::filesystem::path("a/b")) == json("a/b"));
|
||||
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
|
||||
#ifdef __cpp_lib_char8_t
|
||||
CHECK(json(std::u8string(u8"a/b")) == json("a/b"));
|
||||
#endif
|
||||
|
||||
@@ -793,25 +793,6 @@ TEST_CASE("UBJSON")
|
||||
CHECK(j.dump() == "3.141592653589793");
|
||||
}
|
||||
|
||||
SECTION("long floating-point number")
|
||||
{
|
||||
// the SAX parser receives the number text as it is in the
|
||||
// input, also when it is longer than the part of a token
|
||||
// that error messages show
|
||||
const std::vector<std::size_t> lengths = {8192, 8193, 10000};
|
||||
for (const auto length : lengths)
|
||||
{
|
||||
CAPTURE(length)
|
||||
const std::string number = "1." + std::string(length - 2, '3');
|
||||
std::vector<std::uint8_t> vec = {'H', 'I', static_cast<std::uint8_t>(length >> 8), static_cast<std::uint8_t>(length & 0xFF)};
|
||||
vec.insert(vec.end(), number.begin(), number.end());
|
||||
SaxEventLogger logger;
|
||||
CHECK(json::sax_parse(vec, &logger, json::input_format_t::ubjson));
|
||||
CHECK(logger.events == std::vector<std::string>({"number_float(" + number + ")"}));
|
||||
CHECK(json::from_ubjson(vec).is_number_float());
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("errors")
|
||||
{
|
||||
// error while parsing length
|
||||
|
||||
Loaded 100 of 102 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user