added missing 'auto'

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/feature_request.md

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

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

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

.github/pull_request_template.md

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

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

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

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

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

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

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

.github/workflows/ubuntu22-cxx20.yml

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

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

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

.github/workflows/ubuntu24-noexcept.yml

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

.github/workflows/ubuntu24-nothread.yml

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

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

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

.gitignore

@@ -38,7 +38,7 @@ cmake-build-release/
 .history/
 
 # Visual Studio artifacts
-/.vs/
+/VS/
 
 # C/C++ build outputs
 .build/

.vscode/settings.json

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

CMakeLists.txt

@@ -1,9 +1,11 @@
 cmake_minimum_required(VERSION 3.14)
+cmake_policy(VERSION 3.5) # For doctest
+
 
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.0.5
+    VERSION 3.13.0
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,8 +22,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "27.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_VERSION "26.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "27" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_SOVERSION "26" CACHE STRING "simdjson library soversion")
 
 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)

Doxyfile

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

HACKING.md

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

README.md

@@ -1,3 +1,5 @@
+
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
 [![][license img]][license] [![][licensemit img]][licensemit]
 
 
@@ -62,7 +64,6 @@ Real-world usage
 - [WasmEdge](https://wasmedge.org)
 - [RonDB](https://github.com/logicalclocks/rondb)
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
-- [mamba](https://github.com/mamba-org/mamba)
 
 
 If you are planning to use simdjson in a product, please work from one of our releases.
@@ -118,7 +119,6 @@ Godbolt
 -------------
 
 Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-* [C++26 reflection example](https://godbolt.org/z/K3Px64TqK)
 * [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
 * [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)
 

benchmark/CMakeLists.txt

@@ -35,16 +35,6 @@ if (TARGET benchmark::benchmark)
   endif()
 endif()
 
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-std=c++20" SIMDJSON_COMPILER_SUPPORTS_CXX20)
 if(SIMDJSON_STATIC_REFLECTION)
   add_subdirectory(static_reflect)
-else()
-  if(SIMDJSON_EXCEPTIONS AND SIMDJSON_COMPILER_SUPPORTS_CXX20)
-    add_subdirectory(from)
-    add_subdirectory(car_builder)
-  endif()
 endif(SIMDJSON_STATIC_REFLECTION)
-
-

benchmark/car_builder/CMakeLists.txt

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

benchmark/car_builder/benchmark_car_builder.cpp

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

benchmark/dom/parse_stream.cpp

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

benchmark/from/CMakeLists.txt

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

benchmark/from/benchmark_helpers.h

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

benchmark/from/car_helpers.h

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

benchmark/from/from_benchmark.cpp

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

benchmark/get_corpus_benchmark.cpp

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

benchmark/static_reflect/CMakeLists.txt

@@ -6,27 +6,26 @@ CPMAddPackage(
   EXCLUDE_FROM_ALL YES
 )
 
-option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)
 
-if(SIMDJSON_USER_RUST)
+
-  if(NOT WIN32)
+if(NOT WIN32)
-  # We want the check whether Rust is available before trying to build a crate.
+# We want the check whether Rust is available before trying to build a crate.
-  CPMAddPackage(
+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")
+include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
-  endif()
+endif()
 
-  if(RUST_FOUND)
+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()
+else()
   message(STATUS "Rust/Cargo is unavailable." )
   message(STATUS "We will not benchmark serde-benchmark." )
   if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
@@ -38,10 +37,7 @@ if(SIMDJSON_USER_RUST)
     message(STATUS "or" )
     message(STATUS "curl https://sh.rustup.rs -sSf | sh")
   endif()
-  endif()
+endif()
-else(SIMDJSON_USER_RUST)
-  message(STATUS "We will not benchmark serde-benchmark." )
-endif(SIMDJSON_USER_RUST)
 
 # Add the benchmark executable targets
 add_subdirectory(twitter_benchmark)

cmake/developer-options.cmake

@@ -4,7 +4,7 @@
 add_library(simdjson-internal-flags INTERFACE)
 if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
   # We default to ON for all targets, so that we can use the library in shared libraries.
-  set_target_properties(simdjson-internal-flags PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
+  set_target_properties(simdjson-internal-flags PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
 
 option(SIMDJSON_CHECK_EOF "Check for the end of the input buffer. The setting is unnecessary since we require padding of the inputs. You should expect tests to fail with this option turned on." OFF)
@@ -32,9 +32,6 @@ undefined behavior.")
     link_libraries(
         -fsanitize=address -fno-omit-frame-pointer -fno-sanitize-recover=all
     )
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    add_compile_options(-fsanitize=address)
-    link_libraries(-fsanitize=address)
   else()
     message(
         STATUS

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

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

doc/basics.md

@@ -1,51 +1,48 @@
 The Basics
 ==========
 
-An overview of what you need to know to use simdjson to parse JSON documents, with examples.
+An overview of what you need to know to use simdjson, with examples.
-[Our documentation regarding the generation (serialization) of JSON documents is in a
+
-separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.md).
+- [The Basics](#the-basics)
+  - [Requirements](#requirements)
+  - [Including simdjson](#including-simdjson)
+  - [Using simdjson with package managers](#using-simdjson-with-package-managers)
+  - [Using simdjson as a CMake dependency](#using-simdjson-as-a-cmake-dependency)
+  - [Versions](#versions)
+  - [The basics: loading and parsing JSON documents](#the-basics-loading-and-parsing-json-documents)
+  - [Documents are iterators](#documents-are-iterators)
+    - [Parser, document and JSON scope](#parser-document-and-json-scope)
+  - [string_view](#string_view)
+  - [Avoiding pitfalls: enable development checks](#avoiding-pitfalls-enable-development-checks)
+  - [Using the parsed JSON](#using-the-parsed-json)
+    - [Using the parsed JSON: additional examples](#using-the-parsed-json-additional-examples)
+  - [Adding support for custom types](#adding-support-for-custom-types)
+    - [1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)](#1-specialize-simdjsonondemandvalueget-to-get-custom-types-pre-c20)
+    - [2. Use `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20)
+  - [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
+  - [UTF-8 validation (alone)](#utf-8-validation-alone)
+  - [JSON Pointer](#json-pointer)
+  - [JSONPath](#jsonpath)
+  - [Error handling](#error-handling)
+    - [Error handling examples without exceptions](#error-handling-examples-without-exceptions)
+    - [Disabling exceptions](#disabling-exceptions)
+    - [Exceptions](#exceptions)
+    - [Current location in document](#current-location-in-document)
+    - [Checking for trailing content](#checking-for-trailing-content)
+  - [Rewinding](#rewinding)
+  - [Newline-Delimited JSON (ndjson) and JSON lines](#newline-delimited-json-ndjson-and-json-lines)
+  - [Parsing numbers inside strings](#parsing-numbers-inside-strings)
+  - [Dynamic Number Types](#dynamic-number-types)
+  - [Raw strings from keys](#raw-strings-from-keys)
+  - [General direct access to the raw JSON string](#general-direct-access-to-the-raw-json-string)
+  - [Storing directly into an existing string instance](#storing-directly-into-an-existing-string-instance)
+  - [Thread safety](#thread-safety)
+  - [Standard compliance](#standard-compliance)
+  - [Backwards compatibility](#backwards-compatibility)
+  - [Examples](#examples)
+  - [Performance tips](#performance-tips)
+  - [Further reading](#further-reading)
 
-- [Requirements](#requirements)
-- [Including simdjson](#including-simdjson)
-- [Using simdjson with package managers](#using-simdjson-with-package-managers)
-- [Using simdjson as a CMake dependency](#using-simdjson-as-a-cmake-dependency)
-- [Versions](#versions)
-- [The basics: loading and parsing JSON documents](#the-basics-loading-and-parsing-json-documents)
-- [Documents are iterators](#documents-are-iterators)
-  * [Parser, document and JSON scope](#parser-document-and-json-scope)
-- [string_view](#string_view)
-- [Avoiding pitfalls: enable development checks](#avoiding-pitfalls-enable-development-checks)
-- [Using the parsed JSON](#using-the-parsed-json)
-  * [Using the parsed JSON: additional examples](#using-the-parsed-json-additional-examples)
-- [Adding support for custom types](#adding-support-for-custom-types)
-  * [1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)](#1-specialize-simdjsonondemandvalueget-to-get-custom-types-pre-c20)
-  * [2. Use `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20)
-  * [3. Using static reflection (C++26)](#3-using-static-reflection-c26)
-  * [The simdjson::from shortcut (experimental, C++20)](#the-simdjsonfrom-shortcut-experimental-c20)
-- [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
-- [UTF-8 validation (alone)](#utf-8-validation-alone)
-- [JSON Pointer](#json-pointer)
-- [JSONPath](#jsonpath)
-- [Error handling](#error-handling)
-  * [Error handling examples without exceptions](#error-handling-examples-without-exceptions)
-  * [Disabling exceptions](#disabling-exceptions)
-  * [Exceptions](#exceptions)
-  * [Current location in document](#current-location-in-document)
-  * [Checking for trailing content](#checking-for-trailing-content)
-- [Rewinding](#rewinding)
-- [Newline-Delimited JSON (ndjson) and JSON lines](#newline-delimited-json-ndjson-and-json-lines)
-- [Parsing numbers inside strings](#parsing-numbers-inside-strings)
-- [Dynamic Number Types](#dynamic-number-types)
-- [Raw strings from keys](#raw-strings-from-keys)
-- [General direct access to the raw JSON string](#general-direct-access-to-the-raw-json-string)
-  * [Raw JSON string for objects and arrays](#raw-json-string-for-objects-and-arrays)
-- [Storing directly into an existing string instance](#storing-directly-into-an-existing-string-instance)
-- [Thread safety](#thread-safety)
-- [Standard compliance](#standard-compliance)
-- [Backwards compatibility](#backwards-compatibility)
-- [Examples](#examples)
-- [Performance tips](#performance-tips)
-- [Further reading](#further-reading)
 
 Requirements
 ------------------
@@ -54,7 +51,7 @@ The simdjson library is widely deployed in popular systems such as the Node.js r
 environment.
 
 - A recent compiler (LLVM clang 6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on POSIX systems such as macOS, FreeBSD or Linux. We require that the compiler supports the C++11 standard or better. We test the library on a big-endian system (IBM s390x with Linux).
-- Visual Studio 2017 or better. We support the LLVM clang compiler under Visual Studio (clang-cl) as well as the regular Visual Studio compiler. For better release performance (both compile time and execution time), we recommend Visual Studio users adopt LLVM (clang-cl). We discourage using GCC under Windows: there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).
+- Visual Studio 2017 or better. We support the LLVM clang compiler under Visual Studio (clang-cl) as well as as the regular Visual Studio compiler. For better release performance (both compile time and execution time), we recommend Visual Studio users adopt LLVM (clang-cl). We also support MinGW 64-bit under Windows.
 
 Support for AVX-512 require a processor with AVX512-VBMI2 support (Ice Lake or better, AMD Zen 4 or better) under a 64-bit system and a recent compiler (LLVM clang 6 or better, GCC 8 or better, Visual Studio 2019 or better). You need a correspondingly recent assembler such as gas (2.30+) or nasm (2.14+): recent compilers usually come with recent assemblers. If you mix a recent compiler with an incompatible/old assembler (e.g., when using a recent compiler with an old Linux distribution), you may get errors at build time because the compiler produces instructions that the assembler does not recognize: you should update your assembler to match your compiler (e.g., upgrade binutils to version 2.30 or better under Linux) or use an older compiler matching the capabilities of your assembler.
 
@@ -78,14 +75,14 @@ c++ myproject.cpp simdjson.cpp
 ```
 
 Note:
-- We recommend that you use simdjson by copying the single-header `simdjson.h` file along with the source file `simdjson.cpp` directly into your project, as they are part of [every release](https://github.com/simdjson/simdjson/releases) as assets. In this manner, you only have to compile `simdjson.cpp` as any other source file: it works well in every development environment. However, you may also use simdjson as a git submodule ([example](https://github.com/simdjson/cmakedemo)), using FetchContent ([example](https://github.com/simdjson/cmake_demo_single_file)), with ExternalProject_Add ([example](https://github.com/simdjson/cmakedemo_externalproject)) or with CPM ([example](https://github.com/cpm-cmake/CPM.cmake/tree/master/examples/simdjson)).
+- We recommend that you use simdjson by copying the single-header `simdjson.h` file along with the source file `simdjson.cpp` directly in your project, as they are part of [every release](https://github.com/simdjson/simdjson/releases) as assets. In this manner, you only have to compile `simdjson.cpp` as any other source file: it works well in every development environment. However, you may also use simdjson as a git submodule ([example](https://github.com/simdjson/cmakedemo)), using FetchContent ([example](https://github.com/simdjson/cmake_demo_single_file)), with ExternalProject_Add ([example](https://github.com/simdjson/cmakedemo_externalproject)) or with CPM ([example](https://github.com/cpm-cmake/CPM.cmake/tree/master/examples/simdjson)).
 - Users on macOS and other platforms where default compilers do not provide C++11 compliant by default should request it with the appropriate flag (e.g., `c++ -std=c++11 myproject.cpp simdjson.cpp`).
 - The library relies on [runtime CPU detection](implementation-selection.md): avoid specifying an architecture at compile time (e.g., `-march-native`) if you want your binaries to run everywhere.
 
 Using simdjson with package managers
 ------------------
 
-You can install the simdjson library on your system or in your project using multiple package managers such as MSYS2, the conan package manager, vcpkg, brew, the apt package manager (debian-based Linux systems), the FreeBSD package manager (FreeBSD), and so on. E.g., [we provide a complete example with vcpkg](https://github.com/simdjson/simdjson-vcpkg) that works under Windows. [Visit our wiki for more details](https://github.com/simdjson/simdjson/wiki/Installing-simdjson-with-a-package-manager).
+You can install the simdjson library on your system or in your project using multiple package managers such as MSYS2, the conan package manager, vcpkg, brew, the apt package manager (debian-based Linux systems), the FreeBSD package manager (FreeBSD), and so on. E.g., [we provide an complete example with vcpkg](https://github.com/simdjson/simdjson-vcpkg) that works under Windows. [Visit our wiki for more details](https://github.com/simdjson/simdjson/wiki/Installing-simdjson-with-a-package-manager).
 
 
 
@@ -180,18 +177,6 @@ auto json = padded_string::load("twitter.json"); // load JSON file 'twitter.json
 ondemand::document doc = parser.iterate(json); // position a pointer at the beginning of the JSON data
 ```
 
-If you prefer not to create your own `ondemand::parser` instance, you can access
-a thread-local version by calling `ondemand::parser.get_parser()`.
-
-
-```c++
-ondemand::document doc = ondemand::parser.get_parser().iterate(json);
-```
-
-However, you should be careful because a parser instance can only be used for one
-document at a time, thus it is only applicable when you are only parsing one
-document per thread at any one time.
-
 You can also create a padded string---and call `iterate()`:
 
 ```c++
@@ -251,6 +236,7 @@ Consider reusing the same buffers and limiting memory allocations.
 
 By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
 
+
 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/98Kx9Kqjn)
@@ -320,7 +306,7 @@ At the cost of some memory allocation, you may convert your `std::string_view` i
 For convenience, we also allow [storing an escaped string directly into an existing string instance](#storing-directly-into-an-existing-string-instance).
 
 The `std::string_view` class has become standard as part of C++17 but it is not always available
-on compilers that only supports C++11. When we detect that `string_view` is natively
+on compilers which only supports C++11. When we detect that `string_view` is natively
 available, we define the macro `SIMDJSON_HAS_STRING_VIEW`.
 
 When we detect that it is unavailable,
@@ -343,7 +329,7 @@ We recommend that you first compile and run your code in debug mode:
 
 The simdjson code will set `SIMDJSON_DEVELOPMENT_CHECKS=1` in debug mode. Because
 the C++ standard does not provide a direct way of checking for a debug build, and
-because you may want the checks while building with optimizations, you can set
+because you may want the checks while building with otimizations, you can set
 the  macro `SIMDJSON_DEVELOPMENT_CHECKS` to 1 prior to including
 the `simdjson.h` header to enable these additional checks: just make sure you remove the
 definition once your code has been tested. When `SIMDJSON_DEVELOPMENT_CHECKS` is set to 1, the
@@ -371,8 +357,9 @@ and arrays (`simdjson::ondemand::array`).
 We also have a generic ephemeral type (`simdjson::ondemand::value`) which represents a potential
 array or object, or scalar type (`double`, `uint64_t`, `int64_t`, `bool`, `null`, string) inside
 an array or an object. Both generic types (`simdjson::ondemand::document` and
-`simdjson::ondemand::value`) have a `type()` method returning a `json_type` value describing indicating the type (`json_type::array`, `json_type::object`, `json_type::number`, `json_type::string`,
+`simdjson::ondemand::value`) have a `type()` method returning a `json_type` value describing the
-`json_type::boolean`, `json_type::null`, and `json_type::unknown` for unrecognized types). The `type()` method does not consume nor validate the value: e.g., you must still call `is_null()` to check that the value is a `null` even if `json_type::null` is returned. Starting with simdjson 4.0, we return `json_type::unknown` for bad tokens such as the `NaN` token in `{"key":NaN}`. A `json_type::unknown` type value indicates an error in the JSON document but you might still be able to proceed, see [General direct access to the raw JSON string](#general-direct-access-to-the-raw-json-string). A generic value (`simdjson::ondemand::value`)
+value (`json_type::array`, `json_type::object`, `json_type::number`, `json_type::string`,
+`json_type::boolean`, `json_type::null`). A generic value (`simdjson::ondemand::value`)
 is only valid temporarily, as soon as you access other values, other keys in objects, etc.
 it becomes invalid: you should therefore consume the value immediately by converting it to a
 scalar type, an array or an object.
@@ -405,7 +392,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   ondemand::object and ondemand::array. We also have explicit methods such as `get_string()`, `get_double()`,
   `get_uint64()`, `get_int64()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
   the number, string or boolean will be parsed, or the initial `{` or `[` will be verified for `ondemand::object` and `ondemand::array`. An exception may be thrown if
-  the cast is not possible: the error code is `simdjson::INCORRECT_TYPE` (see [Error handling](#error-handling)). Importantly, when getting an ondemand::object or ondemand::array instance, its content is
+  the cast is not possible: there error code is `simdjson::INCORRECT_TYPE` (see [Error handling](#error-handling)). Importantly, when getting an ondemand::object or ondemand::array instance, its content is
   not validated: you are only guaranteed that the corresponding initial character (`{` or `[`) is present. Thus,
   for example, you could have an ondemand::object instance pointing at the invalid JSON `{ "this is not a valid object" }`: the validation occurs as you access the content.
   The `get_string()` returns a valid UTF-8 string, after
@@ -452,7 +439,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`. This will
   scan through the object looking for the field with the matching string, doing a character-by-character
   comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
-  not do `object["foo"]` followed by `object["foo"]` with the same `object` instance. Generally, you should not mix and match iterating through an object (`for(auto field : object) {...}`) and key accesses (`object["foo"]`): if you need to iterate through an object after a key access, you need to call `reset()` on the object. Whenever you call `reset()`, you need to keep in mind that though you can iterate over the array repeatedly, values should be consumedonly once (e.g., repeatedly calling `unescaped_key()` on the same  key is forbidden). Keep in mind that On-Demand does not buffer or save the result of the parsing: if you repeatedly access `object["foo"]`, then it must repeatedly seek the key and parse the content. The library does not provide a distinct function to check if a key is present, instead we recommend you attempt to access the key: e.g., by doing `ondemand::value val{}; if (!object["foo"].get(val)) {...}`, you have that `val` contains the requested value inside the if clause.  It is your responsibility as a user to temporarily keep a reference to the value (`auto v = object["foo"]`), or to consume the content and store it in your own data structures. If you consume an
+  not do `object["foo"]` followed by `object["foo"]` with the same `object` instance. For best performance, you should try to query the keys in the same order they appear in the document. If you need several keys and you cannot predict the order they will appear in, it is recommended to iterate through all keys `for(auto field : object) {...}`. Generally, you should not mix and match iterating through an object (`for(auto field : object) {...}`) and key accesses (`object["foo"]`): if you need to iterate through an object after a key access, you need to call `reset()` on the object. Whenever you call `reset()`, you need to keep in mind that though you can iterate over the array repeatedly, values should be consumedonly once (e.g., repeatedly calling `unescaped_key()` on the same  key is forbidden). Keep in mind that On-Demand does not buffer or save the result of the parsing: if you repeatedly access `object["foo"]`, then it must repeatedly seek the key and parse the content. The library does not provide a distinct function to check if a key is present, instead we recommend you attempt to access the key: e.g., by doing `ondemand::value val{}; if (!object["foo"].get(val)) {...}`, you have that `val` contains the requested value inside the if clause.  It is your responsibility as a user to temporarily keep a reference to the value (`auto v = object["foo"]`), or to consume the content and store it in your own data structures. If you consume an
   object twice: `std::string_view(object["foo"]` followed by `std::string_view(object["foo"]` then your code
   is in error. Furthermore, you can only consume one field at a time, on the same object. The
   value instance you get from  `content["bids"]` becomes invalid when you call `content["asks"]`.
@@ -515,7 +502,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   > double y = doc["y"]; // The cursor is now after the 2 (at })
   > double x = doc["x"]; // Success: [] loops back around to find "x"
   > ```
-* **Output to strings:** Given a document, a value, an array or an object in a JSON document, you can output a JSON string version suitable to be parsed again as JSON content: `simdjson::to_json_string(element)`. A call to `to_json_string` consumes fully the element: if you apply it on a document, the internal pointer is advanced to the end of the document. The `simdjson::to_json_string` does not allocate memory. The `to_json_string` function should not be confused with retrieving the value of a string instance which are escaped and represented using a lightweight `std::string_view` instance pointing at an internal string buffer inside the parser instance. To illustrate, the first of the following two code segments will print the unescaped string `"test"` complete with the quote whereas the second one will print the escaped content of the string (without the quotes).
+* **Output to strings:** Given a document, a value, an array or an object in a JSON document, you can output a JSON string version suitable to be parsed again as JSON content: `simdjson::to_json_string(element)`. A call to `to_json_string` consumes fully the element: if you apply it on a document, the JSON pointer is advanced to the end of the document. The `simdjson::to_json_string` does not allocate memory. The `to_json_string` function should not be confused with retrieving the value of a string instance which are escaped and represented using a lightweight `std::string_view` instance pointing at an internal string buffer inside the parser instance. To illustrate, the first of the following two code segments will print the unescaped string `"test"` complete with the quote whereas the second one will print the escaped content of the string (without the quotes).
   > ```C++
   > // serialize a JSON to an escaped std::string instance so that it can be parsed again as JSON
   > auto silly_json = R"( { "test": "result"  }  )"_padded;
@@ -698,9 +685,6 @@ support for users who avoid exceptions. See [the simdjson error handling documen
         cout << "null";
       }
       break;
-    case ondemand::json_type::unknown:
-      cout << "unknown"; // indicates an error
-      break;
     }
   }
   void basics_treewalk() {
@@ -842,7 +826,7 @@ There are 3 main ways provided by simdjson to deserialize a value into a custom
    1. Specialize `simdjson::ondemand::document::get` for the whole document
    2. Specialize `simdjson::ondemand::value::get` for each value
 2. Using `tag_invoke` *(the recommended way if your system supports C++20 or better)*
-3. Using static reflection (requires C++26 or better)
+3. Using static reflectioin (requires C++26 or better)
 
 We describe all of them in the following sections. Most users who have systems compatible with
 C++20 or better should skip ahead to [using `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20) as it is more powerful and simpler.
@@ -884,13 +868,13 @@ type:
 
 We may do so by providing additional template definitions to the `ondemand::value` type.
 We may start by providing a definition for `std::vector<double>` as follows. Observe
-how we guard the code with `#if !SIMDJSON_SUPPORTS_CONCEPTS`: that is because the necessary code
+how we guard the code with `#if !SIMDJSON_SUPPORTS_DESERIALIZATION`: that is because the necessary code
 is automatically provided by simdjson if C++20 (and concepts) are available.
 See [Use `tag_invoke` for custom types](#2-use-tag_invoke-for-custom-types-c20) if you have
 C++20 support.
 
 ```c++
-#if !SIMDJSON_SUPPORTS_CONCEPTS
+#if !SIMDJSON_SUPPORTS_DESERIALIZATION
 // The code is unnecessary with C++20:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
@@ -946,7 +930,7 @@ struct Car {
   std::vector<double> tire_pressure;
 };
 
-#if !SIMDJSON_SUPPORTS_CONCEPTS
+#if !SIMDJSON_SUPPORTS_DESERIALIZATION
 // This code is not necessary if you have a C++20 compliant system:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
@@ -1047,7 +1031,7 @@ struct Car {
   std::vector<double> tire_pressure;
 };
 
-#if !SIMDJSON_SUPPORTS_CONCEPTS
+#if !SIMDJSON_SUPPORTS_DESERIALIZATION
 // This code is not necessary if you have a C++20 compliant system:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
@@ -1142,7 +1126,7 @@ The first argument is usually a tag type (often an empty struct) that uniquely i
 
 If your system supports C++20, we recommend that you adopt the `tag_invoke` approach
 instead to deserialize custom types. It may prove to be considerably simpler. When
-simdjson detects the necessary support, it sets the `SIMDJSON_SUPPORTS_CONCEPTS` macro
+simdjson detects the necessary support, it sets the `SIMDJSON_SUPPORTS_DESERIALIZATION` macro
 to 1, otherwise it is set to 0.
 
 Consider a custom class `Car`:
@@ -1156,7 +1140,7 @@ struct Car {
 };
 ```
 
-Observe how we define the class to use types that simdjson does not directly support (`float`, `int`).
+Observe how we defined the class to use types that simdjson does not directly support (`float`, `int`).
 With C++20 support, the library grabs from the JSON the generic type (`double`, `int`) and then it
 casts it automatically.
 
@@ -1359,9 +1343,6 @@ auto tag_invoke(deserialize_tag, simdjson_value &val, std::list<Car>& car) {
 With this code, deserializing an `std::list<Car>` instance would capture only the cars
 that are not made by Toyota.
 
-
-
-
 ### 3. Using static reflection (C++26)
 
 If you have a C++26 compatible compiler, you can compile
@@ -1374,134 +1355,18 @@ your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 ```
 
 Then you can deserialize a type such as `Car` automatically:
-
+```cpp
-
-
-```C++
-struct Car {
-  std::string make;
-  std::string model;
-  int year;
-  std::vector<float> tire_pressure;
-};
-
 std::string json =  R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] } )";
 simdjson::ondemand::parser parser;
-simdjson::ondemand::document doc = parser.iterate(simdjson::pad(json));
+simdjson::ondemand::document doc = parser.iterate(simdjson::pad(json)).get(doc);
 Car c = doc.get<Car>();
 ```
 
-
-We try to automate the parsing of any given structure or class
-by looking at its non-static public members. At compile-time,
-the library looks at a simple structure like `Car` and
-maps it to parsing code. We call the default constructor,
-and then assign values to the public members.
-
-
-#### Special cases
-
-However, there are instances where the construction cannot
-be easily automated. Let us consider a class without any
-public member.
-
-```cpp
-
-class MyDate {
-public:
-    void assign(std::string_view str) {
-        date_str = str;
-    }
-    const std::string& to_string() const {
-        return date_str;
-    }
-private:
-    std::string date_str;
-};
-```
-
-This class has a default constructor, but it must be initialized
-with the `assign` method. We need to help the library with
-a `tag_invoke` function (just as in the C++20 case).
-
-
-```cpp
-namespace simdjson {
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, MyDate& date) {
-    std::string_view str;
-    auto error = val.get_string().get(str);
-    if(error) { return error; }
-    date.assign(str);
-  return simdjson::SUCCESS;
-}
-} // namespace simdjson
-```
-
-Once this is done, we can now automatically parse a custom type
-like `complicated_weather_data` containing `MyDate` values.
-
-
-```cpp
-struct complicated_weather_data {
-    std::vector<MyDate> time;
-    std::vector<float> temperature;
-};
-```
-
-The code might be as simple as the following.
-
-```cpp
-auto padded = R"({"time":["2023-03-15T12:00:00Z"],"temperature":[42]})"_padded;
-simdjson::ondemand::parser parser;
-simdjson::ondemand::document doc = parser.iterate(padded);
-complicated_weather_data p = doc.get<>(complicated_weather_data);
-```
-
-Thus you can combine C++26 static reflection with custom deserialization
-functions.
-
 You can also automatically serialize the `Car` instance to a JSON string, see
 our [Builder documentation](builder.md).
 
 
-
-### The simdjson::from shortcut (experimental, C++20)
-
-
-For even more convenience, you can parse a JSON document directly to a supported
-type without a document instance like so:
-
-```cpp
-Car car = simdjson::from(json);
-```
-
-You can also use the `simdjson::from` syntax without exceptions, like so:
-```cpp
-Car car;
-simdjson::error_code err = simdjson::from(json_car).get(car);
-```
-
-You can also use the `simdjson::from` syntax to iterate over an array.
-
-```cpp
-for(auto val : simdjson::from(json).array()) {
-  Car c = val.get<Car>(); // ...
-}
-```
-
-Standard STL types are supported:
-
-
-```cpp
-std::map<std::string, std::string> obj =
-       simdjson::from(R"({"key": "value"})"_padded);
-```
-
-
-The `simdjson::from` construction is EXPERIMENTAL and subject to changes.
-
 Minifying JSON strings without parsing
 ----------------------
 
@@ -1543,9 +1408,9 @@ If you find yourself needing only fast Unicode functions, consider using the sim
 JSON Pointer
 ------------
 
-The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the `at_pointer()` method, letting you reach further down into the document in a single call. JSON Pointer is supported by both the [DOM approach](https://github.com/simdjson/simdjson/blob/master/doc/dom.md#json-pointer) as well as the On-Demand approach.
+The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the `at_pointer()` method, letting you reach further down into the document in a single call. JSON pointer is supported by both the [DOM approach](https://github.com/simdjson/simdjson/blob/master/doc/dom.md#json-pointer) as well as the On-Demand approach.
 
-**Note:** The On-Demand implementation of JSON Pointer relies on `find_field` which implies that it does not unescape keys when matching.
+**Note:** The On-Demand implementation of JSON pointer relies on `find_field` which implies that it does not unescape keys when matching.
 
 Consider the following example:
 
@@ -1565,7 +1430,7 @@ index allows you to select the indexed node. Within objects, the string value of
 select the value. If your keys contain the characters '/' or '~', they must be escaped as '~1' and
 '~0' respectively. An empty JSON Pointer Path refers to the whole document.
 
-For multiple JSON Pointer queries on a document, one can call `at_pointer` multiple times.
+For multiple JSON pointer queries on a document, one can call `at_pointer` multiple times.
 
 ```c++
 auto cars_json = R"( [
@@ -1720,7 +1585,7 @@ x = obj.at_path("$.d.foo2.a.2"); // 30
 Error handling
 --------------
 
-Error handling with exception and a single try/catch clause makes the code simple, but it gives you little control over errors. For easier debugging or more robust error handling, you may want to consider our exception-free approach.
+Error handing with exception and a single try/catch clause makes the code simple, but it gives you little control over errors. For easier debugging or more robust error handling, you may want to consider our exception-free approach.
 
 The entire simdjson API is usable with and without exceptions. All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
 pair. You can retrieve the value with .get() without generating an exception, like so:
@@ -2314,8 +2179,7 @@ The simdjson library supports parsing valid numbers inside strings which makes i
 three methods: `get_double_in_string`, `get_int64_in_string` and  `get_uint64_in_string`. However, it is important to note that these methods are not substitute to the regular
 `get_double`, `get_int64` and `get_uint64`. The usage of the `get_*_in_string` methods is solely to parse valid JSON numbers inside strings, and so we expect users to call these
 methods appropriately. In particular, a valid JSON number has no leading and no trailing whitespaces, and the strings `"nan"`, `"1e"` and `"infinity"` will not be accepted as valid
-numbers (although you have access to the raw string with the `raw_json_token()` method,  see [General direct access to the raw JSON string](#general-direct-access-to-the-raw-json-string)
+numbers. As an example, suppose we have the following JSON text:
-). As an example, suppose we have the following JSON text:
 
 ```c++
 auto json =
@@ -2634,36 +2498,10 @@ The `raw_json_token()` should be fast and free of allocation.
 Given a quote-deliminated string, you find the string sequence inside the quote with a
 single line of code:
 
-```cpp
+```C++
 std::string_view noquote(std::string_view v) { return {v.data()+1, v.find_last_of('"')-1}; }
 ```
 
-
-The `raw_json_token()` method can enable you to provide fallbacks when parsing fails.
-Consider the following example.
-
-```cpp
-    padded_string json = "{\"key\": NaN}"_padded;
-    simdjson::ondemand::parser parser;
-    simdjson::ondemand::document doc = parser.iterate(json);
-    simdjson::ondemand::object object = doc.get_object();
-    simdjson::ondemand::value val = object["key"];
-    simdjson::ondemand::json_type type = val.type();
-    // type == simdjson::ondemand::json_type::unknown
-    try {
-      double num = val.get_double();
-    } catch (const simdjson::simdjson_error& e) {
-      // e == simdjson::error_code::INCORRECT_TYPE
-      std::string_view str = val.raw_json_token();
-      // str == "NaN"
-    }
-```
-
-The NaN is not supported in JSON. However, in the On-Demand API, you can check
-the string corresponding to the JSON token and determine how to handle it.
-
-### Raw JSON string for objects and arrays
-
 If your value is an array or an object, `raw_json_token()` returns effectively a single
 character (`[`) or (`}`) which is not very useful. For arrays and objects, we have another
 method called `raw_json()` which consumes (traverses) the array or the object.
@@ -3182,45 +3020,10 @@ Performance tips
 - The On-Demand front-end works best when doing a single pass over the input: avoid calling `count_elements`, `rewind`, `reset` and similar methods.
 - If you are familiar with assembly language, you may use the online tool godbolt to explore the compiled code. The following example may work: [https://godbolt.org/z/xE4GWs573](https://godbolt.org/z/xE4GWs573).
 - Given a field `field` in an object, calling `field.key()` is often faster than `field.unescaped_key()` so if you do not need an unescaped `std::string_view` instance, prefer `field.key()`. Similarly, we expect `field.escaped_key()` to be faster than `field.unescaped_key()` even though both return a `std::string_view` instance.
-- For release builds, we recommend setting the `NDEBUG` pre-processor directive when compiling the `simdjson` library. Importantly, using the optimization flags `-O2` or `-O3` under GCC and LLVM clang does not set the `NDEBUG` directive, you must set it manually (e.g., `-DNDEBUG`).
+- For release builds, we recommend setting `NDEBUG` pre-processor directive when compiling the `simdjson` library. Importantly, using the optimization flags `-O2` or `-O3` under GCC and LLVM clang does not set the `NDEBUG` directive, you must set it manually (e.g., `-DNDEBUG`).
 - For long streams of JSON documents, consider [`iterate_many`](iterate_many.md) and [`parse_many`](parse_many.md) for better performance.
 - Never seek to access a field twice (e.g., o["data"] and later again o["data"]). Instead capture once an ondemand::value and reuse it.
-- If you must access several different keys in an object, it might be preferable to iterate through all the fields in the object instead, and branch on the field keys. Consider this example.
+- If you must access several different keys in an object, it might be preferable to iterate through all the fields in the object instead, and branch on the field keys.
-  ```cpp
-
-    auto json = R"({"price": 123.456789, "volume": 9999,
-                    "timestamp": "2025-09-04T09:45:00Z",
-                    "symbol": "XYZ", "currency": "USD", "change": 1.23,
-                    "isActive": true})"_padded;
-
-    simdjson::ondemand::parser parser;
-    simdjson::ondemand::document doc = parser.iterate(json);
-
-    for(auto keyvalue : doc.get_object()) {
-        simdjson::ondemand::raw_json_string key = keyvalue.key();
-        switch(key[0]) {
-            case 'p': // price
-                if (key == "price") {
-                    std::string_view price_str = keyvalue.value().raw_json();
-                    std::cout << "Price: " << price_str << std::endl;
-                }
-                break;
-            case 'v': // volume
-                if (key == "volume") {
-                    std::string_view volume_str = keyvalue.value().raw_json();
-                    std::cout << "Volume: " << volume_str << std::endl;
-                }
-                break;
-            case 't': // timestamp
-                if (key == "timestamp") {
-                    std::string_view timestamp = keyvalue.value();
-                    std::cout << "Timestamp: " << timestamp << std::endl;
-                }
-                break;
-            default: break;
-        }
-    }
-  ```
 - If possible, refer to each object and array in your code once. For example, the following code repeatedly refers to the `"data"` key to create an object...
 	```C++
 	std::string_view make = o["data"]["make"];

doc/builder.md

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

doc/dom.md

@@ -1,10 +1,7 @@
 The Document-Object-Model (DOM) front-end
 ==========
 
-An overview of what you need to know to use simdjson to parse JSON documents with
+An overview of what you need to know to use simdjson, with examples.
-our DOM API, with examples. [Our documentation regarding the generation (serialization) of JSON documents is in a
-separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.md).
-
 
 * [DOM vs On-Demand](#dom-vs-on-demand)
 * [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents-using-the-dom-front-end)
@@ -31,10 +28,6 @@ a conventional Document-Object-Model (DOM) front-end. In such a scenario, the JS
 entirely parsed, validated and materialized in memory as the first step. The programmer may
 then access the parsed data using this in-memory model.
 
-On-Demand is a different model where you parse just what you need, directly into your own
-data structure. The On-Demand approach, when well tuned, can provide superior performance.
-[We refer you to the On-Demand documentation for further details](https://github.com/simdjson/simdjson/blob/master/doc/basics.md).
-
 The Basics: Loading and Parsing JSON Documents using the DOM front-end
 ----------------------------------------------
 
@@ -129,7 +122,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   The strings contain unescaped valid UTF-8 strings: no unmatched surrogate is allowed.
   Internally, numbers are stored as either 64-bit integers or 64-bit floating-point numbers.
   Thus it is possible to get the full 64-bit integer range (either signed or  unsigned).
-  By default, the string `-0` is parsed as the integer 0 as in Python or C++. If you set the macro
+  By default, the string `-0` is parsed as the integer 0 as in Pytho or C++. If you set the macro
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
   as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
@@ -354,74 +347,6 @@ if(error) { /*won't happen*/ }
 ```
 
 
-## Using `at_path_with_wildcard` for JSONPath Queries
-
-The `at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. This allows users to retrieve multiple elements from a JSON document in a single query. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
-
-The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level.  You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the function returns an empty result. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield an empty set.
-
-### Example Usage
-
-Here is an example demonstrating the use of `at_path_with_wildcard`:
-
-```cpp
-simdjson::padded_string json_string = R"(
-{
-  "firstName": "John",
-  "lastName": "doe",
-  "age": 26,
-  "address": {
-    "streetAddress": "naist street",
-    "city": "Nara",
-    "postalCode": "630-0192"
-  },
-  "phoneNumbers": [
-    {
-      "type": "iPhone",
-      "numbers": ["0123-4567-8888", "0123-4567-8788"]
-    },
-    {
-      "type": "home",
-      "numbers": ["0123-4567-8910"]
-    }
-  ]
-})"_padded;
-
-dom::parser parser;
-dom::element parsed_json = parser.parse(json_string);
-std::vector<dom::element> values;
-
-// Fetch all fields in the address object
-auto error = parsed_json.at_path_with_wildcard("$.address.*").get(values);
-if(error) {
-  // do something
-}
-for (auto &value : values) {
-  std::string_view field;
-  error = value.get(field);
-  if(error) {
-    // do something
-  }
-  std::cout << field << std::endl;
-}
-
-// Fetch all phone numbers
-error = parsed_json.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values);
-if(error) {
-  // do something
-}
-for (auto &value : values) {
-  std::string_view number;
-  error = value.get(number);
-  if(error) {
-    // do something
-  }
-  std::cout << number << std::endl;
-}
-```
-
-This function is particularly useful for extracting data from complex JSON structures with nested arrays and objects. By leveraging wildcards, you can simplify your queries and reduce the need for multiple iterations.
-
 Error Handling
 --------------
 

doc/iterate_many.md

@@ -309,7 +309,7 @@ The first argument is usually a tag type (often an empty struct) that uniquely i
 
 
 You can deserialize you own data structures conveniently if your system supports C++20.
-When it is the case, the macro `SIMDJSON_SUPPORTS_CONCEPTS` will be set to 1 by
+When it is the case, the macro `SIMDJSON_SUPPORTS_DESERIALIZATION` will be set to 1 by
 the simdjson library.
 
 Consider a custom class `Car`:

doc/performance.md

@@ -173,6 +173,8 @@ Recent versions of Microsoft Visual Studio on Windows provides support for the L
 
 We recommend Visual Studio users prefer LLVM (clang-cl). It compiles to faster release binaries. Furthermore, it compilers faster in release mode.
 
+Under Windows, we also support the GNU GCC compiler via MSYS2. The performance of 64-bit MSYS2 under Windows is excellent (on par with Linux).
+
 
 Power Usage and Downclocking
 --------------

fuzz/fuzz_minify.cpp

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

include/simdjson.h

@@ -53,6 +53,4 @@
 
 #include "simdjson/dom.h"
 #include "simdjson/ondemand.h"
-#include "simdjson/convert.h"
-#include "simdjson/convert-inl.h"
 #endif // SIMDJSON_H

include/simdjson/arm64/implementation.h

@@ -23,6 +23,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace arm64

include/simdjson/base.h

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

include/simdjson/common_defs.h

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

include/simdjson/compiler_check.h

@@ -81,38 +81,24 @@
 #endif
 #endif
 
-#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
-#include <ranges>
-#define SIMDJSON_SUPPORTS_RANGES 1
-#else
-#define SIMDJSON_SUPPORTS_RANGES 0
-#endif
 
 #if defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
 #if __cpp_concepts >= 201907L
 #include <utility>
-#define SIMDJSON_SUPPORTS_CONCEPTS 1
-#else
-#define SIMDJSON_SUPPORTS_CONCEPTS 0
-#endif
-#else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
-#define SIMDJSON_SUPPORTS_CONCEPTS 0
-#endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
-
-// copy SIMDJSON_SUPPORTS_CONCEPTS to SIMDJSON_SUPPORTS_DESERIALIZATION.
-#if SIMDJSON_SUPPORTS_CONCEPTS
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 1
 #else
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 0
 #endif
-
+#else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
+#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
+#endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
 
 #if !defined(SIMDJSON_CONSTEVAL)
-#if defined(__cpp_consteval) && __cpp_consteval >= 201811L && defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
+#if defined(__cpp_consteval) && __cpp_consteval >= 201811L
 #define SIMDJSON_CONSTEVAL 1
 #else
 #define SIMDJSON_CONSTEVAL 0
-#endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L && defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
+#endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L
 #endif // !defined(SIMDJSON_CONSTEVAL)
 
 #endif // SIMDJSON_COMPILER_CHECK_H

include/simdjson/concepts.h

@@ -1,6 +1,6 @@
 #ifndef SIMDJSON_CONCEPTS_H
 #define SIMDJSON_CONCEPTS_H
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
 
 #include <concepts>
 #include <type_traits>
@@ -32,9 +32,7 @@ SIMDJSON_IMPL_CONCEPT(op_append, operator+=)
 #undef SIMDJSON_IMPL_CONCEPT
 } // namespace details
 
-template <typename T>
+
-concept is_pair = requires { typename T::first_type; typename T::second_type; } &&
-                  std::same_as<T, std::pair<typename T::first_type, typename T::second_type>>;
 template <typename T>
 concept string_view_like = std::is_convertible_v<T, std::string_view> &&
                            !std::is_convertible_v<T, const char*>;
@@ -128,5 +126,5 @@ concept optional_type = requires(std::remove_cvref_t<T> obj) {
 
 } // namespace concepts
 } // namespace simdjson
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 #endif // SIMDJSON_CONCEPTS_H

include/simdjson/constevalutil.h

@@ -1,53 +0,0 @@
-#ifndef SIMDJSON_CONSTEVALUTIL_H
-#define SIMDJSON_CONSTEVALUTIL_H
-
-#include <string>
-#include <string_view>
-#include <array>
-
-#if SIMDJSON_CONSTEVAL
-namespace simdjson {
-namespace constevalutil {
-
-constexpr static std::array<uint8_t, 256> json_quotable_character = {
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-constexpr static std::array<std::string_view, 32> control_chars = {
-    "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006",
-    "\\u0007", "\\b", "\\t",     "\\n",     "\\u000b", "\\f",     "\\r",
-    "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013", "\\u0014",
-    "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b",
-    "\\u001c", "\\u001d", "\\u001e", "\\u001f"};
-// unoptimized, meant for compile-time execution
-consteval std::string consteval_to_quoted_escaped(std::string_view input) {
-  std::string out = "\"";
-  for (char c : input) {
-    if (json_quotable_character[uint8_t(c)]) {
-      if (c == '"') {
-        out.append("\\\"");
-      } else if (c == '\\') {
-        out.append("\\\\");
-      } else {
-        std::string_view v = control_chars[uint8_t(c)];
-        out.append(v);
-      }
-    } else {
-      out.push_back(c);
-    }
-  }
-  out.push_back('"');
-  return out;
-}
-} // namespace constevalutil
-} // namespace simdjson
-#endif  // SIMDJSON_CONSTEVAL
-#endif // SIMDJSON_CONSTEVALUTIL_H

include/simdjson/convert-inl.h

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

include/simdjson/convert.h

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

include/simdjson/dom/array-inl.h

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

include/simdjson/dom/array.h

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

include/simdjson/dom/element-inl.h

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

include/simdjson/dom/element.h

@@ -1,8 +1,6 @@
 #ifndef SIMDJSON_DOM_ELEMENT_H
 #define SIMDJSON_DOM_ELEMENT_H
 
-#include <vector>
-
 #include "simdjson/dom/base.h"
 #include "simdjson/dom/array.h"
 
@@ -401,8 +399,6 @@ public:
    */
   inline simdjson_result<element> at_pointer(const std::string_view json_pointer) const noexcept;
 
-  inline simdjson_result<std::vector<element>> at_path_with_wildcard(const std::string_view json_path) const noexcept;
-
   /**
    * Get the value associated with the given JSONPath expression. We only support
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
@@ -548,7 +544,6 @@ public:
   simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
   simdjson_result<dom::element> operator[](int) const noexcept = delete;
   simdjson_inline simdjson_result<dom::element> at_pointer(const std::string_view json_pointer) const noexcept;
-  simdjson_inline simdjson_result<std::vector<dom::element>> at_path_with_wildcard(const std::string_view json_path) const noexcept;
   simdjson_inline simdjson_result<dom::element> at_path(const std::string_view json_path) const noexcept;
   [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
   simdjson_inline simdjson_result<dom::element> at(const std::string_view json_pointer) const noexcept;

include/simdjson/dom/object-inl.h

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

include/simdjson/dom/object.h

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

include/simdjson/dom/parser-inl.h

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

include/simdjson/dom/parser.h

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

include/simdjson/dom/serialization-inl.h

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

include/simdjson/dom/serialization.h

@@ -5,6 +5,8 @@
 #include "simdjson/dom/element.h"
 #include "simdjson/dom/object.h"
 
+#include <vector>
+
 namespace simdjson {
 
 /**
@@ -14,7 +16,8 @@ namespace simdjson {
  */
 namespace internal {
 
-template <class formatter> class base_formatter {
+template<class formatter>
+class base_formatter {
 public:
   /** Add a comma **/
   simdjson_inline void comma();
@@ -53,77 +56,25 @@ public:
   /** Prints one character **/
   simdjson_inline void one_char(char c);
 
-  /** Prints characters in [begin, end) verbatim. **/
-  simdjson_inline void chars(const char *begin, const char *end);
-
   simdjson_inline void call_print_newline() {
-    static_cast<formatter *>(this)->print_newline();
+      static_cast<formatter*>(this)->print_newline();
   }
 
   simdjson_inline void call_print_indents(size_t depth) {
-    static_cast<formatter *>(this)->print_indents(depth);
+      static_cast<formatter*>(this)->print_indents(depth);
   }
 
   simdjson_inline void call_print_space() {
-    static_cast<formatter *>(this)->print_space();
+      static_cast<formatter*>(this)->print_space();
   }
 
 protected:
   // implementation details (subject to change)
   /** Backing buffer **/
-  struct vector_with_small_buffer {
+  std::vector<char> buffer{}; // not ideal!
-    vector_with_small_buffer() = default;
-    ~vector_with_small_buffer() { free_buffer(); }
-
-    vector_with_small_buffer(const vector_with_small_buffer &) = delete;
-    vector_with_small_buffer &
-    operator=(const vector_with_small_buffer &) = delete;
-
-    void clear() {
-      size = 0;
-      capacity = StaticCapacity;
-      free_buffer();
-      buffer = array;
-    }
-
-    simdjson_inline void push_back(char c) {
-      if (capacity < size + 1)
-        grow(capacity * 2);
-      buffer[size++] = c;
-    }
-
-    simdjson_inline void append(const char *begin, const char *end) {
-      const size_t new_size = size + (end - begin);
-      if (capacity < new_size)
-        // std::max(new_size, capacity * 2); is broken in tests on Windows
-        grow(new_size < capacity * 2 ? capacity * 2 : new_size);
-      std::copy(begin, end, buffer + size);
-      size = new_size;
-    }
-
-    std::string_view str() const { return std::string_view(buffer, size); }
-
-  private:
-    void free_buffer() {
-      if (buffer != array)
-        delete[] buffer;
-    }
-    void grow(size_t new_capacity) {
-      auto new_buffer = new char[new_capacity];
-      std::copy(buffer, buffer + size, new_buffer);
-      free_buffer();
-      buffer = new_buffer;
-      capacity = new_capacity;
-    }
-
-    static const size_t StaticCapacity = 64;
-    char array[StaticCapacity];
-    char *buffer = array;
-    size_t size = 0;
-    size_t capacity = StaticCapacity;
-  } buffer{};
 };
 
+
 /**
  * @private This is the class that we expect to use with the string_builder
  * template. It tries to produce a compact version of the JSON element
@@ -156,11 +107,9 @@ protected:
  * by a "formatter" which handles the details. Thus
  * the string_builder template could support both minification
  * and prettification, and various other tradeoffs.
- *
- * This is not to be confused with the simdjson::builder::string_builder
- * which is a different class.
  */
-template <class formatter = mini_formatter> class string_builder {
+template <class formatter = mini_formatter>
+class string_builder {
 public:
   /** Construct an initially empty builder, would print the empty string **/
   string_builder() = default;
@@ -182,12 +131,11 @@ public:
   simdjson_inline std::string_view str() const;
   /** Append a key_value_pair to the builder (to be printed) **/
   simdjson_inline void append(simdjson::dom::key_value_pair value);
-
 private:
   formatter format{};
 };
 
-} // namespace internal
+} // internal
 
 namespace dom {
 
@@ -196,43 +144,33 @@ namespace dom {
  *
  * @param out The output stream.
  * @param value The element.
- * @throw if there is an error with the underlying output stream. simdjson
+ * @throw if there is an error with the underlying output stream. simdjson itself will not throw.
- * itself will not throw.
  */
-inline std::ostream &operator<<(std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, simdjson::dom::element value);
-                                simdjson::dom::element value);
 #if SIMDJSON_EXCEPTIONS
-inline std::ostream &
+inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::element> x);
-operator<<(std::ostream &out,
-           simdjson::simdjson_result<simdjson::dom::element> x);
 #endif
 /**
  * Print JSON to an output stream.
  *
  * @param out The output stream.
  * @param value The array.
- * @throw if there is an error with the underlying output stream. simdjson
+ * @throw if there is an error with the underlying output stream. simdjson itself will not throw.
- * itself will not throw.
  */
-inline std::ostream &operator<<(std::ostream &out, simdjson::dom::array value);
+inline std::ostream& operator<<(std::ostream& out, simdjson::dom::array value);
 #if SIMDJSON_EXCEPTIONS
-inline std::ostream &
+inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::dom::array> x);
-operator<<(std::ostream &out,
-           simdjson::simdjson_result<simdjson::dom::array> x);
 #endif
 /**
  * Print JSON to an output stream.
  *
  * @param out The output stream.
  * @param value The object.
- * @throw if there is an error with the underlying output stream. simdjson
+ * @throw if there is an error with the underlying output stream. simdjson itself will not throw.
- * itself will not throw.
  */
-inline std::ostream &operator<<(std::ostream &out, simdjson::dom::object value);
+inline std::ostream& operator<<(std::ostream& out, simdjson::dom::object value);
 #if SIMDJSON_EXCEPTIONS
-inline std::ostream &
+inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::dom::object> x);
-operator<<(std::ostream &out,
-           simdjson::simdjson_result<simdjson::dom::object> x);
 #endif
 } // namespace dom
 
@@ -244,47 +182,47 @@ operator<<(std::ostream &out,
  *   cout << to_string(doc) << endl; // prints [1,2,3]
  *
  */
-template <class T> std::string to_string(T x) {
+template <class T>
-  // in C++, to_string is standard:
+std::string to_string(T x)   {
-  // http://www.cplusplus.com/reference/string/to_string/ Currently minify and
+    // in C++, to_string is standard: http://www.cplusplus.com/reference/string/to_string/
-  // to_string are identical but in the future, they may differ.
+    // Currently minify and to_string are identical but in the future, they may
+    // differ.
     simdjson::internal::string_builder<> sb;
     sb.append(x);
     std::string_view answer = sb.str();
     return std::string(answer.data(), answer.size());
 }
 #if SIMDJSON_EXCEPTIONS
-template <class T> std::string to_string(simdjson_result<T> x) {
+template <class T>
-  if (x.error()) {
+std::string to_string(simdjson_result<T> x) {
-    throw simdjson_error(x.error());
+    if (x.error()) { throw simdjson_error(x.error()); }
-  }
     return to_string(x.value());
 }
 #endif
 
 /**
- * Minifies a JSON element or document, printing the smallest possible valid
+ * Minifies a JSON element or document, printing the smallest possible valid JSON.
- * JSON.
  *
  *   dom::parser parser;
  *   element doc = parser.parse("   [ 1 , 2 , 3 ] "_padded);
  *   cout << minify(doc) << endl; // prints [1,2,3]
  *
  */
-template <class T> std::string minify(T x) { return to_string(x); }
+template <class T>
+std::string minify(T x)  {
+  return to_string(x);
+}
 
 #if SIMDJSON_EXCEPTIONS
-template <class T> std::string minify(simdjson_result<T> x) {
+template <class T>
-  if (x.error()) {
+std::string minify(simdjson_result<T> x) {
-    throw simdjson_error(x.error());
+    if (x.error()) { throw simdjson_error(x.error()); }
-  }
     return to_string(x.value());
 }
 #endif
 
 /**
- * Prettifies a JSON element or document, printing the valid JSON with
+ * Prettifies a JSON element or document, printing the valid JSON with indentation.
- * indentation.
  *
  *   dom::parser parser;
  *   element doc = parser.parse("   [ 1 , 2 , 3 ] "_padded);
@@ -300,7 +238,8 @@ template <class T> std::string minify(simdjson_result<T> x) {
  *   cout << prettify(doc) << endl;
  *
  */
-template <class T> std::string prettify(T x) {
+template <class T>
+std::string prettify(T x)  {
     simdjson::internal::string_builder<simdjson::internal::pretty_formatter> sb;
     sb.append(x);
     std::string_view answer = sb.str();
@@ -308,14 +247,14 @@ template <class T> std::string prettify(T x) {
 }
 
 #if SIMDJSON_EXCEPTIONS
-template <class T> std::string prettify(simdjson_result<T> x) {
+template <class T>
-  if (x.error()) {
+std::string prettify(simdjson_result<T> x) {
-    throw simdjson_error(x.error());
+    if (x.error()) { throw simdjson_error(x.error()); }
-  }
     return to_string(x.value());
 }
 #endif
 
 } // namespace simdjson
 
+
 #endif

include/simdjson/error-inl.h

@@ -67,38 +67,8 @@ simdjson_inline error_code simdjson_result_base<T>::error() const noexcept {
   return this->second;
 }
 
-
-template<typename T>
-simdjson_inline bool simdjson_result_base<T>::has_value() const noexcept {
-  return this->error() == SUCCESS;
-}
-
 #if SIMDJSON_EXCEPTIONS
 
-
-template<typename T>
-simdjson_inline T& simdjson_result_base<T>::operator*() &  noexcept(false) {
-  return this->value();
-}
-
-template<typename T>
-simdjson_inline T&& simdjson_result_base<T>::operator*() &&  noexcept(false) {
-  return std::forward<internal::simdjson_result_base<T>>(*this).value();
-}
-
-template<typename T>
-simdjson_inline T* simdjson_result_base<T>::operator->() noexcept(false) {
-  if (this->error()) { throw simdjson_error(this->error()); }
-  return &this->first;
-}
-
-
-template<typename T>
-simdjson_inline const T* simdjson_result_base<T>::operator->() const noexcept(false) {
-  if (this->error()) { throw simdjson_error(this->error()); }
-  return &this->first;
-}
-
 template<typename T>
 simdjson_inline T& simdjson_result_base<T>::value() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -123,7 +93,6 @@ simdjson_inline simdjson_result_base<T>::operator T&&() && noexcept(false) {
 
 #endif // SIMDJSON_EXCEPTIONS
 
-
 template<typename T>
 simdjson_inline const T& simdjson_result_base<T>::value_unsafe() const& noexcept {
   return this->first;
@@ -159,11 +128,27 @@ simdjson_inline void simdjson_result<T>::tie(T &value, error_code &error) && noe
 }
 
 template<typename T>
-simdjson_warn_unused simdjson_inline error_code
+simdjson_warn_unused simdjson_inline error_code simdjson_result<T>::get(T &value) && noexcept {
-simdjson_result<T>::get(T &value) && noexcept {
   return std::forward<internal::simdjson_result_base<T>>(*this).get(value);
 }
 
+template<typename T>
+simdjson_warn_unused simdjson_inline error_code
+simdjson_result<T>::get(std::string &value) && noexcept
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
+requires (!std::is_same_v<T, std::string>)
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
+{
+  // SFINAE : n'active que pour T = std::string_view
+  static_assert(std::is_same<T, std::string_view>::value, "simdjson_result<T>::get(std::string&) n'est disponible que pour T = std::string_view");
+  std::string_view v;
+  error_code error = std::forward<simdjson_result<T>>(*this).get(v);
+  if (!error) {
+    value.assign(v.data(), v.size());
+  }
+  return error;
+}
+
 template<typename T>
 simdjson_inline error_code simdjson_result<T>::error() const noexcept {
   return internal::simdjson_result_base<T>::error();

include/simdjson/error.h

@@ -108,10 +108,6 @@ namespace internal {
 /**
  * The result of a simdjson operation that could fail.
  *
- * IMPORTANT: For the ondemand API, we use implementation_simdjson_result_base<T> as a base class
- * to avoid some compilation issue. Thus, if you modify this class, please ensure that the ondemand
- * implementation_simdjson_result_base<T> is also modified.
- *
  * Gives the option of reading error codes, or throwing an exception by casting to the desired result.
  *
  * This is a base class for implementations that want to add functions to the result type for
@@ -172,27 +168,8 @@ struct simdjson_result_base : protected std::pair<T, error_code> {
    */
   simdjson_inline error_code error() const noexcept;
 
-  /**
-   * Whether there is a value.
-   */
-  simdjson_inline bool has_value() const noexcept;
 #if SIMDJSON_EXCEPTIONS
 
-  /**
-   * Dereference operator to access the contained value.
-   *
-   * @throw simdjson_error if there was an error.
-   */
-  simdjson_inline T& operator*() &  noexcept(false);
-  simdjson_inline T&& operator*() &&  noexcept(false);
-  /**
-   * Arrow operator to access members of the contained value.
-   *
-   * @throw simdjson_error if there was an error.
-   */
-  simdjson_inline T* operator->() noexcept(false);
-  simdjson_inline const T* operator->() const noexcept(false);
-
   /**
    * Get the result value.
    *
@@ -226,42 +203,12 @@ struct simdjson_result_base : protected std::pair<T, error_code> {
   /**
    * Get the result value. This function is safe if and only
    * the error() method returns a value that evaluates to false.
-   * We discourage the use of value_unsafe().
-   *
-   * The recommended pattern is:
-   *
-   * T value; // where T is the type
-   * auto error = result.get(value);
-   * if (error) {
-   *   // handle error
-   * }
-   *
-   * Or you may call 'value()' which will raise an exception
-   * in case of error:
-   *
-   * T value = result.value();
    */
   simdjson_inline const T& value_unsafe() const& noexcept;
 
   /**
    * Take the result value (move it). This function is safe if and only
    * the error() method returns a value that evaluates to false.
-   * We discourage the use of value_unsafe().
-   *
-   * The recommended pattern is:
-   *
-   * T value; // where T is the type
-   * auto error = result.get(value);
-   * if (error) {
-   *   // handle error, return, exit, abort
-   * } else {
-   *   // use value here.
-   * }
-   *
-   * Or you may call 'value()' which will raise an exception
-   * in case of error:
-   *
-   * T value = result.value();
    */
   simdjson_inline T&& value_unsafe() && noexcept;
 
@@ -276,7 +223,6 @@ struct simdjson_result_base : protected std::pair<T, error_code> {
  */
 template<typename T>
 struct simdjson_result : public internal::simdjson_result_base<T> {
-
   /**
    * @private Create a new empty result with error = UNINITIALIZED.
    */
@@ -308,33 +254,24 @@ struct simdjson_result : public internal::simdjson_result_base<T> {
    * @param value The variable to assign the value to. May not be set if there is an error.
    */
   simdjson_warn_unused simdjson_inline error_code get(T &value) && noexcept;
-
+//
   /**
    * Copy the value to a provided std::string, only enabled for std::string_view.
    *
    * @param value The variable to assign the value to. May not be set if there is an error.
    */
-  template <typename U = T>
+  simdjson_warn_unused simdjson_inline error_code get(std::string &value) && noexcept
-  simdjson_warn_unused simdjson_inline error_code get(std::string &value) && noexcept {
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    static_assert(std::is_same<U, std::string_view>::value, "SFINAE");
+  requires (!std::is_same_v<T, std::string>)
-    std::string_view v;
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
-    error_code error = std::forward<simdjson_result<T>>(*this).get(v);
+  ;
-    if (!error) {
-      value.assign(v.data(), v.size());
-    }
-    return error;
-  }
-
   /**
    * The error.
    */
   simdjson_inline error_code error() const noexcept;
 
-
-
 #if SIMDJSON_EXCEPTIONS
-  using internal::simdjson_result_base<T>::operator*;
+
-  using internal::simdjson_result_base<T>::operator->;
   /**
    * Get the result value.
    *

include/simdjson/fallback/implementation.h

@@ -26,6 +26,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace fallback

include/simdjson/generic/implementation_simdjson_result_base-inl.h

@@ -33,37 +33,8 @@ simdjson_inline error_code implementation_simdjson_result_base<T>::error() const
   return this->second;
 }
 
-
-template<typename T>
-simdjson_inline bool implementation_simdjson_result_base<T>::has_value() const noexcept {
-  return this->error() == SUCCESS;
-}
-
 #if SIMDJSON_EXCEPTIONS
 
-template<typename T>
-simdjson_inline T& implementation_simdjson_result_base<T>::operator*() &  noexcept(false) {
-  return this->value();
-}
-
-template<typename T>
-simdjson_inline T&& implementation_simdjson_result_base<T>::operator*() &&  noexcept(false) {
-  return std::forward<implementation_simdjson_result_base<T>>(*this).value();
-}
-
-template<typename T>
-simdjson_inline T* implementation_simdjson_result_base<T>::operator->() noexcept(false) {
-  if (this->error()) { throw simdjson_error(this->error()); }
-  return &this->first;
-}
-
-
-template<typename T>
-simdjson_inline const T* implementation_simdjson_result_base<T>::operator->() const noexcept(false) {
-  if (this->error()) { throw simdjson_error(this->error()); }
-  return &this->first;
-}
-
 template<typename T>
 simdjson_inline T& implementation_simdjson_result_base<T>::value() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }

include/simdjson/generic/implementation_simdjson_result_base.h

@@ -74,11 +74,6 @@ struct implementation_simdjson_result_base {
    */
   simdjson_inline error_code error() const noexcept;
 
-  /**
-   * Whether there is a value.
-   */
-  simdjson_inline bool has_value() const noexcept;
-
 #if SIMDJSON_EXCEPTIONS
 
   /**
@@ -86,16 +81,6 @@ struct implementation_simdjson_result_base {
    *
    * @throw simdjson_error if there was an error.
    */
-  simdjson_inline T& operator*() &  noexcept(false);
-  simdjson_inline T&& operator*() &&  noexcept(false);
-  /**
-   * Arrow operator to access members of the contained value.
-   *
-   * @throw simdjson_error if there was an error.
-   */
-  simdjson_inline T* operator->() noexcept(false);
-  simdjson_inline const T* operator->() const noexcept(false);
-
   simdjson_inline T& value() & noexcept(false);
 
   /**
@@ -137,7 +122,6 @@ struct implementation_simdjson_result_base {
    * the error() method returns a value that evaluates to false.
    */
   simdjson_inline T&& value_unsafe() && noexcept;
-
 protected:
   /** users should never directly access first and second. **/
   T first{}; /** Users should never directly access 'first'. **/

include/simdjson/generic/ondemand/array.h

@@ -132,7 +132,7 @@ public:
    */
   simdjson_inline simdjson_result<value> at(size_t index) noexcept;
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
   /**
    * Get this array as the given type.
    *
@@ -161,7 +161,7 @@ public:
     SIMDJSON_TRY(get<T>(out));
     return out;
   }
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 protected:
   /**
    * Go to the end of the array, no matter where you are right now.
@@ -240,7 +240,7 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
   simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
   // TODO: move this code into object-inl.h
 
   template<typename T>
@@ -261,7 +261,7 @@ public:
     }
     return SUCCESS;
   }
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 };
 
 } // namespace simdjson

include/simdjson/generic/ondemand/array_iterator-inl.h

@@ -36,9 +36,6 @@ simdjson_inline array_iterator &array_iterator::operator++() noexcept {
   return *this;
 }
 
-simdjson_inline bool array_iterator::at_end() const noexcept {
-  return iter.at_end();
-}
 } // namespace ondemand
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
@@ -75,9 +72,7 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterato
   ++(first);
   return *this;
 }
-simdjson_inline bool simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator>::at_end() const noexcept {
+
-  return !first.iter.is_valid() || first.at_end();
-}
 } // namespace simdjson
 
 #endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H

include/simdjson/generic/ondemand/array_iterator.h

@@ -34,8 +34,7 @@ public:
    *
    * Part of the std::iterator interface.
    */
-  simdjson_inline simdjson_result<value>
+  simdjson_inline simdjson_result<value> operator*() noexcept; // MUST ONLY BE CALLED ONCE PER ITERATION.
-  operator*() noexcept; // MUST ONLY BE CALLED ONCE PER ITERATION.
   /**
    * Check if we are at the end of the JSON.
    *
@@ -59,11 +58,6 @@ public:
    */
   simdjson_inline array_iterator &operator++() noexcept;
 
-  /**
-   * Check if the array is at the end.
-   */
-  simdjson_warn_unused simdjson_inline bool at_end() const noexcept;
-
 private:
   value_iterator iter{};
 
@@ -82,6 +76,7 @@ namespace simdjson {
 
 template<>
 struct simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> : public SIMDJSON_IMPLEMENTATION::implementation_simdjson_result_base<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> {
+public:
   simdjson_inline simdjson_result(SIMDJSON_IMPLEMENTATION::ondemand::array_iterator &&value) noexcept; ///< @private
   simdjson_inline simdjson_result(error_code error) noexcept; ///< @private
   simdjson_inline simdjson_result() noexcept = default;
@@ -94,8 +89,6 @@ struct simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> : publ
   simdjson_inline bool operator==(const simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> &) const noexcept;
   simdjson_inline bool operator!=(const simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> &) const noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> &operator++() noexcept;
-
-  simdjson_warn_unused simdjson_inline bool at_end() const noexcept;
 };
 
 } // namespace simdjson

include/simdjson/generic/ondemand/deserialize.h

@@ -1,4 +1,4 @@
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
 
 #ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
@@ -77,7 +77,7 @@ template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
 concept custom_deserializable = tag_invocable<deserialize_tag, ValT&, T&>;
 
 template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
-concept deserializable = custom_deserializable<T, ValT> || is_builtin_deserializable_v<T> || concepts::optional_type<T>;
+concept deserializable = custom_deserializable<T, ValT> || is_builtin_deserializable_v<T>;
 
 template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
 concept nothrow_custom_deserializable = nothrow_tag_invocable<deserialize_tag, ValT&, T&>;
@@ -97,35 +97,35 @@ inline constexpr struct deserialize_tag {
   // Customization Point for array
   template <typename T>
     requires custom_deserializable<T, value_type>
-  simdjson_warn_unused constexpr /* error_code */ auto operator()(array_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
+  [[nodiscard]] constexpr /* error_code */ auto operator()(array_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
     return tag_invoke(*this, object, output);
   }
 
   // Customization Point for object
   template <typename T>
     requires custom_deserializable<T, value_type>
-  simdjson_warn_unused constexpr /* error_code */ auto operator()(object_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
+  [[nodiscard]] constexpr /* error_code */ auto operator()(object_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
     return tag_invoke(*this, object, output);
   }
 
   // Customization Point for value
   template <typename T>
     requires custom_deserializable<T, value_type>
-  simdjson_warn_unused constexpr /* error_code */ auto operator()(value_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
+  [[nodiscard]] constexpr /* error_code */ auto operator()(value_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
     return tag_invoke(*this, object, output);
   }
 
   // Customization Point for document
   template <typename T>
     requires custom_deserializable<T, document_type>
-  simdjson_warn_unused constexpr /* error_code */ auto operator()(document_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, document_type>) {
+  [[nodiscard]] constexpr /* error_code */ auto operator()(document_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, document_type>) {
     return tag_invoke(*this, object, output);
   }
 
   // Customization Point for document reference
   template <typename T>
     requires custom_deserializable<T, document_reference_type>
-  simdjson_warn_unused constexpr /* error_code */ auto operator()(document_reference_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, document_reference_type>) {
+  [[nodiscard]] constexpr /* error_code */ auto operator()(document_reference_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, document_reference_type>) {
     return tag_invoke(*this, object, output);
   }
 
@@ -135,5 +135,5 @@ inline constexpr struct deserialize_tag {
 } // namespace simdjson
 
 #endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 

include/simdjson/generic/ondemand/document-inl.h

@@ -195,8 +195,8 @@ simdjson_inline document::operator object() & noexcept(false) { return get_objec
 simdjson_inline document::operator uint64_t() noexcept(false) { return get_uint64(); }
 simdjson_inline document::operator int64_t() noexcept(false) { return get_int64(); }
 simdjson_inline document::operator double() noexcept(false) { return get_double(); }
-simdjson_inline document::operator std::string_view() noexcept(false) simdjson_lifetime_bound { return get_string(false); }
+simdjson_inline document::operator std::string_view() noexcept(false) { return get_string(false); }
-simdjson_inline document::operator raw_json_string() noexcept(false) simdjson_lifetime_bound { return get_raw_json_string(); }
+simdjson_inline document::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }
 simdjson_inline document::operator bool() noexcept(false) { return get_bool(); }
 simdjson_inline document::operator value() noexcept(false) { return get_value(); }
 

include/simdjson/generic/ondemand/document.h

@@ -183,7 +183,7 @@ public:
    */
   template <typename T>
   simdjson_inline simdjson_result<T> get() &
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
     noexcept
@@ -206,7 +206,7 @@ public:
    */
   template<typename T>
   simdjson_inline simdjson_result<T> get() &&
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
     noexcept
@@ -229,13 +229,13 @@ public:
    */
   template<typename T>
   simdjson_inline error_code get(T &out) &
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
     noexcept
 #endif
   {
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     if constexpr (custom_deserializable<T, document>) {
         return deserialize(*this, out);
     } else {
@@ -247,7 +247,7 @@ public:
       static_cast<void>(out); // to get rid of unused errors
       return UNINITIALIZED;
     }
-#else // SIMDJSON_SUPPORTS_CONCEPTS
+#else // SIMDJSON_SUPPORTS_DESERIALIZATION
     // Unless the simdjson library or the user provides an inline implementation, calling this method should
     // immediately fail.
     static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
@@ -257,7 +257,7 @@ public:
       " You may also add support for custom types, see our documentation.");
     static_cast<void>(out); // to get rid of unused errors
     return UNINITIALIZED;
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
   }
 
   /** @overload template<typename T> error_code get(T &out) & noexcept */
@@ -322,7 +322,7 @@ public:
    *          time it parses a document or when it is destroyed.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator std::string_view() noexcept(false);
   /**
    * Cast this JSON value to a raw_json_string.
    *
@@ -331,7 +331,7 @@ public:
    * @returns A pointer to the raw JSON for the given string.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator raw_json_string() noexcept(false);
   /**
    * Cast this JSON value to a bool.
    *
@@ -481,27 +481,11 @@ public:
    * E.g., you must still call "is_null()" to check that a value is null even if
    * "type()" returns json_type::null.
    *
-   * The answer can be one of
-   * simdjson::ondemand::json_type::object,
-   * simdjson::ondemand::json_type::array,
-   * simdjson::ondemand::json_type::string,
-   * simdjson::ondemand::json_type::number,
-   * simdjson::ondemand::json_type::boolean,
-   * simdjson::ondemand::json_type::null.
-   *
-   * Starting with simdjson 4.0, this function will return simdjson::ondemand::json_type::unknown
-   * given a bad token.
-   * This allows you to identify a case such as {"key": NaN} and identify the NaN value.
-   * The simdjson::ondemand::json_type::unknown value should only happen with non-valid JSON.
-   *
    * NOTE: If you're only expecting a value to be one type (a typical case), it's generally
    * better to just call .get_double, .get_string, etc. and check for INCORRECT_TYPE (or just
    * let it throw an exception).
    *
-   * Prior to simdjson 4.0, this function would return an error given a bad token.
+   * @error TAPE_ERROR when the JSON value is a bad token like "}" "," or "alse".
-   * Starting with simdjson 4.0, it will return simdjson::ondemand::json_type::unknown.
-   * This allows you to identify a case such as {"key": NaN} and identify the NaN value.
-   * The simdjson::ondemand::json_type::unknown value should only happen with non-valid JSON.
    */
   simdjson_inline simdjson_result<json_type> type() noexcept;
 
@@ -791,7 +775,7 @@ public:
   simdjson_inline simdjson_result<bool> is_null() noexcept;
   template <typename T>
   simdjson_inline simdjson_result<T> get() &
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
     noexcept
@@ -804,7 +788,7 @@ public:
   }
   template<typename T>
   simdjson_inline simdjson_result<T> get() &&
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
     noexcept
@@ -827,13 +811,13 @@ public:
    */
   template<typename T>
   simdjson_inline error_code get(T &out) &
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document_reference> : true)
 #else
     noexcept
 #endif
   {
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     if constexpr (custom_deserializable<T, document_reference>) {
         return deserialize(*this, out);
     } else {
@@ -845,7 +829,7 @@ public:
       static_cast<void>(out); // to get rid of unused errors
       return UNINITIALIZED;
     }
-#else // SIMDJSON_SUPPORTS_CONCEPTS
+#else // SIMDJSON_SUPPORTS_DESERIALIZATION
     // Unless the simdjson library or the user provides an inline implementation, calling this method should
     // immediately fail.
     static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
@@ -855,7 +839,7 @@ public:
       " You may also add support for custom types, see our documentation.");
     static_cast<void>(out); // to get rid of unused errors
     return UNINITIALIZED;
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
   }
 
   /** @overload template<typename T> error_code get(T &out) & noexcept */
@@ -942,9 +926,6 @@ public:
   template<typename T> simdjson_inline error_code get(T &out) & noexcept;
   template<typename T> simdjson_inline error_code get(T &out) && noexcept;
 #if SIMDJSON_EXCEPTIONS
-
-  using SIMDJSON_IMPLEMENTATION::implementation_simdjson_result_base<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator*;
-  using SIMDJSON_IMPLEMENTATION::implementation_simdjson_result_base<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator->;
   template <class T, typename std::enable_if<std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document>::value == false>::type>
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);

include/simdjson/generic/ondemand/document_stream-inl.h

@@ -182,19 +182,10 @@ simdjson_inline document_stream::iterator& document_stream::iterator::operator++
   return *this;
 }
 
-simdjson_inline bool document_stream::iterator::at_end() const noexcept {
-  return finished;
-}
-
-
 simdjson_inline bool document_stream::iterator::operator!=(const document_stream::iterator &other) const noexcept {
   return finished != other.finished;
 }
 
-simdjson_inline bool document_stream::iterator::operator==(const document_stream::iterator &other) const noexcept {
-  return finished == other.finished;
-}
-
 simdjson_inline document_stream::iterator document_stream::begin() noexcept {
   start();
   // If there are no documents, we're finished.

include/simdjson/generic/ondemand/document_stream.h

@@ -131,7 +131,6 @@ public:
      * Default constructor.
      */
     simdjson_inline iterator() noexcept;
-    simdjson_inline iterator(const iterator &other) noexcept = default;
     /**
      * Get the current document (or error).
      */
@@ -145,7 +144,6 @@ public:
      * @param other the end iterator to compare to.
      */
     simdjson_inline bool operator!=(const iterator &other) const noexcept;
-    simdjson_inline bool operator==(const iterator &other) const noexcept;
     /**
      * @private
      *
@@ -189,11 +187,6 @@ public:
      */
      inline error_code error() const noexcept;
 
-     /**
-      * Returns whether the iterator is at the end.
-      */
-     inline bool at_end() const noexcept;
-
   private:
     simdjson_inline iterator(document_stream *s, bool finished) noexcept;
     /** The document_stream we're iterating through. */
@@ -205,7 +198,6 @@ public:
     friend class document_stream;
     friend class json_iterator;
   };
-  using iterator = document_stream::iterator;
 
   /**
    * Start iterating the documents in the stream.

include/simdjson/generic/ondemand/json_builder.h

@@ -13,9 +13,8 @@
 
 #include <charconv>
 #include <cstring>
-#include <meta>
+#include <experimental/meta>
 #include <memory>
-#include <optional>
 #include <string_view>
 #include <type_traits>
 #include <utility>
@@ -89,6 +88,9 @@ template<typename number_type,
 constexpr void atom(string_builder &b, const number_type t) {
   b.append(t);
 }
+#if SIMDJSON_CONSTEVAL
+consteval std::string consteval_to_quoted_escaped(std::string_view input);
+#endif
 
 template <class T>
   requires(std::is_class_v<T> && !container_but_not_string<T> &&
@@ -103,10 +105,10 @@ template <class T>
 constexpr void atom(string_builder &b, const T &t) {
   int i = 0;
   b.append('{');
-  template for (constexpr auto dm : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+  [:expand(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked())):] >> [&]<auto dm>() {
     if (i != 0)
       b.append(',');
-    constexpr auto key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
+    constexpr auto key = std::define_static_string(consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
     b.append_raw(key);
     b.append(':');
     atom(b, t.[:dm:]);
@@ -140,16 +142,21 @@ template <typename T>
   requires(std::is_enum_v<T>)
 void atom(string_builder &b, const T &e) {
 #if SIMDJSON_STATIC_REFLECTION
-  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  std::string_view result = "<unnamed>";
-  template for (constexpr auto enum_val : enumerators) {
+  [:expand(std::meta::enumerators_of(^^T)):] >> [&]<auto enum_val>{
-    constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));
     if (e == [:enum_val:]) {
-      b.append_raw(enum_str);
+      result = std::meta::identifier_of(enum_val);
-      return;
     }
   };
+
+  if (result != "<unnamed>") {
+    b.append_raw("\"");
+    b.append_raw(result);
+    b.append_raw("\"");
+  } else {
     // Fallback to integer if enum value not found
     atom(b, static_cast<std::underlying_type_t<T>>(e));
+  }
 #else
   // Fallback: serialize as integer if reflection not available
   atom(b, static_cast<std::underlying_type_t<T>>(e));
@@ -233,10 +240,10 @@ template <class Z>
 void append(string_builder &b, const Z &z) {
   int i = 0;
   b.append('{');
-  template for (constexpr auto dm : std::define_static_array(std::meta::nonstatic_data_members_of(^^Z, std::meta::access_context::unchecked()))) {
+  [:expand(std::meta::nonstatic_data_members_of(^^Z, std::meta::access_context::unchecked())):] >> [&]<auto dm>() {
     if (i != 0)
       b.append(',');
-    constexpr auto key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
+    constexpr auto key = std::define_static_string(consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
     b.append_raw(key);
     b.append(':');
     atom(b, z.[:dm:]);
@@ -263,8 +270,8 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_result<std::string> to_json_string(const Z &z) {
-  string_builder b(initial_capacity);
+  string_builder b;
   append(b, z);
   std::string_view s;
   if(auto e = b.view().get(s); e) { return e; }
@@ -272,33 +279,17 @@ simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, siz
 }
 
 template <class Z>
-simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b(initial_capacity);
+  string_builder b;
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
   s.assign(view);
   return SUCCESS;
 }
-
+} // namespace json_builder
-template <class Z>
-string_builder& operator<<(string_builder& b, const Z& z) {
-  append(b, z);
-  return b;
-}
-} // namespace builder
 } // namespace SIMDJSON_IMPLEMENTATION
-// Alias the function template to 'to' in the global namespace
-template <class Z>
-simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
-  return SIMDJSON_IMPLEMENTATION::builder::to_json_string(z, initial_capacity);
-}
-template <class Z>
-simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
-  return SIMDJSON_IMPLEMENTATION::builder::to_json(z, s, initial_capacity);
-}
 } // namespace simdjson
-
 #endif // SIMDJSON_STATIC_REFLECTION
 
 #endif

include/simdjson/generic/ondemand/json_iterator-inl.h

@@ -218,8 +218,6 @@ simdjson_inline void json_iterator::assert_valid_position(token_position positio
 #ifndef SIMDJSON_CLANG_VISUAL_STUDIO
   SIMDJSON_ASSUME( position >= &parser->implementation->structural_indexes[0] );
   SIMDJSON_ASSUME( position < &parser->implementation->structural_indexes[parser->implementation->n_structural_indexes] );
-#else
-  (void)position; // Suppress unused parameter warning
 #endif
 }
 

include/simdjson/generic/ondemand/json_string_builder-inl.h

@@ -155,17 +155,12 @@ find_next_json_quotable_character(const std::string_view view,
 }
 
 SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
-    "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006",
+    "\\x0000", "\\x0001", "\\x0002", "\\x0003", "\\x0004", "\\x0005", "\\x0006",
-    "\\u0007", "\\b", "\\t",     "\\n",     "\\u000b", "\\f",     "\\r",
+    "\\x0007", "\\x0008", "\\t",     "\\n",     "\\x000b", "\\f",     "\\r",
-    "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013", "\\u0014",
+    "\\x000e", "\\x000f", "\\x0010", "\\x0011", "\\x0012", "\\x0013", "\\x0014",
-    "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b",
+    "\\x0015", "\\x0016", "\\x0017", "\\x0018", "\\x0019", "\\x001a", "\\x001b",
-    "\\u001c", "\\u001d", "\\u001e", "\\u001f"};
+    "\\x001c", "\\x001d", "\\x001e", "\\x001f"};
 
-// All Unicode characters may be placed within the quotation marks, except for the
-// characters that MUST be escaped: quotation mark, reverse solidus, and the control
-// characters (U+0000 through U+001F).
-// There are two-character sequence escape representations of some popular characters:
-// \", \\, \b, \f, \n, \r, \t.
 SIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {
   if (c == '"') {
     memcpy(out, "\\\"", 2);
@@ -206,6 +201,29 @@ inline size_t write_string_escaped(const std::string_view input, char *out) {
   return out - initout;
 }
 
+#if SIMDJSON_CONSTEVAL
+// unoptimized, meant for compile-time execution
+consteval std::string consteval_to_quoted_escaped(std::string_view input) {
+  std::string out = "\"";
+  for (char c : input) {
+    if (json_quotable_character[uint8_t(c)]) {
+      if (c == '"') {
+        out.append("\\\"");
+      } else if (c == '\\') {
+        out.append("\\\\");
+      } else {
+        std::string_view v = control_chars[uint8_t(c)];
+        out.append(v);
+      }
+    } else {
+      out.push_back(c);
+    }
+  }
+  out.push_back('"');
+  return out;
+}
+#endif // SIMDJSON_CONSTEVAL
+
 simdjson_inline string_builder::string_builder(size_t initial_capacity)
     : buffer(new(std::nothrow) char[initial_capacity]), position(0),
       capacity(buffer.get() != nullptr ? initial_capacity : 0),
@@ -284,12 +302,10 @@ simdjson_inline void string_builder::clear() noexcept {
 
 namespace internal {
 
+// We could specialize further for 32-bit integers.
+int int_log2(uint32_t x) { return (63 - leading_zeroes(x | 1)); }
 
-template <typename number_type, typename = typename std::enable_if<
+int fast_digit_count(uint32_t x) {
-                                    std::is_unsigned<number_type>::value>::type>
-simdjson_really_inline int int_log2(number_type x) { return 63 - leading_zeroes(uint64_t(x) | 1); }
-
-simdjson_really_inline int fast_digit_count_32(uint32_t x) {
   static uint64_t table[] = {
       4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
       12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
@@ -301,8 +317,9 @@ simdjson_really_inline int fast_digit_count_32(uint32_t x) {
   return uint32_t((x + table[int_log2(x)]) >> 32);
 }
 
+int int_log2(uint64_t x) { return 63 - leading_zeroes(x | 1); }
 
-simdjson_really_inline int fast_digit_count_64(uint64_t x) {
+int fast_digit_count(uint64_t x) {
   static uint64_t table[] = {9,
                              99,
                              999,
@@ -329,15 +346,11 @@ simdjson_really_inline int fast_digit_count_64(uint64_t x) {
 
 template <typename number_type, typename = typename std::enable_if<
                                     std::is_unsigned<number_type>::value>::type>
-simdjson_really_inline size_t digit_count(number_type v) noexcept {
+simdjson_inline size_t digit_count(number_type v) noexcept {
   static_assert(sizeof(number_type) == 8 || sizeof(number_type) == 4 ||
                     sizeof(number_type) == 2 || sizeof(number_type) == 1,
                 "We only support 8-bit, 16-bit, 32-bit and 64-bit numbers");
-  SIMDJSON_IF_CONSTEXPR(sizeof(number_type) <= 4) {
+  return fast_digit_count(v);
-    return fast_digit_count_32(static_cast<uint32_t>(v));
-  } else {
-    return fast_digit_count_64(static_cast<uint64_t>(v));
-  }
 }
 static const char decimal_table[200] = {
   0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35,
@@ -475,12 +488,6 @@ simdjson_inline void string_builder::escape_and_append_with_quotes(const char* i
   std::string_view cinput(input);
   escape_and_append_with_quotes(cinput);
 }
-#if SIMDJSON_SUPPORTS_CONCEPTS
-template<internal::fixed_string key>
-simdjson_inline void string_builder::escape_and_append_with_quotes()  noexcept {
-  escape_and_append_with_quotes(internal::string_constant<key>::value);
-}
-#endif
 
 simdjson_inline void string_builder::append_raw(const char *c) noexcept {
   size_t len = std::strlen(c);
@@ -502,70 +509,6 @@ simdjson_inline void string_builder::append_raw(const char *str,
     position += len;
   }
 }
-#if SIMDJSON_SUPPORTS_CONCEPTS
-// Support for optional types (std::optional, etc.)
-template <concepts::optional_type T>
-simdjson_inline void string_builder::append(const T &opt) {
-  if (opt) {
-    append(*opt);
-  } else {
-    append_null();
-  }
-}
-template <typename T>
-requires(std::is_convertible<T, std::string_view>::value ||
-std::is_same<T, const char*>::value )
-simdjson_inline void string_builder::append(const T &value) {
-  escape_and_append_with_quotes(value);
-}
-#endif
-
-#if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
-  // Support for range-based appending (std::ranges::view, etc.)
-template <std::ranges::range R>
-requires (!std::is_convertible<R, std::string_view>::value)
-simdjson_inline void string_builder::append(const R &range) noexcept {
-  auto it = std::ranges::begin(range);
-  auto end = std::ranges::end(range);
-  if constexpr (concepts::is_pair<typename R::value_type>) {
-    start_object();
-
-    if (it == end) {
-      end_object();
-      return; // Handle empty range
-    }
-    // Append first item without leading comma
-    append_key_value(it->first, it->second);
-    ++it;
-
-    // Append remaining items with preceding commas
-    for (; it != end; ++it) {
-        append_comma();
-        append_key_value(it->first, it->second);
-    }
-    end_object();
-  } else {
-    start_array();
-    if (it == end) {
-      end_array();
-      return; // Handle empty range
-    }
-
-    // Append first item without leading comma
-    append(*it);
-    ++it;
-
-    // Append remaining items with preceding commas
-    for (; it != end; ++it) {
-        append_comma();
-        append(*it);
-    }
-    end_array();
-
-  }
-}
-
-#endif
 
 #if SIMDJSON_EXCEPTIONS
 simdjson_inline string_builder::operator std::string() const noexcept(false) {
@@ -573,7 +516,7 @@ simdjson_inline string_builder::operator std::string() const noexcept(false) {
 }
 
 simdjson_inline string_builder::operator std::string_view() const
-    noexcept(false) simdjson_lifetime_bound {
+    noexcept(false) {
   return view();
 }
 #endif
@@ -641,6 +584,13 @@ simdjson_inline void string_builder::append_colon()  noexcept {
 
 template<typename key_type, typename value_type>
 simdjson_inline void string_builder::append_key_value(key_type key, value_type value) noexcept {
+  static_assert(
+    std::is_arithmetic<value_type>::value ||
+    std::is_same<value_type, char>::value ||
+    std::is_same<value_type, const char*>::value ||
+    std::is_convertible<value_type, std::string_view>::value ||
+    std::is_same<value_type, std::nullptr_t>::value,
+    "Unsupported value type");
   static_assert(
     std::is_same<key_type, const char*>::value ||
     std::is_convertible<key_type, std::string_view>::value,
@@ -660,25 +610,6 @@ simdjson_inline void string_builder::append_key_value(key_type key, value_type v
   }
 }
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
-template<internal::fixed_string key, typename value_type>
-simdjson_inline void string_builder::append_key_value(value_type value) noexcept {
-  escape_and_append_with_quotes<key>();
-  append_colon();
-  SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, std::nullptr_t>::value) {
-    append_null();
-  } else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, char>::value) {
-    escape_and_append_with_quotes(value);
-  } else SIMDJSON_IF_CONSTEXPR(std::is_convertible<value_type, std::string_view>::value) {
-    escape_and_append_with_quotes(value);
-  } else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, const char*>::value) {
-    escape_and_append_with_quotes(value);
-  } else {
-    append(value);
-  }
-}
-#endif
-
 } // namespace builder
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

include/simdjson/generic/ondemand/json_string_builder.h

@@ -12,40 +12,19 @@
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
-#if SIMDJSON_SUPPORTS_CONCEPTS
-// Helper to create string constants
-namespace internal {
-template <std::size_t N>
-struct fixed_string {
-    constexpr fixed_string(const char (&str)[N]) {
-        for (std::size_t i = 0; i < N; ++i) {
-            data[i] = str[i];
-        }
-    }
-    char data[N];
-    constexpr std::string_view view() const { return {data, N - 1}; }
-};
 
-template <fixed_string str>
-struct string_constant {
-    static constexpr std::string_view value = str.view();
-};
-} // namespace internal
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
 /**
  * A builder for JSON strings representing documents. This is a low-level
  * builder that is not meant to be used directly by end-users. Though it
  * supports atomic types (Booleans, strings), it does not support composed
  * types (arrays and objects).
  *
- * Ultimately, this class can support kernel-specific optimizations. E.g.,
+ * Ultimately, this class should support kernel-specific optimizations. E.g.,
  * it may make use of SIMD instructions to escape strings faster.
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+  simdjson_inline string_builder(size_t initial_capacity = 1024);
-
-  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -83,10 +62,7 @@ public:
    * There is no UTF-8 validation.
    */
   simdjson_inline void escape_and_append_with_quotes(std::string_view input)  noexcept;
-#if SIMDJSON_SUPPORTS_CONCEPTS
+
-  template<internal::fixed_string key>
-  simdjson_inline void escape_and_append_with_quotes()  noexcept;
-#endif
   /**
    * Append the character surrounded by double quotes, after escaping it.
    * There is no UTF-8 validation.
@@ -142,26 +118,6 @@ public:
    */
    template<typename key_type, typename value_type>
   simdjson_inline void append_key_value(key_type key, value_type value) noexcept;
-#if SIMDJSON_SUPPORTS_CONCEPTS
-  template<internal::fixed_string key, typename value_type>
-  simdjson_inline void append_key_value(value_type value) noexcept;
-
-  // Support for optional types (std::optional, etc.)
-  template <concepts::optional_type T>
-  simdjson_inline void append(const T &opt);
-
-  // Support for string-like types
-  template <typename T>
-  requires(std::is_convertible<T, std::string_view>::value ||
-  std::is_same<T, const char*>::value )
-  simdjson_inline void append(const T &value);
-#endif
-#if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
-  // Support for range-based appending (std::ranges::view, etc.)
-  template <std::ranges::range R>
-requires (!std::is_convertible<R, std::string_view>::value)
-  simdjson_inline void append(const R &range) noexcept;
-#endif
   /**
    * Append the std::string_view directly, without escaping.
    * There is no UTF-8 validation.
@@ -190,7 +146,7 @@ requires (!std::is_convertible<R, std::string_view>::value)
    * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
    * Use validate_unicode() to check the content if needed.
    */
-  simdjson_inline operator std::string_view() const noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator std::string_view() const noexcept(false);
 #endif
 
   /**
@@ -254,32 +210,6 @@ private:
 
 }
 }
-
-
-#if !SIMDJSON_STATIC_REFLECTION
-// fallback implementation until we have static reflection
-template <class Z>
-simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
-  simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
-  b.append(z);
-  std::string_view s;
-  auto e = b.view().get(s);
-  if(e) { return e; }
-  return std::string(s);
-}
-template <class Z>
-simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
-  simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
-  b.append(z);
-  std::string_view sv;
-  auto e = b.view().get(sv);
-  if(e) { return e; }
-  s.assign(sv.data(), sv.size());
-  return simdjson::SUCCESS;
-}
-#endif
-
-
 } // namespace simdjson
 
 #endif // SIMDJSON_GENERIC_STRING_BUILDER_H

include/simdjson/generic/ondemand/json_type.h

@@ -15,7 +15,6 @@ namespace ondemand {
  * The type of a JSON value.
  */
 enum class json_type {
-    unknown=0,
     // Start at 1 to catch uninitialized / default values more easily
     array=1, ///< A JSON array   ( [ 1, 2, 3 ... ] )
     object,  ///< A JSON object  ( { "a": 1, "b" 2, ... } )

include/simdjson/generic/ondemand/object.h

@@ -202,7 +202,7 @@ public:
    */
   simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
   /**
    * Get this object as the given type.
    *
@@ -231,7 +231,7 @@ public:
     SIMDJSON_TRY(get<T>(out));
     return out;
   }
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 protected:
   /**
    * Go to the end of the object, no matter where you are right now.
@@ -279,7 +279,7 @@ public:
   inline simdjson_result<bool> is_empty() noexcept;
   inline simdjson_result<size_t> count_fields() & noexcept;
   inline simdjson_result<std::string_view> raw_json() noexcept;
-  #if SIMDJSON_SUPPORTS_CONCEPTS
+  #if SIMDJSON_SUPPORTS_DESERIALIZATION
   // TODO: move this code into object-inl.h
 
   template<typename T>
@@ -300,7 +300,7 @@ public:
     }
     return SUCCESS;
   }
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 };
 
 } // namespace simdjson

include/simdjson/generic/ondemand/parser-inl.h

@@ -49,7 +49,7 @@ simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const u
 #endif
 
 simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
-  if (!json.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
   json.remove_utf8_bom();
 
@@ -65,7 +65,7 @@ simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(p
 
 #ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
-  if (!json.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
   json.remove_utf8_bom();
 
@@ -97,7 +97,10 @@ simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(s
 }
 
 simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
-  return iterate(pad_with_reserve(json));
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
+  }
+  return iterate(padded_string_view(json));
 }
 
 simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
@@ -119,7 +122,7 @@ simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(c
 }
 
 simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
-  if (!json.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
   json.remove_utf8_bom();
 
@@ -134,7 +137,6 @@ simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iter
 }
 
 inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
-  // Warning: no check is done on the buffer padding. We trust the user.
   if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
   if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
     buf += 3;
@@ -143,24 +145,16 @@ inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf,
   if(allow_comma_separated && batch_size < len) { batch_size = len; }
   return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
 inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
-  // Warning: no check is done on the buffer padding. We trust the user.
   return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-inline simdjson_result<document_stream> parser::iterate_many(padded_string_view s, size_t batch_size, bool allow_comma_separated) noexcept {
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
-  if (!s.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
   return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
-  return iterate_many(padded_string_view(s), batch_size, allow_comma_separated);
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
-  return iterate_many(padded_string_view(s), batch_size, allow_comma_separated);
-}
-inline simdjson_result<document_stream> parser::iterate_many(std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
-  return iterate_many(pad(s), batch_size, allow_comma_separated);
 }
+
 simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
   return _capacity;
 }
@@ -195,34 +189,6 @@ simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::u
   return result;
 }
 
-simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() {
-  return *parser::get_parser_instance();
-}
-
-simdjson_inline bool release_parser() {
-  auto &parser_instance = parser::get_threadlocal_parser_if_exists();
-  if (parser_instance) {
-    parser_instance.reset();
-    return true;
-  }
-  return false;
-}
-
-simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& parser::get_parser_instance() {
-  std::unique_ptr<ondemand::parser>& parser_instance = get_threadlocal_parser_if_exists();
-  if (!parser_instance) {
-    parser_instance.reset(new ondemand::parser());
-  }
-  return parser_instance;
-}
-
-simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& parser::get_threadlocal_parser_if_exists() {
-  // @the-moisrex points out that this could be implemented with std::optional (C++17).
-  thread_local std::unique_ptr<ondemand::parser> parser_instance = nullptr;
-  return parser_instance;
-}
-
-
 } // namespace ondemand
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

include/simdjson/generic/ondemand/parser.h

@@ -7,7 +7,6 @@
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
 #include <memory>
-#include <thread>
 
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
@@ -126,9 +125,7 @@ public:
   simdjson_warn_unused simdjson_result<document> iterate(std::string_view json, size_t capacity) & noexcept;
   /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */
   simdjson_warn_unused simdjson_result<document> iterate(const std::string &json) & noexcept;
-  /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept
+  /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */
-      The string instance might be have its capacity extended. Note that this can still
-      result in AddressSanitizer: container-overflow in some cases. */
   simdjson_warn_unused simdjson_result<document> iterate(std::string &json) & noexcept;
   /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */
   simdjson_warn_unused simdjson_result<document> iterate(const simdjson_result<padded_string> &json) & noexcept;
@@ -216,11 +213,6 @@ public:
    * Setting batch_size to excessively large or excessively small values may impact negatively the
    * performance.
    *
-   * ### Threads
-   *
-   * When compiled with SIMDJSON_THREADS_ENABLED, this method will use a single thread under the
-   * hood to do some lookahead.
-   *
    * ### REQUIRED: Buffer Padding
    *
    * The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what
@@ -228,11 +220,11 @@ public:
    * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the
    * SIMDJSON_PADDING bytes to avoid runtime warnings.
    *
-   * This is checked automatically with all iterate_many function calls, except for the two
-   * that take pointers (const char* or const uint8_t*).
-   *
    * ### Threads
    *
+   * When compiled with SIMDJSON_THREADS_ENABLED, this method will use a single thread under the
+   * hood to do some lookahead.
+   *
    * ### Parser Capacity
    *
    * If the parser's current capacity is less than batch_size, it will allocate enough capacity
@@ -257,16 +249,14 @@ public:
    */
   inline simdjson_result<document_stream> iterate_many(const uint8_t *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
   /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
-  inline simdjson_result<document_stream> iterate_many(padded_string_view json, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
-  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
   inline simdjson_result<document_stream> iterate_many(const char *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
   /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
   inline simdjson_result<document_stream> iterate_many(const std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
-  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size)
+  inline simdjson_result<document_stream> iterate_many(const std::string &&s, size_t batch_size, bool allow_comma_separated = false) = delete;// unsafe
-    the string might be automatically padded with up to SIMDJSON_PADDING whitespace characters */
-  inline simdjson_result<document_stream> iterate_many(std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
   /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
   inline simdjson_result<document_stream> iterate_many(const padded_string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
+  inline simdjson_result<document_stream> iterate_many(const padded_string &&s, size_t batch_size, bool allow_comma_separated = false) = delete;// unsafe
+
   /** @private We do not want to allow implicit conversion from C string to std::string. */
   simdjson_result<document_stream> iterate_many(const char *buf, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept = delete;
 
@@ -368,39 +358,13 @@ public:
   bool string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept;
 #endif
 
-  /**
-   * Get a unique parser instance corresponding to the current thread.
-   * This instance can be safely used within the current thread, but it should
-   * not be passed to other threads.
-   *
-   * A parser should only be used for one document at a time.
-   *
-   * Our simdjson::from functions use this parser instance.
-   *
-   * You can free the related parser by calling release_parser().
-   */
-  static simdjson_inline simdjson_warn_unused ondemand::parser& get_parser();
-  /**
-   * Release the parser instance initialized by get_parser() and all the
-   * associated resources (memory). Returns true if a parser instance
-   * was released.
-   */
-  static simdjson_inline bool release_parser();
-
 private:
-  friend bool release_parser();
-  friend ondemand::parser& get_parser();
-  /** Get the thread-local parser instance, allocates it if needed */
-  static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_parser_instance();
-  /** Get the thread-local parser instance, it might be null */
-  static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_threadlocal_parser_if_exists();
   /** @private [for benchmarking access] The implementation to use */
   std::unique_ptr<simdjson::internal::dom_parser_implementation> implementation{};
   size_t _capacity{0};
   size_t _max_capacity;
   size_t _max_depth{DEFAULT_MAX_DEPTH};
   std::unique_ptr<uint8_t[]> string_buf{};
-
 #if SIMDJSON_DEVELOPMENT_CHECKS
   std::unique_ptr<token_position[]> start_positions{};
 #endif

include/simdjson/generic/ondemand/raw_json_string-inl.h

@@ -15,13 +15,8 @@ namespace ondemand {
 
 simdjson_inline raw_json_string::raw_json_string(const uint8_t * _buf) noexcept : buf{_buf} {}
 
-simdjson_inline const char * raw_json_string::raw() const noexcept {
+simdjson_inline const char * raw_json_string::raw() const noexcept { return reinterpret_cast<const char *>(buf); }
-  return reinterpret_cast<const char *>(buf);
-}
 
-simdjson_inline char raw_json_string::operator[](size_t i) const noexcept {
-  return reinterpret_cast<const char *>(buf)[i];
-}
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
@@ -198,10 +193,6 @@ simdjson_inline simdjson_result<const char *> simdjson_result<SIMDJSON_IMPLEMENT
   if (error()) { return error(); }
   return first.raw();
 }
-simdjson_inline char simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string>::operator[](size_t i) const noexcept {
-  if (error()) { return error(); }
-  return first[i];
-}
 simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string>::unescape(SIMDJSON_IMPLEMENTATION::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
   if (error()) { return error(); }
   return first.unescape(iter, allow_replacement);

include/simdjson/generic/ondemand/raw_json_string.h

@@ -58,12 +58,6 @@ public:
    */
   simdjson_inline const char * raw() const noexcept;
 
-  /**
-   * Get the character at index i. This is unchecked.
-   * [0] when the string is of length 0 returns the final quote (").
-   */
-  simdjson_inline char operator[](size_t i) const noexcept;
-
   /**
    * This compares the current instance to the std::string_view target: returns true if
    * they are byte-by-byte equal (no escaping is done) on target.size() characters,
@@ -203,10 +197,10 @@ public:
   simdjson_inline ~simdjson_result() noexcept = default; ///< @private
 
   simdjson_inline simdjson_result<const char *> raw() const noexcept;
-  simdjson_inline char operator[](size_t) const noexcept;
   simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescape(SIMDJSON_IMPLEMENTATION::ondemand::json_iterator &iter, bool allow_replacement) const noexcept;
   simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescape_wobbly(SIMDJSON_IMPLEMENTATION::ondemand::json_iterator &iter) const noexcept;
 };
+
 } // namespace simdjson
 
 #endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_H

include/simdjson/generic/ondemand/std_deserialize.h

@@ -1,4 +1,4 @@
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
 
 #ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
@@ -11,7 +11,7 @@
 #include <concepts>
 #include <limits>
 #if SIMDJSON_STATIC_REFLECTION
-#include <meta>
+#include <experimental/meta>
 // #include <static_reflection> // for std::define_static_string - header not available yet
 #endif
 
@@ -97,12 +97,13 @@ template <concepts::appendable_containers T, typename ValT>
   requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
   using value_type = typename std::remove_cvref_t<T>::value_type;
-  static_assert(
+  /*static_assert(
       deserializable<value_type, ValT>,
-      "The specified type inside the container must itself be deserializable");
+      "The specified type inside the container must itself be deserializable");*/
   static_assert(
       std::is_default_constructible_v<value_type>,
       "The specified type inside the container must default constructible.");
+
   SIMDJSON_IMPLEMENTATION::ondemand::array arr;
   if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
     arr = val;
@@ -247,15 +248,20 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deser
 /**
  * This CPO (Customization Point Object) will help deserialize into optional types.
  */
-template <concepts::optional_type T>
+template <concepts::optional_type T, typename ValT>
   requires(!require_custom_serialization<T>)
-error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::value_type, decltype(val)>) {
+error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::value_type, ValT>) {
   using value_type = typename std::remove_cvref_t<T>::value_type;
 
+  static_assert(
+      deserializable<value_type, ValT>,
+      "The specified type inside the optional must itself be deserializable");
+  static_assert(
+      std::is_default_constructible_v<value_type>,
+      "The specified type inside the optional must default constructible.");
+
   // Check if the value is null
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset(); // Set to nullopt
     return SUCCESS;
   }
@@ -277,6 +283,32 @@ constexpr bool user_defined_type = (std::is_class_v<T>
 !concepts::appendable_containers<T> && !require_custom_serialization<T>);
 
 
+// workaround from
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2996r10.html#back-and-forth
+// for missing expansion statements
+namespace __impl {
+  template<auto... vals>
+  struct replicator_type {
+    template<typename F>
+      constexpr void operator>>(F body) const {
+        (body.template operator()<vals>(), ...);
+      }
+  };
+
+  template<auto... vals>
+  replicator_type<vals...> replicator = {};
+}
+
+template<typename R>
+consteval auto expand(R range) {
+  std::vector<std::meta::info> args;
+  for (auto r : range) {
+    args.push_back(reflect_constant(r));
+  }
+  return substitute(^^__impl::replicator, args);
+}
+// end of workaround
+
 template <typename T, typename ValT>
   requires(user_defined_type<T> && std::is_class_v<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
@@ -287,13 +319,16 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
     SIMDJSON_TRY(val.get_object().get(obj));
   }
   error_code e = simdjson::SUCCESS;
-  template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+
+  [:expand(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked())):] >> [&]<auto mem>() {
     if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
       constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
-      // Note: removed static assert as optional types are now handled generically
+      static_assert(
-      // as long we are successful or the field is not found, we continue
+        deserializable<decltype(out.[:mem:]), SIMDJSON_IMPLEMENTATION::ondemand::object>,
+        "The specified type inside the class must itself be deserializable");
+      // as long we are succesful or the field is not found, we continue
       if(e == simdjson::SUCCESS || e == simdjson::NO_SUCH_FIELD) {
-        e = obj[key].get(out.[:mem:]);
+        obj[key].get(out.[:mem:]);
       }
     }
   };
@@ -307,15 +342,16 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
 #if SIMDJSON_STATIC_REFLECTION
   std::string_view str;
   SIMDJSON_TRY(val.get_string().get(str));
-  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+
-  template for (constexpr auto enum_val : enumerators) {
+  bool found = false;
-    if (str == std::meta::identifier_of(enum_val)) {
+  [:expand(std::meta::enumerators_of(^^T)):] >> [&]<auto enum_val>{
+    if (!found && str == std::meta::identifier_of(enum_val)) {
       out = [:enum_val:];
-      return SUCCESS;
+      found = true;
     }
   };
 
-  return INCORRECT_TYPE;
+  return found ? SUCCESS : INCORRECT_TYPE;
 #else
   // Fallback: deserialize as integer if reflection not available
   std::underlying_type_t<T> int_val;
@@ -363,9 +399,7 @@ error_code tag_invoke(deserialize_tag, simdjson_value &val, std::shared_ptr<T> &
 // Unique pointers
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<bool> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -378,9 +412,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<bool> &out) no
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int64_t> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -393,9 +425,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int64_t> &out)
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<uint64_t> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -408,9 +438,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<uint64_t> &out
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<double> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -423,9 +451,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<double> &out)
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string_view> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -442,9 +468,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string_vi
 // Shared pointers
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<bool> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -457,9 +481,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<bool> &out) no
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<int64_t> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -472,9 +494,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<int64_t> &out)
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<uint64_t> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -487,9 +507,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<uint64_t> &out
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<double> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -502,9 +520,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<double> &out)
 }
 
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string_view> &out) noexcept {
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset();
     return SUCCESS;
   }
@@ -520,15 +536,44 @@ error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string_vi
 ////////////////////////////////////////
 // Explicit optional specializations
 ////////////////////////////////////////
+error_code tag_invoke(deserialize_tag, auto &val, concepts::optional_type auto&out) noexcept {
+  // Check if the value is null
+  if (val.is_null()) {
+    out.reset(); // Set to nullopt
+    return SUCCESS;
+  }
+
+  if (!out) {
+    out.emplace();
+  }
+  std::string_view str;
+  SIMDJSON_TRY(val.get_string().get(str));
+  out.value() = std::string{str};
+  return SUCCESS;
+}
+
+error_code tag_invoke(deserialize_tag, auto &val, concepts::optional_type auto&out) noexcept {
+  // Check if the value is null
+  if (val.is_null()) {
+    out.reset(); // Set to nullopt
+    return SUCCESS;
+  }
+
+  if (!out) {
+    out.emplace();
+  }
+  int64_t temp;
+  SIMDJSON_TRY(val.get_int64().get(temp));
+  out.value() = static_cast<int>(temp);
+  return SUCCESS;
+}
 
 ////////////////////////////////////////
 // Explicit smart pointer specializations for string and int types
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string> &out) noexcept {
   // Check if the value is null
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset(); // Set to nullptr
     return SUCCESS;
   }
@@ -544,9 +589,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string> &
 
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string> &out) noexcept {
   // Check if the value is null
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset(); // Set to nullptr
     return SUCCESS;
   }
@@ -562,9 +605,7 @@ error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string> &
 
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int> &out) noexcept {
   // Check if the value is null
-  bool is_null_value;
+  if (val.is_null()) {
-  SIMDJSON_TRY( val.is_null().get(is_null_value) );
-  if (is_null_value) {
     out.reset(); // Set to nullptr
     return SUCCESS;
   }
@@ -581,4 +622,4 @@ error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int> &out) noe
 } // namespace simdjson
 
 #endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION

include/simdjson/generic/ondemand/value.h

@@ -34,14 +34,14 @@ public:
    *
    * You may use get_double(), get_bool(), get_uint64(), get_int64(),
    * get_object(), get_array(), get_raw_json_string(), or get_string() instead.
-   * When SIMDJSON_SUPPORTS_CONCEPTS is set, custom types are also supported.
+   * When SIMDJSON_SUPPORTS_DESERIALIZATION is set, custom types are also supported.
    *
    * @returns A value of the given type, parsed from the JSON.
    * @returns INCORRECT_TYPE If the JSON value is not the given type.
    */
   template <typename T>
   simdjson_inline simdjson_result<T> get()
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
 #else
     noexcept
@@ -58,7 +58,7 @@ public:
    * Get this value as the given type.
    *
    * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool
-   * If the macro SIMDJSON_SUPPORTS_CONCEPTS is set, then custom types are also supported.
+   * If the macro SIMDJSON_SUPPORTS_DESERIALIZATION is set, then custom types are also supported.
    *
    * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
    * @returns INCORRECT_TYPE If the JSON value is not an object.
@@ -66,30 +66,15 @@ public:
    */
   template <typename T>
   simdjson_inline error_code get(T &out)
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
     noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
 #else
     noexcept
 #endif
  {
-  #if SIMDJSON_SUPPORTS_CONCEPTS
+  #if SIMDJSON_SUPPORTS_DESERIALIZATION
   if constexpr (custom_deserializable<T, value>) {
       return deserialize(*this, out);
-  } else if constexpr (concepts::optional_type<T>) {
-      using value_type = typename std::remove_cvref_t<T>::value_type;
-
-      // Check if the value is null
-      bool is_null_value;
-      SIMDJSON_TRY( is_null().get(is_null_value) );
-      if (is_null_value) {
-        out.reset(); // Set to nullopt
-        return SUCCESS;
-      }
-
-      if (!out) {
-        out.emplace();
-      }
-      return get<value_type>(out.value());
   } else {
     static_assert(!sizeof(T), "The get<T> method with type T is not implemented by the simdjson library. "
       "And you do not seem to have added support for it. Indeed, we have that "
@@ -99,7 +84,7 @@ public:
     static_cast<void>(out); // to get rid of unused errors
     return UNINITIALIZED;
   }
-#else // SIMDJSON_SUPPORTS_CONCEPTS
+#else // SIMDJSON_SUPPORTS_DESERIALIZATION
     // Unless the simdjson library or the user provides an inline implementation, calling this method should
     // immediately fail.
     static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
@@ -819,22 +804,7 @@ public:
   simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) noexcept = delete;
 
   /**
-   * Get the type of this JSON value. It does not validate or consume the value.
+   * Get the type of this JSON value.
-   * E.g., you must still call "is_null()" to check that a value is null even if
-   * "type()" returns json_type::null.
-   *
-   * Given a valid JSON document, the answer can be one of
-   * simdjson::ondemand::json_type::object,
-   * simdjson::ondemand::json_type::array,
-   * simdjson::ondemand::json_type::string,
-   * simdjson::ondemand::json_type::number,
-   * simdjson::ondemand::json_type::boolean,
-   * simdjson::ondemand::json_type::null.
-   *
-   * Starting with simdjson 4.0, this function will return simdjson::ondemand::json_type::unknown
-   * given a bad token.
-   * This allows you to identify a case such as {"key": NaN} and identify the NaN value.
-   * The simdjson::ondemand::json_type::unknown value should only happen with non-valid JSON.
    *
    * NOTE: If you're only expecting a value to be one type (a typical case), it's generally
    * better to just call .get_double, .get_string, etc. and check for INCORRECT_TYPE (or just

include/simdjson/generic/ondemand/value_iterator-inl.h

@@ -1057,7 +1057,7 @@ simdjson_inline simdjson_result<json_type> value_iterator::type() const noexcept
     case '5': case '6': case '7': case '8': case '9':
       return json_type::number;
     default:
-      return json_type::unknown;
+      return TAPE_ERROR;
   }
 }
 

include/simdjson/haswell/implementation.h

@@ -28,6 +28,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace haswell

include/simdjson/icelake/implementation.h

@@ -28,6 +28,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace icelake

include/simdjson/implementation.h

@@ -26,6 +26,15 @@ simdjson_inline simdjson_warn_unused bool validate_utf8(const std::string_view s
   return validate_utf8(sv.data(), sv.size());
 }
 
+/**
+ * Write the string to the output buffer while escaping double-quote, backlash and ascii control characters.
+ *
+ * @param input the string_view to escape
+ * @param out output buffer (for escaped string): to be safe, it should have 6 * input.size() allocated bytes.
+ * @return number of bytes written
+ */
+simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) noexcept;
+
 /**
  * Validate the UTF-8 string.
  *
@@ -127,6 +136,14 @@ public:
    */
   simdjson_warn_unused virtual bool validate_utf8(const char *buf, size_t len) const noexcept = 0;
 
+  /**
+   * Write the string to the output buffer while escaping double-quote, backlash and ascii control characters.
+   *
+   * @param input the string_view to escape
+   * @param out output buffer (for escaped string): to be safe, it should have 6 * input.size() allocated bytes.
+   * @return number of bytes written
+   */
+  simdjson_warn_unused virtual size_t write_string_escaped(const std::string_view input, char *out) const noexcept = 0;
 protected:
   /** @private Construct an implementation with the given name and description. For subclasses. */
   simdjson_inline implementation(

include/simdjson/jsonpathutil.h

@@ -4,8 +4,6 @@
 #include <string>
 #include "simdjson/common_defs.h"
 
-#include <utility>
-
 namespace simdjson {
 /**
  * Converts JSONPath to JSON Pointer.
@@ -14,12 +12,12 @@ namespace simdjson {
  */
 inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
   size_t i = 0;
+
   // if JSONPath starts with $, skip it
-   // json_path.starts_with('$') requires C++20.
   if (!json_path.empty() && json_path.front() == '$') {
     i = 1;
   }
-  if (i >= json_path.size() || (json_path[i] != '.' &&
+  if (json_path.empty() || (json_path[i] != '.' &&
       json_path[i] != '[')) {
     return "-1"; // This is just a sentinel value, the caller should check for this and return an error.
   }
@@ -62,48 +60,5 @@ inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
 
   return result;
 }
-
-inline std::pair<std::string_view, std::string_view> get_next_key_and_json_path(std::string_view& json_path) {
-  std::string_view key;
-
-  if (json_path.empty()) {
-    return {key, json_path};
-  }
-  size_t i = 0;
-
-  // if JSONPath starts with $, skip it
-  if (json_path.front() == '$') {
-    i = 1;
-  }
-
-
-  if (i < json_path.length() && json_path[i] == '.') {
-    i += 1;
-    size_t key_start = i;
-
-    while (i < json_path.length() && json_path[i] != '[' && json_path[i] != '.') {
-      ++i;
-    }
-
-    key = json_path.substr(key_start, i - key_start);
-  } else if ((i+1 < json_path.size()) && json_path[i] == '[' && (json_path[i+1] == '\'' || json_path[i+1] == '"')) {
-    i += 2;
-    size_t key_start = i;
-    while (i < json_path.length() && json_path[i] != '\'' && json_path[i] != '"') {
-      ++i;
-    }
-
-    key = json_path.substr(key_start, i - key_start);
-
-    i += 2;
-  } else if ((i+2 < json_path.size()) && json_path[i] == '[' && json_path[i+1] == '*' && json_path[i+2] == ']') { // i.e [*].additional_keys or [*]["additional_keys"]
-    key = "*";
-    i += 3;
-  }
-
-
-  return std::make_pair(key, json_path.substr(i));
-}
-
 } // namespace simdjson
 #endif // SIMDJSON_JSONPATHUTIL_H

include/simdjson/lasx/implementation.h

@@ -23,6 +23,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace lasx

include/simdjson/lsx/implementation.h

@@ -23,6 +23,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace lsx

include/simdjson/nonstd/string_view.hpp

@@ -409,9 +409,9 @@ using std::operator<<;
 #endif
 
 #if nssv_HAVE_NODISCARD
-# define nssv_nodiscard  simdjson_warn_unused
+# define nssv_nodiscard  [[nodiscard]]
 #else
-# define nssv_nodiscard  /*simdjson_warn_unused*/
+# define nssv_nodiscard  /*[[nodiscard]]*/
 #endif
 
 // Additional includes:

include/simdjson/padded_string-inl.h

@@ -125,9 +125,9 @@ inline const char *padded_string::data() const noexcept { return data_ptr; }
 
 inline char *padded_string::data() noexcept { return data_ptr; }
 
-inline padded_string::operator std::string_view() const simdjson_lifetime_bound { return std::string_view(data(), length()); }
+inline padded_string::operator std::string_view() const { return std::string_view(data(), length()); }
 
-inline padded_string::operator padded_string_view() const noexcept simdjson_lifetime_bound {
+inline padded_string::operator padded_string_view() const noexcept {
   return padded_string_view(data(), length(), length() + SIMDJSON_PADDING);
 }
 

include/simdjson/padded_string_view-inl.h

@@ -35,22 +35,6 @@ inline padded_string_view::padded_string_view(std::string_view s, size_t capacit
   if(_capacity < s.length()) { _capacity = s.length(); }
 }
 
-inline bool padded_string_view::has_sufficient_padding() const noexcept {
-  if (padding() >= SIMDJSON_PADDING) {
-    return true;
-  }
-  size_t missing_padding = SIMDJSON_PADDING - padding();
-  if(length() < missing_padding) { return false; }
-
-  for (size_t i = length() - missing_padding; i < length(); i++) {
-    char c = data()[i];
-    if (c != ' ' && c != '\t' && c != '\n' && c != '\r') {
-      return false;
-    }
-  }
-  return true;
-}
-
 inline size_t padded_string_view::capacity() const noexcept { return _capacity; }
 
 inline size_t padded_string_view::padding() const noexcept { return capacity() - length(); }
@@ -70,33 +54,10 @@ inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string
 #endif
 
 inline padded_string_view pad(std::string& s) noexcept {
-  size_t existing_padding = 0;
+  const auto len = s.size();
-  for (size_t i = s.size(); i > 0; i--) {
+  s.append(SIMDJSON_PADDING, ' ');
-    char c = s[i - 1];
+  return padded_string_view(s.data(), len, s.size());
-    if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
-      existing_padding++;
-    } else {
-      break;
-    }
-  }
-  size_t needed_padding = 0;
-  if (existing_padding < SIMDJSON_PADDING) {
-    needed_padding = SIMDJSON_PADDING - existing_padding;
-    s.append(needed_padding, ' ');
-  }
-
-  return padded_string_view(s.data(), s.size() - needed_padding, s.size());
 }
-
-inline padded_string_view pad_with_reserve(std::string& s) noexcept {
-  if (s.capacity() - s.size() < SIMDJSON_PADDING) {
-    s.reserve(s.size() + SIMDJSON_PADDING );
-  }
-  return padded_string_view(s.data(), s.size(), s.capacity());
-}
-
-
-
 } // namespace simdjson
 
 

include/simdjson/padded_string_view.h

@@ -58,9 +58,6 @@ public:
   /** The number of allocated bytes. */
   inline size_t capacity() const noexcept;
 
-  /** check that the view has sufficient padding */
-  inline bool has_sufficient_padding() const noexcept;
-
   /**
    * Remove the UTF-8 Byte Order Mark (BOM) if it exists.
    *
@@ -87,24 +84,14 @@ inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string
 #endif
 
 /**
- * Create a padded_string_view from a string. The string will be padded with up to SIMDJSON_PADDING
+ * Create a padded_string_view from a string. The string will be padded with SIMDJSON_PADDING
  * space characters. The resulting padded_string_view will have a length equal to the original
- * string, except maybe for trailing white space characters.
- *
- * @param s The string.
- * @return The padded string.
- */
-inline padded_string_view pad(std::string& s) noexcept;
-
-/**
- * Create a padded_string_view from a string. The capacity of the string will be padded with SIMDJSON_PADDING
- * characters. The resulting padded_string_view will have a length equal to the original
  * string.
  *
  * @param s The string.
  * @return The padded string.
  */
-inline padded_string_view pad_with_reserve(std::string& s) noexcept;
+inline padded_string_view pad(std::string& s) noexcept;
 } // namespace simdjson
 
 #endif // SIMDJSON_PADDED_STRING_VIEW_H

include/simdjson/portability.h

@@ -45,22 +45,6 @@ using std::size_t;
 #define SIMDJSON_IS_ARM64 1
 #elif defined(__riscv) && __riscv_xlen == 64
 #define SIMDJSON_IS_RISCV64 1
-  #if __riscv_v_intrinsic >= 11000
-    #define SIMDJSON_HAS_RVV_INTRINSICS 1
-  #endif
-
-  #define SIMDJSON_HAS_ZVBB_INTRINSICS                                          \
-    0 // there is currently no way to detect this
-
-  #if SIMDJSON_HAS_RVV_INTRINSICS && __riscv_vector &&                          \
-      __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64
-    // RISC-V V extension
-    #define SIMDJSON_IS_RVV 1
-    #if SIMDJSON_HAS_ZVBB_INTRINSICS && __riscv_zvbb >= 1000000
-      // RISC-V Vector Basic Bit-manipulation
-      #define SIMDJSON_IS_ZVBB 1
-    #endif
-  #endif
 #elif defined(__loongarch_lp64)
 #define SIMDJSON_IS_LOONGARCH64 1
 #elif defined(__PPC64__) || defined(_M_PPC64)

include/simdjson/ppc64/implementation.h

@@ -32,6 +32,7 @@ public:
                                          size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf,
                                           size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace ppc64

include/simdjson/simdjson_version.h

@@ -4,22 +4,22 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.0.5"
+#define SIMDJSON_VERSION "3.13.0"
 
 namespace simdjson {
 enum {
   /**
    * The major version (MAJOR.minor.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MAJOR = 4,
+  SIMDJSON_VERSION_MAJOR = 3,
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 0,
+  SIMDJSON_VERSION_MINOR = 13,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 5
+  SIMDJSON_VERSION_REVISION = 0
 };
 } // namespace simdjson
 

include/simdjson/westmere/implementation.h

@@ -24,6 +24,7 @@ public:
   ) const noexcept final;
   simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
   simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 
 } // namespace westmere

p2996/Dockerfile

@@ -8,11 +8,7 @@ RUN apt-get update && \
     apt-get install -y --no-install-recommends ca-certificates gnupg \
            build-essential cmake make python3 zlib1g wget subversion unzip ninja-build git linux-perf && \
     rm -rf /var/lib/apt/lists/*
-ARG CLANG_COMMIT=d77eff1cbd78fd065668acf93b1f5f400d39134d
+RUN git clone --depth=1 --branch p2996  https://github.com/bloomberg/clang-p2996.git /tmp/clang-source
-RUN git clone --depth=1 https://github.com/bloomberg/clang-p2996.git /tmp/clang-source && \
-    cd /tmp/clang-source && \
-    git fetch origin $CLANG_COMMIT --depth=1 && \
-    git checkout $CLANG_COMMIT
 RUN cmake -S /tmp/clang-source/llvm -B /tmp/clang-source/build-llvm -DCMAKE_BUILD_TYPE=Release \
     -DLLVM_ENABLE_ASSERTIONS=ON \
     -DLLVM_UNREACHABLE_OPTIMIZE=ON \

p2996/README.md

@@ -64,7 +64,6 @@ cmake --build buildreflect --target benchmark_serialization_citm_catalog benchma
 
 6. Run the tests...
 ```bash
-cmake --build buildreflect
 ctest --test-dir buildreflect --output-on-failure
 ```
 
@@ -78,36 +77,3 @@ You can modify the source code with your favorite editor and run again steps 5 (
 
 You can create a new docker shell at any time by running step 3 (bash script).
 
-## Using static reflection in your own projects
-
-You can import simdjson in your own CMake project. You can configure your project like so:
-
-```
-# Fetch simdjson from GitHub
-# Replace GIT_TAG by the commit you require.
-include(FetchContent)
-FetchContent_Declare(
-    simdjson
-    GIT_REPOSITORY https://github.com/simdjson/simdjson.git
-    GIT_TAG 015daad6a95a4f67c08ed5980d24b57be221c38f
-    CMAKE_ARGS -DSIMDJSON_STATIC_REFLECTION=ON
-)
-FetchContent_MakeAvailable(simdjson)
-
-##########
-# You may also use CPM.
-# https://github.com/cpm-cmake/CPM.cmake
-# CPMAddPackage(
-#    NAME simdjson
-#    GITHUB_REPOSITORY simdjson/simdjson
-#    GIT_TAG 015daad6a95a4f67c08ed5980d24b57be221c38f
-#    OPTIONS "SIMDJSON_STATIC_REFLECTION ON"
-# )
-target_link_libraries(webservice PRIVATE simdjson::simdjson)
-```
-
-Replace the `GIT_TAG` by the appropriate value.
-
-Once C++26 support will be officially available in mainstream compilers,
-we will simplify these instructions and it will no longer be needed
-to specify `SIMDJSON_STATIC_REFLECTION`.

scripts/javascript/generatelargejson.js

@@ -1,5 +1,5 @@
 
-var fs = require('node:fs');
+var fs = require('fs');
 
 var faker = require('faker');
 

singleheader/amalgamate.py

@@ -22,9 +22,6 @@ rules = """
 
 We refer your to the HACKING.md file for more information on how the project is organized.
 
-If you are trying to add a new implementation, you need to edit the amalgamate.py script
-to add your implementation to the IMPLEMENTATIONS list.
-
 To help understand the error, here are the rules for including files in simdjson:
 
 All implementation-specific files, including arm64.h, arm64/implementation.h and
@@ -299,10 +296,10 @@ class SimdjsonRepository:
 
 class Amalgamator:
     @classmethod
-    def amalgamate(cls, output_path: str, filename: str, roots: List[RelativeRoot], timestamp: str, version: str):
+    def amalgamate(cls, output_path: str, filename: str, roots: List[RelativeRoot], timestamp: str):
         print(f"Creating {output_path}")
         fid = open(output_path, 'w')
-        print(f"/* auto-generated on {timestamp}. version {version} Do not edit! */", file=fid)
+        print(f"/* auto-generated on {timestamp}. Do not edit! */", file=fid)
         amalgamator = cls(fid, SimdjsonRepository(PROJECTPATH, roots))
         file = amalgamator.repository[filename]
         assert file, f"{filename} not found in {[os.path.join(PROJECTPATH, root) for root in roots]}!"
@@ -483,44 +480,8 @@ AMAL_C = os.path.join(AMALGAMATE_OUTPUT_PATH, "simdjson.cpp")
 DEMOCPP = os.path.join(AMALGAMATE_OUTPUT_PATH, "amalgamate_demo.cpp")
 README = os.path.join(AMALGAMATE_OUTPUT_PATH, "README.md")
 
-def validate_implementations():
+Amalgamator.amalgamate(AMAL_H, "simdjson.h", ['include'], timestamp).validate_all_files_used('include')
-    """Scan include/simdjson/*/implementation.h and compare with IMPLEMENTATIONS list."""
+Amalgamator.amalgamate(AMAL_C, "simdjson.cpp", ['src', 'include'], timestamp).validate_all_files_used('src')
-    include_simdjson_path = os.path.join(PROJECTPATH, 'include', 'simdjson')
-    found_implementations = set()
-
-    if os.path.exists(include_simdjson_path):
-        for item in os.listdir(include_simdjson_path):
-            item_path = os.path.join(include_simdjson_path, item)
-            if os.path.isdir(item_path):
-                impl_h_path = os.path.join(item_path, 'implementation.h')
-                if os.path.exists(impl_h_path) and item != 'builtin':  # Ignore builtin
-                    found_implementations.add(item)
-
-    expected_implementations = set(IMPLEMENTATIONS)
-    if found_implementations != expected_implementations:
-        missing = expected_implementations - found_implementations
-        extra = found_implementations - expected_implementations
-        warning = "Warning: IMPLEMENTATIONS list does not match found implementations.\n"
-        if missing:
-            warning += f"Missing in filesystem: {sorted(missing)}\n"
-        if extra:
-            warning += f"Extra in filesystem: {sorted(extra)}\n"
-        print(warning)
-        return False
-    return True
-
-def read_version():
-    with open(os.path.join(PROJECTPATH, 'include/simdjson/simdjson_version.h')) as f:
-        return re.search(r'\d+\.\d+\.\d+', f.read()).group(0)
-
-version = read_version()
-if not validate_implementations():
-    print("Validation failed. Please update IMPLEMENTATIONS list in amalgamate.py.")
-    sys.exit(1)
-else:
-    print("implementation validated")
-Amalgamator.amalgamate(AMAL_H, "simdjson.h", ['include'], timestamp, version).validate_all_files_used('include')
-Amalgamator.amalgamate(AMAL_C, "simdjson.cpp", ['src', 'include'], timestamp, version).validate_all_files_used('src')
 
 # copy the README and DEMOCPP
 if SCRIPTPATH != AMALGAMATE_OUTPUT_PATH: