Adding explicit popcnt

.clangd

@@ -1,47 +0,0 @@
-CompileFlags:
-    CompilationDatabase: build
-    Add:
-        - -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
-        - -Wundefined-inline
-Diagnostics:
-    Suppress:
-        - misc-unused-alias-decls
-        - misc-unused-using-decls
-        - misc-definitions-in-headers # TODO fix and remove these violations
----
-If:
-    PathMatch:
-        - include/.*
-        - src/.*
-    PathExclude:
-        - include/simdjson.h
-        - src/simdjson.cpp
-CompileFlags:
-    Add:
-        - -Wno-unneeded-internal-declaration
-        - -Wno-undefined-internal # TODO fix and remove these violations
-        - -Wno-unused-function
-        - -Wno-unused-const-variable
-Diagnostics:
-    Suppress:
-        - pp_including_mainfile_in_preamble
-        - unused-includes
----
-# Amalgamated files that require or partly define an implementation
-If:
-    PathMatch:
-        - .*/(arm64|fallback|haswell|icelake|ppc64|westmere)/begin.h
-        - .*/generic/.*
-Diagnostics:
-    Suppress:
-        - pragma_attribute_no_pop_eof
----
-# clang has a bad time detecting the push/pop together in src/ for some reason
-If:
-    PathMatch:
-        - include/simdjson/.*/end.h
-        - src/(arm64|fallback|haswell|icelake|ppc64|westmere).cpp
-Diagnostics:
-    Suppress:
-        - pragma_attribute_no_pop_eof
-        - pragma_attribute_stack_mismatch

.github/ISSUE_TEMPLATE/bug_report.md

@@ -45,15 +45,11 @@ It is fine to report bugs against our main branch, but if that is what you are d
 
 **Configuration (please complete the following information if relevant)**
  - OS: [e.g. Ubuntu 16.04.6 LTS]
- - Compiler* [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
+ - Compiler [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
  - Version [e.g. 22]
  - Optimization setting (e.g., -O3)
 
-We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug.
-
-* We do not support unreleased or experimental compilers. If you encounter an issue with a
-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.
+We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug. In particular, we do not support legacy 32-bit systems.
 
 **Indicate whether you are willing or able to provide a bug fix as a pull request**
 

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +0,0 @@
-blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -31,7 +31,7 @@ A clear and concise description of any alternative solutions or features you've
 **Additional context**
 Add any other context or screenshots about the feature request here.
 
-**Are you willing to contribute code or documentation toward this new feature?**
+** Are you willing to contribute code or documentation toward this new feature? **
 If you plan to contribute to simdjson, please read our
 * CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
 * HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md

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

@@ -18,7 +18,7 @@ We do not make changes to simdjson without clearly identifiable benefits, which
 
 Is your issue:
 
-1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request. As a matter of policy, we do not consider a compiler warning to be a bug.
+1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request.
 
 2. A build issue? If so, provide all possible details regarding your system configuration. If we cannot reproduce your issue, we cannot fix it.
 

.github/workflows/aarch64.yml

@@ -1,29 +0,0 @@
-name: Ubuntu ppc64le (GCC 11)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
-        name: Test
-        id: runcmd
-        with:
-          arch: aarch64
-          distro: ubuntu_latest
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update -q -y
-            apt-get install -y cmake make g++
-          run: |
-            cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
-            cmake --build build -j=2
-            ctest --output-on-failure --test-dir build

.github/workflows/alpine.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -31,4 +31,4 @@ jobs:
           ./alpine.sh cmake --build build_for_alpine
       - name: test
         run: |
-          ./alpine.sh bash -c "cd build_for_alpine && ctest  -LE explicitonly --output-on-failure"
+          ./alpine.sh bash -c "cd build_for_alpine && ctest  -LE explicitonly"

.github/workflows/cifuzz.yml

@@ -17,7 +17,7 @@ jobs:
         fuzz-seconds: 600
         dry-run: false
     - name: Upload Crash
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
       if: failure() && steps.build.outcome == 'success'
       with:
         name: artifacts

.github/workflows/debian.yaml

@@ -16,7 +16,7 @@ jobs:
       image: debian:testing
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
 
     - name: Install dependencies
       run: |

.github/workflows/documentation.yml

@@ -1,8 +1,9 @@
 name: Doxygen GitHub Pages
 
 on:
-  release:
-    types: [created]
+  push:
+    branches:
+      - master
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
@@ -18,7 +19,7 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install Doxygen
         run: sudo apt-get install doxygen graphviz -y
       - run: mkdir docs

.github/workflows/fix-trailing-whitespace.yml

@@ -6,7 +6,7 @@ jobs:
   whitespace:
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Remove whitespace and check the diff
         run: |
           set -eu
@@ -24,7 +24,7 @@ jobs:
              echo "no trailing whitespace found, good!"
           fi
       - name: Archive whitespace patch
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         if: always()
         with:
           name: whitespace-patch

.github/workflows/fuzzers.yml

@@ -24,7 +24,7 @@ jobs:
       implementations: haswell westmere fallback
       UBSAN_OPTIONS: halt_on_error=1
       MAXLEN: -max_len=4000
-      CLANGVERSION: 19
+      CLANGVERSION: 15
       # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
       OPTLEVEL: -O3
 
@@ -34,18 +34,17 @@ jobs:
         sudo apt update
         sudo apt-get install --quiet ninja-build valgrind zip unzip lsb-release wget software-properties-common gnupg
         wget https://apt.llvm.org/llvm.sh
-        sudo apt-get purge --auto-remove llvm python3-lldb-15 llvm-15
         chmod +x llvm.sh
         sudo ./llvm.sh $CLANGVERSION
 
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
 
-    - uses: actions/cache@v4
+    - uses: actions/cache@v3
       with:
         path: dependencies/.cache
         key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
 
-    - uses: actions/cache@v4
+    - uses: actions/cache@v3
       id: cache-corpus
       with:
         path: out/
@@ -125,7 +124,7 @@ jobs:
         done
 
     - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
         name: corpus
         path: corpus.tar
@@ -148,7 +147,7 @@ jobs:
       run: tar cf valgrind.tar valgrind-*.txt
 
     - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       if: always()
       with:
         name: valgrindresults
@@ -156,7 +155,7 @@ jobs:
         if-no-files-found: ignore
 
     - name: Archive any crashes as an artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       if: always()
       with:
         name: crashes

.github/workflows/loongarch64.yml

@@ -1,50 +0,0 @@
-name: LoongArch64-CI
-
-on: [push, pull_request]
-
-jobs:
-  loongarch64:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - { toolchain-version: 2023.08.08 }
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install build requirements
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y --no-install-recommends cmake
-
-      - uses: actions/cache/restore@v4
-        id: restore-cache
-        with:
-          path: /opt/cross-tools
-          key: loongarch64-${{ matrix.platform.toolchain-version }}
-
-      - name: Download LoongArch64 gcc+glibc toolchain
-        if: ${{ !steps.restore-cache.outputs.cache-hit }}
-        run: |
-          url="https://github.com/loongson/build-tools/releases/download/${{ matrix.platform.toolchain-version }}/x86_64-cross-tools-loongarch64-gcc-libc.tar.xz"
-
-          wget "$url" -O /tmp/toolchain.tar.xz
-
-          mkdir -p /opt
-          tar -C /opt -x -f /tmp/toolchain.tar.xz
-
-      - uses: actions/cache/save@v3
-        if: ${{ !steps.restore-cache.outputs.cache-hit }}
-        with:
-          path: /opt/cross-tools
-          key: loongarch64-${{ matrix.platform.toolchain-version }}
-
-      - name: setup Loongarch64 build environment
-        run: |
-          echo "/opt/cross-tools/bin" >> $GITHUB_PATH
-          echo "CC=loongarch64-unknown-linux-gnu-gcc" >> $GITHUB_ENV
-          echo "CXX=loongarch64-unknown-linux-gnu-g++" >> $GITHUB_ENV
-      - name: configure
-        run: cmake -B build -DCMAKE_SYSTEM_PROCESSOR=loongarch64 -DARCH=lonngarch64 -DCMAKE_SYSTEM_NAME=Linux -DCMAKE_C_COMPILER=loongarch64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=loongarch64-unknown-linux-gnu-g++
-      - name: build
-        run: cmake --build build

.github/workflows/macos.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,25 +20,14 @@ jobs:
           cd builddebug &&
           cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cd .. &&
           mkdir build &&
           cd build &&
           cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cmake --install . &&
           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 &&
           mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
-      - name: Use cmake (shared)
-        run: |
-          mkdir buildshared &&
-          cd buildshared &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-          cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
-          cmake --install . &&
-          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 &&
-          mkdir buildshared && cd buildshared && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildshared/destination .. &&  cmake --build .

.github/workflows/msys2-clang.yml

@@ -20,15 +20,12 @@ jobs:
           - msystem: "MINGW64"
             install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
             type: Debug
-          - msystem: "MINGW64"
-            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
-            type: RelWithDebInfo
     env:
       CMAKE_GENERATOR: Ninja
 
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/msys2.yml

@@ -22,15 +22,12 @@ jobs:
           - msystem: "MINGW64"
             install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
             type: Debug
-          - msystem: "MINGW64"
-            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
-            type: RelWithDebInfo
     env:
       CMAKE_GENERATOR: Ninja
 
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/power-fuzz.yml

@@ -0,0 +1,71 @@
+name: short fuzz on the power arch
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  armv7_job:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    # The host should always be Linux
+    runs-on: ubuntu-20.04
+    name: Build on ubuntu-20.04 ppc64le
+    steps:
+      - uses: actions/checkout@v2.1.0
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        name: Run commands
+        id: runcmd
+        env:
+          DEBIAN_FRONTEND: noninteractive
+        with:
+          arch: ppc64le
+          distro: buster
+
+          # Not required, but speeds up builds by storing container images in
+          # a GitHub package registry.
+          githubToken: ${{ github.token }}
+
+          run: |
+            export CLANGSUFFIX="-7"
+            apt-get -qq update
+            apt-get install -q -y clang-7 libfuzzer-7-dev git wget zip ninja-build gnupg software-properties-common
+            wget -q -O - "https://raw.githubusercontent.com/simdjson/debian-ppa/master/key.gpg" | apt-key add -
+            apt-add-repository "deb https://raw.githubusercontent.com/simdjson/debian-ppa/master simdjson main"
+            apt-get -qq update
+            apt-get purge cmake cmake-data
+            apt-get -t simdjson -y install cmake
+            mkdir -p build ; cd build
+            cmake .. -GNinja \
+                  -DCMAKE_CXX_COMPILER=clang++$CLANGSUFFIX \
+                  -DCMAKE_C_COMPILER=clang$CLANGSUFFIX \
+                  -DBUILD_SHARED_LIBS=OFF \
+                  -DSIMDJSON_DEVELOPER_MODE=ON \
+                  -DSIMDJSON_ENABLE_FUZZING=On \
+                  -DSIMDJSON_COMPETITION=OFF \
+                  -DSIMDJSON_GOOGLE_BENCHMARKS=OFF \
+                  -DSIMDJSON_DISABLE_DEPRECATED_API=On \
+                  -DSIMDJSON_FUZZ_LDFLAGS=-lFuzzer \
+                  -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=" \
+                  -DCMAKE_C_FLAGS="-fsanitize=fuzzer-no-link" \
+                  -DCMAKE_BUILD_TYPE=Release \
+                  -DSIMDJSON_FUZZ_LINKMAIN=Off
+            cd ..
+            builddir=build
+            cmake --build $builddir
+            wget -O corpus.tar.gz https://readonly:readonly@www.pauldreik.se/fuzzdata/index.php?project=simdjson
+            tar xf corpus.tar.gz
+            fuzzernames=$(cmake --build $builddir --target print_all_fuzzernames |tail -n1)
+            for fuzzer in $fuzzernames ; do
+               exe=$builddir/fuzz/$fuzzer
+               shortname=$(echo $fuzzer |cut -f2- -d_)
+               echo found fuzzer $shortname with executable $exe
+               mkdir -p out/$shortname
+               others=$(find out -type d -not -name $shortname -not -name out -not -name cmin)
+               $exe -max_total_time=20  -max_len=4000 out/$shortname $others
+               echo "*************************************************************************"
+            done
+            echo "all is good, no errors found in any of these fuzzers: $fuzzernames"

.github/workflows/ppc64.yml

@@ -1,29 +0,0 @@
-name: Ubuntu ppc64le (GCC 11)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
-        name: Test
-        id: runcmd
-        with:
-          arch: ppc64le
-          distro: ubuntu_latest
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update -q -y
-            apt-get install -y cmake make g++
-          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
-            cmake --build build -j=2
-            ctest --output-on-failure --test-dir build

.github/workflows/riscv64.yml

@@ -1,29 +0,0 @@
-name: Ubuntu riscv64 (GCC 11)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
-        name: Test
-        id: runcmd
-        with:
-          arch: riscv64
-          distro: ubuntu_latest
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update -q -y
-            apt-get install -y cmake make g++
-          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
-            cmake --build build -j=2
-            ctest --output-on-failure --test-dir build

.github/workflows/s390x.yml

@@ -12,8 +12,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: actions/checkout@v3
+      - uses: uraimo/run-on-arch-action@v2
         name: Test
         id: runcmd
         with:
@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/ubuntu20-checkperf.yml

@@ -15,8 +15,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu20-gcc8.yml

@@ -12,8 +12,8 @@ jobs:
       CXX: g++-8
       CC: gcc-8
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -25,13 +25,13 @@ jobs:
           cd builddebug &&
           cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cd .. &&
           mkdir build &&
           cd build &&
           cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cmake --install . &&
           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 &&

.github/workflows/ubuntu20-noexcept.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,13 +20,13 @@ jobs:
           cd builddebug &&
           cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cd .. &&
           mkdir build &&
           cd build &&
           cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           make install  &&
           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 &&

.github/workflows/ubuntu20-nothread.yml

@@ -9,8 +9,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,13 +20,13 @@ jobs:
           cd builddebug &&
           cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cd .. &&
           mkdir build &&
           cd build &&
           cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           make install  &&
           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 &&

.github/workflows/ubuntu20-sani.yml

@@ -3,14 +3,14 @@ name: Ubuntu 20.04 CI (GCC 9) With Memory Sanitizer
 on: [push, pull_request]
 
 jobs:
-  ubuntu-build-address-sanitizier:
+  ubuntu-build:
     if: >-
       ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,22 +20,11 @@ jobs:
           cd builddebug &&
           cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j
-  ubuntu-build-undefined-sanitizer:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+          ctest -j --output-on-failure -LE explicitonly
       - name: Use cmake with undefined sanitizer
         run: |
           mkdir builddebugundefsani &&
           cd builddebugundefsani &&
           cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j
+          ctest -j --output-on-failure -LE explicitonly

.github/workflows/ubuntu20-threadsani.yml

@@ -1,4 +1,4 @@
-name: Ubuntu 22.04 CI (GCC 12) with Thread Sanitizer
+name: Ubuntu 20.04 CI (GCC 9) with Thread Sanitizer
 
 on: [push, pull_request]
 
@@ -7,10 +7,10 @@ jobs:
     if: >-
       ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -18,7 +18,7 @@ jobs:
         run: |
           mkdir build &&
           cd build &&
-          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
           cmake --build . --target document_stream_tests  --target ondemand_document_stream_tests --target parse_many_test  &&
           ctest --output-on-failure  -R parse_many_test  &&
           ctest --output-on-failure  -R document_stream_tests

.github/workflows/ubuntu20.yml

@@ -9,38 +9,24 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Use cmake to build just the library
-        run: |
-          mkdir buildjustlib &&
-          cd buildjustlib &&
-          cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DEVELOPER_MODE=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-          cmake --build .   &&
-          cmake --install . &&
-          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 &&
-          cd ../tests/installation_tests/find &&
-          mkdir buildjustlib &&
-          cd buildjustlib &&
-          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildjustlib/destination .. &&
-          cmake --build .
       - name: Use cmake
         run: |
           mkdir builddebug &&
           cd builddebug &&
           cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cd .. &&
           mkdir build &&
           cd build &&
           cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cmake --install . &&
           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 &&

.github/workflows/ubuntu22-clang13.yml

@@ -9,15 +9,17 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Install clang++-13
+        run: sudo apt-get install -y clang++-13
       - name: Use cmake
         run: |
           mkdir build &&
           cd build &&
           CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j
+          ctest -j --output-on-failure -LE explicitonly

.github/workflows/ubuntu22-clang14.yml

@@ -9,15 +9,17 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Install clang++-14
+        run: sudo apt-get install -y clang++-14
       - name: Use cmake
         run: |
           mkdir build &&
           cd build &&
           CXX=clang++-14 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j
+          ctest -j --output-on-failure -LE explicitonly

.github/workflows/ubuntu22-cxx20.yml

@@ -1,33 +0,0 @@
-name: Ubuntu 22.04 CI (GCC 12, CXX 20)
-
-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-22.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Use cmake
-        run: |
-          mkdir builddebug &&
-          cd builddebug &&
-          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
-          cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
-          cd .. &&
-          mkdir build &&
-          cd build &&
-          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 .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
-          cmake --install . &&
-          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 &&
-          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .

.github/workflows/ubuntu22-gcc12.yml

@@ -9,15 +9,17 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Install gcc12
+        run: sudo apt-get install -y g++-12
       - name: Use cmake
         run: |
           mkdir build &&
           cd build &&
           CXX=g++-12 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j
+          ctest -j --output-on-failure -LE explicitonly

.github/workflows/ubuntu22-glibcxxassertions.yml

@@ -8,8 +8,8 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.github/workflows/ubuntu22.yml

@@ -9,38 +9,24 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: dependencies/.cache
           key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Use cmake to build just the library
-        run: |
-          mkdir buildjustlib &&
-          cd buildjustlib &&
-          cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DEVELOPER_MODE=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-          cmake --build .   &&
-          cmake --install . &&
-          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 &&
-          cd ../tests/installation_tests/find &&
-          mkdir buildjustlib &&
-          cd buildjustlib &&
-          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildjustlib/destination .. &&
-          cmake --build .
       - name: Use cmake
         run: |
           mkdir builddebug &&
           cd builddebug &&
           cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cd .. &&
           mkdir build &&
           cd build &&
           cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
-          ctest --output-on-failure -LE explicitonly -j   &&
+          ctest -j --output-on-failure -LE explicitonly   &&
           cmake --install . &&
           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 &&

.github/workflows/ubuntu24-cxx20.yml

@@ -1,22 +0,0 @@
-name: Ubuntu 24.04 CI (CXX 20)
-
-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_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.yml

@@ -1,25 +0,0 @@
-name: Ubuntu 24.04 CI
-
-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:
-        shared: [ON, OFF]
-        cxx: [g++-13, clang++-16]
-        sanitizer: [ON, OFF]
-        build_type: [RelWithDebInfo, Debug, Release]
-    steps:
-      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
-      - name: Prepare
-        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}}  -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/vs17-arm-ci.yml

