moving the files back to ondemand for now.

.circleci/config.yml

@@ -0,0 +1,316 @@
+version: 2.1
+
+
+# We constantly run out of memory so please do not use parallelism (-j, -j4).
+
+# Reusable image / compiler definitions
+executors:
+  gcc8:
+    docker:
+      - image: conanio/gcc8
+        environment:
+          CXX: g++-8
+          CC: gcc-8
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc9:
+    docker:
+      - image: conanio/gcc9
+        environment:
+          CXX: g++-9
+          CC: gcc-9
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  gcc10:
+    docker:
+      - image: conanio/gcc10
+        environment:
+          CXX: g++-10
+          CC: gcc-10
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang10:
+    docker:
+      - image: conanio/clang10
+        environment:
+          CXX: clang++-10
+          CC: clang-10
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang9:
+    docker:
+      - image: conanio/clang9
+        environment:
+          CXX: clang++-9
+          CC: clang-9
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+  clang6:
+    docker:
+      - image: conanio/clang60
+        environment:
+          CXX: clang++-6.0
+          CC: clang-6.0
+          CMAKE_BUILD_FLAGS:
+          CTEST_FLAGS: --output-on-failure
+
+# Reusable test commands (and initializer for clang 6)
+commands:
+  dependency_restore:
+    steps:
+      - restore_cache:
+          keys:
+            - cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
+
+  dependency_cache:
+    steps:
+      - save_cache:
+          key: cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
+          paths:
+            - dependencies/.cache
+
+  install_cmake:
+    steps:
+      - run: apt-get update -qq
+      - run: apt-get install -y cmake
+
+  cmake_prep:
+    steps:
+      - checkout
+      - run: mkdir -p build
+
+  cmake_build_cache:
+    steps:
+      - cmake_prep
+      - dependency_restore
+      - run: cmake  -DSIMDJSON_DEVELOPER_MODE=ON $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination -B build .
+      - dependency_cache # dependencies are produced in the configure step
+
+  cmake_build:
+    steps:
+      - cmake_build_cache
+      - run: cmake  --build build
+
+  cmake_test:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L acceptance &&
+          ctest $CTEST_FLAGS -LE acceptance -LE explicitonly
+
+  cmake_assert_test:
+    steps:
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -L assert
+
+  cmake_test_all:
+    steps:
+      - cmake_build
+      - run: |
+          cd build &&
+          tools/json2json -h &&
+          ctest $CTEST_FLAGS -DSIMDJSON_IMPLEMENTATION="haswell;westmere;fallback" -L acceptance -LE per_implementation &&
+          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
+          ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
+
+
+  cmake_perftest:
+    steps:
+      - cmake_build_cache
+      - run: |
+          cmake -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON --build  build --target checkperf &&
+          cd build &&
+          ctest --output-on-failure -R checkperf
+
+  # we not only want cmake to build and run tests, but we want also a successful installation from which we can build, link and run programs
+  cmake_install_test: # this version builds, install, test and then verify from the installation
+    steps:
+      - run: cd build && make install
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++17 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+  cmake_installed_test_cxx20: # assuming that it was installed, this tries to build using C++20
+    steps:
+      - run: echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++20 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
+
+jobs:
+
+  # static
+  justlib-gcc10:
+    description: Build just the library, install it and do a basic test
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
+    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
+  assert-gcc10:
+    description: Build the library with asserts on, install it and run tests
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
+    steps: [ cmake_test, cmake_assert_test ]
+  assert-clang10:
+    description: Build just the library, install it and do a basic test
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
+    steps: [ cmake_test, cmake_assert_test ]
+  gcc10-perftest:
+    description: Build and run performance tests on GCC 10 and AVX 2 with a cmake static build, this test performance regression
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_perftest ]
+  gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake static build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  clang6:
+    description: Build and run tests on clang 6 and AVX 2 with a cmake static build
+    executor: clang6
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON  -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # libcpp
+  libcpp-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake static build and libc++
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_USE_LIBCPP=ON  -DBUILD_SHARED_LIBS=OFF }
+    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
+  # sanitize
+  sanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  sanitize-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  threadsanitize-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  threadsanitize-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  # dynamic
+  dynamic-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
+    steps: [ cmake_test, cmake_install_test ]
+  dynamic-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake dynamic build
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
+    steps: [ cmake_test, cmake_install_test ]
+
+  # unthreaded
+  unthreaded-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 *without* threads
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  unthreaded-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 *without* threads
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+
+  # noexcept
+  noexcept-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with exceptions off
+    executor: gcc10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+  noexcept-clang10:
+    description: Build and run tests on Clang 10 and AVX 2 with exceptions off
+    executor: clang10
+    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
+    steps: [ cmake_test, cmake_install_test ]
+
+  #
+  # Misc.
+  #
+
+  # make (test and checkperf)
+  arch-haswell-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=haswell
+    executor: gcc10
+    environment: { CXXFLAGS: -march=haswell }
+    steps: [ cmake_test ]
+  arch-nehalem-gcc10:
+    description: Build, run tests and check performance on GCC 10 with -march=nehalem
+    executor: gcc10
+    environment: { CXXFLAGS: -march=nehalem }
+    steps: [ cmake_test ]
+  sanitize-haswell-gcc10:
+    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
+    executor: gcc10
+    environment: {  CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+  sanitize-haswell-clang10:
+    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
+    executor: clang10
+    environment: { CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
+    steps: [ cmake_test ]
+
+workflows:
+  version: 2.1
+  build_and_test:
+    jobs:
+      # full multi-implementation tests
+      #- gcc7 tested on GitHub actions
+      - gcc10 # do not delete this as it tests our performance
+      - clang6
+      #- clang10 # this gets tested a lot below
+
+      # libc++
+      - libcpp-clang10
+
+      # full single-implementation tests
+      - sanitize-gcc10
+      - sanitize-clang10
+      - threadsanitize-gcc10
+      - threadsanitize-clang10
+      - dynamic-gcc10
+      - dynamic-clang10
+      - unthreaded-gcc10
+      - unthreaded-clang10
+
+      # no exceptions
+      - noexcept-gcc10
+      - noexcept-clang10
+
+      # quicker make single-implementation tests
+      - arch-haswell-gcc10
+      - arch-nehalem-gcc10
+
+
+      # sanitized single-implementation tests
+      - sanitize-haswell-gcc10
+      - sanitize-haswell-clang10
+
+      # testing "just the library"
+      - justlib-gcc10
+
+      # testing asserts
+      - assert-gcc10
+      - assert-clang10
+
+      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,8 +9,7 @@ assignees: ''
 
 Before submitting an issue, please ensure that you have read the documentation:
 
-* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
 * Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
 * Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 * We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017). If you wish to support features that are not part of RFC 8259, then you should not refer to your issue as a bug.
@@ -56,8 +55,6 @@ We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux syste
 pre-release version of a compiler, do not report it as a bug to simdjson. However, we always
 invite contributions either in the form an analysis or of a code contribution.
 
-Under Windows, we support Visual Studio (both with LLVM and without). We do not support MinGW and other alternate compiler systems. Windows users should be aware that there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).
-
 **Indicate whether you are willing or able to provide a bug fix as a pull request**
 
 If you plan to contribute to simdjson, please read our guide:

.github/ISSUE_TEMPLATE/feature_request.md

@@ -9,8 +9,7 @@ assignees: ''
 
 Before submitting an issue, please ensure that you have read the documentation:
 
-* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
 * Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
 * Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 * We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017).

.github/ISSUE_TEMPLATE/standard-issue-template.md

@@ -9,8 +9,7 @@ assignees: ''
 
 Before submitting an issue, please ensure that you have read the documentation:
 
-* Basics is an overview of how to use simdjson and its APIs to parse JSON: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.md
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
 * Performance shows some more advanced scenarios and how to tune for them: https://github.com/simdjson/simdjson/blob/master/doc/performance.md
 * Contributing: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 * We follow the [JSON specification as described by RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.txt) (T. Bray, 2017).

.github/pull_request_template.md

@@ -1,53 +1,8 @@
-Short title (summary):
-
-Description
-- What did you change and why? (1-3 sentences)
-- Issue reproduced / related issue: link the issue if relevant (e.g. #123)
-
-Type of change
-- [ ] Bug fix
-- [ ] New feature
-- [ ] Refactor / cleanup
-- [ ] Documentation / tests
-- [ ] Other (please describe):
-
-How to verify / test
-- Add additional tests to verify bugs or new features.
-- If you claim performance gains, you should provide benchmark numbers using high quality benchmarking code.
 
 
-Please read before contributing:
+Our tests check whether you have introduced trailing white space. If such a test fails, please check the "artifacts button" above, which if you click it gives a link to a downloadable file to help you identify the issue. You can also run scripts/remove_trailing_whitespace.sh locally if you have a bash shell and the sed command available on your system.
-- CONTRIBUTING: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
-- HACKING: https://github.com/simdjson/simdjson/blob/master/HACKING.md
 
+If you plan to contribute to simdjson, please read our
 
-
+CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
-If you can, we recommend running our tests with the sanitizers turned on.
+HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
-For non-Visual Studio users, it is as easy as doing:
-
-
-
-```bash
-cmake -B build -D SIMDJSON_SANITIZE=ON -D SIMDJSON_DEVELOPER_MODE=ON
-cmake --build build
-ctest --test-dir build
-```
-
-
-Our CI checks, among other things, for trailing whitespace. If a test fails for that reason,
-use the "artifacts" button to download the artifact and inspect the problematic lines,
-or run `scripts/remove_trailing_whitespace.sh` locally if you have a bash shell and `sed`.
-
-
-Checklist before submitting
-- [ ] I added/updated tests covering my change (if applicable)
-- [ ] Code builds locally and passes my check
-- [ ] Documentation / README updated if needed
-- [ ] Commits are atomic and messages are clear
-- [ ] I linked the related issue (if applicable)
-
-Final notes
-- For large PRs, prefer smaller incremental PRs or request staged review.
-
-Thanks for the contribution!
-

.github/workflows/aarch64.yml

@@ -1,4 +1,4 @@
-name: Ubuntu aarch64 (GCC 13)
+name: Ubuntu ppc64le (GCC 11)
 
 on:
   push:

.github/workflows/documentation.yml

@@ -2,13 +2,7 @@ name: Doxygen GitHub Pages
 
 on:
   release:
-    # Trigger when a release object is created and when it's published.
+    types: [created]
-    # Some GitHub flows create a release object then publish it later; include both.
-    types: [created, published]
-  # Also trigger on tag creation pushes so releasing via Git tags still runs the workflow
-  push:
-    tags:
-      - "v*"  # common release tag pattern like v1.2.3
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
@@ -33,7 +27,7 @@ jobs:
       - name: Generate Doxygen Documentation
         run: doxygen
       - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v4
+        uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: doc/api/html

.github/workflows/rvv-1024-clang-18.yml

@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=1024 (clang 18)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-18
-    - name: Build
-      run: |
-        CXX=clang++-18 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=1024
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/rvv-128-clang-17.yml

@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=128 (clang 17)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-17
-    - name: Build
-      run: |
-        CXX=clang++-17 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=128
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/rvv-256-gcc-14.yml

@@ -1,29 +0,0 @@
-name: Ubuntu rvv VLEN=256 (gcc 14)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-14-riscv64-linux-gnu qemu-user-static
-    - name: Build
-      run: |
-        CXX=riscv64-linux-gnu-g++-14 CXXFLAGS=-march=rv64gcv \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=256
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/ubuntu22-cxx20.yml

@@ -14,52 +14,20 @@ jobs:
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-
+      - name: Use cmake
-      - name: Configure Debug Build
         run: |
-          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -B builddebug
+          mkdir builddebug &&
-
+          cd builddebug &&
-      - name: Compile Debug Build
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
-        run: |
+          cmake --build .   &&
-          cmake --build builddebug
+          ctest --output-on-failure -LE explicitonly -j   &&
-
+          cd .. &&
-      - name: Test Debug Build
+          mkdir build &&
-        run: |
+          cd build &&
-          ctest --output-on-failure -LE explicitonly -j --test-dir builddebug
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-
+          cmake --build .   &&
-      - name: Configure Release Build
+          ctest --output-on-failure -LE explicitonly -j   &&
-        run: |
+          cmake --install . &&
-          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -B build
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
-
+          cd ../tests/installation_tests/find &&
-      - name: Compile Release Build
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
-        run: |
-          cmake --build build
-
-      - name: Test Release Build
-        run: |
-          ctest --output-on-failure -LE explicitonly -j --test-dir build
-
-      - name: Install Release Build
-        run: |
-          cmake --install build
-
-      - name: Generate Example Code
-        run: |
-          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp
-
-      - name: Compile Example Code
-        run: |
-          c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson
-
-      - name: Run Example Code
-        run: |
-          ./linkandrun jsonexamples/twitter.json
-
-      - name: Configure Find Tests
-        run: |
-          cd tests/installation_tests/find && \
-          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../destination -B build
-
-      - name: Compile Find Tests
-        run: |
-          cd tests/installation_tests/find && cmake --build build

.github/workflows/ubuntu24-cxx20-noexcept.yml

@@ -1,22 +0,0 @@
-name: Ubuntu 24.04 CI (CXX 20, noexcept)
-
-on: [push, pull_request]
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-24.04
-    strategy:
-      matrix:
-        cxx: [g++-13, clang++-16]
-    steps:
-      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
-      - name: Prepare
-        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_EXCEPTIONS=OFF -DSIMDJSON_DEVELOPER_MODE=ON  -B build
-        env:
-          CXX: ${{matrix.cxx}}
-      - name: Build
-        run: cmake --build build -j=2
-      - name: Test
-        run: ctest --output-on-failure --test-dir build

.github/workflows/ubuntu24-noexcept.yml

@@ -31,4 +31,4 @@ jobs:
           echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
           mkdir testfindpackage &&
           cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .

.github/workflows/ubuntu24-nothread.yml

@@ -31,4 +31,4 @@ jobs:
           echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
           mkdir testfindpackage &&
           cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .

.github/workflows/vs17-ci-sani.yml

@@ -1,30 +0,0 @@
-name: VS17-CI-SANITIZE
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    name: windows-vs17
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSANITIZE=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
-    - name: Build
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
-    - name: Run tests
-      run: |
-        cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure

.gitignore

@@ -38,7 +38,7 @@ cmake-build-release/
 .history/
 
 # Visual Studio artifacts
-/.vs/
+/VS/
 
 # C/C++ build outputs
 .build/
@@ -106,4 +106,4 @@ objs
 !.vscode/extensions.json
 
 # clangd
-.cache
+.cache

.vscode/settings.json

@@ -3,9 +3,6 @@
         {"column": 95 },
         {"column": 120 }
     ],
-    "cmake.configureArgs": [
-        "-DSIMDJSON_DEVELOPER_MODE=ON"
-    ],
     "files.trimTrailingWhitespace": true,
     "files.associations": {
         ".clangd": "yaml",

CMakeLists.txt

@@ -1,9 +1,11 @@
 cmake_minimum_required(VERSION 3.14)
+cmake_policy(VERSION 3.5) # For doctest
+
 
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.2.1
+    VERSION 3.13.0
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,8 +22,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "29.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_VERSION "26.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "29" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_SOVERSION "26" CACHE STRING "simdjson library soversion")
 
 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
@@ -43,20 +45,6 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
   )
 endif()
 
-if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
-    option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
-else()
-    set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)
-    message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")
-endif()
-
-if(SIMDJSON_STATIC_REFLECTION)
-  simdjson_add_props(
-      target_compile_definitions PUBLIC
-      SIMDJSON_STATIC_REFLECTION=1
-  )
-endif()
-
 option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \
 checks for incorrect API usage. Enabled by default in DEBUG." OFF)
 if(SIMDJSON_DEVELOPMENT_CHECKS)
@@ -112,16 +100,7 @@ simdjson_add_props(
     PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )
 
-if(SIMDJSON_STATIC_REFLECTION)
+simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
-  # We would like to require C++26, but no compiler supports that!
-  # This is a hack:
-  simdjson_add_props(
-      target_compile_options PUBLIC
-      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
-  )
-else()
-  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
-endif()
 
 # workaround for GNU GCC poor AVX load/store code generation
 if(

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.2.1"
+PROJECT_NUMBER         = "3.13.0"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

HACKING.md

@@ -20,54 +20,13 @@ If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://gi
 Build Quickstart
 ------------------------------
 
-For non-Windows system,
-
 ```bash
-cmake -B -D SIMDJSON_DEVELOPER_MODE=ON ..
+mkdir build
-cmake --build build
+cd build
-ctest --test-dir build
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
+cmake --build .
 ```
 
-It is similar for Visual Studio users, please see the CMake or Visual Studio documentation.
-
-By default the library is built in Release mode.
-
-
-Assertions and development checks
-------------------------------
-
-We do not use conventional `assert` in simdjson. Instead we use the macro
-`SIMDJSON_ASSUME`:
-
-```cpp
-SIMDJSON_ASSUME(something_that_is_true());
-```
-
-Sometimes, you need to do a bit more work that a simple check.
-The `SIMDJSON_DEVELOPMENT_CHECKS` macro is true only in Debug mode unless manually set.
-It is acceptable to add checks that you would not do in Release mode as long as
-they are guarded:
-
-```cpp
-#if SIMDJSON_DEVELOPMENT_CHECKS
-// do sanity checks here
-```
-
-
-Working with sanitizers
-------------------------------
-
-The simdjson library must be memory-safe. We cannot allow buffer overruns.
-During development, if you system supports it, we recommend configuring
-the project with `-D SIMDJSON_SANITIZE=ON`.
-
-```bash
-cmake -B -D SIMDJSON_SANITIZE=ON -D SIMDJSON_DEVELOPER_MODE=ON ..
-cmake --build build
-ctest --test-dir build
-```
-
-
 Design notes
 ------------------------------
 
@@ -144,9 +103,12 @@ simdjson's source structure, from the top level, looks like this:
     * generic/stage2/*.h: `simdjson::<implementation>::stage2` namespace. Generic implementation of the tape creator, which consumes the index from stage 1 and actually parses numbers and string and such. Used for the DOM interface.
 
 Other important files and directories:
+* **.drone.yml:** Definitions for Drone CI.
+* **.appveyor.yml:** Definitions for Appveyor CI (Windows).
+* **.circleci:** Definitions for Circle CI.
 * **.github/workflows:** Definitions for GitHub Actions (CI).
 * **singleheader:** Contains generated `simdjson.h` and `simdjson.cpp` that we release. The files `singleheader/simdjson.h` and `singleheader/simdjson.cpp` should never be edited by hand.
-* **singleheader/amalgamate.py:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (python script). If you add a new implementation (e.g., rvv), you need to edit this file (IMPLEMENTATIONS).
+* **singleheader/amalgamate.py:** Generates `singleheader/simdjson.h` and `singleheader/simdjson.cpp` for release (python script).
 * **benchmark:** This is where we do benchmarking. Benchmarking is core to every change we make; the
   cardinal rule is don't regress performance without knowing exactly why, and what you're trading
   for it. Many of our benchmarks are microbenchmarks. We are effectively doing controlled scientific experiments for the purpose of understanding what affects our performance. So we simplify as much as possible. We try to avoid irrelevant factors such as page faults, interrupts, unnecessary system calls. We recommend checking the performance as follows:

README.md

@@ -1,3 +1,5 @@
+
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
 [![][license img]][license] [![][licensemit img]][licensemit]
 
 
@@ -62,14 +64,10 @@ Real-world usage
 - [WasmEdge](https://wasmedge.org)
 - [RonDB](https://github.com/logicalclocks/rondb)
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
-- [mamba](https://github.com/mamba-org/mamba)
 
 
 If you are planning to use simdjson in a product, please work from one of our releases.
 
-
-
-
 Quick Start
 -----------
 
@@ -86,7 +84,7 @@ The simdjson library is easily consumable with a single .h and .cpp file.
    ```
 2. Create `quickstart.cpp`:
 
-```cpp
+```c++
 #include <iostream>
 #include "simdjson.h"
 using namespace simdjson;
@@ -111,19 +109,15 @@ Documentation
 Usage documentation is available:
 
 * [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
-* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
 * [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
 * [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
   how you can work with it.
 * [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.
-* [Compile-Time Parsing](doc/compile_time.md) presents our compile-time parsing function (C++26 only).
-
 
 Godbolt
 -------------
 
 Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-* [C++26 reflection example](https://godbolt.org/z/K3Px64TqK)
 * [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
 * [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)
 
@@ -232,13 +226,6 @@ Contributing to simdjson
 Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing to simdjson, and
 [HACKING.md](HACKING.md) for information on source, building, and architecture/design.
 
-
-Stars
-------
-
-[![Star History Chart](https://api.star-history.com/svg?repos=simdjson/simdjson&type=Date)](https://www.star-history.com/#simdjson/simdjson&Date)
-
-
 License
 -------
 

benchmark/CMakeLists.txt

@@ -4,9 +4,6 @@ add_subdirectory(dom)
 include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
-if(SIMDJSON_STATIC_REFLECTION)
-  add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
-endif(SIMDJSON_STATIC_REFLECTION)
 
 add_executable(benchfeatures benchfeatures.cpp)
 add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
@@ -35,16 +32,3 @@ if (TARGET benchmark::benchmark)
   endif()
 endif()
 
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-std=c++20" SIMDJSON_COMPILER_SUPPORTS_CXX20)
-if(SIMDJSON_STATIC_REFLECTION)
-  add_subdirectory(static_reflect)
-else()
-  if(SIMDJSON_EXCEPTIONS AND SIMDJSON_COMPILER_SUPPORTS_CXX20)
-    add_subdirectory(from)
-    add_subdirectory(car_builder)
-  endif()
-endif(SIMDJSON_STATIC_REFLECTION)
-
-

benchmark/accessor_performance/README.md

@@ -1,46 +0,0 @@
-# Accessor Performance Benchmarks (C++26)
-
-These benchmarks compare the performance of runtime vs compile-time JSON accessors.
-For the comparison to be meaningful, you must build simdjson with support for
-C++26 reflexion. See the `p2996` repository in the main project directory.
-
-## Files
-
-- `accessor_benchmark.h` - Common benchmark framework and test data
-- `runtime_accessors.h` - Runtime `at_path()` benchmarks
-- `compile_time_accessors.h` - Compile-time `at_path_compiled()` benchmarks (requires C++26 reflection)
-
-## Benchmarks
-
-Each benchmark measures parsing + single field access:
-
-1. **accessor_simple** - Simple field: `.name`
-2. **accessor_nested** - Nested field: `.address.city`
-3. **accessor_deep** - Deep nested field: `.address.coordinates.lat`
-
-## Building (Linux/macOS)
-
-```bash
-cmake -B build -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON
-cmake --build build --target=bench_ondemand
-```
-
-The `SIMDJSON_STATIC_REFLECTION` will be made unnecessary once mainstream compilers
-begin supporting C++26 sufficiently well.
-
-## Running (Linux/macOS)
-
-
-```bash
-# Run all accessor benchmarks
-./build/bench_ondemand --benchmark_filter="accessor"
-```
-
-## Results
-
-We find that compile-time accessors show performance improvements that scale with path depth:
-- Simple fields: ~1.2x faster
-- Nested fields: ~1.5x faster
-- Deep nested fields: ~1.8x faster
-
-The speedup comes from eliminating runtime path parsing and conversion overhead.

benchmark/accessor_performance/accessor_benchmark.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#include "json_benchmark/file_runner.h"
-#include <string>
-
-namespace accessor_performance {
-
-using namespace json_benchmark;
-
-// Test JSON for accessor benchmarks
-static const char* TEST_JSON = R"({
-  "name": "Alice",
-  "age": 30,
-  "email": "alice@example.com",
-  "address": {
-    "street": "123 Main St",
-    "city": "Boston",
-    "state": "MA",
-    "zip": 12345,
-    "coordinates": {
-      "lat": 42.3601,
-      "lon": -71.0589
-    }
-  },
-  "scores": [95, 87, 92, 88, 91],
-  "preferences": {
-    "theme": "dark",
-    "notifications": {
-      "email": true,
-      "push": false,
-      "sms": true
-    }
-  }
-})";
-
-// Struct definitions for compile-time validation
-#if SIMDJSON_STATIC_REFLECTION
-struct Coordinates {
-  double lat;
-  double lon;
-};
-
-struct Address {
-  std::string street;
-  std::string city;
-  std::string state;
-  int64_t zip;
-  Coordinates coordinates;
-};
-
-struct Notifications {
-  bool email;
-  bool push;
-  bool sms;
-};
-
-struct Preferences {
-  std::string theme;
-  Notifications notifications;
-};
-
-struct TestData {
-  std::string name;
-  int64_t age;
-  std::string email;
-  Address address;
-  std::vector<int64_t> scores;
-  Preferences preferences;
-};
-#endif // SIMDJSON_STATIC_REFLECTION
-
-// Single-access benchmark runner: measures ONE field access per iteration
-template<typename I>
-struct single_access_runner : public file_runner<I> {
-  std::string result_string;
-  int64_t result_int{};
-  double result_double{};
-  bool result_bool{};
-
-  bool setup(benchmark::State &state) {
-    this->json = simdjson::padded_string(TEST_JSON, strlen(TEST_JSON));
-    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(this->json.size()));
-    return true;
-  }
-
-  bool before_run(benchmark::State &state) {
-    if (!file_runner<I>::before_run(state)) { return false; }
-    result_string.clear();
-    result_int = 0;
-    result_double = 0.0;
-    result_bool = false;
-    return true;
-  }
-
-  bool run(benchmark::State &) {
-    return this->implementation.run(this->json, result_string, result_int, result_double, result_bool);
-  }
-
-  template<typename R>
-  bool diff(benchmark::State &state, single_access_runner<R> &reference) {
-    if (result_string != reference.result_string ||
-        result_int != reference.result_int ||
-        result_double != reference.result_double ||
-        result_bool != reference.result_bool) {
-      std::cerr << "Accessor benchmark results differ!" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  size_t items_per_iteration() {
-    return 1;
-  }
-};
-
-// Benchmark template definitions
-struct runtime_at_path_simple;
-template<typename I> simdjson_inline static void accessor_simple(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_simple>>(state);
-}
-
-struct runtime_at_path_nested;
-template<typename I> simdjson_inline static void accessor_nested(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_nested>>(state);
-}
-
-struct runtime_at_path_deep;
-template<typename I> simdjson_inline static void accessor_deep(benchmark::State &state) {
-  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_deep>>(state);
-}
-
-} // namespace accessor_performance

benchmark/accessor_performance/compile_time_accessors.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION
-
-#include "accessor_benchmark.h"
-
-namespace accessor_performance {
-
-using namespace simdjson;
-
-struct compile_time_at_path_simple {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view name;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".name">(doc);
-    if (r.get(name) != SUCCESS) return false;
-    result_str = name;
-    return true;
-  }
-};
-
-struct compile_time_at_path_nested {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view city;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.city">(doc);
-    if (r.get(city) != SUCCESS) return false;
-    result_str = city;
-    return true;
-  }
-};
-
-struct compile_time_at_path_deep {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
-    auto doc = parser.iterate(json);
-    double lat;
-    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.coordinates.lat">(doc);
-    if (r.get(lat) != SUCCESS) return false;
-    result_dbl = lat;
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(accessor_simple, compile_time_at_path_simple)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_nested, compile_time_at_path_nested)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_deep, compile_time_at_path_deep)->UseManualTime();
-
-} // namespace accessor_performance
-
-#endif // SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION

benchmark/accessor_performance/runtime_accessors.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS
-
-#include "accessor_benchmark.h"
-
-namespace accessor_performance {
-
-using namespace simdjson;
-
-struct runtime_at_path_simple {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view name;
-    if (doc.at_path(".name").get(name) != SUCCESS) return false;
-    result_str = name;
-    return true;
-  }
-};
-
-struct runtime_at_path_nested {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
-    auto doc = parser.iterate(json);
-    std::string_view city;
-    if (doc.at_path(".address.city").get(city) != SUCCESS) return false;
-    result_str = city;
-    return true;
-  }
-};
-
-struct runtime_at_path_deep {
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
-    auto doc = parser.iterate(json);
-    double lat;
-    if (doc.at_path(".address.coordinates.lat").get(lat) != SUCCESS) return false;
-    result_dbl = lat;
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(accessor_simple, runtime_at_path_simple)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_nested, runtime_at_path_nested)->UseManualTime();
-BENCHMARK_TEMPLATE(accessor_deep, runtime_at_path_deep)->UseManualTime();
-
-} // namespace accessor_performance
-
-#endif // SIMDJSON_EXCEPTIONS

benchmark/bench_ondemand.cpp

@@ -148,9 +148,4 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "large_amazon_cellphones/simdjson_dom.h"
 #include "large_amazon_cellphones/simdjson_ondemand.h"
 
-#include "accessor_performance/runtime_accessors.h"
-#if SIMDJSON_STATIC_REFLECTION
-#include "accessor_performance/compile_time_accessors.h"
-#endif
-
 BENCHMARK_MAIN();

benchmark/benchmark_reflection_usage_compilation.sh

@@ -1,618 +0,0 @@
-#!/bin/bash
-
-# JSON Parsing Compilation Benchmark: Reflection Usage vs Manual Parsing
-# Compares compilation times when ACTUALLY USING reflection for parsing vs manual parsing
-# This measures the compile-time cost of reflection-based automatic deserialization
-
-set -e
-
-echo "=== simdjson Reflection Usage Compilation Benchmark ==="
-echo "Measuring compilation impact of ACTUALLY USING reflection for parsing"
-echo "Starting at: $(date)"
-echo
-echo "╔════════════════════════════════════════════════════════════════════════════╗"
-echo "║                              METHODOLOGY                                   ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-echo "║ FAIR COMPARISON STRATEGY:                                                  ║"
-echo "║ This benchmark compares two DIFFERENT approaches to parsing the same JSON: ║"
-echo "║                                                                            ║"
-echo "║ • MANUAL PARSING: Traditional simdjson with explicit .get() calls          ║"
-echo "║   - Uses doc[\"field\"].get(variable) for each field                         ║"
-echo "║   - No reflection involved                                                 ║"
-echo "║                                                                            ║"
-echo "║ • REFLECTION PARSING: Automatic deserialization with reflection            ║"
-echo "║   - Uses doc.get<MyStruct>() for automatic field mapping                   ║"
-echo "║   - Relies on compile-time reflection to generate parsing code             ║"
-echo "║                                                                            ║"
-echo "║ WHAT WE'RE MEASURING:                                                      ║"
-echo "║ • Compile-time cost of reflection-based automatic deserialization          ║"
-echo "║ • Template instantiation overhead for reflection parsing                   ║"
-echo "║ • Code generation complexity from using reflection features                ║"
-echo "║                                                                            ║"
-echo "║ TEST SCENARIOS:                                                            ║"
-echo "║                                                                            ║"
-echo "║ 1. SIMPLE STRUCT: Basic fields (string, int, bool)                         ║"
-echo "║    - Measures baseline reflection overhead                                 ║"
-echo "║                                                                            ║"
-echo "║ 2. NESTED STRUCT: Multiple levels of nested objects                        ║"
-echo "║    - Measures reflection complexity scaling                                ║"
-echo "║                                                                            ║"
-echo "║ 3. COMPLEX STRUCT: Arrays, optional fields, mixed types                    ║"
-echo "║    - Measures real-world reflection usage impact                           ║"
-echo "║                                                                            ║"
-echo "║ WHY THIS IS MEANINGFUL:                                                    ║"
-echo "║ • Shows actual cost of using reflection features                           ║"
-echo "║ • Measures compile-time code generation overhead                           ║"
-echo "║ • Helps developers understand reflection's compilation impact              ║"
-echo "║ • Compares equivalent functionality implemented two different ways         ║"
-echo "║                                                                            ║"
-echo "╚════════════════════════════════════════════════════════════════════════════╝"
-echo
-
-# Configuration
-ITERATIONS=10
-JOBS=4
-
-# ───────────────────────────── BOX-PRINT HELPER ────────────────────────────
-BOX_WIDTH=74                               # characters between the pipes
-print_box_line() {                         # usage: print_box_line "text"
-  printf "║ %-*s ║\n" "${BOX_WIDTH}" "$1"
-}
-
-# Function to test if a compiler supports reflection with debug output
-test_reflection_support() {
-    local compiler="$1"
-    echo "  → Testing compiler: $compiler"
-
-    if [ ! -x "$compiler" ] && ! command -v "$compiler" >/dev/null 2>&1; then
-        echo "  → Compiler not found or not executable"
-        return 1
-    fi
-
-    # Check compiler version first
-    echo "  → Compiler version: $("$compiler" --version 2>/dev/null | head -n1 || echo "version check failed")"
-
-    # Simple test: check if compiler accepts reflection flags
-    local test_file=$(mktemp /tmp/reflection_test_XXXXXX.cpp)
-    cat > "$test_file" << 'EOF'
-int main() {
-    return 0;
-}
-EOF
-
-    echo "  → Testing basic reflection flags..."
-    local test_exe=$(mktemp /tmp/reflection_test_XXXXXX)
-    local basic_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
-    local basic_exit_code=$?
-
-    if [ $basic_exit_code -ne 0 ]; then
-        echo "  → Basic flags FAILED with exit code $basic_exit_code"
-        echo "  → Error output: $basic_result"
-        rm -f "$test_file" "$test_exe"
-        return 1
-    fi
-    echo "  → Basic flags: OK"
-    rm -f "$test_exe"
-
-    # Test reflection syntax
-    echo "  → Testing reflection syntax..."
-    cat > "$test_file" << 'EOF'
-struct Test {
-    int x;
-};
-
-int main() {
-    auto refl = ^^Test;
-    return 0;
-}
-EOF
-
-    local syntax_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
-    local syntax_exit_code=$?
-
-    if [ $syntax_exit_code -eq 0 ]; then
-        echo "  → Reflection syntax: OK"
-        echo "  → ✓ REFLECTION SUPPORT CONFIRMED"
-        rm -f "$test_file" "$test_exe"
-        return 0
-    else
-        echo "  → Reflection syntax FAILED with exit code $syntax_exit_code"
-        echo "  → Error output: $syntax_result"
-        rm -f "$test_file" "$test_exe"
-        return 1
-    fi
-}
-
-# Find a compiler with reflection support
-echo "Searching for clang++ with reflection support..."
-
-REFLECTION_CXX=""
-REFLECTION_CC=""
-
-# List of potential clang++ locations to check
-POTENTIAL_COMPILERS=(
-    "/usr/local/bin/clang++"
-    "/opt/clang/bin/clang++"
-    "/usr/bin/clang++"
-    "clang++"
-)
-
-# If CXX is already set, test it first
-if [ -n "$CXX" ]; then
-    echo "Testing user-specified compiler: $CXX"
-    if test_reflection_support "$CXX"; then
-        REFLECTION_CXX="$CXX"
-        echo "✓ User-specified compiler supports reflection: $CXX"
-    else
-        echo "✗ User-specified compiler does not support reflection: $CXX"
-        echo "Will search for alternative..."
-    fi
-fi
-
-# If we don't have a working compiler yet, search for one
-if [ -z "$REFLECTION_CXX" ]; then
-    for compiler in "${POTENTIAL_COMPILERS[@]}"; do
-        echo "Testing: $compiler"
-        if test_reflection_support "$compiler"; then
-            REFLECTION_CXX="$compiler"
-            echo "✓ Found reflection-enabled compiler: $compiler"
-            break
-        else
-            echo "✗ No reflection support: $compiler"
-        fi
-    done
-fi
-
-# Check if we found a working compiler
-if [ -z "$REFLECTION_CXX" ]; then
-    echo
-    echo "╔════════════════════════════════════════════════════════════════════════════╗"
-    echo "║                                 ERROR                                      ║"
-    echo "╠════════════════════════════════════════════════════════════════════════════╣"
-    echo "║                                                                            ║"
-    echo "║ No clang++ compiler with reflection support found!                        ║"
-    echo "║                                                                            ║"
-    echo "║ This benchmark requires a compiler that supports C++26 reflection.        ║"
-    echo "║                                                                            ║"
-    echo "║ Options:                                                                   ║"
-    echo "║ 1. Use the Docker container: ./p2996/run_docker.sh                        ║"
-    echo "║ 2. Build clang with reflection from: https://github.com/bloomberg/clang-p2996 ║"
-    echo "║ 3. Set CXX environment variable to point to reflection-enabled clang++    ║"
-    echo "║                                                                            ║"
-    echo "║ Example: CXX=/path/to/reflection-clang++ ./benchmark_script.sh            ║"
-    echo "║                                                                            ║"
-    echo "╚════════════════════════════════════════════════════════════════════════════╝"
-    exit 1
-fi
-
-# Set the compilers
-export CXX="$REFLECTION_CXX"
-
-# Find corresponding C compiler
-if [ -n "$CC" ]; then
-    REFLECTION_CC="$CC"
-elif [ "$REFLECTION_CXX" = "/usr/local/bin/clang++" ]; then
-    REFLECTION_CC="/usr/local/bin/clang"
-elif [ "$REFLECTION_CXX" = "/opt/clang/bin/clang++" ]; then
-    REFLECTION_CC="/opt/clang/bin/clang"
-elif [ "$REFLECTION_CXX" = "/usr/bin/clang++" ]; then
-    REFLECTION_CC="/usr/bin/clang"
-else
-    REFLECTION_CC="clang"
-fi
-
-export CC="$REFLECTION_CC"
-
-echo
-echo "Using reflection-enabled compiler: $($CXX --version | head -n1)"
-echo "Using C compiler: $($CC --version | head -n1)"
-echo
-
-# Function to create manual parsing test
-create_manual_parsing_test() {
-    local test_name="$1"
-    local struct_complexity="$2"
-
-    cat > "${test_name}_manual.cpp" << 'EOF'
-#include <simdjson.h>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <optional>
-
-// Test structures
-struct Person {
-    std::string name;
-    int age;
-    bool active;
-};
-
-struct Address {
-    std::string street;
-    std::string city;
-    int zipcode;
-};
-
-struct Employee {
-    Person person;
-    Address address;
-    std::vector<std::string> skills;
-    std::optional<std::string> department;
-    double salary;
-};
-
-// Manual parsing functions
-bool parse_person_manual(simdjson::ondemand::value& val, Person& person) {
-    auto obj = val.get_object();
-    if (obj.error()) return false;
-
-    for (auto field : obj) {
-        std::string_view key = field.unescaped_key();
-        if (key == "name") {
-            std::string_view name_val;
-            if (field.value().get(name_val)) return false;
-            person.name = name_val;
-        } else if (key == "age") {
-            if (field.value().get(person.age)) return false;
-        } else if (key == "active") {
-            if (field.value().get(person.active)) return false;
-        }
-    }
-    return true;
-}
-
-bool parse_address_manual(simdjson::ondemand::value& val, Address& address) {
-    auto obj = val.get_object();
-    if (obj.error()) return false;
-
-    for (auto field : obj) {
-        std::string_view key = field.unescaped_key();
-        if (key == "street") {
-            std::string_view street_val;
-            if (field.value().get(street_val)) return false;
-            address.street = street_val;
-        } else if (key == "city") {
-            std::string_view city_val;
-            if (field.value().get(city_val)) return false;
-            address.city = city_val;
-        } else if (key == "zipcode") {
-            if (field.value().get(address.zipcode)) return false;
-        }
-    }
-    return true;
-}
-
-bool parse_employee_manual(simdjson::ondemand::document& doc, Employee& employee) {
-    auto obj = doc.get_object();
-    if (obj.error()) return false;
-
-    for (auto field : obj) {
-        std::string_view key = field.unescaped_key();
-        if (key == "person") {
-            auto person_val = field.value();
-            if (!parse_person_manual(person_val, employee.person)) return false;
-        } else if (key == "address") {
-            auto addr_val = field.value();
-            if (!parse_address_manual(addr_val, employee.address)) return false;
-        } else if (key == "skills") {
-            auto skills_array = field.value().get_array();
-            if (skills_array.error()) return false;
-            for (auto skill : skills_array) {
-                std::string_view skill_val;
-                if (skill.get(skill_val)) return false;
-                employee.skills.emplace_back(skill_val);
-            }
-        } else if (key == "department") {
-            std::string_view dept_val;
-            if (!field.value().get(dept_val)) {
-                employee.department = dept_val;
-            }
-        } else if (key == "salary") {
-            if (field.value().get(employee.salary)) return false;
-        }
-    }
-    return true;
-}
-
-int main() {
-    simdjson::ondemand::parser parser;
-    std::string json_str = R"({
-        "person": {
-            "name": "John Doe",
-            "age": 30,
-            "active": true
-        },
-        "address": {
-            "street": "123 Main St",
-            "city": "Anytown",
-            "zipcode": 12345
-        },
-        "skills": ["C++", "JSON", "Programming"],
-        "department": "Engineering",
-        "salary": 85000.50
-    })";
-
-    simdjson::ondemand::document doc;
-    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
-    if (error) {
-        std::cerr << "Parse error" << std::endl;
-        return 1;
-    }
-
-    Employee employee;
-    if (!parse_employee_manual(doc, employee)) {
-        std::cerr << "Manual parsing failed" << std::endl;
-        return 1;
-    }
-
-    std::cout << "Manual parsing successful: " << employee.person.name
-              << ", age " << employee.person.age << std::endl;
-    return 0;
-}
-EOF
-}
-
-# Function to create reflection parsing test
-create_reflection_parsing_test() {
-    local test_name="$1"
-    local struct_complexity="$2"
-
-    cat > "${test_name}_reflection.cpp" << 'EOF'
-#include <simdjson.h>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <optional>
-
-// Test structures (same as manual version)
-struct Person {
-    std::string name;
-    int age;
-    bool active;
-};
-
-struct Address {
-    std::string street;
-    std::string city;
-    int zipcode;
-};
-
-struct Employee {
-    Person person;
-    Address address;
-    std::vector<std::string> skills;
-    std::optional<std::string> department;
-    double salary;
-};
-
-int main() {
-    simdjson::ondemand::parser parser;
-    std::string json_str = R"({
-        "person": {
-            "name": "John Doe",
-            "age": 30,
-            "active": true
-        },
-        "address": {
-            "street": "123 Main St",
-            "city": "Anytown",
-            "zipcode": 12345
-        },
-        "skills": ["C++", "JSON", "Programming"],
-        "department": "Engineering",
-        "salary": 85000.50
-    })";
-
-    simdjson::ondemand::document doc;
-    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
-    if (error) {
-        std::cerr << "Parse error" << std::endl;
-        return 1;
-    }
-
-    // Use reflection-based automatic deserialization
-    Employee employee;
-    auto result = doc.get<Employee>();
-    if (result.error()) {
-        std::cerr << "Reflection parsing failed" << std::endl;
-        return 1;
-    }
-    employee = result.value();
-
-    std::cout << "Reflection parsing successful: " << employee.person.name
-              << ", age " << employee.person.age << std::endl;
-    return 0;
-}
-EOF
-}
-
-# Function to time compilation of parsing approach
-time_parsing_compilation() {
-    local description="$1"
-    local test_file="$2"
-    local use_reflection="$3"
-    local iteration="$4"
-
-    echo "[$iteration] $description"
-
-    # Clean build
-    rm -rf build_parsing_test
-    mkdir build_parsing_test
-    cd build_parsing_test
-
-    # Copy test file
-    cp "../$test_file" .
-
-    echo "  Configuring..."
-    if [ "$use_reflection" = "true" ]; then
-        cmake -DCMAKE_CXX_COMPILER="$CXX" \
-              -DSIMDJSON_DEVELOPER_MODE=ON \
-              -DSIMDJSON_STATIC_REFLECTION=ON \
-              -DBUILD_SHARED_LIBS=OFF \
-              ../.. >/dev/null 2>&1
-    else
-        cmake -DCMAKE_CXX_COMPILER="$CXX" \
-              -DSIMDJSON_DEVELOPER_MODE=ON \
-              -DSIMDJSON_STATIC_REFLECTION=OFF \
-              -DBUILD_SHARED_LIBS=OFF \
-              ../.. >/dev/null 2>&1
-    fi
-
-    echo "  Building simdjson..."
-    cmake --build . --target simdjson >/dev/null 2>&1
-
-    echo "  Compiling parsing test..."
-    # Time just the test compilation
-    start_time=$(date +%s.%N)
-
-    "$CXX" -std=c++17 -I../../include "$test_file" -L. -lsimdjson -o parsing_test >/dev/null 2>&1
-
-    end_time=$(date +%s.%N)
-
-    # Calculate time duration
-    time_taken=$(echo "$end_time $start_time" | awk '{printf "%.3f", $1 - $2}')
-    echo "  Completed in: ${time_taken}s"
-
-    cd ..
-    rm -rf build_parsing_test
-
-    echo "$time_taken"
-}
-
-# Create test files
-echo "Creating test files..."
-create_manual_parsing_test "complex" "complex"
-create_reflection_parsing_test "complex" "complex"
-
-# Arrays to store times
-times_manual=""
-times_reflection=""
-
-echo
-echo "=== MANUAL PARSING COMPILATION ==="
-echo "Testing traditional simdjson parsing with explicit .get() calls"
-echo
-
-for i in $(seq 1 $ITERATIONS); do
-    time_result=$(time_parsing_compilation "Compiling manual parsing test" "complex_manual.cpp" "false" "$i" | tail -n1)
-    times_manual="$times_manual $time_result"
-done
-
-echo
-echo "=== REFLECTION PARSING COMPILATION ==="
-echo "Testing automatic deserialization with doc.get<Struct>()"
-echo
-
-for i in $(seq 1 $ITERATIONS); do
-    time_result=$(time_parsing_compilation "Compiling reflection parsing test" "complex_reflection.cpp" "true" "$i" | tail -n1)
-    times_reflection="$times_reflection $time_result"
-done
-
-echo
-echo "╔════════════════════════════════════════════════════════════════════════════╗"
-echo "║           REFLECTION USAGE COMPILATION RESULTS                             ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-echo "║ MANUAL PARSING (explicit .get() calls):                                    ║"
-count=1
-for t in $times_manual; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
-        print_box_line "$line"
-        count=$((count + 1))
-    fi
-done
-echo "║                                                                            ║"
-echo "║ REFLECTION PARSING (automatic doc.get<Struct>()):                          ║"
-count=1
-for t in $times_reflection; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
-        print_box_line "$line"
-        count=$((count + 1))
-    fi
-done
-echo "╚════════════════════════════════════════════════════════════════════════════╝"
-
-echo
-echo "╔════════════════════════════════════════════════════════════════════════════╗"
-echo "║                              ANALYSIS SUMMARY                              ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-
-# Calculate averages and percentages - filter to only numeric values first
-manual_numbers=""
-reflection_numbers=""
-
-for t in $times_manual; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        manual_numbers="$manual_numbers $t"
-    fi
-done
-
-for t in $times_reflection; do
-    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
-        reflection_numbers="$reflection_numbers $t"
-    fi
-done
-
-if [ -n "$manual_numbers" ] && [ -n "$reflection_numbers" ]; then
-    manual_avg=$(echo "$manual_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
-    reflection_avg=$(echo "$reflection_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
-    overhead=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.3f", $1 - $2}')
-
-    if [ $(echo "$manual_avg > 0" | awk '{print ($1 > 0)}') -eq 1 ]; then
-        percent=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.1f", ($1 - $2) / $2 * 100}')
-    else
-        percent="0"
-    fi
-
-    print_box_line "MANUAL PARSING RESULTS:"
-    print_box_line "$(printf "Average compilation time: %.3fs" "$manual_avg")"
-    print_box_line ""
-    print_box_line "REFLECTION PARSING RESULTS:"
-    print_box_line "$(printf "Average compilation time: %.3fs" "$reflection_avg")"
-    print_box_line ""
-    print_box_line "REFLECTION OVERHEAD:"
-    print_box_line "$(printf "Additional time: %.3fs (%+.1f%%)" "$overhead" "$percent")"
-    print_box_line ""
-else
-    echo "║ ERROR: Could not extract valid timing data                                 ║"
-    echo "║ Manual times: $times_manual"
-    echo "║ Reflection times: $times_reflection"
-    echo "║                                                                            ║"
-fi
-
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                              INTERPRETATION                                ║"
-echo "╠════════════════════════════════════════════════════════════════════════════╣"
-echo "║                                                                            ║"
-echo "║ WHAT THESE RESULTS SHOW:                                                   ║"
-echo "║                                                                            ║"
-echo "║ • COMPILE-TIME COST: How much longer reflection parsing takes to compile   ║"
-echo "║   - Higher % = more expensive template instantiation and codegen           ║"
-echo "║                                                                            ║"
-echo "║ • CODE GENERATION OVERHEAD: Reflection creates parsing code at compile     ║"
-echo "║   time, which requires more template processing than manual parsing        ║"
-echo "║                                                                            ║"
-echo "║ • DEVELOPER TRADE-OFF: Reflection provides automatic deserialization       ║"
-echo "║   but at the cost of increased compilation time                            ║"
-echo "║                                                                            ║"
-echo "║ EVALUATION:                                                                ║"
-echo "║ • Low overhead (0-20%): Reflection is compile-time efficient               ║"
-echo "║ • Medium overhead (20-50%): Noticeable but potentially acceptable          ║"
-echo "║ • High overhead (50%+): Significant compilation cost for reflection        ║"
-echo "║                                                                            ║"
-echo "║ REAL-WORLD IMPACT:                                                         ║"
-echo "║ • Small projects: Absolute time matters more than percentage               ║"
-echo "║ • Large projects: Percentage overhead compounds across many files          ║"
-echo "║ • CI/CD pipelines: Longer builds affect development velocity               ║"
-echo "║                                                                            ║"
-echo "╚════════════════════════════════════════════════════════════════════════════╝"
-
-# Clean up test files
-rm -f complex_manual.cpp complex_reflection.cpp
-
-echo
-echo "Completed at: $(date)"

benchmark/car_builder/CMakeLists.txt

@@ -1,14 +0,0 @@
-# Executable
-add_executable(benchmark_car_builder benchmark_car_builder.cpp)
-
-# Compile for C++20.
-target_compile_features(benchmark_car_builder PRIVATE cxx_std_20)
-
-# Check if -march=native is supported
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-march=native" SIMDJSON_SUPPORTS_MARCH_NATIVE)
-if(SIMDJSON_SUPPORTS_MARCH_NATIVE)
-  target_compile_options(benchmark_car_builder PRIVATE -march=native)
-endif()
-
-target_include_directories(benchmark_car_builder PRIVATE ${CMAKE_CURRENT_LIST_DIR}/..)

benchmark/car_builder/benchmark_car_builder.cpp

@@ -1,127 +0,0 @@
-#include "event_counter.h"
-#include <random>
-#include <vector>
-
-#include <simdjson.h>
-
-event_collector collector;
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year; // We deliberately do not include the tire pressure.
-};
-
-std::vector<Car> generate_random_cars(size_t count) {
-  static const std::vector<std::string> makes = {"Toyota", "Honda", "Ford",
-                                                 "BMW", "Mazda"};
-  static const std::vector<std::string> models = {"Camry", "Civic", "Focus",
-                                                  "320i", "3"};
-  static thread_local std::mt19937 rng{std::random_device{}()};
-  std::uniform_int_distribution<int> make_dist(0, makes.size() - 1);
-  std::uniform_int_distribution<int> model_dist(0, models.size() - 1);
-  std::uniform_int_distribution<int64_t> year_dist(2000, 2025);
-  std::uniform_real_distribution<double> pressure_dist(30.0, 45.0);
-
-  std::vector<Car> cars;
-  cars.reserve(count);
-  for (size_t i = 0; i < count; ++i) {
-    Car car;
-    car.make = makes[make_dist(rng)];
-    car.model = models[model_dist(rng)];
-    car.year = year_dist(rng);
-    cars.push_back(std::move(car));
-  }
-  return cars;
-}
-
-std::string_view serialize(simdjson::builder::string_builder &sb,
-                           const std::vector<Car> &cars) {
-  sb.clear();
-  sb.start_array();
-  for (const auto &car : cars) {
-    sb.start_object();
-    sb.append_key_value("make", car.make);
-    sb.append_comma();
-    sb.append_key_value("model", car.model);
-    sb.append_comma();
-    sb.append_key_value("year", car.year);
-    sb.end_object();
-  }
-  sb.end_array();
-  std::string_view result;
-  if (sb.view().get(result)) {
-    return ""; // unexpected (error)
-  }
-  return result;
-}
-
-double pretty_print(const std::string &name, size_t num_chars,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-template <class function_type>
-std::pair<event_aggregate, size_t>
-bench(const function_type &&function, size_t min_repeat = 100,
-      size_t min_time_ns = 40'000'000, size_t max_repeat = 10000000) {
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  event_aggregate warm_aggregate{};
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    warm_aggregate << allocate_count;
-    if ((i + 1 == N) && (warm_aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  event_aggregate aggregate{};
-  for (size_t i = 0; i < 10; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    for (size_t i = 0; i < N; i++) {
-      function();
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-  }
-  return {aggregate, N};
-}
-
-void run_benchmarks() {
-  std::vector<Car> source = generate_random_cars(100000);
-  simdjson::builder::string_builder sb;
-  size_t volume = serialize(sb, source).size();
-
-  pretty_print("string_builder", volume, bench([&source, &sb]() -> size_t {
-                 return serialize(sb, source).size();
-               }));
-}
-
-int main() {
-  for (size_t trial = 0; trial < 3; trial++) {
-    printf("Trial %zu:\n", trial + 1);
-    run_benchmarks();
-    printf("\n");
-  }
-  return EXIT_SUCCESS;
-}

benchmark/distinct_user_id/yyjson.h

@@ -44,10 +44,7 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
@@ -55,15 +52,11 @@ BENCHMARK_TEMPLATE(distinct_user_id, yyjson)->UseManualTime();
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(distinct_user_id, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace distinct_user_id
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/dom/parse_stream.cpp

@@ -25,11 +25,12 @@ int main(int argc, char *argv[]) {
     exit(1);
   }
   const char *filename = argv[1];
-  simdjson::padded_string p;
+  auto v = simdjson::padded_string::load(filename);
-  if (simdjson::padded_string::load(filename).get(p)) {
+  if (v.error()) {
     std::cerr << "Could not load the file " << filename << std::endl;
     return EXIT_FAILURE;
   }
+  const simdjson::padded_string& p = v.value_unsafe();
   if (test_baseline) {
     std::wclog << "Baseline: Getline + normal parse... " << std::endl;
     std::cout << "Gigabytes/second\t"

benchmark/event_counter.h

@@ -122,7 +122,6 @@ struct event_aggregate {
   }
 
   double elapsed_sec() const { return total.elapsed_sec() / iterations; }
-  double total_elapsed_ns() const { return total.elapsed_ns(); }
   double elapsed_ns() const { return total.elapsed_ns() / iterations; }
   double cycles() const { return total.cycles() / iterations; }
   double instructions() const { return total.instructions() / iterations; }

benchmark/find_tweet/yyjson.h

@@ -36,26 +36,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), find_id, result);
-    bool b = yyjson_base::run(doc, find_id, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(find_tweet, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, uint64_t find_id, std::string_view &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), find_id, result);
-    bool b = yyjson_base::run(doc, find_id, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(find_tweet, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace find_tweet
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/from/CMakeLists.txt

@@ -1,15 +0,0 @@
-# Executable
-add_executable(from_benchmark from_benchmark.cpp)
-
-# Compile for C++20.
-if(CMAKE_CXX_STANDARD LESS 20)
-  target_compile_features(from_benchmark PRIVATE cxx_std_20)
-endif()
-# Check if -march=native is supported
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-march=native" SIMDJSON_SUPPORTS_MARCH_NATIVE)
-if(SIMDJSON_SUPPORTS_MARCH_NATIVE)
-  target_compile_options(from_benchmark PRIVATE -march=native)
-endif()
-
-target_include_directories(from_benchmark PRIVATE ${CMAKE_CURRENT_LIST_DIR}/..)

benchmark/from/benchmark_helpers.h

@@ -1,77 +0,0 @@
-#ifndef BENCHMARK_HELPERS_H
-#define BENCHMARK_HELPERS_H
-
-#include "event_counter.h"
-#include <atomic>
-
-event_collector collector;
-
-template <class function_type>
-std::pair<event_aggregate, size_t>
-bench(const function_type &&function, size_t min_repeat = 10,
-      size_t min_time_ns = 40'000'000, size_t max_repeat = 10000000) {
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  event_aggregate warm_aggregate{};
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    warm_aggregate << allocate_count;
-    if ((i + 1 == N) && (warm_aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  event_aggregate aggregate{};
-  for (size_t i = 0; i < 10; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    for (size_t i = 0; i < N; i++) {
-      function();
-    }
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-  }
-  return {aggregate, N};
-}
-
-double pretty_print(const std::string &name, size_t num_chars,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-double pretty_print_array(const std::string &name, size_t num_chars, size_t num_elements,
-                    std::pair<event_aggregate, size_t> result) {
-  const auto &agg = result.first;
-  size_t N = result.second;
-  num_chars *= N;
-  printf("%-40s : %8.2f ns/char %8.2f ns/value %8.2f GB/s", name.c_str(),
-         agg.elapsed_ns() / num_chars, agg.elapsed_ns() / num_elements, num_chars / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %8.2f GHz %8.2f cycles/char %8.2f ins./char %8.2f ins./value %8.2f i/c",
-           agg.cycles() / agg.elapsed_ns(), agg.cycles() / num_chars,
-           agg.instructions() / num_chars, agg.instructions() / num_elements, agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-  return num_chars / agg.elapsed_ns();
-}
-
-
-#endif

benchmark/from/car_helpers.h

@@ -1,146 +0,0 @@
-#ifndef CAR_HELPERS_H
-#define CAR_HELPERS_H
-
-#include <iomanip>
-#include <random>
-#include <sstream>
-#include <vector>
-
-#include <simdjson.h>
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year; // We deliberately do not include the tire pressure.
-};
-
-using namespace simdjson;
-
-std::string random_car_json() {
-  static const std::vector<std::string> makes = {"Toyota", "Honda", "Ford",
-                                                 "BMW", "Mazda"};
-  static const std::vector<std::string> models = {"Camry", "Civic", "Focus",
-                                                  "320i", "3"};
-  static thread_local std::mt19937 rng{std::random_device{}()};
-  std::uniform_int_distribution<int> make_dist(0, makes.size() - 1);
-  std::uniform_int_distribution<int> model_dist(0, models.size() - 1);
-  std::uniform_int_distribution<int> year_dist(2000, 2025);
-  std::uniform_real_distribution<double> pressure_dist(30.0, 45.0);
-
-  std::ostringstream oss;
-  oss << R"({ "make": ")" << makes[make_dist(rng)] << R"(", "model": ")"
-      << models[model_dist(rng)] << R"(",  "year": )" << year_dist(rng)
-      << R"(, "tire_pressure": [ )" << std::fixed << std::setprecision(1)
-      << pressure_dist(rng) << ", " << pressure_dist(rng) << R"( ] })";
-  return oss.str();
-}
-
-std::string generate_car_json_stream(size_t N) {
-  std::ostringstream oss;
-  for (size_t i = 0; i < N; ++i) {
-    oss << random_car_json();
-    oss << "\n";
-  }
-  return oss.str();
-}
-
-std::string generate_car_json_array(size_t N) {
-  std::ostringstream oss;
-  oss << "[\n";
-  for (size_t i = 0; i < N; ++i) {
-    oss << random_car_json();
-    if (i < N - 1) {
-      oss << ",";
-    }
-    oss << "\n";
-  }
-  oss << "]";
-  return oss.str();
-}
-
-// We want to maximize C++ portability, but this is not needed with static
-// reflection (C++26).
-template <>
-simdjson_inline simdjson_result<Car>
-simdjson::ondemand::document::get() & noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-template <>
-simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-template <>
-simdjson_inline simdjson_result<Car>
-simdjson::ondemand::document_reference::get() & noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-template <>
-simdjson_inline simdjson_result<Car>
-simdjson::ondemand::document_reference::get() && noexcept {
-  ondemand::object obj;
-  auto error = get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  Car car;
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get_int64().get(car.year))) {
-    return error;
-  }
-  return car;
-}
-
-#endif

benchmark/from/from_benchmark.cpp

@@ -1,132 +0,0 @@
-// We are going to assume C++20.
-
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <simdjson.h>
-#include <string>
-
-#include "benchmark_helpers.h"
-#include "car_helpers.h"
-
-using namespace simdjson;
-
-void run_benchmarks() {
-  printf("Running benchmarks on tiny input...\n");
-  simdjson::padded_string json =
-      R"({ "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  volatile size_t dummy = 0;
-  ondemand::parser parser;
-
-  // Classic On-Demand
-  pretty_print("simdjson classic", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 ondemand::document doc = parser.iterate(json);
-                 Car car = doc.get<Car>();
-                 dummy = dummy + car.year;
-               }));
-
-  // Benchmark simdjson::from() without parser
-  pretty_print("simdjson::from<Car>() (no parser)", json.size(),
-               bench([&json, &dummy]() {
-                 Car car = simdjson::from(json);
-                 dummy = dummy + car.year;
-               }));
-
-  // Benchmark simdjson::from() with parser
-  pretty_print("simdjson::from<Car>() (with parser)", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 Car car = simdjson::from(parser, json);
-                 dummy = dummy + car.year;
-               }));
-}
-
-void run_array_benchmarks() {
-  printf("Running benchmarks on large array...\n");
-  size_t N = 1'000'000;
-  simdjson::padded_string json = generate_car_json_array(N);
-  volatile size_t dummy = 0;
-  ondemand::parser parser;
-
-  // Classic On-Demand
-  pretty_print_array("simdjson classic", json.size(), N,
-                     bench([&json, &dummy, &parser]() {
-                       dummy = 0;
-                       ondemand::document doc = parser.iterate(json);
-                       ondemand::array array = doc.get_array();
-                       for (auto value : array) {
-                         Car car = value.get<Car>();
-                         dummy = dummy + car.year;
-                       }
-                     }));
-
-  // from with array
-  pretty_print_array("simdjson::from(json).array()", json.size(), N,
-                     bench([&json, &dummy, &parser]() {
-                       dummy = 0;
-
-                       for (auto value : simdjson::from(json).array()) {
-                         Car car = value.get<Car>();
-                         dummy = dummy + car.year;
-                       }
-                     }));
-#if SIMDJSON_SUPPORTS_RANGES_FROM
-  // Benchmark simdjson::from() without parser (EXPERIMENTAL)
-  pretty_print_array("simdjson::from<Car>() (experimental, no parser)",
-                     json.size(), N, bench([&json, &dummy]() {
-                       dummy = 0;
-                       for (Car car :
-                            simdjson::from(json) | simdjson::as<Car>()) {
-                         dummy = dummy + car.year;
-                       }
-                     }));
-
-  // Benchmark simdjson::from() with parser (EXPERIMENTAL)
-  pretty_print_array("simdjson::from<Car>() (experimental, with parser)",
-                     json.size(), N, bench([&json, &dummy, &parser]() {
-                       dummy = 0;
-                       for (Car car : simdjson::from(parser, json) |
-                                          simdjson::as<Car>()) {
-                         dummy = dummy + car.year;
-                       }
-                     }));
-#endif // SIMDJSON_SUPPORTS_RANGES_FROM
-}
-
-void run_stream_benchmarks() {
-  printf("Running stream benchmarks...\n");
-  simdjson::padded_string json = generate_car_json_stream(1'000'000);
-  volatile size_t dummy = 0;
-  ondemand::parser parser;
-
-  // Classic On-Demand
-  pretty_print("simdjson classic", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 ondemand::document_stream stream = parser.iterate_many(json);
-                 for (auto doc : stream) {
-                   Car car = doc.get<Car>();
-                   dummy = dummy + car.year;
-                 }
-               }));
-  // from_many
-  pretty_print("simdjson with thread local", json.size(),
-               bench([&json, &dummy, &parser]() {
-                 ondemand::document_stream stream =
-                     ondemand::parser::get_parser().iterate_many(json);
-                 for (auto doc : stream) {
-                   Car car = doc.get<Car>();
-                   dummy = dummy + car.year;
-                 }
-               }));
-}
-
-int main() {
-  for (size_t trial = 0; trial < 3; trial++) {
-    printf("Trial %zu:\n", trial + 1);
-    run_array_benchmarks();
-    run_stream_benchmarks();
-    run_benchmarks();
-    printf("\n");
-  }
-  return EXIT_SUCCESS;
-}

benchmark/get_corpus_benchmark.cpp

@@ -9,11 +9,7 @@ simdjson_never_inline
 double bench(std::string filename, simdjson::padded_string& p) {
   std::chrono::time_point<std::chrono::steady_clock> start_clock =
       std::chrono::steady_clock::now();
-  auto error = simdjson::padded_string::load(filename).get(p);
+  simdjson::padded_string::load(filename).value_unsafe().swap(p);
-  if(error) {
-    std::cerr << simdjson::error_message(error) << std::endl;
-    std::abort();
-  }
   std::chrono::time_point<std::chrono::steady_clock> end_clock =
       std::chrono::steady_clock::now();
   std::chrono::duration<double> elapsed = end_clock - start_clock;

benchmark/json2msgpack/yyjson.h

@@ -100,7 +100,6 @@ struct yyjson : yyjson2msgpack {
            std::string_view &result) {
     yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
     result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    yyjson_doc_free(doc);
     return true;
   }
 };
@@ -114,7 +113,6 @@ struct yyjson_insitu : yyjson2msgpack {
     yyjson_doc *doc =
         yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
     result = to_msgpack(doc, reinterpret_cast<uint8_t*>(buffer));
-    yyjson_doc_free(doc);
     return true;
   }
 };
@@ -122,4 +120,4 @@ BENCHMARK_TEMPLATE(json2msgpack, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
 } // namespace json2msgpack
 
-#endif // SIMDJSON_COMPETITION_YYJSON
+#endif // SIMDJSON_COMPETITION_YYJSON

benchmark/kostya/yyjson.h

@@ -49,26 +49,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(kostya, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(kostya, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace kostya
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/large_random/simdjson_ondemand.h

@@ -23,29 +23,7 @@ struct simdjson_ondemand {
 };
 
 BENCHMARK_TEMPLATE(large_random, simdjson_ondemand)->UseManualTime();
-#if SIMDJSON_STATIC_REFLECTION
 
-struct simdjson_ondemand_static_reflect {
-  static constexpr diff_flags DiffFlags = diff_flags::NONE;
-
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    auto doc = parser.iterate(json);
-    if(auto e = doc.get_array().get<std::vector<point>>(result); e) { return false; }
-    // We can also do it like so:
-    //for (ondemand::object coord : doc) {
-    //  result.emplace_back(coord.get<point>());
-    //}
-    // It seems that doing the reflection is slower than doing the manual lookup.
-    // E.g., it is faster if we do result.emplace_back(coord["x"], coord["y"], coord["z"]);
-    return true;
-  }
-};
-BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_static_reflect)->UseManualTime();
-
-
-#endif
 } // namespace large_random
 
 #endif // SIMDJSON_EXCEPTIONS

benchmark/large_random/yyjson.h

@@ -47,26 +47,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(large_random, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(large_random, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace large_random
 
 #endif // SIMDJSON_COMPETITION_YYJSON

benchmark/partial_tweets/yyjson.h

@@ -62,26 +62,19 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(partial_tweets, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), result);
-    bool b = yyjson_base::run(doc, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(partial_tweets, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace partial_tweets
 
 #endif // SIMDJSON_COMPETITION_YYJSON
+

benchmark/static_reflect/CMakeLists.txt

@@ -1,48 +0,0 @@
-# Include reflect-cpp
-CPMAddPackage(
-  NAME reflect-cpp
-  GITHUB_REPOSITORY getml/reflect-cpp
-  GIT_TAG v0.17.0
-  EXCLUDE_FROM_ALL YES
-)
-
-option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)
-
-if(SIMDJSON_USER_RUST)
-  if(NOT WIN32)
-  # We want the check whether Rust is available before trying to build a crate.
-  CPMAddPackage(
-    NAME corrosion
-    GITHUB_REPOSITORY corrosion-rs/corrosion
-    VERSION 0.4.4
-    DOWNLOAD_ONLY ON
-    OPTIONS "Rust_FIND_QUIETLY OFF"
-  )
-  include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
-  endif()
-
-  if(RUST_FOUND)
-    message(STATUS "Rust found: " ${Rust_VERSION} )
-    add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
-    # Important: we want to build in release mode!
-    corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
-  else()
-    message(STATUS "Rust/Cargo is unavailable." )
-    message(STATUS "We will not benchmark serde-benchmark." )
-    if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-      message(STATUS "Under macOS, you may be able to install rust with")
-      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-      message(STATUS "Under Linux, you may be able to install rust with a command such as")
-      message(STATUS "apt-get install cargo" )
-      message(STATUS "or" )
-      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-    endif()
-  endif()
-else(SIMDJSON_USER_RUST)
-  message(STATUS "We will not benchmark serde-benchmark." )
-endif(SIMDJSON_USER_RUST)
-
-# Add the benchmark executable targets
-add_subdirectory(twitter_benchmark)
-add_subdirectory(citm_catalog_benchmark)

benchmark/static_reflect/benchmark_utils/benchmark_helper.h

@@ -1,52 +0,0 @@
-#ifndef BENCHMARK_HELPER_HPP
-#define BENCHMARK_HELPER_HPP
-#include "event_counter.h"
-#include <atomic>
-
-inline event_collector &get_collector() {
-  static event_collector collector;
-  return collector;
-}
-
-template <class function_type>
-event_aggregate bench(const function_type &function, size_t min_repeat = 10,
-                      size_t min_time_ns = 1000000000,
-                      size_t max_repeat = 100000) {
-  event_collector &collector = get_collector();
-  event_aggregate aggregate{};
-  size_t N = min_repeat;
-  if (N == 0) {
-    N = 1;
-  }
-  for (size_t i = 0; i < N; i++) {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    collector.start();
-    function();
-    std::atomic_thread_fence(std::memory_order_release);
-    event_count allocate_count = collector.end();
-    aggregate << allocate_count;
-    if ((i + 1 == N) && (aggregate.total_elapsed_ns() < min_time_ns) &&
-        (N < max_repeat)) {
-      N *= 10;
-    }
-  }
-  return aggregate;
-}
-
-// Source of the 2 functions below:
-// https://github.com/simdutf/simdutf/blob/master/benchmarks/base64/benchmark_base64.cpp
-inline void pretty_print(size_t strings, size_t bytes, std::string name,
-                         event_aggregate agg) {
-  event_collector &collector = get_collector();
-  printf("%-60s : ", name.c_str());
-  printf(" %5.2f MB/s ", bytes * 1000 / agg.elapsed_ns());
-  printf(" %5.2f Ms/s ", strings * 1000 / agg.elapsed_ns());
-  if (collector.has_events()) {
-    printf(" %5.2f GHz ", agg.cycles() / agg.elapsed_ns());
-    printf(" %5.2f c/b ", agg.cycles() / bytes);
-    printf(" %5.2f i/b ", agg.instructions() / bytes);
-    printf(" %5.2f i/c ", agg.instructions() / agg.cycles());
-  }
-  printf("\n");
-}
-#endif

benchmark/static_reflect/citm_catalog_benchmark/CMakeLists.txt

@@ -1,14 +0,0 @@
-add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
-
-# Link with Rust benchmarking code if available
-if(TARGET serde-benchmark)
-    message(STATUS "serde-benchmark target was created. Linking CITM catalog benchmark with serde-benchmark.")
-    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-
-target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::simdjson nlohmann_json)
-target_link_libraries(benchmark_serialization_citm_catalog PRIVATE reflectcpp)
-target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
-
-target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")

benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog.cpp

@@ -1,177 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "citm_catalog_data.h"
-#include "nlohmann_citm_catalog_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-
-#if SIMDJSON_BENCH_CPP_REFLECT
-#include <rfl.hpp>
-#include <rfl/json.hpp>
-void bench_reflect_cpp(CitmCatalog &data) {
-  std::string output = rfl::json::write(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_reflect_cpp",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = rfl::json::write(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif // SIMDJSON_BENCH_CPP_REFLECT
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust(serde_benchmark::CitmCatalog *data) {
-  const char * output = serde_benchmark::str_from_citm(data);
-  size_t output_volume = strlen(output);
-  printf("# output volume: %zu bytes\n", output_volume);
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_rust",
-               bench([&data, &measured_volume, &output_volume]() {
-                 const char * output = serde_benchmark::str_from_citm(data);
-                 measured_volume = strlen(output);
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-                 serde_benchmark::free_str(const_cast<char*>(output));
-               }));
-  serde_benchmark::free_str(const_cast<char*>(output));
-}
-#endif // SIMDJSON_RUST_VERSION
-
-void bench_nlohmann(CitmCatalog &data) {
-  std::string output = nlohmann_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_nlohmann",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = nlohmann_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-void bench_simdjson_static_reflection(CitmCatalog &data) {
-  simdjson::builder::string_builder sb;
-  simdjson::builder::append(sb, data);
-  std::string_view p;
-  if(sb.view().get(p)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p.size();
-  sb.clear();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume, &sb]() {
-                 sb.clear();
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-std::string read_file(const std::string &file_path, size_t read_size = 65536) {
-  std::ifstream stream(file_path, std::ios::binary);
-  if(!stream) {
-    std::cerr << "Could not open file '" << file_path << "'" << std::endl;
-    exit(EXIT_FAILURE);
-  }
-  stream.exceptions(std::ios_base::badbit);
-  std::string out;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name contains filter substring
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-  // Testing correctness of round-trip (serialization + deserialization)
-  std::string json_str = read_file(JSON_FILE);
-
-  // Loading up the data into a structure.
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
-    std::cerr << "Error loading the document!" << std::endl;
-    return EXIT_FAILURE;
-  }
-  CitmCatalog my_struct;
-  if(doc.get<CitmCatalog>().get(my_struct)) {
-    std::cerr << "Error loading CitmCatalog!" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Benchmarking the serialization
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann(my_struct);
-  }
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection(my_struct);
-  }
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
-    // Create a Rust-compatible CitmCatalog structure from the JSON string
-    serde_benchmark::CitmCatalog* rust_data =
-      serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
-
-    if (rust_data == nullptr) {
-      printf("# Failed to initialize Rust data structure\n");
-    } else {
-      bench_rust(rust_data);
-      serde_benchmark::free_citm(rust_data);
-    }
-  }
-#endif
-#if SIMDJSON_BENCH_CPP_REFLECT
-  if (matches_filter("reflect_cpp", filter)) {
-    bench_reflect_cpp(my_struct);
-  }
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/citm_catalog_benchmark/citm_catalog_data.h

@@ -1,82 +0,0 @@
-#ifndef CITM_CATALOG_DATA_H
-#define CITM_CATALOG_DATA_H
-
-#include <string>
-#include <vector>
-#include <map>
-
-struct Area {
-  int64_t id;
-  std::string name;
-  int64_t parent;
-  std::vector<int64_t> childAreas;
-  bool operator==(const Area &other) const = default;
-};
-
-struct AudienceSubCategory {
-  int64_t id;
-  std::string name;
-  int64_t parent;
-  bool operator==(const AudienceSubCategory &other) const = default;
-};
-
-struct Event {
-  int64_t id;
-  std::string name;
-  std::string description;
-  int64_t subTopic;
-  int64_t topic;
-  std::vector<int64_t> audience;
-  bool operator==(const Event &other) const = default;
-};
-
-struct Performance {
-  int64_t id;
-  std::string name;
-  int64_t event;
-  std::string start;
-  int64_t venueCode;
-  bool operator==(const Performance &other) const = default;
-};
-
-struct SeatCategory {
-  int64_t id;
-  std::string name;
-  std::vector<int64_t> areas;
-  bool operator==(const SeatCategory &other) const = default;
-};
-
-struct SubTopic {
-  int64_t id;
-  std::string name;
-  int64_t parent;
-  bool operator==(const SubTopic &other) const = default;
-};
-
-struct Topic {
-  int64_t id;
-  std::string name;
-  bool operator==(const Topic &other) const = default;
-};
-
-struct Venue {
-  int64_t id;
-  std::string name;
-  int64_t address;
-  bool operator==(const Venue &other) const = default;
-};
-
-struct CitmCatalog {
-  std::map<std::string, Area> areas;
-  std::map<std::string, AudienceSubCategory> audienceSubCategory;
-  std::map<std::string, Event> events;
-  std::map<std::string, Performance> performances;
-  std::map<std::string, SeatCategory> seatCategory;
-  std::map<std::string, SubTopic> subTopic;
-  std::map<std::string, Topic> topic;
-  std::map<std::string, Venue> venue;
-
-  bool operator==(const CitmCatalog &other) const = default;
-};
-
-#endif

benchmark/static_reflect/citm_catalog_benchmark/nlohmann_citm_catalog_data.h

@@ -1,171 +0,0 @@
-// nlohmann_citm_catalog_data.h
-#ifndef NLOHMANN_CITM_CATALOG_DATA_H
-#define NLOHMANN_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <nlohmann/json.hpp>
-#include <string>
-
-using json = nlohmann::json;
-
-// ---- Area ----
-inline void to_json(json &j, const Area &a) {
-    j = json{
-      {"id", a.id},
-      {"name", a.name},
-      {"parent", a.parent},
-      {"childAreas", a.childAreas}
-    };
-}
-inline void from_json(const json &j, Area &a) {
-    j.at("id").get_to(a.id);
-    j.at("name").get_to(a.name);
-    j.at("parent").get_to(a.parent);
-    j.at("childAreas").get_to(a.childAreas);
-}
-
-// ---- AudienceSubCategory ----
-inline void to_json(json &j, const AudienceSubCategory &asc) {
-    j = json{
-      {"id", asc.id},
-      {"name", asc.name},
-      {"parent", asc.parent}
-    };
-}
-inline void from_json(const json &j, AudienceSubCategory &asc) {
-    j.at("id").get_to(asc.id);
-    j.at("name").get_to(asc.name);
-    j.at("parent").get_to(asc.parent);
-}
-
-// ---- Event ----
-inline void to_json(json &j, const Event &e) {
-    j = json{
-      {"id", e.id},
-      {"name", e.name},
-      {"description", e.description},
-      {"subTopic", e.subTopic},
-      {"topic", e.topic},
-      {"audience", e.audience}
-    };
-}
-inline void from_json(const json &j, Event &e) {
-    j.at("id").get_to(e.id);
-    j.at("name").get_to(e.name);
-    j.at("description").get_to(e.description);
-    j.at("subTopic").get_to(e.subTopic);
-    j.at("topic").get_to(e.topic);
-    j.at("audience").get_to(e.audience);
-}
-
-// ---- Performance ----
-inline void to_json(json &j, const Performance &p) {
-    j = json{
-      {"id", p.id},
-      {"name", p.name},
-      {"event", p.event},
-      {"start", p.start},
-      {"venueCode", p.venueCode}
-    };
-}
-inline void from_json(const json &j, Performance &p) {
-    j.at("id").get_to(p.id);
-    j.at("name").get_to(p.name);
-    j.at("event").get_to(p.event);
-    j.at("start").get_to(p.start);
-    j.at("venueCode").get_to(p.venueCode);
-}
-
-// ---- SeatCategory ----
-inline void to_json(json &j, const SeatCategory &sc) {
-    j = json{
-      {"id", sc.id},
-      {"name", sc.name},
-      {"areas", sc.areas}
-    };
-}
-inline void from_json(const json &j, SeatCategory &sc) {
-    j.at("id").get_to(sc.id);
-    j.at("name").get_to(sc.name);
-    j.at("areas").get_to(sc.areas);
-}
-
-// ---- SubTopic ----
-inline void to_json(json &j, const SubTopic &st) {
-    j = json{
-      {"id", st.id},
-      {"name", st.name},
-      {"parent", st.parent}
-    };
-}
-inline void from_json(const json &j, SubTopic &st) {
-    j.at("id").get_to(st.id);
-    j.at("name").get_to(st.name);
-    j.at("parent").get_to(st.parent);
-}
-
-// ---- Topic ----
-inline void to_json(json &j, const Topic &t) {
-    j = json{
-      {"id", t.id},
-      {"name", t.name}
-    };
-}
-inline void from_json(const json &j, Topic &t) {
-    j.at("id").get_to(t.id);
-    j.at("name").get_to(t.name);
-}
-
-// ---- Venue ----
-inline void to_json(json &j, const Venue &v) {
-    j = json{
-      {"id", v.id},
-      {"name", v.name},
-      {"address", v.address}
-    };
-}
-inline void from_json(const json &j, Venue &v) {
-    j.at("id").get_to(v.id);
-    j.at("name").get_to(v.name);
-    j.at("address").get_to(v.address);
-}
-
-// ---- CitmCatalog ----
-inline void to_json(json &j, const CitmCatalog &c) {
-    j = json{
-      {"areas", c.areas},
-      {"audienceSubCategory", c.audienceSubCategory},
-      {"events", c.events},
-      {"performances", c.performances},
-      {"seatCategory", c.seatCategory},
-      {"subTopic", c.subTopic},
-      {"topic", c.topic},
-      {"venue", c.venue}
-    };
-}
-inline void from_json(const json &j, CitmCatalog &c) {
-    j.at("areas").get_to(c.areas);
-    j.at("audienceSubCategory").get_to(c.audienceSubCategory);
-    j.at("events").get_to(c.events);
-    j.at("performances").get_to(c.performances);
-    j.at("seatCategory").get_to(c.seatCategory);
-    j.at("subTopic").get_to(c.subTopic);
-    j.at("topic").get_to(c.topic);
-    j.at("venue").get_to(c.venue);
-}
-
-// Optional convenience functions for benchmarking
-inline std::string nlohmann_serialize(const CitmCatalog &catalog) {
-    json j = catalog;
-    return j.dump();
-}
-inline bool nlohmann_deserialize(const std::string &json_in, CitmCatalog &catalog) {
-    try {
-        catalog = json::parse(json_in);
-        return false; // success
-    } catch(...) {
-        return true;  // failure
-    }
-}
-
-#endif // NLOHMANN_CITM_CATALOG_DATA_H

benchmark/static_reflect/serde-benchmark/Cargo.lock

@@ -1,103 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "itoa"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
-
-[[package]]
-name = "libc"
-version = "0.2.158"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
-
-[[package]]
-name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
-
-[[package]]
-name = "serde"
-version = "1.0.209"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-benchmark"
-version = "0.1.0"
-dependencies = [
- "libc",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.209"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.127"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
-dependencies = [
- "itoa",
- "memchr",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.76"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

benchmark/static_reflect/serde-benchmark/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "serde-benchmark"
-version = "0.1.0"
-
-[lib]
-path = "lib.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-libc = "0.2"
-serde_json = "1.0"
-
-[profile.release]
-opt-level = 3
-debug = false
-lto = true

benchmark/static_reflect/serde-benchmark/README.md

@@ -1,18 +0,0 @@
-## Rust Serde FFI
-
-This folder includes FFI bindings for rust/serde.
-
-### Links
-
-- https://github.com/eqrion/cbindgen/blob/master/docs.md
-- https://gist.github.com/zbraniecki/b251714d77ffebbc73c03447f2b2c69f
-- https://michael-f-bryan.github.io/rust-ffi-guide/setting_up.html
-
-### Building
-
-- Generating cbindgen output
-  - Install dependencies with `brew install cbindgen` or `apt-get install cbindgen` or `cargo install cbindgen` or the equivalent: we used `cargo install --version 0.23.0 cbindgen`.
-  - Go to the directory where this README.md file is located
-  - Generate with `cbindgen --config cbindgen.toml --crate serde-benchmark --output serde_benchmark.h`
-- Building
-  - Run with `cargo build --release`

benchmark/static_reflect/serde-benchmark/cbindgen.toml

@@ -1,12 +0,0 @@
-autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
-include_version = true
-braces = "SameLine"
-line_length = 100
-tab_width = 2
-language = "C++"
-namespaces = ["serde_benchmark"]
-include_guard = "serde_benchmark_ffi_h"
-
-[parse]
-parse_deps = true
-include = ["serde_json", "serde"]

benchmark/static_reflect/serde-benchmark/lib.rs

@@ -1,482 +0,0 @@
-extern crate serde;
-extern crate serde_json;
-extern crate libc;
-
-use libc::{c_char, size_t};
-use serde::{Serialize, Deserialize};
-use std::{collections::HashMap, ffi::CString, ptr, slice};
-use serde::de::{self, Deserializer};
-/******************************************************/
-/******************************************************/
-/**
- * Warning: the C++ code may not generate the same JSON.
- */
- /******************************************************/
- /******************************************************/
-
-// This has no equivalent in C++:
-#[derive(Serialize, Deserialize)]
-pub struct Metadata {
-    result_type: String,
-    iso_language_code: String,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct User {
-    id: i64,
-    id_str: String,
-    name: String,
-    screen_name: String,
-    location: String,
-    description: String,
-    // C++ does not have those:
-    // url: Option<String>,
-    //protected: bool,
-    //listed_count: i64,
-    //created_at: String,
-    //favourites_count: i64,
-    //utc_offset: Option<i64>,
-    //time_zone: Option<String>,
-    //geo_enabled: bool,
-    verified: bool,
-    followers_count: i64,
-    friends_count: i64,
-    statuses_count: i64,
-    // C++ does not have those:
-    //lang: String,
-    //profile_background_color: String,
-    //profile_background_image_url: String,
-    //profile_background_image_url_https: String,
-    //profile_background_tile: bool,
-    //profile_image_url: String,
-    //profile_image_url_https: String,
-    //profile_banner_url: Option<String>,
-    //profile_link_color: String,
-    //profile_sidebar_border_color: String,
-    //profile_sidebar_fill_color: String,
-    //profile_text_color: String,
-    //profile_use_background_image: bool,
-    //default_profile: bool,
-    //default_profile_image: bool,
-    //following: bool,
-    //follow_request_sent: bool,
-    //notifications: bool,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Hashtag {
-    text: String,
-
-    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
-    // int64_t indices_start;
-    // int64_t indices_end;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Url {
-    url: String,
-    expanded_url: String,
-    display_url: String,
-    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
-    // int64_t indices_start;
-    // int64_t indices_end;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct UserMention {
-    id: i64,
-    name: String,
-    screen_name: String,
-    // Not in the C++ equivalent:
-    //id_str: String,
-    //indices: Vec<i64>,
-    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
-    // int64_t indices_start;
-    // int64_t indices_end;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Entities {
-    hashtags: Vec<Hashtag>,
-    urls: Vec<Url>,
-    user_mentions: Vec<UserMention>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Status {
-    created_at: String,
-    id: i64,
-    text: String,
-    user: User,
-    entities: Entities,
-    retweet_count: i64,
-    favorite_count: i64,
-    favorited: bool,
-    retweeted: bool,
-    // None of these are in the C++ equivalent:
-    /*
-    metadata: Metadata,
-    id_str: String,
-    source: String,
-    truncated: bool,
-    in_reply_to_status_id: Option<i64>,
-    in_reply_to_status_id_str: Option<String>,
-    in_reply_to_user_id: Option<i64>,
-    in_reply_to_user_id_str: Option<String>,
-    in_reply_to_screen_name: Option<String>,
-    geo: Option<String>,
-    coordinates: Option<String>,
-    place: Option<String>,
-    contributors: Option<String>,
-    lang: String,
-    */
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct TwitterData {
-    statuses: Vec<Status>,
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn  twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
-  let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
-  match serde_json::from_str(&input) {
-    Ok(result) => Box::into_raw(Box::new(result)),
-    Err(_) => std::ptr::null_mut(),
-  }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
-  let twitter_thing = { &*raw };
-  let serialized = serde_json::to_string(&twitter_thing).unwrap();
-  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
-}
-
-
-#[no_mangle]
-pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
-  if raw.is_null() {
-    return;
-  }
-
-  drop(Box::from_raw(raw))
-}
-
-
-#[no_mangle]
-pub unsafe extern fn free_string(ptr: *const c_char) {
-    let _ = std::ffi::CString::from_raw(ptr as *mut _);
-}
-
-// Functions associated with the CitmCatalog benchmark
-
-#[derive(Serialize, Deserialize)]
-pub struct Area {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-    pub parent: i64,
-    #[serde(rename = "childAreas")]
-    pub child_areas: Vec<i64>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct AudienceSubCategory {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-    pub parent: i64,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Event {
-    #[serde(default)]
-    pub description: Option<String>,
-    pub id: i64,
-    #[serde(default)]
-    pub logo: Option<String>,
-    #[serde(default)]
-    pub name: Option<String>,
-    #[serde(default)]
-    pub subTopicIds: Vec<i64>,
-    #[serde(default)]
-    pub subjectCode: Option<String>,
-    #[serde(default)]
-    pub subtitle: Option<String>,
-    #[serde(default)]
-    pub topicIds: Vec<i64>,
-    // Add a catch-all for any other fields
-    #[serde(flatten)]
-    pub extra: HashMap<String, serde_json::Value>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Performance {
-    #[serde(default)]
-    pub id: i64,
-
-    #[serde(default)]
-    pub name: Option<String>,
-
-    #[serde(default)]
-    pub event: i64,
-
-    // This is the key fix - accept any JSON value type for timestamps
-    // This allows both string dates and integer timestamps (line 3511)
-    #[serde(default)]
-    pub start: serde_json::Value,
-
-    #[serde(rename = "venueCode")]
-    pub venue_code: String,
-
-    // Add a catch-all for any other fields
-    #[serde(flatten)]
-    pub extra: HashMap<String, serde_json::Value>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SeatCategory {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-    pub areas: Vec<i64>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SubTopic {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-    pub parent: i64,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Topic {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Venue {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-    pub address: i64,
-}
-
-// Custom deserializers
-fn deserialize_string_to_area<'de, D>(deserializer: D) -> Result<HashMap<String, Area>, D::Error>
-where D: Deserializer<'de> {
-    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
-    let mut result = HashMap::new();
-
-    for (id, name) in string_map {
-        let id_num = id.parse::<i64>().unwrap_or(0);
-        result.insert(id.clone(), Area {
-            id: id_num,
-            name: Some(name),
-            parent: 0,
-            child_areas: Vec::new(),
-        });
-    }
-
-    Ok(result)
-}
-
-fn deserialize_string_to_audience_subcategory<'de, D>(deserializer: D) -> Result<HashMap<String, AudienceSubCategory>, D::Error>
-where D: Deserializer<'de> {
-    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
-    let mut result = HashMap::new();
-
-    for (id, name) in string_map {
-        let id_num = id.parse::<i64>().unwrap_or(0);
-        result.insert(id.clone(), AudienceSubCategory {
-            id: id_num,
-            name: Some(name),
-            parent: 0,
-        });
-    }
-
-    Ok(result)
-}
-
-fn deserialize_string_to_seat_category<'de, D>(deserializer: D) -> Result<HashMap<String, SeatCategory>, D::Error>
-where D: Deserializer<'de> {
-    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
-    let mut result = HashMap::new();
-
-    for (id, name) in string_map {
-        let id_num = id.parse::<i64>().unwrap_or(0);
-        result.insert(id.clone(), SeatCategory {
-            id: id_num,
-            name: Some(name),
-            areas: Vec::new(),
-        });
-    }
-
-    Ok(result)
-}
-
-fn deserialize_string_to_subtopic<'de, D>(deserializer: D) -> Result<HashMap<String, SubTopic>, D::Error>
-where D: Deserializer<'de> {
-    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
-    let mut result = HashMap::new();
-
-    for (id, name) in string_map {
-        let id_num = id.parse::<i64>().unwrap_or(0);
-        result.insert(id.clone(), SubTopic {
-            id: id_num,
-            name: Some(name),
-            parent: 0,
-        });
-    }
-
-    Ok(result)
-}
-
-fn deserialize_string_to_topic<'de, D>(deserializer: D) -> Result<HashMap<String, Topic>, D::Error>
-where D: Deserializer<'de> {
-    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
-    let mut result = HashMap::new();
-
-    for (id, name) in string_map {
-        let id_num = id.parse::<i64>().unwrap_or(0);
-        result.insert(id.clone(), Topic {
-            id: id_num,
-            name: Some(name),
-        });
-    }
-
-    Ok(result)
-}
-
-fn deserialize_string_to_venue<'de, D>(deserializer: D) -> Result<HashMap<String, Venue>, D::Error>
-where D: Deserializer<'de> {
-    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
-    let mut result = HashMap::new();
-
-    for (id, name) in string_map {
-        result.insert(id.clone(), Venue {
-            id: 0,
-            name: Some(name),
-            address: 0,
-        });
-    }
-
-    Ok(result)
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct CitmCatalog {
-    #[serde(rename = "areaNames")]
-    pub area_names: HashMap<String, String>,
-
-    #[serde(rename = "audienceSubCategoryNames")]
-    pub audience_subcategory_names: HashMap<String, String>,
-
-    #[serde(default)]
-    #[serde(rename = "blockNames")]
-    pub block_names: HashMap<String, String>,
-
-    pub events: HashMap<String, Event>,
-
-    #[serde(default)]
-    pub performances: Vec<Performance>,
-
-    #[serde(rename = "seatCategoryNames")]
-    pub seat_category_names: HashMap<String, String>,
-
-    #[serde(rename = "subTopicNames")]
-    pub subtopic_names: HashMap<String, String>,
-
-    #[serde(default)]
-    #[serde(rename = "subjectNames")]
-    pub subject_names: HashMap<String, String>,
-
-    #[serde(rename = "topicNames")]
-    pub topic_names: HashMap<String, String>,
-
-    #[serde(rename = "topicSubTopics")]
-    pub topic_subtopics: HashMap<String, Vec<i64>>,
-
-    #[serde(rename = "venueNames")]
-    pub venue_names: HashMap<String, String>,
-
-    // Catch-all for other fields
-    #[serde(flatten)]
-    pub extra: HashMap<String, serde_json::Value>,
-}
-
-/// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
-#[no_mangle]
-pub unsafe extern "C" fn citm_from_str(
-    raw_input: *const c_char,
-    raw_input_length: usize
-) -> *mut CitmCatalog {
-    if raw_input.is_null() {
-        eprintln!("Error: Input pointer is null");
-        return ptr::null_mut();
-    }
-
-    // Convert the raw pointer + length into a Rust slice
-    let bytes = slice::from_raw_parts(raw_input as *const u8, raw_input_length);
-    let input_str = match std::str::from_utf8(bytes) {
-        Ok(s) => s,
-        Err(e) => {
-            eprintln!("Error: Invalid UTF-8 string: {}", e);
-            return ptr::null_mut();
-        }
-    };
-
-    // Try deserializing the input string into CitmCatalog
-    match serde_json::from_str::<CitmCatalog>(input_str) {
-        Ok(catalog) => Box::into_raw(Box::new(catalog)),
-        Err(e) => {
-            eprintln!("Error deserializing JSON: {}", e);
-            eprintln!("JSON snippet (first 200 chars): {:.200}...", input_str);
-            ptr::null_mut()
-        }
-    }
-}
-
-/// Serializes a CitmCatalog into a JSON string (UTF-8).
-#[no_mangle]
-pub unsafe extern "C" fn str_from_citm(raw_catalog: *mut CitmCatalog) -> *mut c_char {
-    if raw_catalog.is_null() {
-        eprintln!("Error: Catalog pointer is null");
-        return ptr::null_mut();
-    }
-
-    // Fix: Actually serialize the catalog
-    let catalog = &*raw_catalog;
-
-    match serde_json::to_string(catalog) {
-        Ok(serialized) => {
-            match CString::new(serialized) {
-                Ok(cstr) => cstr.into_raw(),
-                Err(e) => {
-                    eprintln!("Error creating CString: {}", e);
-                    ptr::null_mut()
-                }
-            }
-        },
-        Err(e) => {
-            eprintln!("Error serializing catalog to JSON: {}", e);
-            ptr::null_mut()
-        }
-    }
-}
-
-/// Frees the CitmCatalog pointer.
-#[no_mangle]
-pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
-    if !raw_catalog.is_null() {
-        drop(Box::from_raw(raw_catalog));
-    }
-}
-
-#[no_mangle]
-pub extern "C" fn free_str(ptr: *mut c_char) {
-    if !ptr.is_null() {
-        unsafe {
-            // Convert back into a CString, which automatically frees the memory
-            let _ = CString::from_raw(ptr);
-        }
-    }
-}

benchmark/static_reflect/serde-benchmark/serde_benchmark.h

@@ -1,45 +0,0 @@
-#ifndef serde_benchmark_ffi_h
-#define serde_benchmark_ffi_h
-
-/* Generated with cbindgen:0.28.0 */
-
-/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
-
-#include <cstdarg>
-#include <cstdint>
-#include <cstdlib>
-#include <ostream>
-#include <new>
-
-namespace serde_benchmark {
-
-struct CitmCatalog;
-
-struct TwitterData;
-
-extern "C" {
-
-TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
-
-const char *str_from_twitter(TwitterData *raw);
-
-void free_twitter(TwitterData *raw);
-
-void free_string(const char *ptr);
-
-/// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
-CitmCatalog *citm_from_str(const char *raw_input, uintptr_t raw_input_length);
-
-/// Serializes a CitmCatalog into a JSON string (UTF-8).
-char *str_from_citm(CitmCatalog *raw_catalog);
-
-/// Frees the CitmCatalog pointer.
-void free_citm(CitmCatalog *raw_catalog);
-
-void free_str(char *ptr);
-
-}  // extern "C"
-
-}  // namespace serde_benchmark
-
-#endif  // serde_benchmark_ffi_h

benchmark/static_reflect/twitter_benchmark/CMakeLists.txt

@@ -1,14 +0,0 @@
-
-# Add executable targets
-add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
-
- if(TARGET serde-benchmark)
-    message(STATUS "serde-benchmark target was created. Linking benchmarks and serde-benchmark.")
-    target_link_libraries(benchmark_serialization_twitter PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-target_link_libraries(benchmark_serialization_twitter PRIVATE simdjson::simdjson nlohmann_json)
-target_link_libraries(benchmark_serialization_twitter PRIVATE reflectcpp)
-target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
-
-target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")

benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter.cpp

@@ -1,168 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "twitter_data.h"
-#include "nlohmann_twitter_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-#if SIMDJSON_BENCH_CPP_REFLECT
-#include <rfl.hpp>
-#include <rfl/json.hpp>
-void bench_reflect_cpp(TwitterData &data) {
-  std::string output = rfl::json::write(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_reflect_cpp",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = rfl::json::write(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif // SIMDJSON_BENCH_CPP_REFLECT
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-
-void bench_rust(serde_benchmark::TwitterData *data) {
-  const char * output = serde_benchmark::str_from_twitter(data);
-  size_t output_volume = strlen(output);
-  printf("# output volume: %zu bytes\n", output_volume);
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_rust",
-               bench([&data, &measured_volume, &output_volume]() {
-                 const char * output = serde_benchmark::str_from_twitter(data);
-                 serde_benchmark::free_string(output);
-               }));
-}
-#endif
-
-template <class T> void bench_simdjson_static_reflection(T &data) {
-  simdjson::builder::string_builder sb;
-  simdjson::builder::append(sb, data);
-  std::string_view p;
-  if(sb.view().get(p)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p.size();
-  sb.clear();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume, &sb]() {
-                 sb.clear();
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-void bench_nlohmann(TwitterData &data) {
-  std::string output = nlohmann_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_nlohmann",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = nlohmann_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
-  ((std::string *)userp)->append((char *)contents, size * nmemb);
-  return size * nmemb;
-}
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename.c_str());
-  stream.exceptions(std::ios_base::badbit);
-  std::string out;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name contains filter substring
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-  // Testing correctness of round-trip (serialization + deserialization)
-  std::string json_str = read_file(JSON_FILE);
-
-  // Loading up the data into a structure.
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
-    std::cerr << "Error loading the document!" << std::endl;
-    return EXIT_FAILURE;
-  }
-  TwitterData my_struct;
-  if(doc.get<TwitterData>().get(my_struct)) {
-    std::cerr << "Error loading TwitterData!" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Benchmarking the serialization
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann(my_struct);
-  }
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection(my_struct);
-  }
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
-    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
-    bench_rust(td);
-    serde_benchmark::free_twitter(td);
-  }
-#endif
-#if SIMDJSON_BENCH_CPP_REFLECT
-  if (matches_filter("reflect_cpp", filter)) {
-    bench_reflect_cpp(my_struct);
-  }
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/twitter_benchmark/nlohmann_twitter_data.h

@@ -1,116 +0,0 @@
-#ifndef NLOHMANN_TWITTER_DATA_H
-#define NLOHMANN_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <nlohmann/json.hpp>
-
-void to_json(nlohmann::json &j, const User &u) {
-  j = nlohmann::json{{"id", u.id},
-                     {"name", u.name},
-                     {"screen_name", u.screen_name},
-                     {"location", u.location},
-                     {"description", u.description},
-                     {"verified", u.verified},
-                     {"followers_count", u.followers_count},
-                     {"friends_count", u.friends_count},
-                     {"statuses_count", u.statuses_count}};
-}
-
-void to_json(nlohmann::json &j, const Hashtag &h) {
-  j = nlohmann::json{{"text", h.text},
-                     {"indices_start", h.indices_start},
-                     {"indices_end", h.indices_end}};
-}
-
-void to_json(nlohmann::json &j, const Url &u) {
-  j = nlohmann::json{{"url", u.url},
-                     {"expanded_url", u.expanded_url},
-                     {"display_url", u.display_url},
-                     {"indices_start", u.indices_start},
-                     {"indices_end", u.indices_end}};
-}
-
-void to_json(nlohmann::json &j, const UserMention &um) {
-  j = nlohmann::json{{"id", um.id},
-                     {"name", um.name},
-                     {"screen_name", um.screen_name},
-                     {"indices_start", um.indices_start},
-                     {"indices_end", um.indices_end}};
-}
-
-void to_json(nlohmann::json &j, const Entities &e) {
-  j = nlohmann::json{{"hashtags", e.hashtags},
-                     {"urls", e.urls},
-                     {"user_mentions", e.user_mentions}};
-}
-
-void to_json(nlohmann::json &j, const Status &s) {
-  j = nlohmann::json{{"created_at", s.created_at},
-                     {"id", s.id},
-                     {"text", s.text},
-                     {"user", s.user},
-                     {"entities", s.entities},
-                     {"retweet_count", s.retweet_count},
-                     {"favorite_count", s.favorite_count},
-                     {"favorited", s.favorited},
-                     {"retweeted", s.retweeted}};
-}
-
-
-std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const Hashtag & h : v) {
-    a.push_back(nlohmann::json{{"text", h.text},
-                     {"indices_start", h.indices_start},
-                     {"indices_end", h.indices_end}});
-  }
-  return a.dump();
-}
-std::string nlohmann_serialize(const std::vector<Url>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const Url & u : v) {
-    a.push_back(nlohmann::json{{"url", u.url},
-                     {"expanded_url", u.expanded_url},
-                     {"display_url", u.display_url},
-                     {"indices_start", u.indices_start},
-                     {"indices_end", u.indices_end}});
-  }
-  return a.dump();
-}
-std::string nlohmann_serialize(const std::vector<UserMention>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const UserMention & um : v) {
-    a.push_back(nlohmann::json{{"id", um.id},
-                     {"name", um.name},
-                     {"screen_name", um.screen_name},
-                     {"indices_start", um.indices_start},
-                     {"indices_end", um.indices_end}});
-  }
-  return a.dump();
-}
-
-std::string nlohmann_serialize(const std::vector<Status>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const Status & s : v) {
-    a.push_back(nlohmann::json{{"created_at", s.created_at},
-                     {"id", s.id},
-                     {"text", s.text},
-                     {"user", s.user},
-                     {"entities", s.entities},
-                     {"retweet_count", s.retweet_count},
-                     {"favorite_count", s.favorite_count},
-                     {"favorited", s.favorited},
-                     {"retweeted", s.retweeted}});
-  }
-  return a.dump();
-}
-
-void to_json(nlohmann::json &j, const TwitterData &t) {
-  j = nlohmann::json{{"statuses", t.statuses}};
-}
-
-std::string nlohmann_serialize(const TwitterData &data) {
-  return nlohmann_serialize(data.statuses);
-}
-
-#endif // NLOHMANN_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/twitter_data.h

@@ -1,71 +0,0 @@
-#ifndef TWITTER_DATA_H
-#define TWITTER_DATA_H
-
-#include <string>
-#include <vector>
-
-struct User {
-  int64_t id;
-  std::string id_str;
-  std::string name;
-  std::string screen_name;
-  std::string location;
-  std::string description;
-  bool verified;
-  int64_t followers_count;
-  int64_t friends_count;
-  int64_t statuses_count;
-  bool operator<=>(const User &other) const = default;
-};
-
-struct Hashtag {
-  std::string text;
-  int64_t indices_start;
-  int64_t indices_end;
-  bool operator<=>(const Hashtag &other) const = default;
-};
-
-struct Url {
-  std::string url;
-  std::string expanded_url;
-  std::string display_url;
-  int64_t indices_start;
-  int64_t indices_end;
-  bool operator<=>(const Url &other) const = default;
-};
-
-struct UserMention {
-  int64_t id;
-  std::string name;
-  std::string screen_name;
-  int64_t indices_start;
-  int64_t indices_end;
-  bool operator<=>(const UserMention &other) const = default;
-};
-
-struct Entities {
-  std::vector<Hashtag> hashtags;
-  std::vector<Url> urls;
-  std::vector<UserMention> user_mentions;
-  bool operator==(const Entities &other) const = default;
-};
-
-struct Status {
-  std::string created_at;
-  int64_t id;
-  std::string text;
-  User user;
-  Entities entities;
-  int64_t retweet_count;
-  int64_t favorite_count;
-  bool favorited;
-  bool retweeted;
-  bool operator==(const Status &other) const = default;
-};
-
-struct TwitterData {
-  std::vector<Status> statuses;
-  bool operator==(const TwitterData &other) const = default;
-};
-
-#endif

benchmark/top_tweet/yyjson.h

@@ -51,26 +51,18 @@ struct yyjson_base {
 
 struct yyjson : yyjson_base {
   bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
-    yyjson_doc *doc = yyjson_read(json.data(), json.size(), 0);
+    return yyjson_base::run(yyjson_read(json.data(), json.size(), 0), max_retweet_count, result);
-    bool b = yyjson_base::run(doc, max_retweet_count, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(top_tweet, yyjson)->UseManualTime();
-
 #if SIMDJSON_COMPETITION_ONDEMAND_INSITU
 struct yyjson_insitu : yyjson_base {
   bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
-    yyjson_doc *doc = yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0);
+    return yyjson_base::run(yyjson_read_opts(json.data(), json.size(), YYJSON_READ_INSITU, 0, 0), max_retweet_count, result);
-    bool b = yyjson_base::run(doc, max_retweet_count, result);
-    yyjson_doc_free(doc);
-    return b;
   }
 };
 BENCHMARK_TEMPLATE(top_tweet, yyjson_insitu)->UseManualTime();
 #endif // SIMDJSON_COMPETITION_ONDEMAND_INSITU
-
 } // namespace top_tweet
 
 #endif // SIMDJSON_COMPETITION_YYJSON

cmake/developer-options.cmake

@@ -4,7 +4,7 @@
 add_library(simdjson-internal-flags INTERFACE)
 if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
   # We default to ON for all targets, so that we can use the library in shared libraries.