@@ -10,12 +10,12 @@ jobs:
        fail-fast: false
        matrix:
          include:
+           - {arch: ARM}
            - {arch: ARM64}
-           - {arch: ARM64EC}
      steps:
        - name: checkout
-         uses: actions/checkout@v4
+         uses: actions/checkout@v3
        - name: Use cmake
          run: |
-           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
-           cmake --build build --verbose
+           cmake -A ${{ matrix.arch }} -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
+           cmake --build build --verbose

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

@@ -1,44 +0,0 @@
-name: VS17-CI CXX20
-
-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: Win32, shared: ON}
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-    - name: Configure
-      run: |
-        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
-    - name: Build Debug
-      run: cmake --build build --config Debug --verbose
-    - name: Build Release
-      run: cmake --build build --config Release --verbose
-    - name: Run Release tests
-      run: |
-        cd build
-        ctest -C Release  -LE explicitonly  --output-on-failure
-    - name: Run Debug tests
-      run: |
-        cd build
-        ctest -C Debug  -LE explicitonly  --output-on-failure
-    - name: Install
-      run: |
-        cmake --install build --config Release
-    - name: Test Installation
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config Release

.github/workflows/vs17-ci.yml

@@ -13,28 +13,32 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: ON, build_type: Release}
-          - {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}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
     steps:
     - name: checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
     - name: Configure
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
     - name: Build Debug
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
-    - name: Run tests
+      run: cmake --build build --config Debug --verbose
+    - name: Build Release
+      run: cmake --build build --config Release --verbose
+    - name: Run Release tests
       run: |
         cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
+        ctest -C Release  -LE explicitonly  --output-on-failure
+    - name: Run Debug tests
+      run: |
+        cd build
+        ctest -C Debug  -LE explicitonly  --output-on-failure
     - name: Install
       run: |
-        cmake --install build --config ${{matrix.build_type}}
+        cmake --install build --config Release
     - name: Test Installation
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
+        cmake --build build_install_test --config Release

.github/workflows/vs17-clang-ci-cxx20.yml

@@ -1,37 +0,0 @@
-name: VS17-CLANG-CI
-
-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, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v4
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -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
-    - name: Install
-      run: |
-        cmake --install build --config ${{matrix.build_type}}
-    - name: Test Installation
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}

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

@@ -13,25 +13,29 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
-          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
+          - {gen: Visual Studio 17 2022, arch: x64}
     steps:
     - name: checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
     - name: Configure
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
-    - name: Build
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
-    - name: Run tests
+    - name: Build Debug
+      run: cmake --build build --config Debug --verbose
+    - name: Build Release
+      run: cmake --build build --config Release --verbose
+    - name: Run Release tests
       run: |
         cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
+        ctest -C Release  -LE explicitonly  --output-on-failure
+    - name: Run Debug tests
+      run: |
+        cd build
+        ctest -C Debug  -LE explicitonly  --output-on-failure
     - name: Install
       run: |
-        cmake --install build --config ${{matrix.build_type}}
+        cmake --install build --config Release
     - name: Test Installation
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
+        cmake --build build_install_test --config Release

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

@@ -7,8 +7,8 @@ jobs:
     name: windows-vs17
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/cache@v4
+    - uses: actions/checkout@v3
+    - uses: actions/cache@v3
       with:
         path: dependencies/.cache
         key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

.gitignore

@@ -104,6 +104,3 @@ objs
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
-
-# clangd
-.cache

.vscode/extensions.json

@@ -4,15 +4,10 @@
 
 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
-		// C++
-		"llvm-vs-code-extensions.vscode-clangd",
-		"xaver.clang-format",
-		// Python
-		"ms-python.python",
-		// .github/*
-		"github.vscode-github-actions",
-		// cmake
+		// Syntax
+		"ms-vscode.cpptools",
 		"ms-vscode.cmake-tools",
+		"ms-python.python",
 		"twxs.cmake"
 	],
 	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.

.vscode/settings.json

@@ -5,7 +5,6 @@
     ],
     "files.trimTrailingWhitespace": true,
     "files.associations": {
-        ".clangd": "yaml",
         "array": "cpp",
         "iterator": "cpp",
         "chrono": "cpp",
@@ -98,34 +97,6 @@
         "queue": "cpp",
         "shared_mutex": "cpp",
         "ranges": "cpp",
-        "span": "cpp",
-        "__verbose_abort": "cpp",
-        "charconv": "cpp",
-        "source_location": "cpp",
-        "strstream": "cpp",
-        "typeindex": "cpp",
-        "*.tcc": "cpp",
-        "memory_resource": "cpp",
-        "numbers": "cpp",
-        "semaphore": "cpp",
-        "stop_token": "cpp",
-        "cfenv": "cpp",
-        "format": "cpp",
-        "xlocmes": "cpp",
-        "xlocmon": "cpp",
-        "xlocnum": "cpp",
-        "xloctime": "cpp",
-        "xutility": "cpp",
-        "coroutine": "cpp",
-        "xfacet": "cpp",
-        "xhash": "cpp",
-        "xiosbase": "cpp",
-        "xlocale": "cpp",
-        "xlocbuf": "cpp",
-        "xlocinfo": "cpp",
-        "xmemory": "cpp",
-        "xstring": "cpp",
-        "xtr1common": "cpp",
-        "xtree": "cpp"
+        "span": "cpp"
     }
 }

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 3.12.2
+    VERSION 3.1.7
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,14 +20,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "25.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "25" 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)
-  message(WARNING "SIMDJSON_BUILD_STATIC_LIB only makes sense if BUILD_SHARED_LIBS is set to ON")
-  message(WARNING "You might be building and installing a two identical static libraries.")
-endif()
+set(SIMDJSON_LIB_VERSION "15.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "15" CACHE STRING "simdjson library soversion")
 
 option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
 
@@ -43,20 +37,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)
@@ -69,7 +49,6 @@ endif()
 if(is_top_project)
   option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
   option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
-  option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)
 endif()
 
 include(cmake/handle-deprecations.cmake)
@@ -77,17 +56,8 @@ include(cmake/developer-options.cmake)
 
 # ---- simdjson library ----
 
-set(SIMDJSON_SOURCES src/simdjson.cpp)
-
-add_library(simdjson ${SIMDJSON_SOURCES})
+add_library(simdjson src/simdjson.cpp)
 add_library(simdjson::simdjson ALIAS simdjson)