-  set_target_properties(simdjson-internal-flags PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
+  set_target_properties(simdjson-internal-flags PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
 
 option(SIMDJSON_CHECK_EOF "Check for the end of the input buffer. The setting is unnecessary since we require padding of the inputs. You should expect tests to fail with this option turned on." OFF)
@@ -32,9 +32,6 @@ undefined behavior.")
     link_libraries(
         -fsanitize=address -fno-omit-frame-pointer -fno-sanitize-recover=all
     )
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    add_compile_options(-fsanitize=address)
-    link_libraries(-fsanitize=address)
   else()
     message(
         STATUS
@@ -115,14 +112,8 @@ endif()
 
 # We compile tools, tests, etc. with C++ 17. Override yourself if you need on a
 # target.
-if(SIMDJSON_STATIC_REFLECTION)
+set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
-  # This is temporary.
+set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
-  set(SIMDJSON_CXX_STANDARD 26 CACHE STRING "the C++ standard to use for simdjson")
-  #set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
-else()
-  set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
-  set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
-endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
@@ -174,10 +165,6 @@ else()
       -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
       -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
   )
-  if(CMAKE_CXX_STANDARD VERSION_GREATER_EQUAL 20)
-    target_compile_options(simdjson-internal-flags INTERFACE -Wctad-maybe-unsupported)
-  endif()
-
 endif()
 
 option(SIMDJSON_GLIBCXX_ASSERTIONS "Set _GLIBCXX_ASSERTIONS" OFF)

cmake/exception-flags.cmake

@@ -17,9 +17,8 @@ editing CMAKE_CXX_FLAGS")
     # /EHc used in conjection with /EHs indicates that extern "C" functions
     # never throw (terminate-on-throw)
     # Here, we disable both with the - argument negation operator
-    if(CMAKE_CXX_FLAGS)
+    string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-        string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+
-    endif()
     # Because we cannot change the flag above on an individual target (yet), the
     # definition below must similarly be added globally
     add_definitions(-D_HAS_EXCEPTIONS=0)

cmake/toolchains-ci/riscv64-linux-gnu.cmake

@@ -1,4 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR riscv64)
-
-set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-riscv64-static")

dependencies/CMakeLists.txt

@@ -106,7 +106,7 @@ int main() {}
 
   CPMAddPackage(
       NAME rapidjson
-      URL https://github.com/Tencent/rapidjson/archive/805d7ed5dfe97a39b8b0816fd5eeed8731dc4936.zip
+      URL https://github.com/Tencent/rapidjson/archive/f54b0e47a08782a6131cc3d60f94d038fa6e0a51.zip
       DOWNLOAD_ONLY YES
   )
   add_library(rapidjson INTERFACE)

doc/basics_doxygen.md

@@ -1,8 +1,5 @@
 We take our documentation seriously. Please start reading the documentation before you attempt to use simdjson. We hope you will enjoy reading us.
 
-* [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
+* Basics: https://github.com/simdjson/simdjson/blob/master/doc/basics.md is an overview of how to use simdjson and its APIs.
-* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
+* iterate_many: https://github.com/simdjson/simdjson/blob/master/doc/iterate_many.md describes an interface providing features to work with files or streams containing multiple small JSON documents. As fast and convenient as possible.
-* [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
+* Performance: https://github.com/simdjson/simdjson/blob/master/doc/performance.md shows some more advanced scenarios and how to tune for them.
-* [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
-  how you can work with it.
-* [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.

doc/builder.md

@@ -1,366 +0,0 @@
-Builder
-==========
-
-Sometimes you want to generate JSON string outputs efficiently.
-The simdjson library provides high-performance low-level facilities.
-When using these low-level functionalities, you are responsible to
-define the structure of your JSON document. Our more advanced interface
-automates the process using C++26 static reflection: you get both high
-speed and high convenience.
-
-- [Builder](#builder)
-  * [Overview: string_builder](#overview--string-builder)
-  * [Example: string_builder](#example--string-builder)
-  * [C++26 static reflection](#c--26-static-reflection)
-    + [Without `string_buffer` instance](#without--string-buffer--instance)
-    + [Without `string_buffer` instance but with explicit error handling](#without--string-buffer--instance-but-with-explicit-error-handling)
-
-Overview: string_builder
----------------------------
-
-The string_builder class is a low-level utility for constructing JSON strings representing documents. It is optimized for performance, potentially leveraging kernel-specific features like SIMD instructions for tasks such as string escaping. This class supports atomic types (e.g., booleans, numbers, strings) but does not handle composed types directly (like arrays or objects).
-Note that JSON strings are always encoded as UTF-8.
-
-An `string_builder` is created with an initial buffer capacity (e.g., 1kB). The memory
-is reallocated when needed.
-The efficiency of `string_builder` stems from its internal use of a resizable array or buffer. When you append data, it adds the characters to this buffer, resizing it only when necessary, typically in a way that minimizes reallocations. This approach contrasts with regular string concatenation, where each operation creates a new string, copying all previous content, leading to quadratic time complexity for repeated concatenations.
-
-
-It has the following methods to add content to the string:
-
-
-- `append(number_type v)`: Appends a number (including booleans) to the JSON buffer. Booleans are converted to the strings "false" or "true". Numbers are formatted according to the JSON standard, with floating-point numbers using the shortest representation that accurately reflects the value.
-- `append(char c)`: Appends a single character to the JSON buffer.
-- `append_null()`: Appends the string "null" to the JSON buffer.
-- `clear()`: Clears the contents of the JSON buffer, resetting the position to 0 while retaining the allocated capacity.
-- `escape_and_append(std::string_view input)`: Appends a string view to the JSON buffer after escaping special characters (e.g., quotes, backslashes) as required by JSON.
-- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters. For constant strings, you may also do `escape_and_append_with_quotes<"mystring">()`.
-- `escape_and_append_with_quotes(char input)`: Appends a single character surrounded by double quotes (e.g., "c") to the JSON buffer after escaping it if necessary.
-- `append_raw(const char *c)`: Appends a null-terminated C string directly to the JSON buffer without escaping.
-- `append_raw(std::string_view input)`: Appends a string view directly to the JSON buffer without escaping.
-- `append_raw(const char *str, size_t len)`: Appends a specified number of characters from a C string directly to the JSON
-- `append_key_value(key,value)`: Appends a key and a value (`"json":somevalue`)
-- `append_key_value<"mykey">(value)`: Appends a key and a value (`"json":somevalue`), useful when the key is a compile-time constant (C++20).
-
-After writing the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
-
-- `validate_unicode()`: Checks if the content in the JSON buffer is valid UTF-8. Returns: true if the content is valid UTF-8, false otherwise.
-
-You might need to do unicode validation if you have strings in your data structures containing
-malformed UTF-8. Note that we do not automatically call `validate_unicode()`.
-
-Once you are satisfied, you can recover the string as follows:
-
-- `operator std::string()`: Converts the JSON buffer to an std::string. (Might throw if an error occurred.)
-- `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
-- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>` (C++20).
-
-The later method (`view()`) is recommended.  For performance reasons, we expect you to explicitly call `validate_unicode()` as needed (e.g., prior to calling `view()`).
-
-Example: string_builder
----------------------------
-
-```cpp
-struct Car {
-    std::string make;
-    std::string model;
-    int64_t year;
-    std::vector<double> tire_pressure;
-};
-
-void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
-    // start of JSON
-    builder.start_object();
-
-    // "make"
-    builder.append_key_value("make", car.make);
-    builder.append_comma();
-
-    // "model"
-    builder.append_key_value("model", car.model);
-    builder.append_comma();
-
-    // "year"
-    builder.append_key_value("year", car.year);
-    builder.append_comma();
-
-    // "tire_pressure"
-    builder.escape_and_append_with_quotes("tire_pressure");
-    builder.append_colon();
-    builder.start_array();
-    // vector tire_pressure
-    for (size_t i = 0; i < car.tire_pressure.size(); ++i) {
-        builder.append(car.tire_pressure[i]);
-        if (i < car.tire_pressure.size() - 1) {
-            builder.append_comma();
-        }
-    }
-    builder.end_array();
-    builder.end_object();
-}
-
-bool car_test() {
-    simdjson::builder::string_builder sb;
-    Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-    serialize_car(c, sb);
-    std::string_view p{sb};
-    // p holds the JSON:
-    // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
-    return true;
-}
-```
-
-
-
-
-The `string_builder` constructor takes an optional parameter which specifies the initial
-memory allocation in byte. If you know approximately the size of your JSON output, you can
-pass this value as a parameter (e.g., `simdjson::builder::string_builder sb{1233213}`).
-
-The `string_builder` might throw an exception in case of error when you cast it result to `std::string_view`. If you wish to avoid exceptions, you can use the following programming pattern:
-
-```cpp
-    std::string_view p;
-    if(sb.view().get(p)) {
-        return false; // there was an error
-    }
-```
-
-In all cases, the `std::string_view` instance depends the corresponding `string_builder` instance.
-
-### C++20
-
-
-
-If you have C++20, you can simplify the code, as the `std::vector<double>` is automatically supported. Further, we can pass the keys (which are compile-time
-constant) as template parameter (for improved performance).
-
-```cpp
-    Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-    simdjson::builder::string_builder sb;
-    sb.start_object();
-    sb.append_key_value<"make">(c.make);
-    sb.append_comma();
-    sb.append_key_value<"model">(c.model);
-    sb.append_comma();
-    sb.append_key_value<"year">(c.year);
-    sb.append_comma();
-    sb.append_key_value<"tire_pressure">(c.tire_pressure);
-    sb.end_object();
-    std::string_view p = sb.view();
-```
-
-With C++20, you can similarly handle standard containers transparently.
-For example, you can serialize `std::map<std::string,T>` types.
-
-```cpp
-    std::map<std::string,double> c = {{"key1", 1}, {"key2", 1}};
-    simdjson::builder::string_builder sb;
-    sb.append(c);
-    std::string_view p = sb.view();
-```
-
-You can also serialize `std::vector<T>` types.
-
-```cpp
-    std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
-    simdjson::builder::string_builder sb;
-    sb.append(c);
-    std::string_view p = sb.view();
-```
-
-You can also skip the creation for the `string_builder` instance in such simple cases.
-
-```cpp
-std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
-std::string json = simdjson::to_json(c);
-```
-
-We also have an overload for when you want to reuse the same `std::string` instance:
-
-
-```cpp
-std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
-std::string json;
-auto error = simdjson::to_json(c, json);
-if(error) { /* there was an error */ }
-```
-
-
-We do recommend that you create and reuse the `string_builder` instance for performance
-reasons.
-
-You can also add custom serialization functions using a `tag_invoke` function.
-For example, the following
-function will allow you to serialize instances of the type `Car`.
-
-```cpp
-#include <simdjson>
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<float> tire_pressure;
-};
-
-namespace simdjson {
-
-template <typename builder_type>
-void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
-  builder.start_object();
-  builder.append_key_value("make", car.make);
-  builder.append_comma();
-  builder.append_key_value("model", car.model);
-  builder.append_comma();
-  builder.append_key_value("year", car.year);
-  builder.append_comma();
-  builder.append_key_value("tire_pressure", car.tire_pressure);
-  builder.end_object();
-}
-
-} // namespace simdjson
-```
-
-C++26 static reflection
-------------------------
-
-Static reflection (or compile-time reflection) in C++26 introduces a powerful compile-time mechanism that allows a program to inspect and manipulate its own structure, such as types, variables, functions, and other program elements, during compilation. Unlike runtime reflection in languages like Java or Python, C++26’s static reflection operates entirely at compile time, aligning with C++’s emphasis on zero-overhead abstractions and high performance. It means
-that you can delegate much of the work to the library.
-If you have a compiler with support C++26 static reflection, you can compile
-your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
-
-```cpp
-#define SIMDJSON_STATIC_REFLECTION 1
-//...
-#include "simdjson.h"
-```
-
-And then you can append your data structures to a `string_builder` instance
-automatically. In most cases, it should work automatically:
-
-```cpp
-    struct Car {
-        std::string make;
-        std::string model;
-        int64_t year;
-        std::vector<double> tire_pressure;
-    };
-
-    bool car_test() {
-        simdjson::builder::string_builder sb;
-        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-        sb << c;
-        std::string_view p{sb};
-        // p holds the JSON:
-        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
-        return true;
-    }
-```
-
-
-### Without `string_buffer` instance
-
-In some instances, you might want to create a string directly from your own data type.
-You can create a string directly, without an explicit `string_builder` instance
-with the `simdjson::to_json` template function.
-(Under the hood a `string_builder` instance may still be created.)
-
-```cpp
-    struct Car {
-        std::string make;
-        std::string model;
-        int64_t year;
-        std::vector<double> tire_pressure;
-    };
-
-    void f() {
-        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-        std::string json = simdjson::to_json(c);
-    }
-```
-
-If you know the output size, in bytes, of your JSON string, you may
-pass it as a second parameter (e.g., `simdjson::to_json(c, 31123)`).
-
-Sometimes you may want to reuse the same `std::string` instance. We
-have an overload for this purpose:
-
-```cpp
-Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-std::string s;
-auto error = simdjson::to_json(c, s);
-if(error) { /* there was an error */ }
-```
-
-You can then also add a third parameter for the expected output size in bytes.
-
-### Extracting just some fields
-In some instances, your class might have many fields that you do not want to serialize.
-You can achieve this result with the `simdjson::extract_from` template. In the following
-example, we serialize only the `year` and `price` fields on the `Car` instance.
-```cpp
-struct Car {
-    std::string make;
-    std::string model;
-    int year;
-    double price;
-    bool electric;
-};
-Car car{"Ford", "F-150", 2024, 55000.0, false};
-// Extract year and price
-std::string json_result = simdjson::extract_from<"year", "price">(car);
-// Alternatively:
-// std::string json_result;
-// auto error =  extract_from<"year", "price">(car).get(json_result);
-// if(error) { /* error handling */ }
-```
-
-### Without `string_buffer` instance but with explicit error handling
-
-If prefer a version without exceptions and explicit error handling, you can use the following
-pattern:
-
-```cpp
-  std::string json;
-  if(simdjson::to_json(c).get(json)) {
-    // there was an error
-  } else {
-    // json contain the serialized JSON
-  }
-```
-
-### Customization
-
-If you want to serialize a value in a custome way, you can do it with a
-`tag_invoke` specialization like the following example which will map
-the year attribute to a string.
-
-
-```cpp
-#include <simdjson>
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<float> tire_pressure;
-};
-
-namespace simdjson {
-
-template <typename builder_type>
-void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
-  builder.start_object();
-  builder.append_key_value("make", car.make);
-  builder.append_comma();
-  builder.append_key_value("model", car.model);
-  builder.append_comma();
-  builder.append_key_value("year", std::to_string(car.year));
-  builder.append_comma();
-  builder.append_key_value("tire_pressure", car.tire_pressure);
-  builder.end_object();
-}
-
-} // namespace simdjson
-```

doc/compile_time.md

@@ -1,164 +0,0 @@
-# Parse json at compile time
-   * [Introduction](#introduction)
-   * [Example](#example)
-   * [Loading from disk](#loading-from-disk)
-   * [Limitations (compile-time errors)](#limitations-compile-time-errors)
-
-
-## Introduction
-In some instances, you may want to configure your software at compile-time with a JSON document.
-Maybe you have a single code base but many different possible configurations, all resulting in
-different software. For example, you might be programming robots, using the same software, but
-different robot configurations.
-
-To achieve the desired result, you have a few options. You may start the software and parser a
-JSON file at runtime. Or you might convert your JSON data into C++ code that you can compile with
-your software.
-
-With C++26, there is another way: parse the JSON file along with your C++ code. In this manner,
-the JSON data becomes native C++ data.
-
-The simdjson library supports parsing JSON documents at compile time if you have C++26 support. To
-activate C++26 reflection support, you can compile
-your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
-
-```cpp
-#define SIMDJSON_STATIC_REFLECTION 1
-//...
-#include "simdjson.h"
-```
-
-The `simdjson::compile_time::parse_json` function parses a JSON document at **compile time** and returns a `constexpr` structure reflecting its content. We support the full range of JSON values, which are mapped to C++ types as in
-the following table.
-
-
-| JSON type      | C++ type                         |
-|----------------|----------------------------------|
-| object         | anonymous struct                 |
-| array          | `std::array<T, N>` (homogeneous) |
-| string         | `const char*` (UTF-8)            |
-| number         | `int64_t`, `uint64_t`, `double`  |
-| `true`/`false` | `bool`                           |
-| `null`         | `std::nullptr_t`                 |
-
-## Example
-
-Suppose you want to parse the following JSON document:
-
-```cpp
-{
-    "port": 8080,
-    "host": "localhost",
-    "debug": true
-}
-```
-
-**Reminder**: In C++, `R"( )"` allows us to write multi-line strings with unescaped quotes.
-
-
-You can do so, at compile-time, as follows:
-
-
-```cpp
-constexpr auto cfg = R"(
-
-{
-    "port": 8080,
-    "host": "localhost",
-    "debug": true
-}
-
-)"_json;
-
-// cfg.port == 8080
-// std::string_view(cfg.host) == "localhost"
-// cfg.debug == true
-```
-
-You can nest objects and arrays:
-
-```cpp
-constexpr auto data = R"(
-
-{
-    "servers": [
-        {"host": "s1", "port": 3000},
-        {"host": "s2", "port": 3001}
-    ]
-}
-
-)"_json;
-
-
-// data.servers.size() == 2
-// std::string_view(data.servers[0].host) == "s1"
-```
-
-Top-level arrays are allowed:
-
-```cpp
-constexpr auto arr = R"(
-
-[1, 2, 3]
-
-)"_json;
-static_assert(arr.size() == 3);
-static_assert(arr[1] == 2);
-```
-
-## Loading from disk
-
-In practice, you may have a JSON file, say `json_data` that you want to parse
-at compile time. You may do so as follows.
-
-```c++
-constexpr const char json_data[] = {
-    #embed "test.json"
-    , 0
-};
-
-constexpr auto json = simdjson::compile_time::parse_json<json_data>();
-```
-
-
-## Limitations (compile-time errors)
-
-We have a few limitations which trigger compile-time errors if violated.
-
-
-- Only JSON objects and arrays are supported at the top level (no primitives).
-  We will lift this limitation in the future.
-- Strings are represented using the `const char*` in UTF-8, but they must not
-  contain embedded nulls. We would prefer to represent them as std::string or
-  std::string_view, and hope to do so in the future.
-- Heterogeneous arrays are not supported yet. E.g., you need to have arrays of
-  all integers, or all strings, all floats, all compatible objects, etc.
-  For example, the following is accepted:
-  ```json
-   [
-    { "name": "Alice", "age": 30 },
-    { "name": "Bob", "age": 25 },
-    { "name": "Charlie", "age": 35 }
-  ]
-  ```
-  but the following is not:
-  ```json
-  [
-    { "name": "Alice", "age": 30 },
-    "Just a string",
-    42,
-    { "name": "Charlie", "age": 35 }
-  ]
-  ```
-  We may support heterogeneous arrays in the future with std::variant types.
-- We parse the first JSON document encountered in the string. Trailing
-  characters are ignored. Thus if your JSON begins with {"a":1}, everything
-  after the closing brace is ignored. This limitation will be lifted in the future,
-  reporting an error.
-
-These limitations are safe in the sense that they result in compile-time errors.
-Thus you will not get truncated strings or imprecise floats silently.
-
-
-Although we are committed to maintaining the functionality in the long run, the
-`compile_time::parse_json` function is subject to change.

doc/compile_time_accessors.md

@@ -1,445 +0,0 @@
-# Compile-Time JSONPath and JSON Pointer Accessors
-
-**Note:** This feature requires C++26 Static Reflection support (P2996) and is currently only available with experimental compilers. You must enable it with `-DSIMDJSON_STATIC_REFLECTION=ON` when building.
-
-## Overview
-
-simdjson provides compile-time JSONPath and JSON Pointer accessors that validate paths against struct definitions at compile time and generate optimized accessor code with zero runtime overhead. This combines the safety of compile-time type checking with the performance of pre-parsed, pre-validated access paths.
-
-## Requirements
-
-- C++26 compiler with Static Reflection support (P2996)
-- Experimental compiler flags:
-  - Clang with P2996 support: `-std=c++26 -freflection -fexpansion-statements`
-- Build configuration: `-DSIMDJSON_STATIC_REFLECTION=ON`
-
-## How It Works
-
-**Compile Time:**
-1. Path string is parsed and converted to access steps
-2. Path is validated against struct definition using reflection
-3. Field types are checked and verified
-4. Optimized accessor code is generated
-
-**Runtime:**
-- Direct navigation with no parsing
-- No validation overhead
-- No string comparisons for path components
-- Type-safe extraction
-
-## Two Usage Modes
-
-### Mode 1: With Type Validation (Recommended)
-
-When you provide a struct type, the compiler validates the entire path at compile time:
-
-```cpp
-struct User {
-  std::string name;
-  int age;
-  std::vector<std::string> emails;
-};
-
-//  R"( ... )" is a C++ raw string literal.
-const padded_string json = R"({
-  "name": "Alice",
-  "age": 30,
-  "emails": ["alice@example.com", "alice@work.com"]
-})"_padded;
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-
-// Compile-time validation: checks that User has "name" field of type std::string
-std::string name;
-auto result = ondemand::json_path::at_path_compiled<User, ".name">(doc);
-result.get(name); // name = "Alice"
-
-// Compile-time validation: checks that "emails" is array-like with string elements
-std::string email;
-result = ondemand::json_path::at_path_compiled<User, ".emails[0]">(doc);
-result.get(email); // email = "alice@example.com"
-```
-
-**Benefits:**
-- **Compile-time errors** if path doesn't exist in struct
-- **Type safety** - verifies field types match expected types
-- **Refactoring protection** - renaming struct fields causes compile errors
-
-**What gets validated:**
-- Field existence
-- Field types
-- Array/container access validity
-- Nested struct navigation
-
-### Mode 2: Without Validation
-
-When you omit the struct type, the path is parsed at compile time but not validated:
-
-```cpp
-const padded_string json = R"({
-  "name": "Alice",
-  "age": 30,
-  "address": {"city": "Boston"}
-})"_padded;
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-
-// No compile-time validation - path is only parsed
-std::string name;
-auto result = ondemand::json_path::at_path_compiled<".name">(doc);
-result.get(name); // name = "Alice"
-
-std::string_view city;
-result = ondemand::json_path::at_path_compiled<".address.city">(doc);
-result.get(city); // city = "Boston"
-```
-
-**Benefits:**
-- Works with dynamic/unknown JSON structures
-- Still benefits from compile-time path parsing
-- No runtime string parsing overhead
-
-**Use when:**
-- JSON structure is not known at compile time
-- Working with varied JSON schemas
-- Prototyping or exploratory parsing
-
-## JSONPath Syntax
-
-JSONPath uses dot notation and bracket notation for field access:
-
-### Supported Syntax
-
-| Syntax | Description | Example |
-|--------|-------------|---------|
-| `.field` | Dot notation for field access | `.name`, `.address.city` |
-| `["field"]` | Bracket notation with quotes | `["name"]`, `["address"]["city"]` |
-| `[index]` | Array index access | `[0]`, `[1]` |
-| Mixed | Combination of notations | `.emails[0]`, `["users"][0].name` |
-| `$` prefix | Optional root indicator | `$.name`, `$["name"]` |
-
-### Examples
-
-```cpp
-struct Address {
-  std::string city;
-  int zip;
-};
-
-struct Person {
-  std::string name;
-  int age;
-  Address address;
-  std::vector<std::string> emails;
-};
-
-// Dot notation
-at_path_compiled<Person, ".name">(doc)
-at_path_compiled<Person, ".address.city">(doc)
-
-// Bracket notation
-at_path_compiled<Person, "[\"name\"]">(doc)
-at_path_compiled<Person, "[\"address\"][\"city\"]">(doc)
-
-// Array access
-at_path_compiled<Person, ".emails[0]">(doc)
-at_path_compiled<Person, ".emails[1]">(doc)
-
-// Mixed notation
-at_path_compiled<Person, ".address[\"zip\"]">(doc)
-at_path_compiled<Person, "[\"emails\"][0]">(doc)
-
-// With root indicator
-at_path_compiled<Person, "$.name">(doc)
-at_path_compiled<Person, "$.address.city">(doc)
-```
-
-## JSON Pointer Syntax
-
-JSON Pointer (RFC 6901) uses slash-separated paths:
-
-### Supported Syntax
-
-| Syntax | Description | Example |
-|--------|-------------|---------|
-| `/field` | Field access | `/name`, `/address/city` |
-| `/index` | Array index | `/0`, `/1` |
-| `~0` | Escaped `~` | `/field~0name` → field~name |
-| `~1` | Escaped `/` | `/field~1name` → field/name |
-
-### Examples
-
-```cpp
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<double> tire_pressure;
-};
-
-// Field access
-at_pointer_compiled<Car, "/make">(doc)
-at_pointer_compiled<Car, "/model">(doc)
-
-// Array access
-at_pointer_compiled<Car, "/tire_pressure/0">(doc)
-at_pointer_compiled<Car, "/tire_pressure/1">(doc)
-
-// Root pointer (returns whole document)
-at_pointer_compiled<Car, "">(doc)
-at_pointer_compiled<Car, "/">(doc)
-```
-
-## API Reference
-
-### JSONPath Functions
-
-```cpp
-// With type validation
-template<typename T, constevalutil::fixed_string Path, typename DocOrValue>
-simdjson_result<value> at_path_compiled(DocOrValue& doc_or_val);
-
-// Without validation
-template<constevalutil::fixed_string Path, typename DocOrValue>
-simdjson_result<value> at_path_compiled(DocOrValue& doc_or_val);
-```
-
-### JSON Pointer Functions
-
-```cpp
-// With type validation
-template<typename T, constevalutil::fixed_string Pointer, typename DocOrValue>
-simdjson_result<value> at_pointer_compiled(DocOrValue& doc_or_val);
-
-// Without validation
-template<constevalutil::fixed_string Pointer, typename DocOrValue>
-simdjson_result<value> at_pointer_compiled(DocOrValue& doc_or_val);
-```
-
-### Direct Field Extraction
-
-Extract values directly into variables with compile-time type checking:
-
-```cpp
-// JSONPath
-template<typename T, constevalutil::fixed_string Path>
-struct path_accessor {
-  template<typename DocOrValue, typename FieldType>
-  static error_code extract_field(DocOrValue& doc_or_val, FieldType& target);
-};
-
-// JSON Pointer
-template<typename T, constevalutil::fixed_string Pointer>
-struct pointer_accessor {
-  template<typename DocOrValue, typename FieldType>
-  static error_code extract_field(DocOrValue& doc_or_val, FieldType& target);
-};
-```
-
-**Example:**
-
-```cpp
-struct User {
-  std::string name;
-  int age;
-};
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-
-// Extract directly into variable
-std::string name;
-ondemand::json_path::path_accessor<User, ".name">::extract_field(doc, name);
-
-int age;
-ondemand::json_path::pointer_accessor<User, "/age">::extract_field(doc, age);
-```
-
-The compiler verifies that the target variable type matches the field type at the path.
-
-## Complete Examples
-
-### Example 1: Validated Access
-
-```cpp
-#include "simdjson.h"
-using namespace simdjson;
-
-struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<double> tire_pressure;
-};
-
-int main() {
-  const padded_string json = R"({
-    "make": "Toyota",
-    "model": "Camry",
-    "year": 2018,
-    "tire_pressure": [40.1, 39.9, 37.7, 40.4]
-  })"_padded;
-
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // Type-validated access
-  std::string make;
-  auto result = ondemand::json_path::at_path_compiled<Car, ".make">(doc);
-  result.get(make); // make = "Toyota"
-
-  // Array access with validation
-  double pressure;
-  result = ondemand::json_path::at_path_compiled<Car, ".tire_pressure[1]">(doc);
-  result.get(pressure); // pressure = 39.9
-
-  return 0;
-}
-```
-
-### Example 2: Non-Validated Access
-
-```cpp
-#include "simdjson.h"
-using namespace simdjson;
-
-int main() {
-  const padded_string json = R"({
-    "user": {
-      "name": "Alice",
-      "preferences": {
-        "theme": "dark",
-        "notifications": true
-      }
-    }
-  })"_padded;
-
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // No validation - works with any JSON structure
-  std::string_view theme;
-  auto result = ondemand::json_path::at_path_compiled<".user.preferences.theme">(doc);
-  result.get(theme); // theme = "dark"
-
-  bool notifications;
-  result = ondemand::json_path::at_path_compiled<".user.preferences.notifications">(doc);
-  result.get(notifications); // notifications = true
-
-  return 0;
-}
-```
-
-### Example 3: Direct Extraction
-
-```cpp
-#include "simdjson.h"
-using namespace simdjson;
-
-struct Person {
-  std::string name;
-  int age;
-  std::vector<std::string> emails;
-};
-
-int main() {
-  const padded_string json = R"({
-    "name": "Bob",
-    "age": 25,
-    "emails": ["bob@example.com", "bob@work.com"]
-  })"_padded;
-
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // Extract with type validation
-  std::string name;
-  ondemand::json_path::path_accessor<Person, ".name">::extract_field(doc, name);
-  // name = "Bob"
-
-  int age;
-  ondemand::json_path::pointer_accessor<Person, "/age">::extract_field(doc, age);
-  // age = 25
-
-  std::string email;
-  ondemand::json_path::path_accessor<Person, ".emails[0]">::extract_field(doc, email);
-  // email = "bob@example.com"
-
-  return 0;
-}
-```
-
-## Error Handling
-
-Compile-time errors occur when:
-- Path doesn't exist in struct: `static_assert` failure
-- Field type mismatch: `static_assert` failure
-- Invalid array access on non-array field: `static_assert` failure
-
-Runtime errors occur when:
-- JSON structure doesn't match expected structure
-- Array index out of bounds
-- Type conversion failures
-
-```cpp
-struct User {
-  std::string name;
-  int age;
-};
-
-// Compile-time error: no "email" field in User
-// auto result = ondemand::json_path::at_path_compiled<User, ".email">(doc);
-
-// Compile-time error: age is not an array
-// auto result = ondemand::json_path::at_path_compiled<User, ".age[0]">(doc);
-
-// Runtime error if JSON doesn't have "name" field
-auto result = ondemand::json_path::at_path_compiled<User, ".name">(doc);
-std::string name;
-if (result.get(name) != SUCCESS) {
-  // Handle error
-}
-```
-
-## Performance
-
-Compile-time accessors provide:
-- **Zero path parsing overhead** - paths parsed at compile time
-- **Zero validation overhead** - validation done at compile time
-- **Direct field access** - no runtime path traversal
-- **Type-safe extraction** - no dynamic type checking
-
-Compared to runtime `at_path()` and `at_pointer()`:
-- Eliminates runtime path string parsing
-- Eliminates runtime path validation
-- Generates optimal code path directly
-
-## Limitations
-
-- Requires C++26 compiler with P2996 support (experimental)
-- Paths must be compile-time constants (string literals)
-- Cannot use runtime-computed paths
-- Limited to struct types that support reflection
-- Array indices must be compile-time constants in the path
-
-## When to Use
-
-**Use compile-time accessors when:**
-- You have well-defined struct types
-- JSON structure is known at compile time
-- You want maximum type safety
-- Performance is critical
-
-**Use runtime `at_path()`/`at_pointer()` when:**
-- JSON structure varies or is unknown
-- Paths are computed at runtime
-- Working with C++20 or earlier
-- Flexibility is more important than compile-time checks
-
-## See Also
-
-- [JSON Pointer](basics.md#json-pointer) - Runtime JSON Pointer support
-- [JSONPath](basics.md#jsonpath) - Runtime JSONPath support
-- [Static Reflection for Deserialization](basics.md#3-using-static-reflection-c26) - Using reflection for full struct deserialization

doc/dom.md

@@ -1,10 +1,7 @@
 The Document-Object-Model (DOM) front-end
 ==========
 
-An overview of what you need to know to use simdjson to parse JSON documents with
+An overview of what you need to know to use simdjson, with examples.
-our DOM API, with examples. [Our documentation regarding the generation (serialization) of JSON documents is in a
-separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.md).
-
 
 * [DOM vs On-Demand](#dom-vs-on-demand)
 * [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents-using-the-dom-front-end)
@@ -31,17 +28,13 @@ a conventional Document-Object-Model (DOM) front-end. In such a scenario, the JS
 entirely parsed, validated and materialized in memory as the first step. The programmer may
 then access the parsed data using this in-memory model.
 
-On-Demand is a different model where you parse just what you need, directly into your own
-data structure. The On-Demand approach, when well tuned, can provide superior performance.
-[We refer you to the On-Demand documentation for further details](https://github.com/simdjson/simdjson/blob/master/doc/basics.md).
-
 The Basics: Loading and Parsing JSON Documents using the DOM front-end
 ----------------------------------------------
 
 The simdjson library offers a simple DOM tree API, which you can access by creating a
 `dom::parser` and calling the `load()` method:
 
-```cpp
+```c++
 dom::parser parser;
 dom::element doc = parser.load(filename); // load and parse a file
 ```
@@ -49,21 +42,21 @@ dom::element doc = parser.load(filename); // load and parse a file
 Or by creating a padded string (for efficiency reasons, simdjson requires a string with
 SIMDJSON_PADDING bytes at the end) and calling `parse()`:
 
-```cpp
+```c++
 dom::parser parser;
 dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string, the _padded suffix creates a simdjson::padded_string instance
 ```
 
 You can copy your data directly on a `simdjson::padded_string` as follows:
 
-```cpp
+```c++
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
 Or as follows...
 
-```cpp
+```c++
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
@@ -83,7 +76,7 @@ container-overflow checks, you may encounter sanitizer warnings.
 You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
 string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
 
-```cpp
+```c++
 std::string json = "[1]";
 dom::element doc = parser.parse(simdjson::pad(json));
 ```
@@ -117,9 +110,8 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   dom::object and dom::array. An exception (`simdjson::simdjson_error`) is thrown if the cast is not possible.
 * **Extracting Values (without exceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`, `std::string_view`,
   `dom::object` and `dom::array`) and pass it by reference to `get()` which gives you back an error code: e.g.,
-  ```cpp
+  ```c++
   simdjson::error_code error;
-  // _padded returns an simdjson::padded_string instance
   simdjson::padded_string numberstring = "1.2"_padded; // our JSON input ("1.2")
   simdjson::dom::parser parser;
   double value; // variable where we store the value to be parsed
@@ -130,7 +122,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   The strings contain unescaped valid UTF-8 strings: no unmatched surrogate is allowed.
   Internally, numbers are stored as either 64-bit integers or 64-bit floating-point numbers.
   Thus it is possible to get the full 64-bit integer range (either signed or  unsigned).
-  By default, the string `-0` is parsed as the integer 0 as in Python or C++. If you set the macro
+  By default, the string `-0` is parsed as the integer 0 as in Pytho or C++. If you set the macro
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
   as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
@@ -153,8 +145,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 
 The following code illustrates all of the above:
 
-```cpp
+```c++
-//  R"( ... )" is a C++ raw string literal.
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -187,7 +178,7 @@ for (dom::object car : parser.parse(cars_json)) {
 
 Here is a different example illustrating the same ideas:
 
-```cpp
+```C++
 auto abstract_json = R"( [
     {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
     {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
@@ -209,7 +200,7 @@ for (dom::object obj : parser.parse(abstract_json)) {
 And another one:
 
 
-```cpp
+```C++
   auto abstract_json = R"(
     {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
   dom::parser parser;
@@ -223,7 +214,7 @@ C++17 Support
 
 While the simdjson library can be used in any project using C++ 11 and above, field iteration has special support C++ 17's destructuring syntax. For example:
 
-```cpp
+```c++
 padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
 dom::parser parser;
 dom::object object; // invalid until the get() succeeds
@@ -236,7 +227,7 @@ for (auto [key, value] : object) {
 
 For comparison, here is the C++ 11 version of the same code:
 
-```cpp
+```c++
 // C++ 11 version for comparison
 padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
 dom::parser parser;
@@ -253,7 +244,7 @@ C++20 Support
 
 simdjson library also supports some C++20 feature including `std::ranges`:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -272,7 +263,7 @@ JSON Pointer
 The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the
 `at_pointer()` method, letting you reach further down into the document in a single call:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -293,7 +284,7 @@ You can apply a JSON Pointer expression to any node and the path gets interprete
 
 Consider the following example:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -315,11 +306,11 @@ JSONPath
 ------------
 
 
-The simdjson library supports a subset of [JSONPath](https://www.rfc-editor.org/rfc/rfc9535) (RFC 9535) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
 
 Consider the following example:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -338,7 +329,7 @@ cout << p << endl; // Prints 39.9
 
 We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
 
-```cpp
+```c++
 auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
 dom::parser parser;
 dom::element doc;
@@ -356,81 +347,13 @@ if(error) { /*won't happen*/ }
 ```
 
 
-## Using `at_path_with_wildcard` for JSONPath Queries
-
-The `at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. This allows users to retrieve multiple elements from a JSON document in a single query. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
-
-The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level.  You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the function returns an empty result. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield an empty set.
-
-### Example Usage
-
-Here is an example demonstrating the use of `at_path_with_wildcard`:
-
-```cpp
-simdjson::padded_string json_string = R"(
-{
-  "firstName": "John",
-  "lastName": "doe",
-  "age": 26,
-  "address": {
-    "streetAddress": "naist street",
-    "city": "Nara",
-    "postalCode": "630-0192"
-  },
-  "phoneNumbers": [
-    {
-      "type": "iPhone",
-      "numbers": ["0123-4567-8888", "0123-4567-8788"]
-    },
-    {
-      "type": "home",
-      "numbers": ["0123-4567-8910"]
-    }
-  ]
-})"_padded;
-
-dom::parser parser;
-dom::element parsed_json = parser.parse(json_string);
-std::vector<dom::element> values;
-
-// Fetch all fields in the address object
-auto error = parsed_json.at_path_with_wildcard("$.address.*").get(values);
-if(error) {
-  // do something
-}
-for (auto &value : values) {
-  std::string_view field;
-  error = value.get(field);
-  if(error) {
-    // do something
-  }
-  std::cout << field << std::endl;
-}
-
-// Fetch all phone numbers
-error = parsed_json.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values);
-if(error) {
-  // do something
-}
-for (auto &value : values) {
-  std::string_view number;
-  error = value.get(number);
-  if(error) {
-    // do something
-  }
-  std::cout << number << std::endl;
-}
-```
-
-This function is particularly useful for extracting data from complex JSON structures with nested arrays and objects. By leveraging wildcards, you can simplify your queries and reduce the need for multiple iterations.
-
 Error Handling
 --------------
 
 All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
 pair. You can retrieve the value with .get(), like so:
 
-```cpp
+```c++
 dom::element doc;
 auto error = parser.parse(json).get(doc);
 if (error) { cerr << error << endl; exit(1); }
@@ -464,7 +387,7 @@ We can write a "quick start" example where we attempt to parse the following JSO
 Our program loads the file, selects value corresponding to key "search_metadata" which expected to be an object, and then
 it selects the key "count" within that object.
 
-```cpp
+```C++
 #include <iostream>
 #include "simdjson.h"
 
@@ -492,7 +415,7 @@ triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break t
 
 Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
 
-```cpp
+```C++
 #include <iostream>
 #include "simdjson.h"
 
@@ -516,7 +439,7 @@ over the content of an array.
 
 This is how the example in "Using the Parsed JSON" could be written using only error code checking:
 
-```cpp
+```c++
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -563,7 +486,7 @@ for (dom::element car_element : cars) {
 
 Here is another example:
 
-```cpp
+```C++
 auto abstract_json = R"( [
     {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
     {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
@@ -596,7 +519,7 @@ for (dom::element elem : array) {
 
 And another one:
 
-```cpp
+```C++
   auto abstract_json = R"(
     {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
   dom::parser parser;
@@ -610,7 +533,7 @@ Notice how we can string several operations (`parser.parse(abstract_json)["str"]
 
 The next two functions will take as input a JSON document containing an array with a single element, either a string or a number. They return true upon success.
 
-```cpp
+```C++
 simdjson::dom::parser parser{};
 
 bool parse_double(const char *j, double &d) {
@@ -642,7 +565,7 @@ target_compile_definitions(simdjson PUBLIC SIMDJSON_EXCEPTIONS=OFF)
 
 Users more comfortable with an exception flow may choose to directly cast the `simdjson_result<T>` to the desired type:
 
-```cpp
+```c++
 dom::element doc = parser.parse(json); // Throws an exception if there was an error!
 ```
 
@@ -652,7 +575,7 @@ program from continuing if there was an error.
 
 If one is willing to trigger exceptions, it is possible to write simpler code:
 
-```cpp
+```C++
 #include <iostream>
 #include "simdjson.h"
 
@@ -673,7 +596,7 @@ inspect or walk over JSON elements. To do that, you can use iterators and the ty
 example, here's a quick and dirty recursive function that verbosely prints the JSON document as JSON
 (* ignoring nuances like trailing commas and escaping strings, for brevity's sake):
 
-```cpp
+```c++
 void print_json(dom::element element) {
   switch (element.type()) {
     case dom::element_type::ARRAY:
@@ -729,7 +652,7 @@ and reuse it. The simdjson library will allocate and retain internal buffers bet
 buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
 you can parse terabytes of JSON data without doing any new allocation.
 
-```cpp
+```c++
 dom::parser parser;
 
 // This initializes buffers and a document big enough to handle this JSON.
@@ -772,7 +695,7 @@ without bound:
 
 * You can set a *max capacity* when constructing a parser:
 
-  ```cpp
+  ```c++
   dom::parser parser(1000*1000); // Never grow past documents > 1MB
   for (web_request request : listen()) {
     dom::element doc;
@@ -788,7 +711,7 @@ without bound:
 * You can set a *fixed capacity* that never grows, as well, which can be excellent for
   predictability and reliability, since simdjson will never call malloc after startup!
 
-  ```cpp
+  ```c++
   dom::parser parser(0); // This parser will refuse to automatically grow capacity
   auto error = parser.allocate(1000*1000); // This allocates enough capacity to handle documents <= 1MB
   if (error) { cerr << error << endl; exit(1); }
@@ -819,7 +742,7 @@ When calling `parser.parse` on a pointer (e.g., `parser.parse(my_char_pointer, m
 Some users may not be able use our `padded_string` class or to load the data directly from disk (`parser.load`). They may need to pass data pointers to the library.  If these users wish to avoid temporary copies and corresponding temporary memory allocations, they may want to call `parser.parse` with the `realloc_if_needed` parameter set to false (e.g., `parser.parse(my_char_pointer, my_length_in_bytes, false)`). In such cases, they need to ensure that there are at least SIMDJSON_PADDING extra bytes at the end that can be safely accessed and read. They do not need to initialize the padded bytes to any value in particular. The following example is safe:
 
 
-```cpp
+```C++
 const char *json      = R"({"key":"value"})";
 const size_t json_len = std::strlen(json);
 std::unique_ptr<char[]> padded_json_copy{new char[json_len + SIMDJSON_PADDING]};

doc/implementation-selection.md

@@ -55,7 +55,7 @@ Inspecting the Detected Implementation
 
 You can check what implementation is running with `active_implementation`:
 
-```cpp
+```c++
 cout << "simdjson v" << SIMDJSON_VERSION << endl;
 cout << "Detected the best implementation for your machine: " << simdjson::get_active_implementation()->name();
 cout << "(" << simdjson::get_active_implementation()->description() << ")" << endl;
@@ -68,7 +68,7 @@ Querying Available Implementations
 
 You can list all available implementations, regardless of which one was selected:
 
-```cpp
+```c++
 for (auto implementation : simdjson::get_available_implementations()) {
   cout << implementation->name() << ": " << implementation->description() << endl;
 }
@@ -76,7 +76,7 @@ for (auto implementation : simdjson::get_available_implementations()) {
 
 And look them up by name:
 
-```cpp
+```c++
 cout << simdjson::get_available_implementations()["fallback"]->description() << endl;
 ```
 When an implementation is not available, the bracket call `simdjson::get_available_implementations()[name]`
@@ -93,7 +93,7 @@ Manually Selecting the Implementation
 If you're trying to do performance tests or see how different implementations of simdjson run, you
 can select the CPU architecture yourself:
 
-```cpp
+```c++
 // Use the fallback implementation, even though my machine is fast enough for anything
 simdjson::get_active_implementation() = simdjson::get_available_implementations()["fallback"];
 ```
@@ -102,7 +102,7 @@ You are responsible for ensuring that the requirements of the selected implement
 Furthermore, you should check that the implementation is available before setting it to `simdjson::get_active_implementation()`
 by comparing it with the null pointer.
 
-```cpp
+```c++
 auto my_implementation = simdjson::get_available_implementations()["haswell"];
 if (! my_implementation) { exit(1); }
 if (! my_implementation->supported_by_runtime_system()) { exit(1); }
@@ -114,7 +114,7 @@ Checking that an Implementation can Run on your System
 
 You should call `supported_by_runtime_system()` to compare the processor's features with the need of the implementation.
 
-```cpp
+```c++
 for (auto implementation : simdjson::get_available_implementations()) {
   if (implementation->supported_by_runtime_system()) {
     cout << implementation->name() << ": " << implementation->description() << endl;

doc/iterate_many.md

@@ -132,7 +132,7 @@ E.g., `[1,2]{"32":1}` is recognized as two documents.
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -140,10 +140,8 @@ API
 
 Example:
 
-```cpp
+```c++
-//  R"( ... )" is a C++ raw string literal.
 auto json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )"_padded;
-// _padded returns an simdjson::padded_string instance
 ondemand::parser parser;
 ondemand::document_stream docs = parser.iterate_many(json);
 for (auto doc : docs) {
@@ -199,7 +197,7 @@ and `error()` to check if there were any error.
 Let us illustrate the idea with code:
 
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
@@ -240,7 +238,7 @@ Some users may need to work with truncated streams. The simdjson may truncate do
 
 Consider the following example where a truncated document (`{"key":"intentionally unclosed string  `) containing 39 bytes has been left within the stream. In such cases, the first two whole documents are parsed and returned, and the `truncated_bytes()` method returns 39.
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} {"key":"intentionally unclosed string  )"_padded;
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
@@ -269,7 +267,7 @@ is effectively ignored, as it is set to at least the document size.
 
 Example:
 
-```cpp
+```C++
     auto json = R"( 1, 2, 3, 4, "a", "b", "c", {"hello": "world"} , [1, 2, 3])"_padded;
     ondemand::parser parser;
     ondemand::document_stream doc_stream;
@@ -311,12 +309,12 @@ The first argument is usually a tag type (often an empty struct) that uniquely i
 
 
 You can deserialize you own data structures conveniently if your system supports C++20.
-When it is the case, the macro `SIMDJSON_SUPPORTS_CONCEPTS` will be set to 1 by
+When it is the case, the macro `SIMDJSON_SUPPORTS_DESERIALIZATION` will be set to 1 by
 the simdjson library.
 
 Consider a custom class `Car`:
 
-```cpp
+```C++
 struct Car {
   std::string make;
   std::string model;
@@ -330,7 +328,7 @@ You may support deserializing directly from a JSON value or document to your own
 by defining a single `tag_invoke` function:
 
 
-```cpp
+```C++
 namespace simdjson {
 // This tag_invoke MUST be inside simdjson namespace
 template <typename simdjson_value>
@@ -372,7 +370,7 @@ tag_invoke functions.
 Given a stream of JSON documents, you can add them to a data structure
 such as a `std::vector<Car>` like so if you support exceptions:
 
-```cpp
+```C++
   padded_string json =
       R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] }
@@ -393,7 +391,7 @@ such as a `std::vector<Car>` like so if you support exceptions:
 Otherwise you may use this longer version for explicit handling of errors:
 
 
-```cpp
+```C++
   std::vector<Car> cars;
   for(auto doc : stream) {
     Car c;

doc/ondemand_design.md

@@ -23,7 +23,7 @@ applications with a computation efficiency that is difficult to surpass.
 
 A code example illustrates our API from a programmer's point of view:
 
-```cpp
+```c++
 ondemand::parser parser;
 auto doc = parser.iterate(json);
 for (auto tweet : doc["statuses"]) {
@@ -109,7 +109,7 @@ The DOM approach was the only way to parse JSON documents up to version 0.6 of t
 Our DOM API looks similar to our On-Demand example, except
 it calls `parse` instead of `iterate`:
 
-```cpp
+```c++
 dom::parser parser;
 auto doc = parser.parse(json);
 for (auto tweet : doc["statuses"]) {
@@ -157,7 +157,7 @@ examples. To make it short enough to use as an example at all, it has heavily re
 a part of the problem (does not get user.screen_name), it has bugs (it does not handle sub-objects
 in a tweet at all), and it uses a theoretical, simple event-based API that minimizes ceremony.
 
-```cpp
+```c++
 struct twitter_callbacks {
   bool in_statuses;
   bool in_tweet;
@@ -284,14 +284,14 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    This declaration does not allocate any memory; that will happen in the next step.
 
-   ```cpp
+   ```c++
    ondemand::parser parser;
    ```
 
 2. We then start iterating the JSON document by allocating internal parser buffers, preprocessing
    the JSON, and initializing the iterator.
 
-   ```cpp
+   ```c++
    auto doc = parser.iterate(json);
    ```
 
@@ -337,14 +337,14 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 3. We iterate over the "statuses" field using a typical C++ iterator, reading past the initial
    `{ "statuses": [ {`.
 
-   ```cpp
+   ```c++
    for (ondemand::object tweet : doc["statuses"]) {
    ```
 
    This shorthand does a lot, and it is helpful to see what it expands to.
    Comments in front of each one explain what's going on:
 
-   ```cpp
+   ```c++
    // Validate that the top-level value is an object: check for {. Increase depth to 2 (root > field).
    ondemand::object top = doc.get_object();
 
@@ -396,7 +396,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 4. We get the `"text"` field as a string.
 
-   ```cpp
+   ```c++
    std::string_view text        = tweet["text"];
    ```
 
@@ -435,7 +435,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 4. We get the `"screen_name"` from the `"user"` object.
 
-   ```cpp
+   ```c++
       ondemand::object user        = tweet["user"];
       screen_name                  = user["screen_name"];
    ```
@@ -469,7 +469,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 5. We get `"retweet_count"` as an unsigned integer.
 
-   ```cpp
+   ```c++
    uint64_t         retweets    = tweet["retweet_count"];
    ```
 
@@ -513,7 +513,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 6. We loop to the next tweet.
 
-   ```cpp
+   ```c++
    for (ondemand::object tweet : doc["statuses"]) {
      ...
    }
@@ -521,7 +521,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    The relevant parts of the loop  are:
 
-   ```cpp
+   ```c++
    while (iter != statuses.end()) {
      ondemand::object tweet = *iter;
      ...
@@ -566,7 +566,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 8. The loop ends. Recall the relevant parts of the statuses loop:
 
-   ```cpp
+   ```c++
    while (iter != statuses.end()) {
      ondemand::object tweet = *iter;
      ...
@@ -610,7 +610,7 @@ When the user requests strings, we unescape them to a single string buffer much
 so that users enjoy the same string performance as the core simdjson. We do not write the length to the
 string buffer, however; that is stored in the `string_view` instance we return to the user.
 
-```cpp
+```C++
   ondemand::parser parser;
   auto doc = parser.iterate(json);
   std::set<std::string_view> default_users;
@@ -645,7 +645,7 @@ from the `unescaped_key()` method has a lifecycle tied to the `parser` instance:
 is destroyed or reused with another document, the `std::string_view` instance becomes invalid.
 
 
-```cpp
+```C++
 auto doc = parser.iterate(json);
 for(auto field : doc.get_object())  {
       std::string_view keyv = field.unescaped_key();
@@ -670,11 +670,9 @@ in production systems:
   Some care is needed when using the On-Demand API in scenarios where you need to access several sibling arrays or objects because
   only one object or array can be active at any one time. Let us consider the following example:
 
-```cpp
+```C++
     ondemand::parser parser;
-    //  R"( ... )" is a C++ raw string literal.
     const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
-    // _padded returns an simdjson padded_string instance
     auto doc = parser.iterate(json);
     ondemand::object parent = doc["parent"];
     // parent owns the focus
@@ -690,7 +688,7 @@ in production systems:
 
 A correct usage is given by the following example:
 
-```cpp
+```C++
     ondemand::parser parser;
     const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
     auto doc = parser.iterate(json);
@@ -756,7 +754,7 @@ Some users wish to run at the best possible speed. Under recent Intel and AMD pr
 
 Given that the On-Demand API offer limited runtime dispatching, it matters that your code is compiled against a specific CPU target. You should verify that the code is compiled against the target you expect. Thankfully, the simdjson library will tell you exactly what it detects as an implementation: `icelake` (AVX512 x64 processors), `haswell` (AVX2 x64 processors), `westmere` (SSE4 x64 processors), `arm64` (64-bit ARM), `ppc64` (64-bit POWER), `lasx` (LoongArch), `lsx` (LoongArch),  `fallback` (others). Under x64 processors, many programmers will want to target `haswell` whereas under ARM, most programmers will want to target `arm64` (and it should do so automatically). The `fallback` is probably only good for testing purposes, not for deployment.
 
-```cpp
+```C++
   std::cout << simdjson::builtin_implementation()->name() << std::endl;
 ```
 

doc/parse_many.md

@@ -132,7 +132,7 @@ Whitespace Characters:
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -184,7 +184,7 @@ You may also call the `source()` method to get a `std::string_view` instance on
 Let us illustrate the idea with code:
 
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;
@@ -225,7 +225,7 @@ Some users may need to work with truncated streams. The simdjson may truncate do
 
 Consider the following example where a truncated document (`{"key":"intentionally unclosed string  `) containing 39 bytes has been left within the stream. In such cases, the first two whole documents are parsed and returned, and the `truncated_bytes()` method returns 39.
 
-```cpp
+```C++
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} {"key":"intentionally unclosed string  )"_padded;
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;

doc/performance.md

@@ -47,7 +47,7 @@ and reuse it. The simdjson library will allocate and retain internal buffers bet
 buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
 you can parse terabytes of JSON data without doing any new allocation.
 
-```cpp
+```c++
 ondemand::parser parser;
 
 // This initializes buffers  big enough to handle this JSON.
@@ -71,14 +71,14 @@ Reusing string buffers
 
 We recommend against creating many `std::string` or `simdjson::padded_string` instances to store the JSON content in your application. [Creating many non-trivial objects is convenient but often surprisingly slow](https://lemire.me/blog/2020/08/08/performance-tip-constructing-many-non-trivial-objects-is-slow/). Instead, as much as possible, you should allocate (once or a few times) reusable memory buffers where you write your JSON content. If you have a buffer `json_str` (of type `char*`) allocated for  `capacity` bytes and you store a JSON document spanning `length` bytes, you can pass it to simdjson as follows:
 
-```cpp
+```c++
  auto doc = parser.iterate(padded_string_view(json_str, length, capacity));
 ```
 
 or simply
 
 
-```cpp
+```c++
  auto doc = parser.iterate(json_str, length, capacity);
 ```
 
@@ -89,7 +89,7 @@ Server Loops: Long-Running Processes and Memory Capacity
 The On-Demand approach also automatically expands its memory capacity when larger documents are parsed. However, for longer processes where very large files are processed (such as server loops), this capacity is not resized down. On-Demand also lets you adjust the maximal capacity that the parser can process:
 
 * You can set an upper bound (*max_capacity*) when construction the parser:
-```cpp
+```C++
     ondemand::parser parser(1000*1000);  // Never grows past documents > 1 MB
     auto doc = parser.iterate(json);
     for (web_request request : listen()) {
@@ -105,7 +105,7 @@ The On-Demand approach also automatically expands its memory capacity when large
 The capacity will grow as the parser encounters larger documents up to 1 MB.
 
 * You can also allocate a *fixed capacity* that will never grow:
-```cpp
+```C++
     ondemand::parser parser(1000*1000);
     parser.allocate(1000*1000)  // Fix the capacity to 1 MB
     auto doc = parser.iterate(json);
@@ -173,6 +173,8 @@ Recent versions of Microsoft Visual Studio on Windows provides support for the L
 
 We recommend Visual Studio users prefer LLVM (clang-cl). It compiles to faster release binaries. Furthermore, it compilers faster in release mode.
 
+Under Windows, we also support the GNU GCC compiler via MSYS2. The performance of 64-bit MSYS2 under Windows is excellent (on par with Linux).
+
 
 Power Usage and Downclocking
 --------------
@@ -253,7 +255,7 @@ long page_size() {
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
   return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
-    + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));
+    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
 }
 
 simdjson::padded_string_view

examples/quickstart/CMakeLists.txt

@@ -20,14 +20,10 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   endif()
 
   add_quickstart_test(quickstart_noexceptions   quickstart_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
-  if(NOT SIMDJSON_STATIC_REFLECTION)
+  add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
-    add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
-  endif(NOT SIMDJSON_STATIC_REFLECTION)
 
   add_quickstart_test(quickstart2_noexceptions   quickstart2_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
-  if(NOT SIMDJSON_STATIC_REFLECTION)
+  add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
-    add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
-  endif(NOT SIMDJSON_STATIC_REFLECTION)
 
   # On-Demand Quick Start
   if (SIMDJSON_EXCEPTIONS)
@@ -37,8 +33,6 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   endif()
 
   add_quickstart_test(quickstart_ondemand_noexceptions   quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS LABELS quickstart_ondemand acceptance)
-  if(NOT SIMDJSON_STATIC_REFLECTION)
+  add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
-    add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
-  endif(NOT SIMDJSON_STATIC_REFLECTION)
 
 endif()

fuzz/fuzz_minify.cpp

@@ -18,7 +18,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
     auto error = parser.parse(str).get(elem);
     if (error) { return 0; }
 
-    std::string minified = simdjson::minify(elem);
+    std::string minified=simdjson::minify(elem);
     (void)minified;
     return 0;
 }

include/simdjson.h

@@ -53,11 +53,4 @@
 
 #include "simdjson/dom.h"
 #include "simdjson/ondemand.h"
-#include "simdjson/convert.h"
-#include "simdjson/convert-inl.h"
-
-// Compile-time JSON parsing (C++26 P2996 reflection)
-#include "simdjson/compile_time_json.h"
-#include "simdjson/compile_time_json-inl.h"
-
 #endif // SIMDJSON_H

include/simdjson/arm64/simd.h

@@ -134,12 +134,6 @@ namespace {
       tmp = vpaddq_u8(tmp, tmp);
       return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);
     }
-    // Returns 4-bit out of each byte, alternating between the high 4 bits and low
-    // bits result it is 64 bit.
-    simdjson_inline uint64_t to_bitmask64() const {
-      return vget_lane_u64(
-          vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
-    }
     simdjson_inline bool any() const { return vmaxvq_u32(vreinterpretq_u32_u8(*this)) != 0; }
   };
 
@@ -216,7 +210,7 @@ namespace {
 
     // Bit-specific operations
     simdjson_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const { return vtstq_u8(*this, bits); }
-    simdjson_inline bool any_bits_set_anywhere() const { return vmaxvq_u32(vreinterpretq_u32_u8(*this)) != 0; }
+    simdjson_inline bool any_bits_set_anywhere() const { return this->max_val() != 0; }
     simdjson_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const { return (*this & bits).any_bits_set_anywhere(); }
     template<int N>
     simdjson_inline simd8<uint8_t> shr() const { return vshrq_n_u8(*this, N); }
@@ -229,12 +223,7 @@ namespace {
       return lookup_table.apply_lookup_16_to(*this);
     }
 
-    // Returns 4-bit out of each byte, alternating between the high 4 bits and low
+
-    // bits result it is 64 bit.
-    simdjson_inline uint64_t to_bitmask64() const {
-      return vget_lane_u64(
-          vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
-    }
     // Copies to 'output" all bytes corresponding to a 0 in the mask (interpreted as a bitset).
     // Passing a 0 value for mask would be equivalent to writing out every byte to output.
     // Only the first 16 - count_ones(mask) bytes of the result are significant but 16 bytes

include/simdjson/arm64/stringparsing_defs.h

@@ -17,7 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
+  simdjson_inline static backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
   simdjson_inline bool has_backslash() { return bs_bits != 0; }
@@ -46,32 +46,6 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   };
 }
 
-struct escaping {
-  static constexpr uint32_t BYTES_PROCESSED = 16;
-  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
-
-  simdjson_inline bool has_escape() { return escape_bits != 0; }
-  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits) / 4; }
-
-  uint64_t escape_bits;
-}; // struct escaping
-
-
-
-simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
-  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
-  simd8<uint8_t> v(src);
-  v.store(dst);
-  simd8<bool> is_quote = (v == '"');
-  simd8<bool> is_backslash = (v == '\\');
-  simd8<bool> is_control = (v < 32);
-  return {
-    (is_backslash | is_quote | is_control).to_bitmask64()
-  };
-}
-
-
-
 } // unnamed namespace
 } // namespace arm64
 } // namespace simdjson

include/simdjson/base.h

@@ -10,7 +10,6 @@
 #include "simdjson/error.h"
 #include "simdjson/portability.h"
 #include "simdjson/concepts.h"
-#include "simdjson/constevalutil.h"
 
 /**
  * @brief The top level simdjson namespace, containing everything the library provides.

include/simdjson/common_defs.h

@@ -199,6 +199,17 @@ double from_chars(const char *first, const char* end) noexcept;
     // We assume by default static linkage
     #define SIMDJSON_DLLIMPORTEXPORT
     #endif
+
+/**
+ * Workaround for the vcpkg package manager. Only vcpkg should
+ * ever touch the next line. The SIMDJSON_USING_LIBRARY macro is otherwise unused.
+ */
+#if SIMDJSON_USING_LIBRARY
+#define SIMDJSON_DLLIMPORTEXPORT __declspec(dllimport)
+#endif
+/**
+ * End of workaround for the vcpkg package manager.
+ */
 #else
     #define SIMDJSON_DLLIMPORTEXPORT
 #endif
@@ -345,16 +356,4 @@ namespace std {
 #define SIMDJSON_AVX512_ALLOWED 1
 #endif
 
-
-#ifndef __has_cpp_attribute
-#define simdjson_lifetime_bound
-#elif __has_cpp_attribute(msvc::lifetimebound)
-#define simdjson_lifetime_bound [[msvc::lifetimebound]]
-#elif __has_cpp_attribute(clang::lifetimebound)
-#define simdjson_lifetime_bound [[clang::lifetimebound]]
-#elif __has_cpp_attribute(lifetimebound)
-#define simdjson_lifetime_bound [[lifetimebound]]
-#else
-#define simdjson_lifetime_bound
-#endif
 #endif // SIMDJSON_COMMON_DEFS_H

include/simdjson/compile_time_json.h

@@ -1,75 +0,0 @@
-/**
- * @file compile_time_json.h
- * @brief Compile-time JSON parsing using C++26 reflection with
- * std::meta::substitute()
- */
-
-#ifndef SIMDJSON_GENERIC_COMPILE_TIME_JSON_H
-#define SIMDJSON_GENERIC_COMPILE_TIME_JSON_H
-
-#if SIMDJSON_STATIC_REFLECTION
-
-#include <algorithm>
-#include <array>
-#include <charconv>
-#include <cstdint>
-#include <expected>
-#include <meta>
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace simdjson {
-namespace compile_time {
-
-/**
- * @brief Compile-time JSON parser. This function parses the provided JSON
- * string at compile time and returns a custom struct type representing the JSON
- * object.
- *
- * We have a few limitations which trigger compile-time errors if violated:
- * - Only JSON objects and arrays are supported at the top level (no primitives).
- *   We will lift this limitation in the future.
- * - Strings are represented using the const char * in UTF-8, but they must not
- *   contain embedded nulls. We would prefer to represent them as std::string or
- *   std::string_view, and hope to do so in the future.
- * - Heterogeneous arrays are not supported yet. E.g., you need to have arrays of
- *   all integers, or all strings, all floats, all compatible objects, etc.
- *   For example, the following is accepted:
- *    [
- *     { "name": "Alice", "age": 30 },
- *     { "name": "Bob", "age": 25 },
- *     { "name": "Charlie", "age": 35 }
- *   ]
- *   but the following is not:
- *   [
- *     { "name": "Alice", "age": 30 },
- *     "Just a string",
- *     42,
- *     { "name": "Charlie", "age": 35 }
- *   ]
- *
- *    We may support heterogeneous arrays in the future with std::variant types.
- * - We parse the first JSON document encountered in the string. Trailing
- *   characters are ignored. Thus if your JSON begins with {"a":1}, everything
- *   after the closing } is ignored. This limitation will be lifted in the future,
- *   reporting an error.
- *
- * These limitations are safe in the sense that they result in compile-time errors.
- * Thus you will not get truncated strings or imprecise floats silently.
- *
- * This function is subject to change in the future.
- */
-template <constevalutil::fixed_string json_str> consteval auto parse_json();
-
-} // namespace compile_time
-} // namespace simdjson
-
-
-template <simdjson::constevalutil::fixed_string str>
-consteval auto operator ""_json() {
-  return simdjson::compile_time::parse_json<str>();
-}
-
-#endif // SIMDJSON_STATIC_REFLECTION
-#endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_H

include/simdjson/compiler_check.h

@@ -13,11 +13,6 @@
 #endif
 #endif
 
-// C++ 26
-#if !defined(SIMDJSON_CPLUSPLUS26) && (SIMDJSON_CPLUSPLUS >= 202402L) // update when the standard is finalized
-#define SIMDJSON_CPLUSPLUS26 1
-#endif
-
 // C++ 23
 #if !defined(SIMDJSON_CPLUSPLUS23) && (SIMDJSON_CPLUSPLUS >= 202302L)
 #define SIMDJSON_CPLUSPLUS23 1
@@ -55,69 +50,28 @@
 #endif
 #endif
 
-#ifndef SIMDJSON_CONSTEXPR_LAMBDA
-#if SIMDJSON_CPLUSPLUS17
-#define SIMDJSON_CONSTEXPR_LAMBDA constexpr
-#else
-#define SIMDJSON_CONSTEXPR_LAMBDA
-#endif
-#endif
-
-
-
 #ifdef __has_include
 #if __has_include(<version>)
 #include <version>
 #endif
 #endif
 
-// The current specification is unclear on how we detect
-// static reflection, both __cpp_lib_reflection and
-// __cpp_impl_reflection are proposed in the draft specification.
-// For now, we disable static reflect by default. It must be
-// specified at compiler time.
-#ifndef SIMDJSON_STATIC_REFLECTION
-#define SIMDJSON_STATIC_REFLECTION 0 // disabled by default.
-#endif
-
 #if defined(__apple_build_version__)
 #if __apple_build_version__ < 14000000
 #define SIMDJSON_CONCEPT_DISABLED 1 // apple-clang/13 doesn't support std::convertible_to
 #endif
 #endif
 
-#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
-#include <ranges>
-#define SIMDJSON_SUPPORTS_RANGES 1
-#else
-#define SIMDJSON_SUPPORTS_RANGES 0
-#endif
 
 #if defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
 #if __cpp_concepts >= 201907L
 #include <utility>
-#define SIMDJSON_SUPPORTS_CONCEPTS 1
-#else
-#define SIMDJSON_SUPPORTS_CONCEPTS 0
-#endif
-#else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
-#define SIMDJSON_SUPPORTS_CONCEPTS 0
-#endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
-
-// copy SIMDJSON_SUPPORTS_CONCEPTS to SIMDJSON_SUPPORTS_DESERIALIZATION.
-#if SIMDJSON_SUPPORTS_CONCEPTS
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 1
 #else
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 0
 #endif
-
+#else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
-
+#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
-#if !defined(SIMDJSON_CONSTEVAL)
+#endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
-#if defined(__cpp_consteval) && __cpp_consteval >= 201811L && defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
-#define SIMDJSON_CONSTEVAL 1
-#else
-#define SIMDJSON_CONSTEVAL 0
-#endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L && defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
-#endif // !defined(SIMDJSON_CONSTEVAL)
 
 #endif // SIMDJSON_COMPILER_CHECK_H

include/simdjson/concepts.h

@@ -1,6 +1,6 @@
 #ifndef SIMDJSON_CONCEPTS_H
 #define SIMDJSON_CONCEPTS_H
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
 
 #include <concepts>
 #include <type_traits>
@@ -32,9 +32,7 @@ SIMDJSON_IMPL_CONCEPT(op_append, operator+=)
 #undef SIMDJSON_IMPL_CONCEPT
 } // namespace details
 
-template <typename T>
+
-concept is_pair = requires { typename T::first_type; typename T::second_type; } &&
-                  std::same_as<T, std::pair<typename T::first_type, typename T::second_type>>;
 template <typename T>
 concept string_view_like = std::is_convertible_v<T, std::string_view> &&
                            !std::is_convertible_v<T, const char*>;
@@ -117,70 +115,17 @@ concept optional_type = requires(std::remove_cvref_t<T> obj) {
   { obj.value() } -> std::same_as<typename std::remove_cvref_t<T>::value_type&>;
   requires requires(typename std::remove_cvref_t<T>::value_type &&val) {
     obj.emplace(std::move(val));
+    obj = std::move(val);
     {
       obj.value_or(val)
     } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
   };
   { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
-  { obj.reset() } noexcept -> std::same_as<void>;
 };
 
 
 
-// Types we serialize as JSON strings (not as containers)
-template <typename T>
-concept string_like =
-  std::is_same_v<std::remove_cvref_t<T>, std::string> ||
-  std::is_same_v<std::remove_cvref_t<T>, std::string_view> ||
-  std::is_same_v<std::remove_cvref_t<T>, const char*> ||
-  std::is_same_v<std::remove_cvref_t<T>, char*>;
-
-// Concept that checks if a type is a container but not a string (because
-// strings handling must be handled differently)
-// Now uses iterator-based approach for broader container support
-template <typename T>
-concept container_but_not_string =
-  std::ranges::input_range<T> && !string_like<T> && !concepts::string_view_keyed_map<T>;
-
-
-
-// Concept: Indexable container that is not a string or associative container
-// Accepts: std::vector, std::array, std::deque (have operator[], value_type, not string_like)
-// Rejects: std::string (string_like), std::list (no operator[]), std::map (has key_type)
-template<typename Container>
-concept indexable_container = requires {
-  typename Container::value_type;
-  requires !concepts::string_like<Container>;
-  requires !requires { typename Container::key_type; };  // Reject maps/sets
-  requires requires(Container& c, std::size_t i) {
-    { c[i] } -> std::convertible_to<typename Container::value_type>;
-  };
-};
-
-
-// Variable template to use with std::meta::substitute
-template<typename Container>
-constexpr bool indexable_container_v = indexable_container<Container>;
-
 } // namespace concepts
-
-
-/**
- * We use tag_invoke as our customization point mechanism.
- */
-template <typename Tag, typename... Args>
-concept tag_invocable = requires(Tag tag, Args... args) {
-  tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-};
-
-template <typename Tag, typename... Args>
-concept nothrow_tag_invocable =
-    tag_invocable<Tag, Args...> && requires(Tag tag, Args... args) {
-      {
-        tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...)
-      } noexcept;
-    };
-
 } // namespace simdjson
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 #endif // SIMDJSON_CONCEPTS_H

include/simdjson/constevalutil.h

@@ -1,89 +0,0 @@
-#ifndef SIMDJSON_CONSTEVALUTIL_H
-#define SIMDJSON_CONSTEVALUTIL_H
-
-#include <string>
-#include <string_view>
-#include <array>
-
-namespace simdjson {
-namespace constevalutil {
-#if SIMDJSON_CONSTEVAL
-
-constexpr static std::array<uint8_t, 256> json_quotable_character = {
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-constexpr static std::array<std::string_view, 32> control_chars = {
-    "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006",
-    "\\u0007", "\\b", "\\t",     "\\n",     "\\u000b", "\\f",     "\\r",
-    "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013", "\\u0014",
-    "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b",
-    "\\u001c", "\\u001d", "\\u001e", "\\u001f"};
-// unoptimized, meant for compile-time execution
-consteval std::string consteval_to_quoted_escaped(std::string_view input) {
-  std::string out = "\"";
-  for (char c : input) {
-    if (json_quotable_character[uint8_t(c)]) {
-      if (c == '"') {
-        out.append("\\\"");
-      } else if (c == '\\') {
-        out.append("\\\\");
-      } else {
-        std::string_view v = control_chars[uint8_t(c)];
-        out.append(v);
-      }
-    } else {
-      out.push_back(c);
-    }
-  }
-  out.push_back('"');
-  return out;
-}
-#endif  // SIMDJSON_CONSTEVAL
-
-
-#if SIMDJSON_SUPPORTS_CONCEPTS
-template <size_t N>
-struct fixed_string {
-    constexpr fixed_string(const char (&str)[N])  {
-        for (std::size_t i = 0; i < N; ++i) {
-            data[i] = str[i];
-        }
-    }
-    char data[N];
-    constexpr std::string_view view() const { return {data, N - 1}; }
-    constexpr size_t size() const { return N ; }
-    constexpr operator std::string_view() const { return view(); }
-    constexpr char operator[](std::size_t index) const { return data[index]; }
-    constexpr bool operator==(const fixed_string& other) const {
-        if (N != other.size()) {
-            return false;
-        }
-        for (std::size_t i = 0; i < N; ++i) {
-            if (data[i] != other.data[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-};
-template <std::size_t N>
-fixed_string(const char (&)[N]) -> fixed_string<N>;
-
-template <fixed_string str>
-struct string_constant {
-    static constexpr std::string_view value = str.view();
-};
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
-
-} // namespace constevalutil
-} // namespace simdjson
-#endif // SIMDJSON_CONSTEVALUTIL_H

include/simdjson/convert-inl.h

@@ -1,135 +0,0 @@
-
-#ifndef SIMDJSON_CONVERT_INL_H
-#define SIMDJSON_CONVERT_INL_H
-
-#include "simdjson/convert.h"
-#if SIMDJSON_SUPPORTS_CONCEPTS
-namespace simdjson {
-namespace convert {
-namespace internal {
-// auto_parser method definitions
-template <typename parser_type>
-inline auto_parser<parser_type>::auto_parser(parser_type &&parser, ondemand::document &&doc) noexcept requires(!std::is_pointer_v<parser_type>)
-  : m_parser{std::move(parser)}, m_doc{std::move(doc)} {}
-
-template <typename parser_type>
-inline auto_parser<parser_type>::auto_parser(parser_type &&parser, padded_string_view const str) noexcept requires(!std::is_pointer_v<parser_type>)
-  : m_parser{std::move(parser)}, m_doc{}, m_error{SUCCESS} {
-  m_error = m_parser.iterate(str).get(m_doc);
-}
-
-template <typename parser_type>
-inline auto_parser<parser_type>::auto_parser(std::remove_pointer_t<parser_type> &parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>)
-  : m_parser{&parser}, m_doc{std::move(doc)} {}
-
-template <typename parser_type>
-inline auto_parser<parser_type>::auto_parser(std::remove_pointer_t<parser_type> &parser, padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>)
-  : m_parser{&parser}, m_doc{}, m_error{SUCCESS} {
-  m_error = m_parser->iterate(str).get(m_doc);
-}
-
-template <typename parser_type>
-inline auto_parser<parser_type>::auto_parser(padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>)
-  : auto_parser{ondemand::parser::get_parser(), str} {}
-
-template <typename parser_type>
-inline auto_parser<parser_type>::auto_parser(parser_type parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>)
-  : auto_parser{*parser, std::move(doc)} {}
-
-
-
-
-
-template <typename parser_type>
-inline std::remove_pointer_t<parser_type> &auto_parser<parser_type>::parser() noexcept {
-  if constexpr (std::is_pointer_v<parser_type>) {
-    return *m_parser;
-  } else {
-    return m_parser;
-  }
-}
-
-template <typename parser_type>
-template <typename T>
-inline simdjson_result<T> auto_parser<parser_type>::result() noexcept(is_nothrow_gettable<T>) {
-  if (m_error != SUCCESS) {
-    return m_error;
-  }
-  return m_doc.get<T>();
-}
-
-template <typename parser_type>
-template <typename T>
-simdjson_warn_unused simdjson_inline error_code auto_parser<parser_type>::get(T &value) && noexcept(is_nothrow_gettable<T>) {
-  return result<T>().get(value);
-}
-
-template <typename parser_type>
-inline simdjson_result<ondemand::array> auto_parser<parser_type>::array() noexcept {
-  return result<ondemand::array>();
-}
-
-template <typename parser_type>
-inline simdjson_result<ondemand::object> auto_parser<parser_type>::object() noexcept {
-  return result<ondemand::object>();
-}
-
-template <typename parser_type>
-inline simdjson_result<ondemand::number> auto_parser<parser_type>::number() noexcept {
-  return result<ondemand::number>();
-}
-
-#if SIMDJSON_EXCEPTIONS
-template <typename parser_type>
-template <typename T>
-inline auto_parser<parser_type>::operator T() noexcept(false) {
-  if (m_error != SUCCESS) {
-    throw simdjson_error(m_error);
-  }
-  return m_doc.get<T>();
-}
-#endif // SIMDJSON_EXCEPTIONS
-
-template <typename parser_type>
-template <typename T>
-inline std::optional<T> auto_parser<parser_type>::optional() noexcept(is_nothrow_gettable<T>) {
-  if (m_error != SUCCESS) {
-    return std::nullopt;
-  }
-  T value;
-  if (m_doc.get<T>().get(value)) [[unlikely]] {
-    return std::nullopt;
-  }
-  return {std::move(value)};
-}
-
-// to_adaptor method definitions
-template <typename T>
-inline T to_adaptor<T>::operator()(simdjson_result<ondemand::value> &val) const noexcept {
-  return val.get<T>();
-}
-
-template <typename T>
-inline auto to_adaptor<T>::operator()(padded_string_view const str) const noexcept {
-  return auto_parser<ondemand::parser *>{str};
-}
-
-template <typename T>
-inline auto to_adaptor<T>::operator()(ondemand::parser &parser, padded_string_view const str) const noexcept {
-  return auto_parser<ondemand::parser *>{parser, str};
-}
-
-template <typename T>
-inline auto to_adaptor<T>::operator()(std::string str) const noexcept {
-  return auto_parser<ondemand::parser *>{pad_with_reserve(str)};
-}
-
-template <typename T>
-inline auto to_adaptor<T>::operator()(ondemand::parser &parser, std::string str) const noexcept {
-  return auto_parser<ondemand::parser *>{parser, pad_with_reserve(str)};
-}
-} // namespace internal
-} // namespace convert
-} // namespace simdjson
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
-#endif // SIMDJSON_CONVERT_INL_H

include/simdjson/convert.h

@@ -1,121 +0,0 @@
-
-#ifndef SIMDJSON_CONVERT_H
-#define SIMDJSON_CONVERT_H
-
-#include "simdjson/ondemand.h"
-#include <optional>
-
-#if SIMDJSON_SUPPORTS_CONCEPTS
-
-
-namespace simdjson {
-namespace convert {
-namespace internal {
-
-/**
- * A utility class for automatically parsing JSON documents.
- * This template is NOT part of our public API.
- * It is subject to changes.
- * @private
- */
-template <typename parser_type = ondemand::parser*>
-struct auto_parser {
-private:
-	parser_type m_parser;
-	ondemand::document m_doc;
-	error_code m_error{SUCCESS};
-
-	template <typename T>
-	static constexpr bool is_nothrow_gettable = requires(ondemand::document doc) {
-		{ doc.get<T>() } noexcept;
-	};
-public:
-	explicit auto_parser(parser_type &&parser, ondemand::document &&doc) noexcept requires(!std::is_pointer_v<parser_type>);
-	explicit auto_parser(parser_type &&parser, padded_string_view const str) noexcept requires(!std::is_pointer_v<parser_type>);
-	explicit auto_parser(std::remove_pointer_t<parser_type> &parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>);
-	explicit auto_parser(std::remove_pointer_t<parser_type> &parser, padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>);
-	explicit auto_parser(padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>);
-	explicit auto_parser(parser_type parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>);
-		auto_parser(auto_parser const &) = delete;
-		auto_parser &operator=(auto_parser const &) = delete;
-		auto_parser(auto_parser &&) noexcept = default;
-		auto_parser &operator=(auto_parser &&) noexcept = default;
-		~auto_parser() = default;
-
-	simdjson_warn_unused std::remove_pointer_t<parser_type> &parser() noexcept;
-
-	template <typename T>
-	simdjson_warn_unused simdjson_inline simdjson_result<T> result() noexcept(is_nothrow_gettable<T>);
-	template <typename T>
-	simdjson_warn_unused simdjson_inline error_code get(T &value) && noexcept(is_nothrow_gettable<T>);
-
-
-	simdjson_warn_unused simdjson_inline simdjson_result<ondemand::array> array() noexcept;
-	simdjson_warn_unused simdjson_inline simdjson_result<ondemand::object> object() noexcept;
-	simdjson_warn_unused simdjson_inline simdjson_result<ondemand::number> number() noexcept;
-
-
-#if SIMDJSON_EXCEPTIONS
-	template <typename T>
-	simdjson_warn_unused simdjson_inline explicit(false) operator T() noexcept(false);
-#endif // SIMDJSON_EXCEPTIONS
-
-	template <typename T>
-	simdjson_warn_unused simdjson_inline std::optional<T> optional() noexcept(is_nothrow_gettable<T>);
-};
-
-
-/**
- * A utility class for adapting values for the `auto_parser`.
- * This template is not part of our public API. It is subject to changes.
- * @private
- */
-template <typename T = void>
-struct to_adaptor {
-	T operator()(simdjson_result<ondemand::value> &val) const noexcept;
-	auto operator()(padded_string_view const str) const noexcept;
-	auto operator()(ondemand::parser &parser, padded_string_view const str) const noexcept;
-	// The std::string is padded with reserve to ensure there is enough space for padding.
-	// Some sanitizers may not like this, so you can use simdjson::pad instead.
-	// simdjson::from(simdjson::pad(str))
-	auto operator()(std::string str) const noexcept;
-	auto operator()(ondemand::parser &parser, std::string str) const noexcept;
-};
-// deduction guide
-auto_parser(padded_string_view const str) -> auto_parser<ondemand::parser*>;
-} // namespace internal
-} // namespace convert
-
-/**
- * The simdjson::from instance is EXPERIMENTAL AND SUBJECT TO CHANGES.
- *
- * The `from` instance is a utility adaptor for parsing JSON strings into objects.
- * It provides a convenient way to convert JSON data into C++ objects using the `auto_parser`.
- *
- * Example usage:
- *
- * ```cpp
- * std::map<std::string, std::string> obj =
- *   simdjson::from(R"({"key": "value"})"_padded);
- * ```
- *
- * This will parse the JSON string and return an object representation. By default, we
- * use the simdjson::ondemand::parser::get_parser() instance. A parser instance should
- * be used for just one document at a time.
- *
- * You can also pass you own parser instance:
- * ```cpp
- * simdjson::ondemand::parser parser;
- * std::map<std::string, std::string> obj =
- *   simdjson::from(parser, R"({"key": "value"})"_padded);
- * ```
- * The parser instance can be reused.
- *
- * This functionality requires C++20 or better.
- */
-static constexpr convert::internal::to_adaptor<> from{};
-
-} // namespace simdjson
-
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
-#endif // SIMDJSON_CONVERT_H

include/simdjson/dom/array-inl.h

@@ -52,22 +52,11 @@ inline simdjson_result<dom::element> simdjson_result<dom::array>::at_pointer(std
   return at_pointer(json_pointer);
  }
 
-inline simdjson_result<std::vector<dom::element>> simdjson_result<dom::array>::at_path_with_wildcard(std::string_view json_path) const noexcept {
-  if (error()) {
-    return error();
-  }
-  return first.at_path_with_wildcard(json_path);
-}
-
 inline simdjson_result<dom::element> simdjson_result<dom::array>::at(size_t index) const noexcept {
   if (error()) { return error(); }
   return first.at(index);
 }
 
-inline std::vector<dom::element>& simdjson_result<dom::array>::get_values(std::vector<dom::element>& out) const noexcept {
-  return first.get_values(out);
-}
-
 namespace dom {
 
 //
@@ -138,93 +127,6 @@ inline simdjson_result<element> array::at_path(std::string_view json_path) const
   return at_pointer(json_pointer);
 }
 
-inline void array::process_json_path_of_child_elements(std::vector<element>::iterator& current, std::vector<element>::iterator& end, const std::string_view& path_suffix, std::vector<element>& accumulator) const noexcept {
-  if (current == end) {
-    return;
-  }
-
-  simdjson_result<std::vector<element>> result;
-
-
-  for (auto it = current; it != end; ++it) {
-    std::vector<element> child_result;
-    auto error = it->at_path_with_wildcard(path_suffix).get(child_result);
-    if(error) {
-      continue;
-    }
-    accumulator.reserve(accumulator.size() + child_result.size());
-    accumulator.insert(accumulator.end(),
-                        std::make_move_iterator(child_result.begin()),
-                        std::make_move_iterator(child_result.end()));
-  }
-}
-
-inline simdjson_result<std::vector<element>> array::at_path_with_wildcard(std::string_view json_path) const noexcept {
-  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
-
-  size_t i = 0;
-   // json_path.starts_with('$') requires C++20.
-  if (!json_path.empty() && json_path.front() == '$') {
-    i = 1;
-  }
-
-  if (i >= json_path.size() || (json_path[i] != '.' && json_path[i] != '[')) {
-    return INVALID_JSON_POINTER;
-  }
-
-  if (json_path.find("*") != std::string::npos) {
-    std::vector<element> child_values;
-
-    if (
-      (json_path.compare(i, 3, "[*]") == 0 && json_path.size() == i + 3) ||
-      (json_path.compare(i, 2,".*") == 0 && json_path.size() == i + 2)
-    ) {
-      get_values(child_values);
-      return child_values;
-    }
-
-    std::pair<std::string_view, std::string_view> key_and_json_path = get_next_key_and_json_path(json_path);
-
-    std::string_view key = key_and_json_path.first;
-    json_path = key_and_json_path.second;
-
-    if (key.size() > 0) {
-      if (key == "*") {
-        get_values(child_values);
-      } else {
-        element pointer_result;
-        std::string json_pointer = std::string("/") + std::string(key);
-        auto error = at_pointer(json_pointer).get(pointer_result);
-
-        if (!error) {
-          child_values.emplace_back(pointer_result);
-        }
-      }
-
-      std::vector<element> result = {};
-
-      if (child_values.size() > 0) {
-        std::vector<element>::iterator child_values_begin = child_values.begin();
-        std::vector<element>::iterator child_values_end = child_values.end();
-
-        process_json_path_of_child_elements(child_values_begin, child_values_end, json_path, result);
-      }
-
-      return result;
-    } else {
-      return INVALID_JSON_POINTER;
-    }
-  } else {
-    element result;
-    auto error = at_path(json_path).get(result);
-    if (error) {
-      return error;
-    }
-
-    return std::vector<element>{std::move(result)};
-  }
-}
-
 inline simdjson_result<element> array::at(size_t index) const noexcept {
   SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
   size_t i=0;
@@ -235,15 +137,6 @@ inline simdjson_result<element> array::at(size_t index) const noexcept {
   return INDEX_OUT_OF_BOUNDS;
 }
 
-inline std::vector<element>& array::get_values(std::vector<element>& out) const noexcept {
-  out.reserve(this->size());
-  for (auto element : *this) {
-    out.emplace_back(element);
-  }
-
-  return out;
-}
-
 inline array::operator element() const noexcept {
 	return element(tape);
 }
@@ -290,13 +183,13 @@ inline bool array::iterator::operator>(const array::iterator& other) const noexc
 
 #include "simdjson/dom/element-inl.h"
 
-#if SIMDJSON_SUPPORTS_RANGES
+#if defined(__cpp_lib_ranges)
 static_assert(std::ranges::view<simdjson::dom::array>);
 static_assert(std::ranges::sized_range<simdjson::dom::array>);
 #if SIMDJSON_EXCEPTIONS
 static_assert(std::ranges::view<simdjson::simdjson_result<simdjson::dom::array>>);
 static_assert(std::ranges::sized_range<simdjson::simdjson_result<simdjson::dom::array>>);
 #endif // SIMDJSON_EXCEPTIONS
-#endif // SIMDJSON_SUPPORTS_RANGES
+#endif // defined(__cpp_lib_ranges)
 
 #endif // SIMDJSON_ARRAY_INL_H

include/simdjson/dom/array.h

@@ -1,8 +1,6 @@
 #ifndef SIMDJSON_DOM_ARRAY_H
 #define SIMDJSON_DOM_ARRAY_H
 
-#include <vector>
-
 #include "simdjson/dom/base.h"
 #include "simdjson/internal/tape_ref.h"
 
@@ -110,23 +108,12 @@ public:
    */
   inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
 
-  /**
-   * Recursive function which processes the JSON path of each child element
-   */
-  inline void process_json_path_of_child_elements(std::vector<element>::iterator& current, std::vector<element>::iterator& end, const std::string_view& path_suffix, std::vector<element>& accumulator) const noexcept;
-
-
-  /**
-   * Adds support for JSONPath expression with wildcards '*'
-   */
-  inline simdjson_result<std::vector<element>> at_path_with_wildcard(std::string_view json_path) const noexcept;
-
   /**
    * Get the value associated with the given JSONPath expression. We only support
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
+   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
@@ -154,15 +141,6 @@ public:
    */
   inline simdjson_result<element> at(size_t index) const noexcept;
 
-  /**
-   * Gets the values of items in an array element
-   * This function has linear-time complexity: the values are checked one by one.
-   *
-   * @return The child elements of an array
-   */
-
-  inline std::vector<element>& get_values(std::vector<element>& out) const noexcept;
-
   /**
    * Implicitly convert object to element
    */
@@ -189,11 +167,8 @@ public:
   simdjson_inline simdjson_result(error_code error) noexcept; ///< @private
 
   inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
-  inline void process_json_path_of_child_elements(std::vector<dom::element>::iterator& current, std::vector<dom::element>::iterator& end, const std::string_view& path_suffix, std::vector<dom::element>& accumulator) const noexcept;
-  inline simdjson_result<std::vector<dom::element>> at_path_with_wildcard(std::string_view json_path) const noexcept;
   inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
   inline simdjson_result<dom::element> at(size_t index) const noexcept;
-  inline std::vector<dom::element>& get_values(std::vector<dom::element>& out) const noexcept;
 
 #if SIMDJSON_EXCEPTIONS
   inline dom::array::iterator begin() const noexcept(false);
@@ -206,7 +181,9 @@ public:
 
 } // namespace simdjson
 
-#if SIMDJSON_SUPPORTS_RANGES
+#if defined(__cpp_lib_ranges)
+#include <ranges>
+
 namespace std {
 namespace ranges {
 template<>
@@ -217,6 +194,6 @@ inline constexpr bool enable_view<simdjson::simdjson_result<simdjson::dom::array
 #endif // SIMDJSON_EXCEPTIONS
 } // namespace ranges
 } // namespace std
-#endif // SIMDJSON_SUPPORTS_RANGES
+#endif // defined(__cpp_lib_ranges)
 
 #endif // SIMDJSON_DOM_ARRAY_H

include/simdjson/dom/document_stream.h

@@ -74,7 +74,7 @@ public:
   /**
    * Construct an uninitialized document_stream.
    *
-   *  ```cpp
+   *  ```c++
    *  document_stream docs;
    *  error = parser.parse_many(json).get(docs);
    *  ```

include/simdjson/dom/element-inl.h

@@ -128,12 +128,6 @@ simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_
   if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
   return at_pointer(json_pointer);
 }
-
-simdjson_inline simdjson_result<std::vector<dom::element>> simdjson_result<dom::element>::at_path_with_wildcard(const std::string_view json_path) const noexcept {
-  if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
-}
-
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
 [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at(const std::string_view json_pointer) const noexcept {
@@ -424,20 +418,6 @@ inline simdjson_result<element> element::at_pointer(std::string_view json_pointe
     }
   }
 }
-
-inline simdjson_result<std::vector<element>> element::at_path_with_wildcard(std::string_view json_path) const noexcept {
-  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
-
-  switch (tape.tape_ref_type()) {
-    case internal::tape_type::START_OBJECT:
-      return object(tape).at_path_with_wildcard(json_path);
-    case internal::tape_type::START_ARRAY:
-      return array(tape).at_path_with_wildcard(json_path);
-    default:
-      return std::vector<element>{};
-  }
-}
-
 inline simdjson_result<element> element::at_path(std::string_view json_path) const noexcept {
   auto json_pointer = json_path_to_pointer_conversion(json_path);
   if (json_pointer == "-1") { return INVALID_JSON_POINTER; }

include/simdjson/dom/element.h

@@ -1,8 +1,6 @@
 #ifndef SIMDJSON_DOM_ELEMENT_H
 #define SIMDJSON_DOM_ELEMENT_H
 
-#include <vector>
-
 #include "simdjson/dom/base.h"
 #include "simdjson/dom/array.h"
 
@@ -401,14 +399,12 @@ public:
    */
   inline simdjson_result<element> at_pointer(const std::string_view json_pointer) const noexcept;
 
-  inline simdjson_result<std::vector<element>> at_path_with_wildcard(const std::string_view json_path) const noexcept;
-
   /**
    * Get the value associated with the given JSONPath expression. We only support
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
+   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
@@ -548,7 +544,6 @@ public:
   simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
   simdjson_result<dom::element> operator[](int) const noexcept = delete;
   simdjson_inline simdjson_result<dom::element> at_pointer(const std::string_view json_pointer) const noexcept;
-  simdjson_inline simdjson_result<std::vector<dom::element>> at_path_with_wildcard(const std::string_view json_path) const noexcept;
   simdjson_inline simdjson_result<dom::element> at_path(const std::string_view json_path) const noexcept;
   [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
   simdjson_inline simdjson_result<dom::element> at(const std::string_view json_pointer) const noexcept;

include/simdjson/dom/object-inl.h

@@ -40,19 +40,10 @@ inline simdjson_result<dom::element> simdjson_result<dom::object>::at_path(std::
   if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
   return at_pointer(json_pointer);
 }
-inline simdjson_result<std::vector<dom::element>> simdjson_result<dom::object>::at_path_with_wildcard(std::string_view json_path) const noexcept {
-  if (error()) {
-    return error();
-  }
-  return first.at_path_with_wildcard(json_path);
-}
 inline simdjson_result<dom::element> simdjson_result<dom::object>::at_key(std::string_view key) const noexcept {
   if (error()) { return error(); }
   return first.at_key(key);
 }
-inline std::vector<dom::element>& simdjson_result<dom::object>::get_values(std::vector<dom::element>& out) const noexcept {
-  return first.get_values(out);
-}
 inline simdjson_result<dom::element> simdjson_result<dom::object>::at_key_case_insensitive(std::string_view key) const noexcept {
   if (error()) { return error(); }
   return first.at_key_case_insensitive(key);
@@ -152,97 +143,6 @@ inline simdjson_result<element> object::at_path(std::string_view json_path) cons
   return at_pointer(json_pointer);
 }
 
-inline void object::process_json_path_of_child_elements(std::vector<element>::iterator& current, std::vector<element>::iterator& end, const std::string_view& path_suffix, std::vector<element>& accumulator) const noexcept {
-  if (current == end) {
-    return;
-  }
-
-  simdjson_result<std::vector<element>> result;
-
-  for (auto it = current; it != end; ++it) {
-    std::vector<element> child_result;
-    auto error = it->at_path_with_wildcard(path_suffix).get(child_result);
-    if(error) {
-      continue;
-    }
-    accumulator.reserve(accumulator.size() + child_result.size());
-    accumulator.insert(accumulator.end(),
-                        std::make_move_iterator(child_result.begin()),
-                        std::make_move_iterator(child_result.end()));
-  }
-}
-
-inline simdjson_result<std::vector<element>> object::at_path_with_wildcard(std::string_view json_path) const noexcept {
-  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
-
-  size_t i = 0;
-  if (json_path.empty()) {
-    return INVALID_JSON_POINTER;
-  }
-  // if JSONPath starts with $, skip it
-  // json_path.starts_with('$') requires C++20.
-  if (json_path.front() == '$') {
-    i = 1;
-  }
-
-  if (i >= json_path.size() || (json_path[i] != '.' && json_path[i] != '[')) {
-    // expect JSONPath expressions to always start with $ but this isn't currently
-    // expected in jsonpathutil.h.
-    return INVALID_JSON_POINTER;
-  }
-
-  if (json_path.find("*") != std::string::npos) {
-
-    std::vector<element> child_values;
-
-    if (
-      (json_path.compare(i, 3, "[*]") == 0 && json_path.size() == i + 3) ||
-      (json_path.compare(i, 2,".*") == 0 && json_path.size() == i + 2)
-    ) {
-      get_values(child_values);
-      return child_values;
-    }
-
-    std::pair<std::string_view, std::string_view> key_and_json_path = get_next_key_and_json_path(json_path);
-
-    std::string_view key = key_and_json_path.first;
-    json_path = key_and_json_path.second;
-
-    if (key.size() > 0) {
-      if (key == "*") {
-        get_values(child_values);
-      } else {
-        element pointer_result;
-        auto error = at_pointer(std::string("/") + std::string(key)).get(pointer_result);
-
-        if (!error) {
-          child_values.emplace_back(pointer_result);
-        }
-      }
-
-      std::vector<element> result = {};
-      if (child_values.size() > 0) {
-
-        std::vector<element>::iterator child_values_begin = child_values.begin();
-        std::vector<element>::iterator child_values_end = child_values.end();
-
-        process_json_path_of_child_elements(child_values_begin, child_values_end, json_path, result);
-      }
-
-      return result;
-    } else {
-      return INVALID_JSON_POINTER;
-    }
-  } else {
-    element result;
-    auto error = this->at_path(json_path).get(result);
-    if (error) {
-      return error;
-    }
-    return std::vector<element>{std::move(result)};
-  }
-}
-
 inline simdjson_result<element> object::at_key(std::string_view key) const noexcept {
   iterator end_field = end();
   for (iterator field = begin(); field != end_field; ++field) {
@@ -252,18 +152,6 @@ inline simdjson_result<element> object::at_key(std::string_view key) const noexc
   }
   return NO_SUCH_FIELD;
 }
-
-inline std::vector<element>& object::get_values(std::vector<element>& out) const noexcept {
-  iterator end_field = end();
-  iterator begin_field = begin();
-
-  out.reserve(std::distance(begin_field, end_field));
-  for (iterator field = begin_field; field != end_field; ++field) {
-    out.emplace_back(field.value());
-  }
-
-  return out;
-}
 // In case you wonder why we need this, please see
 // https://github.com/simdjson/simdjson/issues/323
 // People do seek keys in a case-insensitive manner.
@@ -375,13 +263,13 @@ inline key_value_pair::key_value_pair(std::string_view _key, element _value) noe
 
 } // namespace simdjson
 
-#if SIMDJSON_SUPPORTS_RANGES
+#if defined(__cpp_lib_ranges)
 static_assert(std::ranges::view<simdjson::dom::object>);
 static_assert(std::ranges::sized_range<simdjson::dom::object>);
 #if SIMDJSON_EXCEPTIONS
 static_assert(std::ranges::view<simdjson::simdjson_result<simdjson::dom::object>>);
 static_assert(std::ranges::sized_range<simdjson::simdjson_result<simdjson::dom::object>>);
 #endif // SIMDJSON_EXCEPTIONS
-#endif // SIMDJSON_SUPPORTS_RANGES
+#endif // defined(__cpp_lib_ranges)
 
 #endif // SIMDJSON_OBJECT_INL_H

include/simdjson/dom/object.h

@@ -1,8 +1,6 @@
 #ifndef SIMDJSON_DOM_OBJECT_H
 #define SIMDJSON_DOM_OBJECT_H
 
-#include <vector>
-
 #include "simdjson/dom/base.h"
 #include "simdjson/dom/element.h"
 #include "simdjson/internal/tape_ref.h"
@@ -174,22 +172,12 @@ public:
    */
   inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
 
-  /**
-   * Recursive function which processes the JSON path of each child element
-   */
-  inline void process_json_path_of_child_elements(std::vector<element>::iterator& current, std::vector<element>::iterator& end, const std::string_view& path_suffix, std::vector<element>& accumulator) const noexcept;
-
-  /**
-   * Adds support for JSONPath expression with wildcards '*'
-   */
-  inline simdjson_result<std::vector<element>> at_path_with_wildcard(std::string_view json_path) const noexcept;
-
   /**
    * Get the value associated with the given JSONPath expression. We only support
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
+   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
@@ -215,14 +203,6 @@ public:
    */
   inline simdjson_result<element> at_key(std::string_view key) const noexcept;
 
-  /**
-   * Gets the values associated with keys of an object
-   * This function has linear-time complexity: the keys are checked one by one.
-   *
-   * @return the values associated with each key of an object
-   */
-  inline std::vector<element>& get_values(std::vector<element>& out) const noexcept;
-
   /**
    * Get the value associated with the given key in a case-insensitive manner.
    * It is only guaranteed to work over ASCII inputs.
@@ -281,11 +261,8 @@ public:
   inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
   simdjson_result<dom::element> operator[](int) const noexcept = delete;
   inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
-  inline void process_json_path_of_child_elements(std::vector<dom::element>::iterator& current, std::vector<dom::element>::iterator& end, const std::string_view& path_suffix, std::vector<dom::element>& accumulator) const noexcept;
-  inline simdjson_result<std::vector<dom::element>> at_path_with_wildcard(std::string_view json_path_new) const noexcept;
   inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
   inline simdjson_result<dom::element> at_key(std::string_view key) const noexcept;
-  inline std::vector<dom::element>& get_values(std::vector<dom::element>& out) const noexcept;
   inline simdjson_result<dom::element> at_key_case_insensitive(std::string_view key) const noexcept;
 
 #if SIMDJSON_EXCEPTIONS
@@ -297,7 +274,9 @@ public:
 
 } // namespace simdjson
 
-#if SIMDJSON_SUPPORTS_RANGES
+#if defined(__cpp_lib_ranges)
+#include <ranges>
+
 namespace std {
 namespace ranges {
 template<>
@@ -308,6 +287,6 @@ inline constexpr bool enable_view<simdjson::simdjson_result<simdjson::dom::objec
 #endif // SIMDJSON_EXCEPTIONS
 } // namespace ranges
 } // namespace std
-#endif // SIMDJSON_SUPPORTS_RANGES
+#endif // defined(__cpp_lib_ranges)
 
 #endif // SIMDJSON_DOM_OBJECT_H

include/simdjson/dom/parser-inl.h

@@ -35,11 +35,11 @@ inline bool parser::dump_raw_tape(std::ostream &os) const noexcept {
   return valid ? doc.dump_raw_tape(os) : false;
 }
 
-inline simdjson_result<size_t> parser::read_file(std::string_view path) noexcept {
+inline simdjson_result<size_t> parser::read_file(const std::string &path) noexcept {
   // Open the file
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(path.data(), "rb");
+  std::FILE *fp = std::fopen(path.c_str(), "rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -91,18 +91,18 @@ inline simdjson_result<size_t> parser::read_file(std::string_view path) noexcept
   return bytes_read;
 }
 
-inline simdjson_result<element> parser::load(std::string_view path) & noexcept {
+inline simdjson_result<element> parser::load(const std::string &path) & noexcept {
   return load_into_document(doc, path);
 }
 
-inline simdjson_result<element> parser::load_into_document(document& provided_doc, std::string_view path) & noexcept {
+inline simdjson_result<element> parser::load_into_document(document& provided_doc, const std::string &path) & noexcept {
   size_t len;
   auto _error = read_file(path).get(len);
   if (_error) { return _error; }
   return parse_into_document(provided_doc, loaded_bytes.get(), len, false);
 }
 
-inline simdjson_result<document_stream> parser::load_many(std::string_view path, size_t batch_size) noexcept {
+inline simdjson_result<document_stream> parser::load_many(const std::string &path, size_t batch_size) noexcept {
   size_t len;
   auto _error = read_file(path).get(len);
   if (_error) { return _error; }

include/simdjson/dom/parser.h

@@ -102,8 +102,8 @@ public:
    *         - other json errors if parsing fails. You should not rely on these errors to always the same for the
    *           same document: they may vary under runtime dispatch (so they may vary depending on your system and hardware).
    */
-  inline simdjson_result<element> load(std::string_view path) & noexcept;
+  inline simdjson_result<element> load(const std::string &path) & noexcept;
-  inline simdjson_result<element> load(std::string_view path) &&  = delete ;
+  inline simdjson_result<element> load(const std::string &path) &&  = delete ;
 
   /**
    * Load a JSON document from a file into a provide document instance and return a temporary reference to it.
@@ -148,8 +148,8 @@ public:
    *         - other json errors if parsing fails. You should not rely on these errors to always the same for the
    *           same document: they may vary under runtime dispatch (so they may vary depending on your system and hardware).
    */
-  inline simdjson_result<element> load_into_document(document& doc, std::string_view path) & noexcept;
+  inline simdjson_result<element> load_into_document(document& doc, const std::string &path) & noexcept;
-  inline simdjson_result<element> load_into_document(document& doc, std::string_view path) && =delete;
+  inline simdjson_result<element> load_into_document(document& doc, const std::string &path) && =delete;
 
   /**
    * Parse a JSON document and return a temporary reference to it.
@@ -386,7 +386,7 @@ public:
    *         - other json errors if parsing fails. You should not rely on these errors to always the same for the
    *           same document: they may vary under runtime dispatch (so they may vary depending on your system and hardware).
    */
-  inline simdjson_result<document_stream> load_many(std::string_view path, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;
+  inline simdjson_result<document_stream> load_many(const std::string &path, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;
 
   /**
    * Parse a buffer containing many JSON documents.
@@ -657,7 +657,7 @@ private:
   inline error_code ensure_capacity(document& doc, size_t desired_capacity) noexcept;
 
   /** Read the file into loaded_bytes */
-  inline simdjson_result<size_t> read_file(std::string_view path) noexcept;
+  inline simdjson_result<size_t> read_file(const std::string &path) noexcept;
 
   friend class parser::Iterator;
   friend class document_stream;

include/simdjson/dom/serialization-inl.h

@@ -3,8 +3,8 @@
 #define SIMDJSON_SERIALIZATION_INL_H
 
 #include "simdjson/dom/base.h"
-#include "simdjson/dom/parser.h"
 #include "simdjson/dom/serialization.h"
+#include "simdjson/dom/parser.h"
 #include "simdjson/internal/tape_type.h"
 
 #include "simdjson/dom/array-inl.h"
@@ -16,9 +16,7 @@
 namespace simdjson {
 namespace dom {
 inline bool parser::print_json(std::ostream &os) const noexcept {
-  if (!valid) {
+  if (!valid) { return false; }
-    return false;
-  }
   simdjson::internal::string_builder<> sb;
   sb.append(doc.root());
   std::string_view answer = sb.str();
@@ -26,51 +24,37 @@ inline bool parser::print_json(std::ostream &os) const noexcept {
   return true;
 }
 
-inline std::ostream &operator<<(std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, simdjson::dom::element value) {
-                                simdjson::dom::element value) {
+    simdjson::internal::string_builder<> sb;
-  simdjson::internal::string_builder<> sb;
+    sb.append(value);
-  sb.append(value);
+    return (out << sb.str());
-  return (out << sb.str());
 }
 #if SIMDJSON_EXCEPTIONS
-inline std::ostream &
+inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::element> x) {
-operator<<(std::ostream &out,
+    if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-           simdjson::simdjson_result<simdjson::dom::element> x) {
+    return (out << x.value());
-  if (x.error()) {
-    throw simdjson::simdjson_error(x.error());
-  }
-  return (out << x.value());
 }
 #endif
-inline std::ostream &operator<<(std::ostream &out, simdjson::dom::array value) {
+inline std::ostream& operator<<(std::ostream& out, simdjson::dom::array value)  {
-  simdjson::internal::string_builder<> sb;
+    simdjson::internal::string_builder<> sb;
-  sb.append(value);
+    sb.append(value);
-  return (out << sb.str());
+    return (out << sb.str());
 }
 #if SIMDJSON_EXCEPTIONS
-inline std::ostream &
+inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::array> x) {
-operator<<(std::ostream &out,
+    if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-           simdjson::simdjson_result<simdjson::dom::array> x) {
+    return (out << x.value());
-  if (x.error()) {
-    throw simdjson::simdjson_error(x.error());
-  }
-  return (out << x.value());
 }
 #endif
-inline std::ostream &operator<<(std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, simdjson::dom::object value)   {
-                                simdjson::dom::object value) {
+    simdjson::internal::string_builder<> sb;
-  simdjson::internal::string_builder<> sb;
+    sb.append(value);
-  sb.append(value);
+    return (out << sb.str());
-  return (out << sb.str());
 }
 #if SIMDJSON_EXCEPTIONS
-inline std::ostream &
+inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::dom::object> x) {
-operator<<(std::ostream &out,
+    if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-           simdjson::simdjson_result<simdjson::dom::object> x) {
+    return (out << x.value());
-  if (x.error()) {
-    throw simdjson::simdjson_error(x.error());
-  }
-  return (out << x.value());
 }
 #endif
 
@@ -85,9 +69,8 @@ namespace {
  * We expect that most compilers will use 8 bytes for this data structure.
  **/
 struct escape_sequence {
-  uint8_t length;
+    uint8_t length;
-  const char
+    const char string[7]; // technically, we only ever need 6 characters, we pad to 8
-      string[7]; // technically, we only ever need 6 characters, we pad to 8
 };
 /**@private
  * This converts a signed integer into a character sequence.
@@ -103,7 +86,7 @@ static char *fast_itoa(char *output, int64_t value) noexcept {
   char buffer[20];
   uint64_t value_positive;
   // In general, negating a signed integer is unsafe.
-  if (value < 0) {
+  if(value < 0) {
     *output++ = '-';
     // Doing value_positive = -value; while avoiding
     // undefined behavior warnings.
@@ -122,7 +105,7 @@ static char *fast_itoa(char *output, int64_t value) noexcept {
   // A faster approach is possible if we expect large integers:
   // unroll the loop (work in 100s, 1000s) and use some kind of
   // memoization.
-  while (value_positive >= 10) {
+  while(value_positive >= 10) {
     *write_pointer-- = char('0' + (value_positive % 10));
     value_positive /= 10;
   }
@@ -148,7 +131,7 @@ static char *fast_itoa(char *output, uint64_t value) noexcept {
   // A faster approach is possible if we expect large integers:
   // unroll the loop (work in 100s, 1000s) and use some kind of
   // memoization.
-  while (value >= 10) {
+  while(value >= 10) {
     *write_pointer-- = char('0' + (value % 10));
     value /= 10;
   };
@@ -158,6 +141,7 @@ static char *fast_itoa(char *output, uint64_t value) noexcept {
   return output + len;
 }
 
+
 } // anonymous namespace
 namespace internal {
 
@@ -165,208 +149,193 @@ namespace internal {
  * Minifier/formatter code.
  **/
 
-template <class formatter>
+template<class formatter>
 simdjson_inline void base_formatter<formatter>::number(uint64_t x) {
   char number_buffer[24];
   char *newp = fast_itoa(number_buffer, x);
-  chars(number_buffer, newp);
+  buffer.insert(buffer.end(), number_buffer, newp);
 }
 
-template <class formatter>
+template<class formatter>
 simdjson_inline void base_formatter<formatter>::number(int64_t x) {
   char number_buffer[24];
   char *newp = fast_itoa(number_buffer, x);
-  chars(number_buffer, newp);
+  buffer.insert(buffer.end(), number_buffer, newp);
 }
 
-template <class formatter>
+template<class formatter>
 simdjson_inline void base_formatter<formatter>::number(double x) {
   char number_buffer[24];
   // Currently, passing the nullptr to the second argument is
   // safe because our implementation does not check the second
   // argument.
   char *newp = internal::to_chars(number_buffer, nullptr, x);
-  chars(number_buffer, newp);
+  buffer.insert(buffer.end(), number_buffer, newp);
 }
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void base_formatter<formatter>::start_array() {
+simdjson_inline void base_formatter<formatter>::start_array() { one_char('['); }
-  one_char('[');
-}
 
-template <class formatter>
-simdjson_inline void base_formatter<formatter>::end_array() {
-  one_char(']');
-}
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void base_formatter<formatter>::start_object() {
+simdjson_inline void base_formatter<formatter>::end_array() { one_char(']'); }
-  one_char('{');
-}
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void base_formatter<formatter>::end_object() {
+simdjson_inline void base_formatter<formatter>::start_object() { one_char('{'); }
-  one_char('}');
-}
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void base_formatter<formatter>::comma() {
+simdjson_inline void base_formatter<formatter>::end_object() { one_char('}'); }
-  one_char(',');
-}
 
-template <class formatter>
+template<class formatter>
+simdjson_inline void base_formatter<formatter>::comma() { one_char(','); }
+
+template<class formatter>
 simdjson_inline void base_formatter<formatter>::true_atom() {
-  const char *s = "true";
+  const char * s = "true";
-  chars(s, s + 4);
+  buffer.insert(buffer.end(), s, s + 4);
 }
 
-template <class formatter>
+template<class formatter>
 simdjson_inline void base_formatter<formatter>::false_atom() {
-  const char *s = "false";
+  const char * s = "false";
-  chars(s, s + 5);
+  buffer.insert(buffer.end(), s, s + 5);
 }
 
-template <class formatter>
+template<class formatter>
 simdjson_inline void base_formatter<formatter>::null_atom() {
-  const char *s = "null";
+  const char * s = "null";
-  chars(s, s + 4);
+  buffer.insert(buffer.end(), s, s + 4);
 }
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void base_formatter<formatter>::one_char(char c) {
+simdjson_inline void base_formatter<formatter>::one_char(char c) { buffer.push_back(c); }
-  buffer.push_back(c);
-}
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void base_formatter<formatter>::chars(const char *begin,
+simdjson_inline void base_formatter<formatter>::key(std::string_view unescaped) {
-                                                      const char *end) {
-  buffer.append(begin, end);
-}
-
-template <class formatter>
-simdjson_inline void
-base_formatter<formatter>::key(std::string_view unescaped) {
   string(unescaped);
   one_char(':');
 }
 
-template <class formatter>
+template<class formatter>
-simdjson_inline void
+simdjson_inline void base_formatter<formatter>::string(std::string_view unescaped) {
-base_formatter<formatter>::string(std::string_view unescaped) {
   one_char('\"');
   size_t i = 0;
-  // Fast path for the case where we have no control character, no ", and no
+  // Fast path for the case where we have no control character, no ", and no backslash.
-  // backslash. This should include most keys.
+  // This should include most keys.
   //
-  // We would like to use 'bool' but some compilers take offense to bitwise
+  // We would like to use 'bool' but some compilers take offense to bitwise operation
-  // operation with bool types.
+  // with bool types.
-  constexpr static char needs_escaping[] = {
+  constexpr static char needs_escaping[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-      1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  for(;i + 8 <= unescaped.length(); i += 8) {
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-  for (; i + 8 <= unescaped.length(); i += 8) {
     // Poor's man vectorization. This could get much faster if we used SIMD.
     //
-    // It is not the case that replacing '|' with '||' would be neutral
+    // It is not the case that replacing '|' with '||' would be neutral performance-wise.
-    // performance-wise.
+    if(needs_escaping[uint8_t(unescaped[i])] | needs_escaping[uint8_t(unescaped[i+1])]
-    if (needs_escaping[uint8_t(unescaped[i])] |
+      | needs_escaping[uint8_t(unescaped[i+2])] | needs_escaping[uint8_t(unescaped[i+3])]
-        needs_escaping[uint8_t(unescaped[i + 1])] |
+      | needs_escaping[uint8_t(unescaped[i+4])] | needs_escaping[uint8_t(unescaped[i+5])]
-        needs_escaping[uint8_t(unescaped[i + 2])] |
+      | needs_escaping[uint8_t(unescaped[i+6])] | needs_escaping[uint8_t(unescaped[i+7])]
-        needs_escaping[uint8_t(unescaped[i + 3])] |
+      ) { break; }
-        needs_escaping[uint8_t(unescaped[i + 4])] |
-        needs_escaping[uint8_t(unescaped[i + 5])] |
-        needs_escaping[uint8_t(unescaped[i + 6])] |
-        needs_escaping[uint8_t(unescaped[i + 7])]) {
-      break;
-    }
   }
-  for (; i < unescaped.length(); i++) {
+  for(;i < unescaped.length(); i++) {
-    if (needs_escaping[uint8_t(unescaped[i])]) {
+    if(needs_escaping[uint8_t(unescaped[i])]) { break; }
-      break;
-    }
   }
-  // The following is also possible and omits a 256-byte table, but it is
+  // The following is also possible and omits a 256-byte table, but it is slower:
-  // slower: for (; (i < unescaped.length()) && (uint8_t(unescaped[i]) > 0x1F)
+  // for (; (i < unescaped.length()) && (uint8_t(unescaped[i]) > 0x1F)
   //      && (unescaped[i] != '\"') && (unescaped[i] != '\\'); i++) {}
 
   // At least for long strings, the following should be fast. We could
   // do better by integrating the checks and the insertion.
-  chars(unescaped.data(), unescaped.data() + i);
+  buffer.insert(buffer.end(), unescaped.data(), unescaped.data() + i);
   // We caught a control character if we enter this loop (slow).
   // Note that we are do not restart from the beginning, but rather we continue
   // from the point where we encountered something that requires escaping.
   for (; i < unescaped.length(); i++) {
     switch (unescaped[i]) {
-    case '\"': {
+    case '\"':
-      const char *s = "\\\"";
+      {
-      chars(s, s + 2);
+        const char * s = "\\\"";
-    } break;
+        buffer.insert(buffer.end(), s, s + 2);
-    case '\\': {
+      }
-      const char *s = "\\\\";
+      break;
-      chars(s, s + 2);
+    case '\\':
-    } break;
+      {
+        const char * s = "\\\\";
+        buffer.insert(buffer.end(), s, s + 2);
+      }
+      break;
     default:
       if (uint8_t(unescaped[i]) <= 0x1F) {
         // If packed, this uses 8 * 32 bytes.
         // Note that we expect most compilers to embed this code in the data
         // section.
         constexpr static escape_sequence escaped[32] = {
-            {6, "\\u0000"}, {6, "\\u0001"}, {6, "\\u0002"}, {6, "\\u0003"},
+          {6, "\\u0000"}, {6, "\\u0001"}, {6, "\\u0002"}, {6, "\\u0003"},
-            {6, "\\u0004"}, {6, "\\u0005"}, {6, "\\u0006"}, {6, "\\u0007"},
+          {6, "\\u0004"}, {6, "\\u0005"}, {6, "\\u0006"}, {6, "\\u0007"},
-            {2, "\\b"},     {2, "\\t"},     {2, "\\n"},     {6, "\\u000b"},
+          {2, "\\b"},     {2, "\\t"},     {2, "\\n"},     {6, "\\u000b"},
-            {2, "\\f"},     {2, "\\r"},     {6, "\\u000e"}, {6, "\\u000f"},
+          {2, "\\f"},     {2, "\\r"},     {6, "\\u000e"}, {6, "\\u000f"},
-            {6, "\\u0010"}, {6, "\\u0011"}, {6, "\\u0012"}, {6, "\\u0013"},
+          {6, "\\u0010"}, {6, "\\u0011"}, {6, "\\u0012"}, {6, "\\u0013"},
-            {6, "\\u0014"}, {6, "\\u0015"}, {6, "\\u0016"}, {6, "\\u0017"},
+          {6, "\\u0014"}, {6, "\\u0015"}, {6, "\\u0016"}, {6, "\\u0017"},
-            {6, "\\u0018"}, {6, "\\u0019"}, {6, "\\u001a"}, {6, "\\u001b"},
+          {6, "\\u0018"}, {6, "\\u0019"}, {6, "\\u001a"}, {6, "\\u001b"},
-            {6, "\\u001c"}, {6, "\\u001d"}, {6, "\\u001e"}, {6, "\\u001f"}};
+          {6, "\\u001c"}, {6, "\\u001d"}, {6, "\\u001e"}, {6, "\\u001f"}};
         auto u = escaped[uint8_t(unescaped[i])];
-        chars(u.string, u.string + u.length);
+        buffer.insert(buffer.end(), u.string, u.string + u.length);
       } else {
         one_char(unescaped[i]);
       }
     } // switch
-  } // for
+  }   // for
   one_char('\"');
 }
 
-template <class formatter> inline void base_formatter<formatter>::clear() {
+
+template<class formatter>
+inline void base_formatter<formatter>::clear() {
   buffer.clear();
 }
 
-template <class formatter>
+template<class formatter>
 simdjson_inline std::string_view base_formatter<formatter>::str() const {
-  return buffer.str();
+  return std::string_view(buffer.data(), buffer.size());
 }
 
-simdjson_inline void mini_formatter::print_newline() { return; }
+simdjson_inline void mini_formatter::print_newline() {
+    return;
+}
 
 simdjson_inline void mini_formatter::print_indents(size_t depth) {
-  (void)depth;
+    (void)depth;
-  return;
+    return;
 }
 
-simdjson_inline void mini_formatter::print_space() { return; }
+simdjson_inline void mini_formatter::print_space() {
+    return;
+}
 
-simdjson_inline void pretty_formatter::print_newline() { one_char('\n'); }
+simdjson_inline void pretty_formatter::print_newline() {
+    one_char('\n');
+}
 
 simdjson_inline void pretty_formatter::print_indents(size_t depth) {
-  if (this->indent_step <= 0) {
+    if(this->indent_step <= 0) {
-    return;
+        return;
-  }
+    }
-  for (size_t i = 0; i < this->indent_step * depth; i++) {
+    for(size_t i = 0; i < this->indent_step * depth; i++) {
-    one_char(' ');
+        one_char(' ');
-  }
+    }
 }
 
-simdjson_inline void pretty_formatter::print_space() { one_char(' '); }
+simdjson_inline void pretty_formatter::print_space() {
+    one_char(' ');
+}
 
 /***
  * String building code.
@@ -545,8 +514,7 @@ inline void string_builder<serializer>::append(simdjson::dom::array value) {
 }
 
 template <class serializer>
-simdjson_inline void
+simdjson_inline void string_builder<serializer>::append(simdjson::dom::key_value_pair kv) {
-string_builder<serializer>::append(simdjson::dom::key_value_pair kv) {
   format.key(kv.key);
   append(kv.value);
 }
@@ -561,6 +529,7 @@ simdjson_inline std::string_view string_builder<serializer>::str() const {
   return format.str();
 }
 
+
 } // namespace internal
 } // namespace simdjson