-set(SIMDJSON_LIBRARIES simdjson)
-
-if(SIMDJSON_BUILD_STATIC_LIB)
-  add_library(simdjson_static STATIC ${SIMDJSON_SOURCES})
-  add_library(simdjson::simdjson_static ALIAS simdjson_static)
-  list(APPEND SIMDJSON_LIBRARIES simdjson_static)
-endif()
 
 set_target_properties(
     simdjson PROPERTIES
@@ -112,16 +82,7 @@ simdjson_add_props(
     PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )
 
-if(SIMDJSON_STATIC_REFLECTION)
-  # 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()
+simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
 
 # workaround for GNU GCC poor AVX load/store code generation
 if(
@@ -134,24 +95,6 @@ if(
   )
 endif()
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(loongarch64)$")
-    option(SIMDJSON_PREFER_LSX "Prefer LoongArch SX" ON)
-    include(CheckCXXCompilerFlag)
-    check_cxx_compiler_flag(-mlasx COMPILER_SUPPORTS_LASX)
-    check_cxx_compiler_flag(-mlsx COMPILER_SUPPORTS_LSX)
-    if(COMPILER_SUPPORTS_LASX AND NOT SIMDJSON_PREFER_LSX)
-        simdjson_add_props(
-            target_compile_options PRIVATE
-            -mlasx
-        )
-    elseif(COMPILER_SUPPORTS_LSX)
-        simdjson_add_props(
-            target_compile_options PRIVATE
-            -mlsx
-        )
-    endif()
-endif()
-
 # GCC and Clang have horrendous Debug builds when using SIMD.
 # A common fix is to use '-Og' instead.
 # bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412
@@ -174,22 +117,17 @@ if(SIMDJSON_ENABLE_THREADS)
 endif()
 
 simdjson_apply_props(simdjson)
-if(SIMDJSON_BUILD_STATIC_LIB)
-  simdjson_apply_props(simdjson_static)
-endif()
 
 # ---- Install rules ----
 
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 
-if(SIMDJSON_SINGLEHEADER)
-  install(
-      FILES singleheader/simdjson.h
-      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-      COMPONENT simdjson_Development
-  )
-endif()
+install(
+    FILES singleheader/simdjson.h
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT simdjson_Development
+)
 
 install(
     TARGETS simdjson
@@ -200,6 +138,7 @@ install(
     ARCHIVE COMPONENT simdjson_Development
     INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 )
+
 configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)
 
 write_basic_package_version_file(
@@ -228,21 +167,6 @@ install(
     COMPONENT simdjson_Development
 )
 
-if(SIMDJSON_BUILD_STATIC_LIB)
-  install(
-      TARGETS simdjson_static
-      EXPORT simdjson_staticTargets
-      ARCHIVE COMPONENT simdjson_Development
-      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-  )
-  install(
-      EXPORT simdjson_staticTargets
-      NAMESPACE simdjson::
-      DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-      COMPONENT simdjson_Development
-  )
-endif()
-
 # pkg-config
 include(cmake/JoinPaths.cmake)
 join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
@@ -310,7 +234,6 @@ enable_testing()
 add_custom_target(all_tests)
 
 add_subdirectory(windows)
-include(cmake/CPM.cmake)
 add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
 add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
 
@@ -318,9 +241,8 @@ add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
 # most of the data has been moved to https://github.com/simdjson/simdjson-data
 add_subdirectory(jsonexamples)
 
-if(SIMDJSON_SINGLEHEADER)
+
 add_subdirectory(singleheader)
-endif()
 
 
 

CONTRIBUTING.md

@@ -52,11 +52,10 @@ General Guidelines
 Contributors are encouraged to :
 
 - Document their changes. Though we do not enforce a rule regarding code comments, we prefer that non-trivial algorithms and techniques be somewhat documented in the code.
-- Follow as much as possible the existing code style. We do not enforce a specific code style, but we prefer consistency. We avoid contractions (isn't, aren't) in the comments.
+- Follow as much as possible the existing code style. We do not enforce a specific code style, but we prefer consistency.
 - Modify as few lines of code as possible when working on an issue. The more lines you modify, the harder it is for your fellow human beings to understand what is going on.
 - Tools may report "problems" with the code, but we never delegate programming to tools: if there is a problem with the code, we need to understand it. Thus we will not "fix" code merely to please a static analyzer.
 - Provide tests for any new feature. We will not merge a new feature without tests.
-- Run before/after benchmarks so that we can appreciate the effect of the changes on the performance.
 
 Pull Requests
 --------------

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         = "3.12.2"
+PROJECT_NUMBER         = "3.1.7"
 
 # 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

@@ -6,26 +6,16 @@ Here is wisdom about how to build, test and run simdjson from within the reposit
 
 If you plan to contribute to simdjson, please read our [CONTRIBUTING](https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md) guide.
 
-- [Hacking simdjson](#hacking-simdjson)
-  - [Build Quickstart](#build-quickstart)
+
   - [Design notes](#design-notes)
   - [Developer mode](#developer-mode)
   - [Directory Structure and Source](#directory-structure-and-source)
   - [Runtime Dispatching](#runtime-dispatching)
   - [Regenerating Single-Header Files](#regenerating-single-header-files)
   - [Usage (CMake on 64-bit platforms like Linux, FreeBSD or macOS)](#usage-cmake-on-64-bit-platforms-like-linux-freebsd-or-macos)
-  - [Usage (CMake on 64-bit Windows using Visual Studio 2019 or better)](#usage-cmake-on-64-bit-windows-using-visual-studio-2019-or-better)
+  - [Usage (CMake on 64-bit Windows using Visual Studio 2019)](#usage-cmake-on-64-bit-windows-using-visual-studio-2019)
   - [Various References](#various-references)
 
-Build Quickstart
-------------------------------
-
-```bash
-mkdir build
-cd build
-cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
-cmake --build .
-```
 
 Design notes
 ------------------------------
@@ -73,34 +63,26 @@ simdjson's source structure, from the top level, looks like this:
 
 * **CMakeLists.txt:** The main build system.
 * **include:** User-facing declarations and inline definitions (most user-facing functions are inlined).
-  * simdjson.h: the `simdjson` namespace. A "main include" that includes files from include/simdjson/. This is equivalent to
+  * simdjson.h: A "main include" that includes files from include/simdjson/. This is equivalent to
     the distributed simdjson.h.
-    * simdjson/*.h: Declarations for public simdjson classes and functions.
-    * simdjson/*-inl.h: Definitions for public simdjson classes and functions.
-    * simdjson/internal/*.h: the `simdjson::internal` namespace. Private classes and functions used by the rest of simdjson.
-  * simdjson/dom.h: the `simdjson::dom` namespace. Includes all public DOM classes.
-    * simdjson/dom/*.h: Declarations/definitions for individual DOM classes.
-  * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere.h: `simdjson::<implementation>` namespace. Common implementation-specific tools like number and string parsing, as well as minification.
-    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/*.h: implementation-specific functions such as , etc.
-    * simdjson/generic/*.h: the bulk of the actual code, written generically and compiled for each implementation, using functions defined in the implementation's .h files.
-      * simdjson/generic/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
-      * simdjson/generic/amalgamated.h: all generic ondemand classes for an implementation.
-  * simdjson/ondemand.h: the `simdjson::ondemand` namespace. Includes all public ondemand classes.
-    * simdjson/builtin.h: the `simdjson::builtin` namespace. Aliased to the most universal implementation available.
-    * simdjson/builtin/ondemand.h: the `simdjson::builtin::ondemand` namespace.
-    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/ondemand.h: the `simdjson::<implementation>::ondemand` namespace. On-Demand compiled for the specific implementation.
-    * simdjson/generic/ondemand/*.h: individual On-Demand classes, generically written.
-      * simdjson/generic/ondemand/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
-      * simdjson/generic/ondemand/amalgamated.h: all generic ondemand classes for an implementation.
+  * simdjson/*.h: Declarations for public simdjson classes and functions.
+  * simdjson/*-inl.h: Definitions for public simdjson classes and functions.
 * **src:** The source files for non-inlined functionality (e.g. the architecture-specific parser
   implementations).
   * simdjson.cpp: A "main source" that includes all implementation files from src/. This is
     equivalent to the distributed simdjson.cpp.
-  * *.cpp: other misc. implementations, such as `simdjson::implementation` and the minifier.
-  * arm64|fallback|haswell|icelake|ppc64|westmere.cpp: Architecture-specific parser implementations.
-    * generic/*.h: `simdjson::<implementation>` namespace. Generic implementation of the parser, particularly the `dom_parser_implementation`.
-    * generic/stage1/*.h: `simdjson::<implementation>::stage1` namespace. Generic implementation of the simd-heavy tokenizer/indexer pass of the simdjson parser. Used for the On-Demand interface
-    * 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.
+  * arm64/|fallback/|haswell/|ppc64/|westmere/: Architecture-specific implementations. All functions are
+    Each architecture defines its own namespace, e.g. simdjson::haswell.
+  * generic/: Generic implementations of the simdjson parser. These files may be included and
+    compiled multiple times, from whichever architectures use them. They assume they are already
+    enclosed in a namespace, e.g.:
+    ```c++
+    namespace simdjson {
+      namespace haswell {
+        #include "generic/stage1/json_structural_indexer.h"
+      }
+    }
+    ```
 
 Other important files and directories:
 * **.drone.yml:** Definitions for Drone CI.
@@ -283,6 +265,8 @@ If your compiler does not default on C++11 support or better you may get failing
 
 Note that the name of directory (`build`) is arbitrary, you can name it as you want (e.g., `buildgcc`) and you can have as many different such directories as you would like (one per configuration).
 
+
+
 ## Usage (CMake on 64-bit Windows using Visual Studio 2019 or better)
 
 Recent versions of Visual Studio support CMake natively, [please refer to the Visual Studio documentation](https://learn.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio?view=msvc-170).
@@ -302,15 +286,17 @@ Though having Visual Studio installed is necessary, one can build simdjson using
 - `mkdir build`
 - `cd build`
 - `cmake ..`
-- `cmake --build . --config Release`
+- `cmake --build . -config Release`
 
 
 Furthermore, if you have installed LLVM clang on Windows, for example as a component of Visual Studio 2019, you can configure and build simdjson using LLVM clang on Windows using cmake:
 
+
 - `mkdir build`
 - `cd build`
 - `cmake -T ClangCL ..`
-- `cmake --build . --config Release`
+- `cmake --build . -config Release`
+
 
 ## Various References
 

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2018-2025 The simdjson authors
+   Copyright 2018-2023 The simdjson authors
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE-MIT

@@ -1,18 +0,0 @@
-Copyright 2018-2025 The simdjson authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,7 +1,9 @@
 
+[![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
+![VS16-CI](https://github.com/simdjson/simdjson/workflows/VS16-CI/badge.svg)
 [![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]
-
+![MinGW64-CI](https://github.com/simdjson/simdjson/workflows/MinGW64-CI/badge.svg)
+[![][license img]][license]
 
 [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.github.io/simdjson/)
 
@@ -26,47 +28,16 @@ This library is part of the [Awesome Modern C++](https://awesomecpp.com) list.
 Table of Contents
 -----------------
 
-* [Real-world usage](#real-world-usage)
 * [Quick Start](#quick-start)
 * [Documentation](#documentation)
-* [Godbolt](#godbolt)
 * [Performance results](#performance-results)
-* [Packages](#packages)
+* [Real-world usage](#real-world-usage)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
 * [Contributing to simdjson](#contributing-to-simdjson)
 * [License](#license)
 
-
-Real-world usage
-----------------
-
-- [Node.js](https://nodejs.org/)
-- [ClickHouse](https://github.com/ClickHouse/ClickHouse)
-- [Meta Velox](https://velox-lib.io)
-- [Google Pax](https://github.com/google/paxml)
-- [milvus](https://github.com/milvus-io/milvus)
-- [QuestDB](https://questdb.io/blog/questdb-release-8-0-3/)
-- [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
-- [Shopify HeapProfiler](https://github.com/Shopify/heap-profiler)
-- [StarRocks](https://github.com/StarRocks/starrocks)
-- [Microsoft FishStore](https://github.com/microsoft/FishStore)
-- [Intel PCM](https://github.com/intel/pcm)
-- [WatermelonDB](https://github.com/Nozbe/WatermelonDB)
-- [Apache Doris](https://github.com/apache/doris)
-- [Dgraph](https://github.com/dgraph-io/dgraph)
-- [UJRPC](https://github.com/unum-cloud/ujrpc)
-- [fastgltf](https://github.com/spnda/fastgltf)
-- [vast](https://github.com/tenzir/vast)
-- [ada-url](https://github.com/ada-url/ada)
-- [fastgron](https://github.com/adamritter/fastgron)
-- [WasmEdge](https://wasmedge.org)
-- [RonDB](https://github.com/logicalclocks/rondb)
-
-
-If you are planning to use simdjson in a product, please work from one of our releases.
-
 Quick Start
 -----------
 
@@ -74,9 +45,9 @@ The simdjson library is easily consumable with a single .h and .cpp file.
 
 0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit
    system with a command-line shell (e.g., Linux, macOS, freeBSD). We also support programming
-   environments like Visual Studio and Xcode, but different steps are needed. Users of clang++ may need to specify the C++ version (e.g., `c++ -std=c++17`) since clang++ tends to default on C++98.
+   environments like Visual Studio and Xcode, but different steps are needed.
 1. Pull [simdjson.h](singleheader/simdjson.h) and [simdjson.cpp](singleheader/simdjson.cpp) into a
-   directory, along with the sample file [twitter.json](jsonexamples/twitter.json). You can download them with the `wget` utility:
+   directory, along with the sample file [twitter.json](jsonexamples/twitter.json).
 
    ```
    wget https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.h https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.cpp https://raw.githubusercontent.com/simdjson/simdjson/master/jsonexamples/twitter.json
@@ -93,14 +64,13 @@ int main(void) {
     ondemand::document tweets = parser.iterate(json);
     std::cout << uint64_t(tweets["search_metadata"]["count"]) << " results." << std::endl;
 }
-```
+
+   ```
 3. `c++ -o quickstart quickstart.cpp simdjson.cpp`
 4. `./quickstart`
-
-  ```
+   ```
    100 results.
-  ```
-
+   ```
 
 Documentation
 -------------
@@ -108,18 +78,10 @@ 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.
-
-Godbolt
--------------
-
-Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
-* [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)
+* [API](https://simdjson.org/api/1.0.0/annotated.html) contains the automatically generated API documentation.
 
 Performance results
 -------------------
@@ -147,10 +109,25 @@ speed for [synthetic files over various sizes generated with a script](https://g
 For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).
 
 
-Packages
-------------------------------
-[![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)
 
+Real-world usage
+----------------
+
+- [ClickHouse](https://github.com/ClickHouse/ClickHouse)
+- [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
+- [Shopify HeapProfiler](https://github.com/Shopify/heap-profiler)
+- [StarRocks](https://github.com/StarRocks/starrocks)
+- [Microsoft FishStore](https://github.com/microsoft/FishStore)
+- [Intel PCM](https://github.com/intel/pcm)
+- [WatermelonDB](https://github.com/Nozbe/WatermelonDB)
+- [Apache Doris](https://github.com/apache/doris)
+- [Dgraph](https://github.com/dgraph-io/dgraph)
+- [UJRPC](https://github.com/unum-cloud/ujrpc)
+- [fastgltf](https://github.com/spnda/fastgltf)
+- [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
+- [vast](https://github.com/tenzir/vast)
+
+If you are planning to use simdjson in a product, please work from one of our releases.
 
 Bindings and Ports of simdjson
 ------------------------------
@@ -177,8 +154,6 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [simdjzon](https://github.com/travisstaloch/simdjzon): zig port.
 - [JSON-Simd](https://github.com/rawleyfowler/JSON-simd): Raku bindings.
 - [JSON::SIMD](https://metacpan.org/pod/JSON::SIMD): Perl bindings; fully-featured JSON module that uses simdjson for decoding.
-- [gemmaJSON](https://github.com/sainttttt/gemmaJSON): Nim JSON parser based on simdjson bindings.
-- [simdjson-java](https://github.com/simdjson/simdjson-java): Java port.
 
 About simdjson
 --------------
@@ -187,11 +162,7 @@ The simdjson library takes advantage of modern microarchitectures, parallelizing
 instructions, reducing branch misprediction, and reducing data dependency to take advantage of each
 CPU's multiple execution cores.
 
-Our default front-end is called On-Demand, and we wrote a paper about it:
-
-- John Keiser, Daniel Lemire, [On-Demand JSON: A Better Way to Parse Documents?](http://arxiv.org/abs/2312.17149), Software: Practice and Experience 54 (6), 2024.
-
-Some people [enjoy reading the first (2019) simdjson paper](https://arxiv.org/abs/1902.08318): A description of the design
+Some people [enjoy reading our paper](https://arxiv.org/abs/1902.08318): A description of the design
 and implementation of simdjson is in our research article:
 - Geoff Langdale, Daniel Lemire, [Parsing Gigabytes of JSON per Second](https://arxiv.org/abs/1902.08318), VLDB Journal 28 (6), 2019.
 
@@ -208,17 +179,12 @@ For the video inclined, <br />
 Funding
 -------
 
-The work is supported by the Natural Sciences and Engineering Research Council of Canada under grants
-RGPIN-2017-03910 and RGPIN-2024-03787.
+The work is supported by the Natural Sciences and Engineering Research Council of Canada under grant
+number RGPIN-2017-03910.
 
 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg
 
-
-[licensemit]: LICENSE-MIT
-[licensemit img]: https://img.shields.io/badge/License-MIT-blue.svg
-
-
 Contributing to simdjson
 ------------------------
 
@@ -228,7 +194,7 @@ Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing
 License
 -------
 
-This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) as well as under the MIT License. As a user, you can pick the license you prefer.
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
 
 Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it is under the liberal (business-friendly) MIT license.
 

SECURITY.md

@@ -1,7 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-Please use the following contact information for reporting a vulnerability:
-
-- [Daniel Lemire](https://github.com/lemire) - daniel@lemire.me

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)
@@ -29,12 +26,6 @@ if (TARGET benchmark::benchmark)
     if(TARGET nlohmann_json)
       target_link_libraries(bench_ondemand PRIVATE nlohmann_json)
     endif()
-    if(TARGET boostjson)
-      target_link_libraries(bench_ondemand PRIVATE boostjson)
-    endif()
   endif()
 endif()
 
-if(SIMDJSON_STATIC_REFLECTION)
-  add_subdirectory(static_reflect)
-endif(SIMDJSON_STATIC_REFLECTION)

benchmark/bench_dom_api.cpp

@@ -473,6 +473,28 @@ static void twitter_count(State& state) {
 }
 BENCHMARK(twitter_count);
 
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_DEPRECATED_WARNING
+static void iterator_twitter_count(State& state) {
+  // Prints the number of results in twitter.json
+  padded_string json = padded_string::load(TWITTER_JSON);
+  ParsedJson pj = build_parsed_json(json);
+  for (simdjson_unused auto _ : state) {
+    ParsedJson::Iterator iter(pj);
+    // uint64_t result_count = doc["search_metadata"]["count"];
+    if (!iter.move_to_key("search_metadata")) { return; }
+    if (!iter.move_to_key("count")) { return; }
+    if (!iter.is_integer()) { return; }
+    int64_t result_count = iter.get_integer();
+
+    if (result_count != 100) { return; }
+  }
+}
+BENCHMARK(iterator_twitter_count);
+SIMDJSON_POP_DISABLE_WARNINGS
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
 static void twitter_default_profile(State& state) {
   // Count unique users with a default profile.
   dom::parser parser;
@@ -499,7 +521,7 @@ static void twitter_image_sizes(State& state) {
     set<tuple<uint64_t, uint64_t>> image_sizes;
     for (dom::object tweet : doc["statuses"]) {
       dom::array media;
-      if (! (error = tweet["entities"]["media"].get(media))) {
+      if (not (error = tweet["entities"]["media"].get(media))) {
         for (dom::object image : media) {
           for (auto size : image["sizes"].get_object()) {
              image_sizes.emplace(size.value["w"], size.value["h"]);
@@ -556,6 +578,54 @@ static void error_code_twitter_default_profile(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_default_profile);
 
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_DEPRECATED_WARNING
+
+static void iterator_twitter_default_profile(State& state) {
+  // Count unique users with a default profile.
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
+  ParsedJson pj = build_parsed_json(json);
+  for (simdjson_unused auto _ : state) {
+    set<string_view> default_users;
+    ParsedJson::Iterator iter(pj);
+
+    // for (dom::object tweet : doc["statuses"]) {
+    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
+    if (iter.down()) { // first status
+      do {
+
+        // dom::object user = tweet["user"];
+        if (!(iter.move_to_key("user") && iter.is_object())) { return; }
+
+        // if (user["default_profile"]) {
+        if (iter.move_to_key("default_profile")) {
+          if (iter.is_true()) {
+            if (!iter.up()) { return; } // back to user
+
+            // default_users.insert(user["screen_name"]);
+            if (!(iter.move_to_key("screen_name") && iter.is_string())) { return; }
+            default_users.emplace(iter.get_string(), iter.get_string_length());
+          }
+          if (!iter.up()) { return; } // back to user
+        }
+
+        if (!iter.up()) { return; } // back to status
+
+      } while (iter.next()); // next status
+    }
+
+    if (default_users.size() != 86) { return; }
+  }
+}
+
+SIMDJSON_POP_DISABLE_WARNINGS
+BENCHMARK(iterator_twitter_default_profile);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
 static void error_code_twitter_image_sizes(State& state) noexcept {
   // Count unique image sizes
   dom::parser parser;
@@ -568,7 +638,7 @@ static void error_code_twitter_image_sizes(State& state) noexcept {
     if ((error = doc["statuses"].get(statuses))) { return; }
     for (dom::element tweet : statuses) {
       dom::array images;
-      if (! (error = tweet["entities"]["media"].get(images))) {
+      if (not (error = tweet["entities"]["media"].get(images))) {
         for (dom::element image : images) {
           dom::object sizes;
           if ((error = image["sizes"].get(sizes))) { return; }
@@ -610,4 +680,92 @@ static void parse_surrogate_pairs(State& state) {
 }
 BENCHMARK(parse_surrogate_pairs);
 
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_DEPRECATED_WARNING
+static void iterator_twitter_image_sizes(State& state) {
+  // Count unique image sizes
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
+  ParsedJson pj = build_parsed_json(json);
+  for (simdjson_unused auto _ : state) {
+    set<tuple<uint64_t, uint64_t>> image_sizes;
+    ParsedJson::Iterator iter(pj);
+
+    // for (dom::object tweet : doc["statuses"]) {
+    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
+    if (iter.down()) { // first status
+      do {
+
+        // dom::object media;
+        // not_found = tweet["entities"]["media"].get(media);
+        // if (!not_found) {
+        if (iter.move_to_key("entities")) {
+          if (!iter.is_object()) { return; }
+          if (iter.move_to_key("media")) {
+            if (!iter.is_array()) { return; }
+
+            //   for (dom::object image : media) {
+            if (iter.down()) { // first media
+              do {
+
+                // for (auto [key, size] : dom::object(image["sizes"])) {
+                if (!(iter.move_to_key("sizes") && iter.is_object())) { return; }
+                if (iter.down()) { // first size
+                  do {
+                    iter.move_to_value();
+
+                    // image_sizes.insert({ size["w"], size["h"] });
+                    if (!(iter.move_to_key("w")) && !iter.is_integer()) { return; }
+                    uint64_t width = iter.get_integer();
+                    if (!iter.up()) { return; } // back to size
+                    if (!(iter.move_to_key("h")) && !iter.is_integer()) { return; }
+                    uint64_t height = iter.get_integer();
+                    if (!iter.up()) { return; } // back to size
+                    image_sizes.emplace(width, height);
+
+                  } while (iter.next()); // next size
+                  if (!iter.up()) { return; } // back to sizes
+                }
+                if (!iter.up()) { return; } // back to image
+              } while (iter.next()); // next image
+              if (!iter.up()) { return; } // back to media
+            }
+            if (!iter.up()) { return; } // back to entities
+          }
+          if (!iter.up()) { return; } // back to status
+        }
+      } while (iter.next()); // next status
+    }
+
+    if (image_sizes.size() != 15) { return; };
+  }
+}
+BENCHMARK(iterator_twitter_image_sizes);
+
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+static void print_json(State& state) noexcept {
+  // Prints the number of results in twitter.json
+  dom::parser parser;
+
+  padded_string json;
+  auto error = padded_string::load(TWITTER_JSON).get(json);
+  if (error) { std::cerr << error << std::endl; return; }
+
+  int code = json_parse(json, parser);
+  if (code) { cerr << error_message(code) << endl; return; }
+  for (simdjson_unused auto _ : state) {
+    std::stringstream s;
+    if (!parser.print_json(s)) { cerr << "print_json failed" << endl; return; }
+  }
+}
+BENCHMARK(print_json);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+SIMDJSON_POP_DISABLE_WARNINGS
+
 BENCHMARK_MAIN();

benchmark/bench_ondemand.cpp

@@ -21,10 +21,6 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 #include <nlohmann/json.hpp>
 #endif
 
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-#include <boost/json.hpp>
-#endif
-
 // This has to be last, for reasons I don't yet understand
 #include <benchmark/benchmark.h>
 
@@ -37,7 +33,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "json2msgpack/sajson.h"
 #endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
 #include "json2msgpack/nlohmann_json.h"
-#include "json2msgpack/boostjson.h"
 
 #include "partial_tweets/simdjson_ondemand.h"
 #include "partial_tweets/simdjson_dom.h"
@@ -53,7 +48,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "partial_tweets/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
-#include "partial_tweets/boostjson.h"
 
 
 #include "distinct_user_id/simdjson_ondemand.h"
@@ -72,7 +66,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "distinct_user_id/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
-#include "distinct_user_id/boostjson.h"
 
 #include "find_tweet/simdjson_ondemand.h"
 #include "find_tweet/simdjson_dom.h"
@@ -88,7 +81,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "find_tweet/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
-#include "find_tweet/boostjson.h"
 
 #include "top_tweet/simdjson_ondemand.h"
 #include "top_tweet/simdjson_dom.h"
@@ -104,7 +96,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "top_tweet/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
-#include "top_tweet/boostjson.h"
 
 
 #include "kostya/simdjson_ondemand.h"
@@ -121,7 +112,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "kostya/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
-#include "kostya/boostjson.h"
 
 #include "large_random/simdjson_ondemand.h"
 #if SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
@@ -140,7 +130,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "large_random/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
-#include "large_random/boostjson.h"
 
 #include "amazon_cellphones/simdjson_dom.h"
 #include "amazon_cellphones/simdjson_ondemand.h"

benchmark/bench_parse_call.cpp

@@ -169,6 +169,22 @@ BENCHMARK(parse_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::v
   })->DisplayAggregatesOnly(true);
 
 
+
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_DEPRECATED_WARNING
+static void json_parse(State& state) {
+  ParsedJson pj;
+  if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
+  for (simdjson_unused auto _ : state) {
+    auto error = json_parse(EMPTY_ARRAY, pj);
+    if (error) { return; }
+  }
+}
+SIMDJSON_POP_DISABLE_WARNINGS
+BENCHMARK(json_parse);
+#endif // SIMDJSON_DISABLE_DEPRECATED_API
+
 static void parser_parse_error_code(State& state) {
   dom::parser parser;
   if (parser.allocate(EMPTY_ARRAY.length())) { return; }
@@ -197,6 +213,20 @@ BENCHMARK(parser_parse_exception);
 
 #endif // SIMDJSON_EXCEPTIONS
 
+#ifndef SIMDJSON_DISABLE_DEPRECATED_API
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_DEPRECATED_WARNING
+static void build_parsed_json(State& state) {
+  for (simdjson_unused auto _ : state) {
+    dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
+    if (!parser.valid) { return; }
+  }
+}
+SIMDJSON_POP_DISABLE_WARNINGS
+
+BENCHMARK(build_parsed_json);
+#endif
+
 static void document_parse_error_code(State& state) {
   for (simdjson_unused auto _ : state) {
     dom::parser parser;

benchmark/benchmarker.h

@@ -445,7 +445,7 @@ struct benchmarker {
     return 100.0 * a / b;
   }
 
-  void print(bool tabbed_output, bool stage1_only) const {
+  void print(bool tabbed_output) const {
     if (tabbed_output) {
       char* filename_copy = reinterpret_cast<char*>(malloc(strlen(filename)+1));
       SIMDJSON_PUSH_DISABLE_WARNINGS
@@ -503,28 +503,24 @@ struct benchmarker {
           stats->blocks_with_16_structurals_flipped, percent(stats->blocks_with_16_structurals_flipped, stats->blocks));
       }
       printf("\n");
-      if(!stage1_only) {
-        printf("All Stages (excluding allocation)\n");
-        print_aggregate("|    "   , all_stages_without_allocation.best);
-        // frequently, allocation is a tiny fraction of the running time so we omit it
-        if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
-          printf("|- Allocation\n");
-          print_aggregate("|    ", allocate_stage.best);
-        }
+      printf("All Stages (excluding allocation)\n");
+      print_aggregate("|    "   , all_stages_without_allocation.best);
+      // frequently, allocation is a tiny fraction of the running time so we omit it
+      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
+        printf("|- Allocation\n");
+        print_aggregate("|    ", allocate_stage.best);
       }
       printf("|- Stage 1\n");
       print_aggregate("|    ", stage1.best);
-      if(!stage1_only) {
-        printf("|- Stage 2\n");
-        print_aggregate("|    ", stage2.best);
-      }
+      printf("|- Stage 2\n");
+      print_aggregate("|    ", stage2.best);
       if (collector.has_events()) {
         double freq1 = (stage1.best.cycles() / stage1.best.elapsed_sec()) / 1000000000.0;
         double freq2 = (stage2.best.cycles() / stage2.best.elapsed_sec()) / 1000000000.0;
         double freqall = (all_stages_without_allocation.best.cycles() / all_stages_without_allocation.best.elapsed_sec()) / 1000000000.0;
         double freqmin = min(freq1, freq2);
         double freqmax = max(freq1, freq2);
-        if((freqall < 0.95 * freqmin) || (freqall > 1.05 * freqmax)) {
+        if((freqall < 0.95 * freqmin) or (freqall > 1.05 * freqmax)) {
           printf("\nWarning: The processor frequency fluctuates in an expected way!!!\n"
           "Range for stage 1 and stage 2 : [%.3f GHz, %.3f GHz], overall: %.3f GHz.\n",
           freqmin, freqmax, freqall);

benchmark/distinct_user_id/boostjson.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "distinct_user_id.h"
-
-namespace distinct_user_id {
-
-struct boostjson {
-  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
-
-    auto root = boost::json::parse(json);
-    for (const auto &tweet : root.at("statuses").as_array()) {
-      result.push_back(tweet.at("user").at("id").to_number<uint64_t>());
-
-      if (tweet.as_object().if_contains("retweeted_status")) {
-        result.push_back(tweet.at("retweeted_status").at("user").at("id").to_number<uint64_t>());
-      }
-    }
-
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(distinct_user_id, boostjson)->UseManualTime();
-
-} // namespace distinct_user_id
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/dom/parse.cpp

@@ -218,7 +218,7 @@ int main(int argc, char *argv[]) {
   if (!options.verbose) { progress.erase(); }
 
   for (size_t i=0; i<options.files.size(); i++) {
-    benchmarkers[i]->print(options.tabbed_output, options.stage1_only);
+    benchmarkers[i]->print(options.tabbed_output);
     delete benchmarkers[i];
   }
 

benchmark/event_counter.h

@@ -34,15 +34,11 @@
 #include <string>
 #include <vector>
 
-#ifdef __linux__
 #include "linux-perf-events.h"
+#ifdef __linux__
 #include <libgen.h>
 #endif
 
-#if __APPLE__ &&  __aarch64__
-#include "apple/apple_arm_events.h"
-#endif
-
 #include "simdjson.h"
 
 using std::string;
@@ -122,7 +118,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; }
@@ -139,7 +134,7 @@ struct event_collector {
 
 #if defined(__linux__)
   LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
-  event_collector() : linux_events(vector<int>{
+  event_collector(simdjson_unused bool quiet = false) : linux_events(vector<int>{
   #if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     PERF_COUNT_HW_CPU_CYCLES,
     PERF_COUNT_HW_INSTRUCTIONS,
@@ -154,17 +149,8 @@ struct event_collector {
   bool has_events() {
     return linux_events.is_working();
   }
-#elif __APPLE__ &&  __aarch64__
-  AppleEvents apple_events;
-  performance_counters diff;
-  event_collector() : diff(0) {
-    apple_events.setup_performance_counters();
-  }
-  bool has_events() {
-    return apple_events.setup_performance_counters();
-  }
 #else
-  event_collector() {}
+  event_collector(simdjson_unused bool _quiet = false) {}
   bool has_events() {
     return false;
   }
@@ -173,8 +159,6 @@ struct event_collector {
   simdjson_inline void start() {
 #if defined(__linux)
     linux_events.start();
-#elif __APPLE__ &&  __aarch64__
-    if(has_events()) { diff = apple_events.get_counters(); }
 #endif
     start_clock = steady_clock::now();
   }
@@ -182,16 +166,6 @@ struct event_collector {
     time_point<steady_clock> end_clock = steady_clock::now();
 #if defined(__linux)
     linux_events.end(count.event_counts);
-#elif __APPLE__ &&  __aarch64__
-    if(has_events()) {
-      performance_counters end = apple_events.get_counters();
-      diff = end - diff;
-    }
-    count.event_counts[0] = diff.cycles;
-    count.event_counts[1] = diff.instructions;
-    count.event_counts[2] = diff.missed_branches;
-    count.event_counts[3] = 0;
-    count.event_counts[4] = 0;
 #endif
     count.elapsed = end_clock - start_clock;
     return count;

benchmark/find_tweet/boostjson.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "find_tweet.h"
-
-namespace find_tweet {
-
-struct boostjson {
-  using StringType=std::string;
-
-  bool run(simdjson::padded_string &json, uint64_t find_id, std::string &result) {
-
-    auto root = boost::json::parse(json);
-    for (const auto &tweet : root.at("statuses").as_array()) {
-      if (tweet.at("id") == find_id) {
-        result = tweet.at("text").as_string();
-        return true;
-      }
-    }
-
-    return false;
-  }
-};
-
-BENCHMARK_TEMPLATE(find_tweet, boostjson)->UseManualTime();
-
-} // namespace find_tweet
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/find_tweet/nlohmann_json.h

@@ -13,7 +13,7 @@ struct nlohmann_json {
     auto root = nlohmann::json::parse(json.data(), json.data() + json.size());
     for (auto tweet : root["statuses"]) {
       if (tweet["id"] == find_id) {
-        result = to_string(tweet["text"]);
+        result = tweet["text"];
         return true;
       }
     }

benchmark/json2msgpack/boostjson.h

@@ -1,104 +0,0 @@
-#pragma once
-
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "json2msgpack.h"
-
-namespace json2msgpack {
-
-struct boostjson2msgpack {
-  inline std::string_view to_msgpack(const boost::json::value &root, uint8_t *buf) {
-    buff = buf;
-    recursive_processor(root);
-    return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
-  }
-
-private:
-  uint8_t *buff{};
-
-  inline void write_double(const double d) noexcept {
-    *buff++ = 0xcb;
-    ::memcpy(buff, &d, sizeof(d));
-    buff += sizeof(d);
-  }
-
-  inline void write_byte(const uint8_t b) noexcept {
-    *buff = b;
-    buff++;
-  }
-
-  inline void write_uint32(const uint32_t w) noexcept {
-    ::memcpy(buff, &w, sizeof(w));
-    buff += sizeof(w);
-  }
-
-  inline void write_string(const std::string & str) {
-    write_byte(0xdb);
-    write_uint32(uint32_t(str.size()));
-    ::memcpy(buff, str.data(), str.size());
-    buff += str.size();
-  }
-
-  inline void recursive_processor(const boost::json::value &element) {
-    switch(element.kind()) {
-    case boost::json::kind::array: {
-      write_byte(0xdd);
-      const auto &array = element.as_array();
-      write_uint32(static_cast<uint32_t>(array.size()));
-      for (const auto &child : array) {
-        recursive_processor(child);
-      }
-    } break;
-
-    case boost::json::kind::object: {
-      write_byte(0xdf);
-      const auto &object = element.as_object();
-      write_uint32(static_cast<uint32_t>(object.size()));
-      for (const auto &child : object) {
-        write_string(child.key_c_str());
-        recursive_processor(child.value());
-      }
-    } break;
-
-    case boost::json::kind::int64:
-    case boost::json::kind::uint64:
-    case boost::json::kind::double_:
-      write_double(element.to_number<double>());
-      break;
-
-    case boost::json::kind::string:
-      write_string(element.as_string().c_str());
-      break;
-
-    case boost::json::kind::bool_:
-      write_byte(0xc2 + element.as_bool());
-      break;
-
-    case boost::json::kind::null:
-      write_byte(0xc0);
-      break;
-
-    default:
-      printf("unexpected\n");
-      break;
-    }
-  }
-};
-
-struct boostjson {
-  using StringType=std::string;
-
-  boostjson2msgpack parser{};
-
-  bool run(simdjson::padded_string &json, char *buffer, std::string_view &result) {
-    auto root = boost::json::parse(json);
-    result = parser.to_msgpack(root, reinterpret_cast<uint8_t *>(buffer));
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(json2msgpack, boostjson)->UseManualTime();
-
-} // namespace json2msgpack
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/json2msgpack/simdjson_dom.h

@@ -15,7 +15,7 @@ struct simdjsondom2msgpack {
    * @param json JSON input
    * @param buf temporary buffer (must be large enough, with simdjson::SIMDJSON_PADDING bytes
    * of padding)
-   * @return std::string_view msgpack output, writing to the temporary buffer
+   * @return std::string_view msgpack output, writting to the temporary buffer
    */
   inline std::string_view to_msgpack(const simdjson::padded_string &json,
                                      uint8_t *buf);

benchmark/json2msgpack/simdjson_ondemand.h

@@ -36,7 +36,7 @@ struct simdjson2msgpack {
    * @param json JSON input
    * @param buf temporary buffer (must be large enough, with simdjson::SIMDJSON_PADDING bytes
    * of padding)
-   * @return std::string_view msgpack output, writing to the temporary buffer
+   * @return std::string_view msgpack output, writting to the temporary buffer
    */
   inline std::string_view to_msgpack(const simdjson::padded_string &json,
                                      uint8_t *buf);

benchmark/json_benchmark/file_runner.h

@@ -24,7 +24,7 @@ struct file_runner : public runner_base<I> {
 
   simdjson_warn_unused bool before_run(benchmark::State &state) {
     if (!runner_base<I>::after_run(state)) { return false; };
-    // Copy the original JSON in case we did *in situ* last time
+    // Copy the original json in case we did *in situ* last time
     std::memcpy(json.data(), original_json.data(), original_json.size());
     return true;
   }

benchmark/json_benchmark/run_json_benchmark.h

@@ -19,7 +19,7 @@ void maybe_display_implementation() {
 template<typename B, typename R> static void run_json_benchmark(benchmark::State &state) {
   maybe_display_implementation();
 
-  event_collector collector;
+  event_collector collector(true);
   event_aggregate events;
 
   // Warmup and equality check (make sure the data is right!)

benchmark/json_benchmark/string_runner.h

@@ -13,7 +13,7 @@ struct string_runner : public runner_base<I> {
 
   simdjson_warn_unused bool before_run(benchmark::State &state) {
     if (!runner_base<I>::after_run(state)) { return false; };
-    // Copy the original JSON in case we did *in situ*
+    // Copy the original json in case we did *in situ*
     std::memcpy(json.data(), original_json.data(), original_json.size());
     return true;
   }

benchmark/kostya/boostjson.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "kostya.h"
-
-namespace kostya {
-
-struct boostjson {
-  static constexpr diff_flags DiffFlags = diff_flags::IMPRECISE_FLOATS;
-
-  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    auto root = boost::json::parse(json);
-    for (const auto &point : root.at("coordinates").as_array()) {
-      result.emplace_back(json_benchmark::point{
-        point.at("x").to_number<double>(),
-        point.at("y").to_number<double>(),
-        point.at("z").to_number<double>()
-      });
-    }
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(kostya, boostjson)->UseManualTime();
-
-} // namespace kostya
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/large_random/boostjson.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "large_random.h"
-
-namespace large_random {
-
-struct boostjson {
-  static constexpr diff_flags DiffFlags = diff_flags::IMPRECISE_FLOATS;
-
-  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    auto root = boost::json::parse(json);
-    for (const auto &point : root.as_array()) {
-      result.emplace_back(json_benchmark::point{
-        point.at("x").to_number<double>(),
-        point.at("y").to_number<double>(),
-        point.at("z").to_number<double>()
-      });
-    }
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(large_random, boostjson)->UseManualTime();
-
-} // namespace large_random
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/large_random/simdjson_ondemand.h

@@ -23,30 +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);
-    //ondemand::array arr = doc.get_array();
-    //arr.get<std::vector<point>>(result);
-    // 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/partial_tweets/boostjson.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#ifdef SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "partial_tweets.h"
-
-namespace partial_tweets {
-
-struct boostjson {
-  using StringType=std::string;
-
-  bool run(simdjson::padded_string &json, std::vector<tweet<StringType>> &result) {
-
-    auto root = boost::json::parse(json);
-    for (const auto &tweet : root.at("statuses").as_array()) {
-      const auto &user = tweet.at("user");
-
-      auto in_reply_to_status_id = tweet.as_object().if_contains("in_reply_to_status_id")
-        ? tweet.at("in_reply_to_status_id") : boost::json::value();
-
-      result.emplace_back(partial_tweets::tweet<StringType>{
-        tweet.at("created_at").as_string().c_str(),
-        tweet.at("id").to_number<uint64_t>(),
-        tweet.at("text").as_string().c_str(),
-        in_reply_to_status_id.is_null() ? 0 : in_reply_to_status_id.to_number<uint64_t>(),
-        {
-          user.at("id").to_number<uint64_t>(),
-          user.at("screen_name").as_string().c_str()
-        },
-        tweet.at("retweet_count").to_number<uint64_t>(),
-        tweet.at("favorite_count").to_number<uint64_t>()
-      });
-    }
-
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(partial_tweets, boostjson)->UseManualTime();
-
-} // namespace partial_tweets
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/partial_tweets/ondemand.h

@@ -13,7 +13,7 @@ class OnDemand {
 public:
   OnDemand() {
     if(!displayed_implementation) {
-      std::cout << "On-Demand implementation: " << builtin_implementation()->name() << std::endl;
+      std::cout << "On Demand implementation: " << builtin_implementation()->name() << std::endl;
       displayed_implementation = true;
     }
   }

benchmark/static_reflect/CMakeLists.txt

@@ -1,44 +0,0 @@
-# Include reflect-cpp
-CPMAddPackage(
-  NAME reflect-cpp
-  GITHUB_REPOSITORY getml/reflect-cpp
-  GIT_TAG v0.17.0
-  EXCLUDE_FROM_ALL YES
-)
-
-
-
-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()
-
-
-
-add_subdirectory(twitter_data)

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,170 +0,0 @@
-extern crate serde;
-extern crate serde_json;
-extern crate libc;
-use std::slice;
-
-use libc::{c_char, size_t};
-use serde::{Serialize, Deserialize};
-
-/******************************************************/
-/******************************************************/
-/**
- * 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 _);
-}

benchmark/static_reflect/serde-benchmark/serde_benchmark.h

@@ -1,32 +0,0 @@
-#ifndef serde_benchmark_ffi_h
-#define serde_benchmark_ffi_h
-
-/* Generated with cbindgen:0.24.3 */
-
-/* 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 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);
-
-} // extern "C"
-
-} // namespace serde_benchmark
-
-#endif // serde_benchmark_ffi_h

benchmark/static_reflect/twitter_data/CMakeLists.txt

@@ -1,15 +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_data/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/twitter_data/benchmark_serialization_twitter.cpp

@@ -1,142 +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_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;
-}
-
-int main() {
-  // 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
-  bench_nlohmann(my_struct);
-  bench_simdjson_static_reflection(my_struct);
-#ifdef SIMDJSON_RUST_VERSION
-  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
-  bench_reflect_cpp(my_struct);
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/twitter_data/nlohmann_twitter_data.h

@@ -1,117 +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_data/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/boostjson.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#if SIMDJSON_COMPETITION_BOOSTJSON
-
-#include "top_tweet.h"
-
-namespace top_tweet {
-
-using namespace simdjson;
-
-struct boostjson {
-  using StringType=std::string;
-
-  bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
-    result.retweet_count = -1;
-    boost::json::value top_tweet{};
-
-    auto root = boost::json::parse(json);
-    for (const auto &tweet : root.at("statuses").as_array()) {
-      int64_t retweet_count = tweet.at("retweet_count").as_int64();
-      if (retweet_count <= max_retweet_count && retweet_count >= result.retweet_count) {
-        result.retweet_count = retweet_count;
-        top_tweet = tweet;
-      }
-    }
-
-    result.text = top_tweet.at("text").as_string();
-    result.screen_name = top_tweet.at("user").at("screen_name").as_string();
-    return result.retweet_count != -1;
-  }
-};
-
-BENCHMARK_TEMPLATE(top_tweet, boostjson)->UseManualTime();
-
-} // namespace top_tweet
-
-#endif // SIMDJSON_COMPETITION_BOOSTJSON

benchmark/top_tweet/nlohmann_json.h

@@ -26,8 +26,8 @@ struct nlohmann_json {
       }
     }
 
-    result.text = to_string(top_tweet["text"]);
-    result.screen_name = to_string(top_tweet["user"]["screen_name"]);
+    result.text = top_tweet["text"];
+    result.screen_name = top_tweet["user"]["screen_name"];
     return result.retweet_count != -1;
   }
 };

cmake/CPM.cmake

@@ -1,24 +0,0 @@
-# SPDX-License-Identifier: MIT
-#
-# SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
-
-set(CPM_DOWNLOAD_VERSION 0.40.2)
-set(CPM_HASH_SUM "c8cdc32c03816538ce22781ed72964dc864b2a34a310d3b7104812a5ca2d835d")
-
-if(CPM_SOURCE_CACHE)
-  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
-elseif(DEFINED ENV{CPM_SOURCE_CACHE})
-  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
-else()
-  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
-endif()
-
-# Expand relative path. This is important if the provided path contains a tilde (~)
-get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
-
-file(DOWNLOAD
-     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
-     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
-)
-
-include(${CPM_DOWNLOAD_LOCATION})

cmake/developer-options.cmake

@@ -110,24 +110,13 @@ endif()
 
 # We compile tools, tests, etc. with C++ 17. Override yourself if you need on a
 # target.
-if(SIMDJSON_STATIC_REFLECTION)
-  # This is temporary.
-  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 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_MACOSX_RPATH OFF)
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
-set(SIMDJSON_STRUCTURAL_INDEXER_STEP CACHE STRING "the SIMDJSON_STRUCTURAL_INDEXER_STEP variable")
 
-if(SIMDJSON_STRUCTURAL_INDEXER_STEP)
-  message(STATUS "Setting SIMDJSON_STRUCTURAL_INDEXER_STEP to ${SIMDJSON_STRUCTURAL_INDEXER_STEP}.")
-  add_compile_definitions(SIMDJSON_STRUCTURAL_INDEXER_STEP=${SIMDJSON_STRUCTURAL_INDEXER_STEP})
-endif()
 # LTO seems to create all sorts of fun problems. Let us
 # disable temporarily.
 #include(CheckIPOSupported)

cmake/simdjson-config.cmake.in

@@ -4,4 +4,3 @@ if("@SIMDJSON_ENABLE_THREADS@")
 endif()
 
 include("${CMAKE_CURRENT_LIST_DIR}/simdjsonTargets.cmake")
-include("${CMAKE_CURRENT_LIST_DIR}/simdjson_staticTargets.cmake" OPTIONAL)

dependencies/CMakeLists.txt

@@ -1,4 +1,5 @@
 include(CMakeDependentOption)
+include(import.cmake)
 
 option(SIMDJSON_ALLOW_DOWNLOADS
         "Allow dependencies to be downloaded during configure time"
@@ -10,22 +11,18 @@ cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark
         SIMDJSON_ALLOW_DOWNLOADS OFF)
 
 if(SIMDJSON_GOOGLE_BENCHMARKS)
-  CPMAddPackage(
-        NAME google_benchmarks
-        URL https://github.com/google/benchmark/archive/refs/tags/v1.7.1.zip
-        OPTIONS
-        "BENCHMARK_ENABLE_TESTING OFF"
-        "BENCHMARK_ENABLE_INSTALL OFF"
-        "BENCHMARK_ENABLE_WERROR OFF"
-  )
+  set_off(BENCHMARK_ENABLE_TESTING)
+  set_off(BENCHMARK_ENABLE_INSTALL)
+  set_off(BENCHMARK_ENABLE_WERROR)
+
+  import_dependency(google_benchmarks google/benchmark v1.7.1)
+  add_dependency(google_benchmarks)
 endif()
 
-CPMAddPackage(
-        NAME simdjson-data
-        URL https://github.com/simdjson/simdjson-data/archive/a5b13babe65c1bba7186b41b43d4cbdc20a5c470.zip
-)
+# The bulk of our benchmarking and testing data has been moved simdjson/simdjson-data
+import_dependency(simdjson-data simdjson/simdjson-data a5b13babe65c1bba7186b41b43d4cbdc20a5c470)
+add_dependency(simdjson-data)
 
-option(SIMDJSON_USE_BOOST_JSON "Try to include BOOST_JSON, this may break your binaries under some systems." OFF)
 # This prevents variables declared with set() from unnecessarily escaping and
 # should not be called more than once
 function(competition_scope_)
@@ -39,32 +36,22 @@ function(competition_scope_)
 #endif
 
 int main() {}
-]] SIMDJSON_FOUND_STRING_VIEW)
-  if(SIMDJSON_FOUND_STRING_VIEW AND SIMDJSON_USE_BOOST_JSON)
-    CPMAddPackage(
-        NAME boostjson
-        URL https://github.com/boostorg/json/archive/ee8d72d8502b409b5561200299cad30ccdb91415.zip
-    )
+]] USE_BOOST_JSON)
+  if(USE_BOOST_JSON)
+    import_dependency(boostjson boostorg/json ee8d72d)
     add_library(boostjson STATIC "${boostjson_SOURCE_DIR}/src/src.cpp")
     target_compile_definitions(boostjson PUBLIC BOOST_JSON_STANDALONE)
     target_include_directories(boostjson SYSTEM PUBLIC
             "${boostjson_SOURCE_DIR}/include")
     target_compile_definitions(boostjson INTERFACE SIMDJSON_COMPETITION_BOOSTJSON)
   endif()
-  CPMAddPackage(
-      NAME cjson
-      URL https://github.com/DaveGamble/cJSON/archive/c69134d01746dcf551dd7724b4edb12f922eb0d1.zip
-      DOWNLOAD_ONLY YES
-  )
+
+  import_dependency(cjson DaveGamble/cJSON c69134d)
   add_library(cjson STATIC "${cjson_SOURCE_DIR}/cJSON.c")
   target_include_directories(cjson SYSTEM PUBLIC "${cjson_SOURCE_DIR}")
   target_compile_definitions(cjson INTERFACE SIMDJSON_COMPETITION_CJSON)
 
-  CPMAddPackage(
-      NAME fastjson
-      URL https://github.com/mikeando/fastjson/archive/485f994a61a64ac73fa6a40d4d639b99b463563b.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(fastjson mikeando/fastjson 485f994)
   add_library(fastjson STATIC
           "${fastjson_SOURCE_DIR}/src/fastjson.cpp"
           "${fastjson_SOURCE_DIR}/src/fastjson2.cpp"
@@ -73,36 +60,28 @@ int main() {}
           "${fastjson_SOURCE_DIR}/include")
   target_compile_definitions(fastjson INTERFACE SIMDJSON_COMPETITION_FASTJSON)
 
-  CPMAddPackage(
-      NAME gason
-      URL https://github.com/vivkin/gason/archive/7aee524189da1c1ecd19f67981e3d903dae25470.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(gason vivkin/gason 7aee524)
   add_library(gason STATIC "${gason_SOURCE_DIR}/src/gason.cpp")
   target_include_directories(gason SYSTEM PUBLIC "${gason_SOURCE_DIR}/src")
   target_compile_definitions(gason INTERFACE SIMDJSON_COMPETITION_GASON)
 
-  CPMAddPackage(
-      NAME jsmn
-      URL https://github.com/zserge/jsmn/archive/18e9fe42cbfe21d65076f5c77ae2be379ad1270f.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(jsmn zserge/jsmn 18e9fe4)
   add_library(jsmn STATIC "${jsmn_SOURCE_DIR}/jsmn.c")
   target_include_directories(jsmn SYSTEM PUBLIC "${jsmn_SOURCE_DIR}")
   target_compile_definitions(jsmn INTERFACE SIMDJSON_COMPETITION_JSMN)
 
-  CPMAddPackage(
-      NAME nlohmann_json
-      URL https://github.com/nlohmann/json/archive/refs/tags/v3.10.5.zip
-  )
+  message(STATUS "Importing json (nlohmann/json@v3.10.5)")
+  set(nlohmann_json_SOURCE_DIR "${dep_root}/json")
+  if(NOT EXISTS "${nlohmann_json_SOURCE_DIR}")
+    file(DOWNLOAD
+            "https://github.com/nlohmann/json/releases/download/v3.10.5/json.hpp"
+            "${nlohmann_json_SOURCE_DIR}/nlohmann/json.hpp")
+  endif()
+  add_library(nlohmann_json INTERFACE)
+  target_include_directories(nlohmann_json SYSTEM INTERFACE "${nlohmann_json_SOURCE_DIR}")
+  target_compile_definitions(nlohmann_json INTERFACE SIMDJSON_COMPETITION_NLOHMANN_JSON)
 
-  set_property(TARGET nlohmann_json APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS SIMDJSON_COMPETITION_NLOHMANN_JSON)
-
-  CPMAddPackage(
-      NAME json11
-      URL https://github.com/dropbox/json11/archive/ec4e45219af1d7cde3d58b49ed762376fccf1ace.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(json11 dropbox/json11 ec4e452)
   add_library(json11 STATIC "${json11_SOURCE_DIR}/json11.cpp")
   target_include_directories(json11 SYSTEM PUBLIC "${json11_SOURCE_DIR}")
   target_compile_definitions(json11 INTERFACE SIMDJSON_COMPETITION_JSON11)
@@ -112,11 +91,7 @@ int main() {}
   target_include_directories(jsoncpp SYSTEM PUBLIC "${jsoncpp_SOURCE_DIR}")
   target_compile_definitions(jsoncpp INTERFACE SIMDJSON_COMPETITION_JSONCPP)
 
-  CPMAddPackage(
-      NAME rapidjson
-      URL https://github.com/Tencent/rapidjson/archive/805d7ed5dfe97a39b8b0816fd5eeed8731dc4936.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(rapidjson Tencent/rapidjson f54b0e4)
   add_library(rapidjson INTERFACE)
   target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
   include (TestBigEndian)
@@ -129,28 +104,16 @@ int main() {}
   target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
   target_include_directories(rapidjson SYSTEM INTERFACE
           "${rapidjson_SOURCE_DIR}/include")
-  if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
-    message(STATUS "Disabling rapidjson")
-  else()
-    target_compile_definitions(rapidjson INTERFACE SIMDJSON_COMPETITION_RAPIDJSON)
-  endif()
+  target_compile_definitions(rapidjson INTERFACE SIMDJSON_COMPETITION_RAPIDJSON)
 
-  CPMAddPackage(
-      NAME sajson
-      URL https://github.com/chadaustin/sajson/archive/2dcfd350586375f9910f74821d4f07d67ae455ba.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(sajson chadaustin/sajson 2dcfd35)
   add_library(sajson INTERFACE)
   target_compile_definitions(sajson INTERFACE SAJSON_UNSORTED_OBJECT_KEYS)
   target_include_directories(sajson SYSTEM INTERFACE
           "${sajson_SOURCE_DIR}/include")
   target_compile_definitions(sajson INTERFACE SIMDJSON_COMPETITION_SAJSON)
 
-  CPMAddPackage(
-      NAME ujson4c
-      URL https://github.com/esnme/ujson4c/archive/e14f3fd5207fe30d1bdea723f260609e69d1abfa.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(ujson4c esnme/ujson4c e14f3fd)
   add_library(ujson4c STATIC
           "${ujson4c_SOURCE_DIR}/src/ujdecode.c"
           "${ujson4c_SOURCE_DIR}/3rdparty/ultrajsondec.c")
@@ -159,11 +122,7 @@ int main() {}
           "${ujson4c_SOURCE_DIR}/3rdparty")
   target_compile_definitions(ujson4c INTERFACE SIMDJSON_COMPETITION_UJSON4C)
 
-  CPMAddPackage(
-      NAME yyjson
-      URL https://github.com/ibireme/yyjson/archive/c3856514de0a67d7b66939bf3ed491a2d6e61277.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(yyjson ibireme/yyjson c385651)
   add_library(yyjson STATIC "${yyjson_SOURCE_DIR}/src/yyjson.c")
   target_include_directories(yyjson SYSTEM PUBLIC "${yyjson_SOURCE_DIR}/src")
   target_compile_definitions(yyjson INTERFACE SIMDJSON_COMPETITION_YYJSON)
@@ -171,7 +130,7 @@ int main() {}
   add_library(competition-core INTERFACE)
   target_link_libraries(competition-core INTERFACE nlohmann_json rapidjson sajson cjson jsmn yyjson)
 
-  if(TARGET boostjson)
+  if(USE_BOOST_JSON)
      target_compile_definitions(boostjson INTERFACE HAS_BOOST_JSON)
      target_link_libraries(competition-core INTERFACE boostjson)
   endif()
@@ -188,12 +147,10 @@ cmake_dependent_option(SIMDJSON_CXXOPTS "Download cxxopts (necessary for tools)"
         SIMDJSON_ALLOW_DOWNLOADS OFF)
 
 if(SIMDJSON_CXXOPTS)
-  CPMAddPackage(
-        NAME cxxopts
-        URL https://github.com/jarro2783/cxxopts/archive/59656709c0c58fcd0ed18b38e02938dbe05284c5.zip
-        OPTIONS
-        "CXXOPTS_BUILD_EXAMPLES OFF"
-        "CXXOPTS_BUILD_TESTS OFF"
-        "CXXOPTS_ENABLE_INSTALL OFF"
-  )
+  set_off(CXXOPTS_BUILD_EXAMPLES)
+  set_off(CXXOPTS_BUILD_TESTS)
+  set_off(CXXOPTS_ENABLE_INSTALL)
+
+  import_dependency(cxxopts jarro2783/cxxopts 794c975)
+  add_dependency(cxxopts)
 endif()

dependencies/import.cmake

@@ -0,0 +1,48 @@
+set(dep_root "${simdjson_SOURCE_DIR}/dependencies/.cache")
+if(DEFINED ENV{simdjson_DEPENDENCY_CACHE_DIR})
+  set(dep_root "$ENV{simdjson_DEPENDENCY_CACHE_DIR}")
+endif()
+
+function(import_dependency NAME GITHUB_REPO COMMIT)
+  message(STATUS "Importing ${NAME} (${GITHUB_REPO}@${COMMIT})")
+  set(target "${dep_root}/${NAME}")
+
+  # If the folder exists in the cache, then we assume that everything is as
+  # should be and do nothing
+  if(EXISTS "${target}")
+    set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+    return()
+  endif()
+
+  set(zip_url "https://github.com/${GITHUB_REPO}/archive/${COMMIT}.zip")
+  set(archive "${dep_root}/archive.zip")
+  set(dest "${dep_root}/_extract")
+
+  file(DOWNLOAD "${zip_url}" "${archive}")
+  file(MAKE_DIRECTORY "${dest}")
+  execute_process(
+          WORKING_DIRECTORY "${dest}"
+          COMMAND "${CMAKE_COMMAND}" -E tar xf "${archive}")
+  file(REMOVE "${archive}")
+
+  # GitHub archives only ever have one folder component at the root, so this
+  # will always match that single folder
+  file(GLOB dir LIST_DIRECTORIES YES "${dest}/*")
+
+  file(RENAME "${dir}" "${target}")
+
+  set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+endfunction()
+
+# Delegates to the dependency
+macro(add_dependency NAME)
+  if(NOT DEFINED "${NAME}_SOURCE_DIR")
+    message(FATAL_ERROR "Missing ${NAME}_SOURCE_DIR variable")
+  endif()
+
+  add_subdirectory("${${NAME}_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/${NAME}" EXCLUDE_FROM_ALL)
+endmacro()
+
+function(set_off NAME)
+  set("${NAME}" OFF CACHE INTERNAL "")
+endfunction()

doc/builder.md

@@ -1,141 +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. However, string escaping
-and UTF-8 validation is automated.
-
-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).
-
-An `string_builder` is created with an initial buffer capacity (e.g., 1kB). The memory
-is reallocated when needed. 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.
-Parameters:
-- `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
-
-After writting 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.
-
-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>`.
-
-The later method (`view()`) is recommended.
-
-Example: string_builder
----------------------------
-
-```C++
-
-    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
-        // start of JSON
-        builder.append_raw("{");
-
-        // "make"
-        builder.escape_and_append_with_quotes("make");
-        builder.append_raw(":");
-        builder.escape_and_append_with_quotes(car.make);
-
-        // "model"
-        builder.append_raw(",");
-        builder.escape_and_append_with_quotes("model");
-        builder.append_raw(":");
-        builder.escape_and_append_with_quotes(car.model);
-
-        // "year"
-        builder.append_raw(",");
-        builder.escape_and_append_with_quotes("year");
-        builder.append_raw(":");
-        builder.append(car.year);
-
-        // "tire_pressure"
-        builder.append_raw(",");
-        builder.escape_and_append_with_quotes("tire_pressure");
-        builder.append_raw(":[");
-
-        // 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_raw(",");
-            }
-        }
-        // end of array
-        builder.append_raw("]");
-
-        // end of object
-        builder.append_raw("}");
-    }
-
-    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;
-        if(sb.view().get(p)) {
-            return false; // there was an error
-        }
-        // p holds the JSON:
-        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
-        return true;
-    }
-```
-
-C++26 static reflection
-------------------------
-
-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
-    bool car_test() {
-        simdjson::builder::string_builder sb;
-        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
-        append(sb, c);
-        std::string_view p;
-        if(sb.view().get(p)) {
-            return false; // there was an error
-        }
-        // p holds the JSON:
-        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
-        return true;
-    }
-```
-
-If you prefer, you can also create a string directly:
-
-```cpp
-  std::string json;
-  if(simdjson::builder::to_json_string(c).get(json)) {
-    // there was an error
-  } else {
-    // json contain the serialized JSON
-  }
-```

doc/dom.md

@@ -3,12 +3,11 @@ The Document-Object-Model (DOM) front-end
 
 An overview of what you need to know to use simdjson, with examples.
 
-* [DOM vs On-Demand](#dom-vs-on-demand)
+* [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)
 * [Using the Parsed JSON](#using-the-parsed-json)
 * [C++17 Support](#c17-support)
 * [JSON Pointer](#json-pointer)
-* [JSONPath](#jsonpath)
 * [Error Handling](#error-handling)
   * [Error Handling Example](#error-handling-example)
   * [Exceptions](#exceptions)
@@ -19,7 +18,7 @@ An overview of what you need to know to use simdjson, with examples.
 * [Padding and Temporary Copies](#padding-and-temporary-copies)
 * [Performance Tips](#performance-tips)
 
-DOM vs On-Demand
+DOM vs On Demand
 ----------------------------------------------
 
 The simdjson library offers two distinct approaches on how to access a JSON document. We support
@@ -60,26 +59,6 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 
-You can then parse the JSON document from the `simdjson::padded_string` instance:
-
-```cpp
-simdjson::dom::parser parser;
-simdjson::dom::element doc = parser.parse(my_padded_data);
-```
-
-Whenever you pass an `std::string` reference to `parser::parse`,
-the parser will access the bytes beyond the end of
-the string but before the end of the allocated memory (`std::string::capacity()`).
-If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
-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:
-
-```c++
-std::string json = "[1]";
-dom::element doc = parser.parse(simdjson::pad(json));
-```
-
 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
 You cannot copy a `parser` instance, you may only move it.
 
@@ -92,12 +71,6 @@ For best performance, a `parser` instance should be reused over several files: o
 If you need a lower-level interface, you may call the function `parser.parse(const char * p, size_t l)` on a pointer `p` while specifying the
 length of your input `l` in bytes. To see how to get the very best performance from a low-level approach, you way want to read our [performance notes](https://github.com/simdjson/simdjson/blob/master/doc/performance.md#padding-and-temporary-copies) on this topic (see the Padding and Temporary Copies section).
 
-*Windows-specific*:  Windows users who need to read files with
-non-ANSI characters in the name should set their code page to
-UTF-8 (65001). This should be the default with Windows 11 and better.
-Further, they may use the AreFileApisANSI function to determine whether
-the filename is interpreted using the ANSI or the system default OEM
-codepage, and they may call SetFileApisToOEM accordingly.
 
 Using the Parsed JSON
 ---------------------
@@ -132,7 +105,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
   returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
-* **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`) or a prettified string version (`simdjson::prettify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).
+* **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).
 
 ### Examples
 
@@ -250,13 +223,13 @@ dom::element cars = parser.parse(cars_json);
 cout << cars.at_pointer("/0/tire_pressure/1") << endl; // Prints 39.9
 ```
 
-A JSON Pointer expression is a sequence of segments each starting with the '/' character. Within arrays, an integer
+A JSON Path is a sequence of segments each starting with the '/' character. Within arrays, an integer
 index allows you to select the indexed node. Within objects, the string value of the key allows you to
 select the value. If your keys contain the characters '/' or '~', they must be escaped as '~1' and
-'~0' respectively. An empty JSON Pointer expression refers to the whole document.
+'~0' respectively. An empty JSON Path refers to the whole document.
 
 We also extend the JSON Pointer support to include *relative* paths.
-You can apply a JSON Pointer expression to any node and the path gets interpreted relatively, as if the current node were a whole JSON document.
+You can apply a JSON path to any node and the path gets interpreted relatively, as if the current node were a whole JSON document.
 
 Consider the following example:
 
@@ -278,49 +251,6 @@ for (dom::element car_element : cars) {
 }
 ```
 
-JSONPath
-------------
-
-
-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:
-
-```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 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-] )"_padded;
-dom::parser parser;
-dom::element doc;
-auto error = parser.parse(cars_json).get(doc);
-if(error) { /*won't happen*/ }
-double p;
-error = doc.at_path("[0].tire_pressure[1]").get(p);
-if(error) { /*won't happen*/ }
-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.,
-
-```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;
-auto error = parser.parse(json).get(doc);
-if(error) { /*won't happen*/ }
-dom::object obj;
-error = doc.get_object().get(obj);
-if(error) { /*won't happen*/ }
-int64_t x;
-error = obj.at_path("$[3].foo.a[1]").get(x);
-if(error) { /*won't happen*/ }
-if(x != 20) { /*won't happen*/ }
-x = obj.at_path("$.d.foo2.a.2");
-if(error) { /*won't happen*/ }
-```
 
 
 Error Handling
@@ -399,10 +329,10 @@ int main(void) {
   simdjson::dom::parser parser;
   simdjson::dom::element tweets; // invalid until the get() succeeds
   auto error = parser.load("twitter.json").get(tweets);
-  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   uint64_t identifier;
   error = tweets["statuses"].at(0)["id"].get(identifier);
-  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   std::cout << identifier << std::endl;
   return EXIT_SUCCESS;
 }

doc/implementation-selection.md

@@ -11,31 +11,27 @@ CPU Architecture-Specific Implementations
 Overview
 --------
 
-
-
 The simdjson library takes advantage of SIMD instruction sets such as NEON, SSE and AVX to achieve
 much of its speed. Because these instruction sets work differently, simdjson has to compile a
 different version of the JSON parser for different CPU architectures, often with different
 algorithms to take better advantage of a given CPU!
 
 The current implementations are:
-* icelake: AVX-512F, AVX-512_VBMI, AVX-512_VBMI2, AVX-512_DQ, AVX-512512_CD, AVX-512_BW, AVX-512_VL (2019 Intel Ice Lake, Intel Rocket Lake, Intel Sapphire Rapids, AMD Zen 4)
-* haswell: AVX2 (2013 Intel Haswell or later, all AMD Zen processors)
+* icelake: AVX-512F, AVX-512VBMI, etc.
+* haswell: AVX2 (2013 Intel Haswell or later)
 * westmere: SSE4.2 (2010 Westmere or later).
 * arm64: 64-bit ARMv8-A NEON
-* ppc64: 64-bit POWER8 and POWER9 with VSX and ALTIVEC extensions. Both big endian and little endian are implemented, depending on the compiler you are using. The library is tested on recent, little-endian, POWER systems.
-* lasx: Loongson Advanced SIMD EXtension (LASX),  a 256-bit vector expansion for the LoongArch architecture.
-* lsx: Loongson SIMD EXtension (LSX),  a 128-bit vector expansion for the LoongArch architecture.
+* ppc64: 64-bit POWER8 and POWER9 with VSX and ALTIVEC extensions. Both big endian and little endian are implemented, depends on the compiler you are using. The library is tested on recent, little-endian, POWER systems.
 * fallback: A generic implementation that runs on any 64-bit processor.
 
 In many cases, you don't know where your compiled binary is going to run, so simdjson automatically
 compiles *all* the implementations into the executable. On Intel, it will include 4 implementations
-(icelake, haswell, westmere and fallback), on 64-bit ARM it will include just one since running dispatching is  unnecessary, and on PPC
+(icelake, haswell, westmere and fallback), on ARM it will include 2 (arm64 and fallback), and on PPC
 it will include 2 (ppc64 and fallback).
 
 If you know more about where you're going to run and want to save the space, you can disable any of
 these implementations at compile time with `-DSIMDJSON_IMPLEMENTATION_X=0` (where X is ICELAKE, HASWELL,
-WESTMERE, ARM64, PPC64, LSX, LASX and FALLBACK).
+WESTMERE, ARM64, PPC64 and FALLBACK).
 
 The simdjson library automatically sets header flags for each implementation as it compiles; there
 is no need to set architecture-specific flags yourself (e.g., `-mavx2`, `/AVX2`  or
@@ -79,7 +75,8 @@ And look them up by name:
 ```c++
 cout << simdjson::get_available_implementations()["fallback"]->description() << endl;
 ```
-When an implementation is not available, the bracket call `simdjson::get_available_implementations()[name]`
+Though the fallback implementation should always be available, others might be missing. When
+an implementation is not available, the bracket call `simdjson::get_available_implementations()[name]`
 will return the null pointer.
 
 The available implementations have been compiled but may not necessarily be run safely on your system
@@ -104,8 +101,8 @@ by comparing it with the null pointer.
 
 ```c++
 auto my_implementation = simdjson::get_available_implementations()["haswell"];
-if (! my_implementation) { exit(1); }
-if (! my_implementation->supported_by_runtime_system()) { exit(1); }
+if(! my_implementation) { exit(1); }
+if(! my_implementation->supported_by_runtime_system()) { exit(1); }
 simdjson::get_active_implementation() = my_implementation;
 ```
 
@@ -116,7 +113,7 @@ You should call `supported_by_runtime_system()` to compare the processor's featu
 
 ```c++
 for (auto implementation : simdjson::get_available_implementations()) {
-  if (implementation->supported_by_runtime_system()) {
+  if(implementation->supported_by_runtime_system()) {
     cout << implementation->name() << ": " << implementation->description() << endl;
   }
 }

doc/iterate_many.md

@@ -17,15 +17,11 @@ Contents
 
 - [Motivations](#motivations)
 - [How it works](#how-it-works)
-  - [Context](#context)
-  - [Design](#design)
-  - [Threads](#threads)
 - [Support](#support)
 - [API](#api)
 - [Use cases](#use-cases)
 - [Tracking your position](#tracking-your-position)
 - [Incomplete streams](#incomplete-streams)
-- [C++20 features](#c20-features)
 
 Motivation
 -----------
@@ -103,12 +99,7 @@ remove almost entirely its cost and replaces it by the overhead of a thread, whi
 cheaper. Ain't that awesome!
 
 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
-to the library. Otherwise the library runs in single-thread mode.
-
-You should be consistent. If you link against the simdjson library built for multithreading
-(i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
-system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
 
 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
 
@@ -130,7 +121,7 @@ If your documents are all objects or arrays, then you may even have nothing betw
 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/)
+- [Newline-Delimited JSON (NDJSON)](http://ndjson.org/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
 - [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)
@@ -138,18 +129,6 @@ Some official formats **(non-exhaustive list)**:
 API
 ---
 
-Example:
-
-```c++
-auto json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )"_padded;
-ondemand::parser parser;
-ondemand::document_stream docs = parser.iterate_many(json);
-for (auto doc : docs) {
-  std::cout << doc["foo"] << std::endl;
-}
-// Prints 1 2 3
-```
-
 See [basics.md](basics.md#newline-delimited-json-ndjson-and-json-lines) for an overview of the API.
 
 ## Use cases
@@ -202,12 +181,12 @@ Let us illustrate the idea with code:
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
     auto error = parser.iterate_many(json).get(stream);
-    if (error) { /* do something */ }
+    if( error ) { /* do something */ }
     auto i = stream.begin();
 	 size_t count{0};
     for(; i != stream.end(); ++i) {
         auto doc = *i;
-        if (!i.error()) {
+        if(!i.error()) {
           std::cout << "got full document at " << i.current_index() << std::endl;
           std::cout << i.source() << std::endl;
           count++;
@@ -243,7 +222,7 @@ Consider the following example where a truncated document (`{"key":"intentionall
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
     auto error = parser.iterate_many(json,json.size()).get(stream);
-    if (error) { std::cerr << error << std::endl; return; }
+    if(error) { std::cerr << error << std::endl; return; }
     for(auto i = stream.begin(); i != stream.end(); ++i) {
        std::cout << i.source() << std::endl;
     }
@@ -258,147 +237,3 @@ This will print:
 ```
 
 Importantly, you should only call `truncated_bytes()` after iterating through all of the documents since the stream cannot tell whether there are truncated documents at the very end when it may not have accessed that part of the data yet.
-
-Comma-separated documents
------------
-
-We also support comma-separated documents, but with some performance limitations. The `iterate_many` function  takes in an option to allow parsing of comma separated documents (which defaults on false). In this mode, the entire buffer is processed in one batch. Therefore, the total size of the document should not exceed the maximal capacity of the parser (4 GB). This mode also effectively disallow multithreading. It is therefore mostly suitable for not "very large" inputs. In this mode, the batch_size parameter
-is effectively ignored, as it is set to at least the document size.
-
-Example:
-
-```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;
-    // We pass '32' as the batch size, but it is a bogus parameter because, since
-    // we pass 'true' to the allow_comma parameter, the batch size will be set to at least
-    // the document size.
-    auto error = parser.iterate_many(json, 32, true).get(doc_stream);
-    if (error) { std::cerr << error << std::endl; return; }
-    for (auto doc : doc_stream) {
-        std::cout << doc.type() << std::endl;
-    }
- ```
-
- This will print:
-
-```
-number
-number
-number
-number
-string
-string
-string
-object
-array
-```
-
-
-C++20 features
---------------------
-
-In C++20, the standard introduced the notion of *customization point*.
-A customization point is a function or function object that can be customized for different types. It allows library authors to provide default behavior while giving users the ability to override this behavior for specific types.
-
-A tag_invoke function serves as a mechanism for customization points. It is not directly part of the C++ standard library but is often used in libraries that implement customization points.
-The tag_invoke function is typically a generic function that takes a tag type and additional arguments.
-The first argument is usually a tag type (often an empty struct) that uniquely identifies the customization point (e.g., deserialization of custom types in simdjson). Users or library providers can specialize tag_invoke for their types by defining it in the appropriate namespace, often inline namespace.
-
-
-
-You can deserialize you own data structures conveniently if your system supports C++20.
-When it is the case, the macro `SIMDJSON_SUPPORTS_DESERIALIZATION` will be set to 1 by
-the simdjson library.
-
-Consider a custom class `Car`:
-
-```C++
-struct Car {
-  std::string make;
-  std::string model;
-  int year;
-  std::vector<float> tire_pressure;
-};
-```
-
-
-You may support deserializing directly from a JSON value or document to your own `Car` instance
-by defining a single `tag_invoke` function:
-
-
-```C++
-namespace simdjson {
-// This tag_invoke MUST be inside simdjson namespace
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
-  ondemand::object obj;
-  auto error = val.get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  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(car.year))) {
-    return error;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
-           car.tire_pressure))) {
-    return error;
-  }
-  return simdjson::SUCCESS;
-}
-} // namespace simdjson
-```
-
-Importantly, the `tag_invoke` function must be inside the `simdjson` namespace.
-Let us explain each argument of `tag_invoke` function.
-
-- `simdjson::deserialize_tag`: it is the tag for Customization Point Object (CPO). You may often ignore this parameter. It is used to indicate that you mean to provide a deserialization function for simdjson.
-- `var`: It receives automatically a `simdjson` value type (document, value, document_reference).
-- The third parameter is an instance of the type that you want to support.
-
-Please see our main documentation (`basics.md`) under
-"Use `tag_invoke` for custom types (C++20)" for details about
-tag_invoke functions.
-
-Given a stream of JSON documents, you can add them to a data struture
-such as a `std::vector<Car>` like so if you support exceptions:
-
-```C++
-  padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] }
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-)"_padded;
-  ondemand::parser parser;
-  ondemand::document_stream stream;
-  [[maybe_unused]] auto error = parser.iterate_many(json).get(stream);
-  std::vector<Car> cars;
-  for(auto doc : stream) {
-    cars.push_back((Car)doc); // an exception may be thrown
-  }
-```
-
-Otherwise you may use this longer version for explicit handling of errors:
-
-
-```C++
-  std::vector<Car> cars;
-  for(auto doc : stream) {
-    Car c;
-    if ((error = doc.get<Car>().get(c))) {
-      std::cerr << simdjson::error_message(error); << std::endl;
-      return EXIT_FAILURE;
-    }
-    cars.push_back(c);
-  }
-```

doc/ondemand_design.md

@@ -9,8 +9,8 @@ Whether we parse JSON or XML, or any other serialized format, there are relative
 - Another popular approach is the schema-based deserialization model.
 
 We propose an approach that is as easy to use and often as flexible as the DOM approach, yet as fast and
-efficient as the schema-based or event-based approaches. We call this new approach "On-Demand". The
-simdjson On-Demand API offers a familiar, friendly DOM API and
+efficient as the schema-based or event-based approaches. We call this new approach "On Demand". The
+simdjson On Demand API offers a familiar, friendly DOM API and
 provides the performance of just-in-time parsing on top of the simdjson superior performance.
 
 To achieve ease of use, we mimicked the *form* of a traditional DOM API: you can iterate over
@@ -18,7 +18,7 @@ arrays, look up fields in objects, and extract native values like `double`, `uin
 
 To achieve performance, we introduced some key limitations that make the DOM API *streaming*:
 array/object iteration cannot be restarted, and string/number values can only be parsed once. If
-these limitations are acceptable to you, the On-Demand API could help you write maintainable
+these limitations are acceptable to you, the On Demand API could help you write maintainable
 applications with a computation efficiency that is difficult to surpass.
 
 A code example illustrates our API from a programmer's point of view:
@@ -72,24 +72,24 @@ This streaming approach means that unused fields and values are not parsed or
 converted, thus saving space and time. In our example, the `"name"`, `"followers_count"`,
 and `"friends_count"` keys and matching values are skipped.
 
-Further, the On-Demand API does not parse a value *at all* until you try to convert it (e.g., to `double`,
+Further, the On Demand API does not parse a value *at all* until you try to convert it (e.g., to `double`,
 `int`, `string`, or `bool`). In our example, when accessing the key-value pair `"retweet_count": 82`, the parser
 may not convert the pair of characters `82` to the binary integer 82. Because the programmer specifies the data
 type, we avoid branch mispredictions related to data type determination and improve the performance.
 
 
-We expect users of an On-Demand API to work in terms of a JSON dialect, which is a set of expectations and
+We expect users of an On Demand API to work in terms of a JSON dialect, which is a set of expectations and
 specifications that come in addition to the [JSON specification](https://www.rfc-editor.org/rfc/rfc8259.txt).
-The On-Demand approach is designed around several principles:
+The On Demand approach is designed around several principles:
 
 * **Streaming (\*):** It avoids preparsing values, keeping the memory usage and the latency down.
 * **Forward-Only:** To prevent reiteration of the same values and to keep the number of variables down (literally), only a single index is maintained and everything uses it (even if you have nested for loops). This means when you are going through an array of arrays, for example, that the inner array loop will advance the index to the next comma, and the array can just pick it up and look at it.
 * **Natural Iteration:** A JSON array or object can be iterated with a normal C++ for loop. Nested arrays and objects are supported by nested for loops.
 * **Use-Specific Parsing:** Parsing is always specific to the type required by the programmer. For example, if the programmer asks for an unsigned integer, we just start parsing digits. If there were no digits, we toss an error. There are even different parsers for `double`, `uint64_t` and `int64_t` values. This use-specific parsing avoids the branchiness of a generic "type switch," and makes the code more inlineable and compact.
-* **Validate What You Use:** On-Demand deliberately validates the values you use and the structure leading to it, but nothing else. The goal is a guarantee that the value you asked for is the correct one and is not malformed: there must be no confusion over whether you got the right value.
+* **Validate What You Use:** On Demand deliberately validates the values you use and the structure leading to it, but nothing else. The goal is a guarantee that the value you asked for is the correct one and is not malformed: there must be no confusion over whether you got the right value.
 
 
-To understand why On-Demand is different, it is helpful to review the major
+To understand why On Demand is different, it is helpful to review the major
 approaches to parsing and parser APIs in use today.
 
 ### DOM Parsers
@@ -102,11 +102,11 @@ or indexing (`object["key"]`). In some cases, the values are even deserialized d
 maps.
 
 The DOM approach is conceptually simple and "programmer friendly". Using the
-DOM tree is often easy enough that many users process the DOM as-is instead of creating
+DOM tree is often easy enough that many users use the DOM as-is instead of creating
 their own custom data structures.
 
 The DOM approach was the only way to parse JSON documents up to version 0.6 of the simdjson library.
-Our DOM API looks similar to our On-Demand example, except
+Our DOM API looks similar to our On Demand example, except
 it calls `parse` instead of `iterate`:
 
 ```c++
@@ -152,7 +152,7 @@ a tweet right now, or is this from some other place in the document
 entirely? Though an event-based approach may allow superior performance, it is demanding of the programmer
 who must efficiently keep track of its current state within the JSON input.
 
-The following is event-based example of the Twitter problem we have reviewed in the DOM and On-Demand
+The following is event-based example of the Twitter problem we have reviewed in the DOM and On Demand
 examples. To make it short enough to use as an example at all, it has heavily redacted: it only solves
 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.
@@ -257,7 +257,7 @@ stress the branch prediction. Though branch predictors improve with each new gen
 the cost of branch mispredictions also tends to increase as pipelines expand, and the processors become
 able to schedule longer streams of instructions.
 
-On-Demand parsing is tailor-made to solve this problem at the source, parsing values only after the
+On Demand parsing is tailor-made to solve this problem at the source, parsing values only after the
 user declares their type by asking for a `double`, an `int`, a `string`, etc. It attempts to do so while
 preserving most of the flexibility of DOM parsing.
 
@@ -297,7 +297,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    Since this is the first time this parser has been used, `iterate()` first allocates internal
    parser buffers if this is the first time through. When reusing an existing parser, allocation
-   only happens if the new document is bigger than internal buffers can handle. The On-Demand
+   only happens if the new document is bigger than internal buffers can handle. The On Demand
    API only ever allocates memory in the `iterate()` function call.
 
    The simdjson library then preprocesses the JSON text at high speed, finding all tokens (i.e. the starting
@@ -492,7 +492,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
    Because of the cast to uint64_t, simdjson knows it's parsing an unsigned integer. This lets
    us use a fast parser which *only* knows how to parse digits. It validates that it is an integer
    by rejecting negative numbers, strings, and other values based on the fact that they are not the
-   digits 0-9. This type specificity is part of why parsing with On-Demand is so fast: you lose all
+   digits 0-9. This type specificity is part of why parsing with on demand is so fast: you lose all
    the code that has to understand those other types.
 
    The iterator is advanced to the `}`, and depth decreased back to 3 (root > statuses > tweet).
@@ -597,7 +597,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    This means you can very efficiently do things like read a single value from a JSON file, or take
    the top N, for example. It also means the things you don't use won't be fully validated. This is
-   a general principle of On-Demand: don't validate what you don't use. We still fully validate
+   a general principle of On Demand: don't validate what you don't use. We still fully validate
    values you do use, however, as well as the objects and arrays that lead to them, so that you can
    be sure you get the information you need.
 
@@ -654,7 +654,7 @@ for(auto field : doc.get_object())  {
 
 ### Iteration Safety
 
-The On-Demand API is powerful. To compensate, we add some safeguards to ensure that it can be used without fear
+The On Demand API is powerful. To compensate, we add some safeguards to ensure that it can be used without fear
 in production systems:
 
   - If the value fails to be parsed as one type, the program can try to parse it as something else until the program succeeds. Thus
@@ -667,7 +667,7 @@ in production systems:
     if it was `nullptr` but did not care what the actual value was--it will iterate. The destructor automates
     the iteration.
 
-  Some care is needed when using the On-Demand API in scenarios where you need to access several sibling arrays or objects because
+  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:
 
 ```C++
@@ -679,14 +679,14 @@ in production systems:
     ondemand::object c1 = parent["child1"];
     // c1 owns the focus
     //
-    if (std::string_view(c1["name"]) != "John") { ... }
+    if(std::string_view(c1["name"]) != "John") { ... }
     // c2 attempts to grab the focus from parent but fails
     ondemand::object c2 = parent["child2"];
     // c2 is now in an unsafe state and the following line would be unsafe
-    // if (std::string_view(c2["name"]) != "Daniel") { return false; }
+    // if(std::string_view(c2["name"]) != "Daniel") { return false; }
 ```
 
-A correct usage is given by the following example:
+    A correct usage is given by the following example:
 
 ```C++
     ondemand::parser parser;
@@ -697,7 +697,7 @@ A correct usage is given by the following example:
     {
       ondemand::object c1 = parent["child1"];
       // c1 grabbed the focus from parent
-      if (std::string_view(c1["name"]) != "John") { return false; }
+      if(std::string_view(c1["name"]) != "John") { return false; }
     }
     // c1 went out of scope, so its destructor was called and the focus
     // was handed back to parent.
@@ -705,40 +705,40 @@ A correct usage is given by the following example:
       ondemand::object c2 = parent["child2"];
       // c2 grabbed the focus from parent
       // the following is safe:
-      if (std::string_view(c2["name"]) != "Daniel") { return false; }
+      if(std::string_view(c2["name"]) != "Daniel") { return false; }
     }
 ```
 
-### Benefits of the On-Demand Approach
+### Benefits of the On Demand Approach
 
-We expect that the On-Demand approach has many of the performance benefits of the schema-based approach, while providing a flexibility that is similar to that of the DOM-based approach.
+We expect that the On Demand approach has many of the performance benefits of the schema-based approach, while providing a flexibility that is similar to that of the DOM-based approach.
 
 * Faster than DOM in some cases. Reduced memory usage.
 * Straightforward, programmer-friendly interface (arrays and objects).
 * Highly expressive, beyond deserialization and pointer queries: many tasks can be accomplished with little code.
 
-### Limitations of the On-Demand Approach
+### Limitations of the On Demand Approach
 
-The On-Demand approach has some limitations:
+The On Demand approach has some limitations:
 
 * Because it operates in streaming mode, you only have access to the current element in the JSON document. Furthermore, the document is traversed in order so the code is sensitive to the order of the JSON nodes in the same manner as an event-based approach (e.g., SAX). (The one exception to this is field lookup, which is more *performant* when the order of lookups matches the order of fields in the document, but which will still work with out-of-order fields, with a performance hit.)
-* The On-Demand approach is less safe than DOM: we only validate the components of the JSON document that are used and it is possible to begin ingesting an invalid document only to find out later that the document is invalid. Are you fine ingesting a large JSON document that starts with well formed JSON but ends with invalid JSON content?
+* The On Demand approach is less safe than DOM: we only validate the components of the JSON document that are used and it is possible to begin ingesting an invalid document only to find out later that the document is invalid. Are you fine ingesting a large JSON document that starts with well formed JSON but ends with invalid JSON content?
 
 There are currently additional technical limitations which we expect to resolve in future releases of the simdjson library:
 
-* The simdjson library offers runtime dispatching which allows you to compile one binary and have it run at full speed on different processors, taking advantage of the specific features of the processor. The On-Demand API has limited runtime dispatch support. Under x64 systems, to fully benefit from the On-Demand API, we recommend that you compile your code for a specific processor. E.g., if your processor supports AVX2 instructions, you should compile your binary executable with AVX2 instruction support (by using your compiler's commands). If you are sufficiently technically proficient, you can implement runtime dispatching within your application, by compiling your On-Demand code for different processors.
+* The simdjson library offers runtime dispatching which allows you to compile one binary and have it run at full speed on different processors, taking advantage of the specific features of the processor. The On Demand API has limited runtime dispatch support. Under x64 systems, to fully benefit from the On Demand API, we recommend that you compile your code for a specific processor. E.g., if your processor supports AVX2 instructions, you should compile your binary executable with AVX2 instruction support (by using your compiler's commands). If you are sufficiently technically proficient, you can implement runtime dispatching within your application, by compiling your On Demand code for different processors.
 * There is an initial phase which scans the entire document quickly, irrespective of the size of the document. We plan to break this phase into distinct steps for large files in a future release as we have done with other components of our API (e.g., `parse_many`).
 
-### Applicability of the On-Demand Approach
+### Applicability of the On Demand Approach
 
-At this time we recommend the On-Demand API in the following cases:
+At this time we recommend the On Demand API in the following cases:
 
 1. The 64-bit hardware (CPU) used to run the software is known at compile time. If you need runtime dispatching because you cannot be certain of the hardware used to run your software, you will be better served with the core simdjson API. (This only applies to x64 (AMD/Intel). On 64-bit ARM hardware, runtime dispatching is unnecessary.)
 2. The used parts of JSON files do not need to be validated and the layout of the nodes follows a strict JSON dialect. If you are receiving JSON from other systems, you might be better served with core simdjson API as it fully validates the JSON inputs and allows you to navigate through the document at will.
-3. Speed and efficiency are of the utmost importance. Keep in mind that the core simdjson API is highly efficient so adopting the On-Demand API is not necessary for high efficiency.
+3. Speed and efficiency are of the utmost importance. Keep in mind that the core simdjson API is highly efficient so adopting the On Demand API is not necessary for high efficiency.
 4. As a developer, you value a clean, flexible and maintainable API.
 
-Good applications for the On-Demand API might be:
+Good applications for the On Demand API might be:
 
 * You are working from pre-existing large JSON files that have been vetted. You expect them to be well formed according to a known JSON dialect and to have a consistent layout. For example, you might be doing biomedical research or machine learning on top of static data dumps in JSON.
 * Both the generation and the consumption of JSON data is within your system. Your team controls both the software that produces the JSON and the software the parses it, your team knows and control the hardware. Thus you can fully test your system.
@@ -746,13 +746,13 @@ Good applications for the On-Demand API might be:
 
 ## Checking Your CPU Selection (x64 systems)
 
-The On-Demand API uses advanced architecture-specific code for many common processors to make JSON preprocessing and string parsing faster. By default, however, most c++ compilers will compile to the	least common denominator (since the program could theoretically be run anywhere). Since On-Demand is inlined into your own code, it cannot always use these advanced versions unless the compiler is told to target them.
+The On Demand API uses advanced architecture-specific code for many common processors to make JSON preprocessing and string parsing faster. By default, however, most c++ compilers will compile to the	least common denominator (since the program could theoretically be run anywhere). Since On Demand is inlined into your own code, it cannot always use these advanced versions unless the compiler is told to target them.
 
-On relevant systems, the On-Demand API provides some support for runtime dispatching: that is, it will attempt to detect, at runtime, the instructions that your processor supports and optimize the code accordingly. However, it cannot always make full use of the features of your processor.
+On relevant systems, the On Demand API provides some support for runtime dispatching: that is, it will attempt to detect, at runtime, the instructions that your processor supports and optimize the code accordingly. However, it cannot always make full use of the features of your processor.
 
 Some users wish to run at the best possible speed. Under recent Intel and AMD processors, these users should take additional steps to verify that their code is well optimized.
 
-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.
+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), `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.
 
 ```C++
   std::cout << simdjson::builtin_implementation()->name() << std::endl;
@@ -777,6 +777,6 @@ In these examples, the `-march=haswell` flags targets a haswell processor and th
 
 Instead of specifying a specific microarchitecture, you can let your compiler do the work. The `-march=native` flags says "target the current computer," which is a reasonable default for many applications which both compile and run on the same processor.
 
-Passing `-march=native` to the compiler may make On-Demand faster by allowing it to use optimizations specific to your machine. You cannot do this, however, if you are compiling code	that might be run on less advanced machines. That is, be mindful that when compiling with the `-march=native` flag, the resulting binary will run on the current system but may not run on other systems (e.g., on an old processor).
+Passing `-march=native` to the compiler may make On Demand faster by allowing it to use optimizations specific to your machine. You cannot do this, however, if you are compiling code	that might be run on less advanced machines. That is, be mindful that when compiling with the `-march=native` flag, the resulting binary will run on the current system but may not run on other systems (e.g., on an old processor).
 
-If you are compiling on an ARM or POWER system, you do not need to be concerned with CPU selection during compilation. The `-march=native` flag is useful for best performance on x64 (e.g., Intel) systems but it is generally unsupported on some platforms such as ARM (aarch64) or POWER.
+If you are compiling on an ARM or POWER system, you do not need to be concerned with CPU selection during compilation. The `-march=native` flag useful for best performance on x64 (e.g., Intel) systems but it is generally unsupported on some platforms such as ARM (aarch64) or POWER.

doc/parse_many.md

@@ -103,12 +103,7 @@ cases, remove almost entirely its cost and replaces it by the overhead of a thre
 of magnitude cheaper. Ain't that awesome!
 
 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
-to the library. Otherwise the library runs in single-thread mode.
-
-You should be consistent. If you link against the simdjson library built for multithreading
-(i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
-system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
 
 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
 You should expect the main thread to be fully occupied while the worker thread is partially busy
@@ -130,7 +125,7 @@ Whitespace Characters:
 - **Nothing**
 
 Some official formats **(non-exhaustive list)**:
-- [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec)
+- [Newline-Delimited JSON (NDJSON)](http://ndjson.org/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
 - [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)
@@ -189,12 +184,12 @@ Let us illustrate the idea with code:
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;
     auto error = parser.parse_many(json).get(stream);
-    if (error) { /* do something */ }
+    if( error ) { /* do something */ }
     auto i = stream.begin();
     size_t count{0};
     for(; i != stream.end(); ++i) {
         auto doc = *i;
-        if (!doc.error()) {
+        if(!doc.error()) {
           std::cout << "got full document at " << i.current_index() << std::endl;
           std::cout << i.source() << std::endl;
           count++;
@@ -230,7 +225,7 @@ Consider the following example where a truncated document (`{"key":"intentionall
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;
     auto error = parser.parse_many(json,json.size()).get(stream);
-    if (error) { std::cerr << error << std::endl; return; }
+    if(error) { std::cerr << error << std::endl; return; }
     for(auto doc : stream) {
        std::cout << doc << std::endl;
     }