Merge branch 'master' into francisco/toy_example

.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
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.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
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.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
-* Builder is an overview of how to use simdjson to generate JSON: https://github.com/simdjson/simdjson/blob/master/doc/builder.md
+* Basics is an overview of how to use simdjson and its APIs: https://github.com/simdjson/simdjson/blob/master/doc/basics.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:
-- CONTRIBUTING: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
-- HACKING: https://github.com/simdjson/simdjson/blob/master/HACKING.md
+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.
 
+If you plan to contribute to simdjson, please read our
 
-
-If you can, we recommend running our tests with the sanitizers turned on.
-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!
-
+CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
+HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md

.github/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: Configure Debug Build
+      - name: Use cmake
         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
-
-      - name: Compile Debug Build
-        run: |
-          cmake --build builddebug
-
-      - name: Test Debug Build
-        run: |
-          ctest --output-on-failure -LE explicitonly -j --test-dir builddebug
-
-      - name: Configure Release Build
-        run: |
-          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
-
-      - name: Compile Release 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
+          mkdir builddebug &&
+          cd builddebug &&
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cd .. &&
+          mkdir build &&
+          cd build &&
+          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
+          cd ../tests/installation_tests/find &&
+          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .

.github/workflows/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

@@ -49,6 +49,27 @@ objs
 
 # C++ ignore from https://github.com/github/gitignore/blob/master/C%2B%2B.gitignore
 
+# CMake build artifacts
+CMakeCache.txt
+CMakeFiles/
+CPackConfig.cmake
+CPackSourceConfig.cmake
+Makefile
+cmake_install.cmake
+simdjson-config*.cmake
+simdjson-props.cmake
+simdjson.pc
+
+# Build directories
+deps/
+examples/build_*/
+examples/*_demo
+examples/*_benchmark
+
+# Temporary files
+examples/CMakeLists_demo.txt
+examples/simple_http.h
+
 # Prerequisites
 *.d
 

.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

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.0.1
+    VERSION 4.0.0
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,8 +20,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_SOVERSION "27" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "28.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "28" 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.1"
+PROJECT_NUMBER         = "4.0.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 ..
-cmake --build build
-ctest --test-dir build
+mkdir build
+cd 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]
 
 

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)
-
-
+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;
-  if (simdjson::padded_string::load(filename).get(p)) {
+  auto v = simdjson::padded_string::load(filename);
+  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);
-  if(error) {
-    std::cerr << simdjson::error_message(error) << std::endl;
-    std::abort();
-  }
+  simdjson::padded_string::load(filename).value_unsafe().swap(p);
   std::chrono::time_point<std::chrono::steady_clock> end_clock =
       std::chrono::steady_clock::now();
   std::chrono::duration<double> elapsed = end_clock - start_clock;

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

@@ -5,47 +5,47 @@ An overview of what you need to know to use simdjson to parse JSON documents, wi
 [Our documentation regarding the generation (serialization) of JSON documents is in a
 separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.md).
 
-- [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)
+- [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--simdjson--ondemand--value--get--to-get-custom-types--pre-c--20-)
+    + [2. Use `tag_invoke` for custom types (C++20)](#2-use--tag-invoke--for-custom-types--c--20-)
+    + [3. Using static reflection (C++26)](#3-using-static-reflection--c--26-)
+  * [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
 ------------------
@@ -54,7 +54,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 +78,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 +180,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 +239,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 +309,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 +332,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 +360,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`,
-`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`)
+`simdjson::ondemand::value`) have a `type()` method returning a `json_type` value describing the
+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 +395,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 +442,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 +505,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 +688,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() {
@@ -884,13 +871,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 +933,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 +1034,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 +1129,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`:
@@ -1361,6 +1348,31 @@ that are not made by Toyota.
 
 
 
+For even more convenience, you can do it directly without a parser instance like so:
+
+```cpp
+Car car = simdjson::from(json);
+```
+
+You can also use C++20 ranges to iterate over an array:
+
+```cpp
+  simdjson::padded_string json_cars =
+      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
+        "tire_pressure": [ 40.1, 39.9 ] },
+    { "make": "Kia",    "model": "Soul",   "year": 2012,
+        "tire_pressure": [ 30.1, 31.0 ] },
+    { "make": "Toyota", "model": "Tercel", "year": 1999,
+        "tire_pressure": [ 29.8, 30.0 ] }
+  ])"_padded;
+
+  for (Car car : simdjson::from(json_cars) | simdjson::as<Car>()) {
+    if (car.year < 1998) {
+      return false;
+    }
+  }
+```
+
 
 ### 3. Using static reflection (C++26)
 
@@ -1375,16 +1387,7 @@ your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 
 Then you can deserialize a type such as `Car` automatically:
 
-
-
-```C++
-struct Car {
-  std::string make;
-  std::string model;
-  int year;
-  std::vector<float> tire_pressure;
-};
-
+```cpp
 std::string json =  R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] } )";
 simdjson::ondemand::parser parser;
@@ -1392,110 +1395,35 @@ simdjson::ondemand::document doc = parser.iterate(simdjson::pad(json));
 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 structre 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 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:
+Just like when using `tag_invoke` for custom types (but without the `tag_invoke` code), you can parse a class instance directly without a parser instance:
 
 ```cpp
 Car car = simdjson::from(json);
 ```
 
-You can also use the `simdjson::from` syntax to iterate over an array.
+Similarly, you can also use C++20 ranges to iterate over an array:
 
 ```cpp
-for(auto val : simdjson::from(json).array()) {
-  Car c = val.get<Car>(); // ...
-}
+  simdjson::padded_string json_cars =
+      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
+        "tire_pressure": [ 40.1, 39.9 ] },
+    { "make": "Kia",    "model": "Soul",   "year": 2012,
+        "tire_pressure": [ 30.1, 31.0 ] },
+    { "make": "Toyota", "model": "Tercel", "year": 1999,
+        "tire_pressure": [ 29.8, 30.0 ] }
+  ])"_padded;
+
+  for (Car car : simdjson::from(json_cars) | simdjson::as<Car>()) {
+    if (car.year < 1998) {
+      return false;
+    }
+  }
 ```
 
-Standard STL types are supported:
+You can also automatically serialize the `Car` instance to a JSON string, see
+our [Builder documentation](builder.md).
 
 
-```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
 ----------------------
 
@@ -1537,9 +1465,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:
 
@@ -1559,7 +1487,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"( [
@@ -1714,7 +1642,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:
@@ -2308,8 +2236,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)
-). As an example, suppose we have the following JSON text:
+numbers. As an example, suppose we have the following JSON text:
 
 ```c++
 auto json =
@@ -2628,36 +2555,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.
@@ -3176,45 +3077,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.
-  ```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 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.
 - 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

@@ -46,7 +46,7 @@ After writting the content, if you have reasons to believe that the content migh
 - `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()`.
+malformed UTF-8.
 
 Once you are satisfied, you can recover the string as follows:
 
@@ -54,7 +54,7 @@ Once you are satisfied, you can recover the string as follows:
 - `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
 - `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>`.
 
-The later method (`view()`) is recommended.  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
 ---------------------------
@@ -109,9 +109,6 @@ bool car_test() {
 }
 ```
 
-
-
-
 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}`).
@@ -127,57 +124,6 @@ The `string_builder` might throw an exception in case of error when you cast it
 
 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.
-
-```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 do recommend that you create and reuse the `string_builder` instance for performance
-reasons.
-
 C++26 static reflection
 ------------------------
 

doc/dom.md

@@ -354,74 +354,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
 --------------

examples/BUILD_INSTRUCTIONS.md

@@ -0,0 +1,254 @@
+# 🛠️ Build Instructions for simdjson One-Liner Demo
+
+## Prerequisites
+
+### For Both Examples
+- **cpr library** (for HTTP requests) - See [INSTALL_CPR.md](INSTALL_CPR.md) for installation
+- **curl library** (cpr dependency) - Usually pre-installed on most systems
+- **simdjson library** - Included in this repository
+
+### For Legacy Example (github_legacy.cpp)
+- Any C++20 compatible compiler (GCC 10+, Clang 10+, MSVC 2019+)
+
+### For Modern Example (github_modern.cpp)  
+- Bloomberg Clang fork with C++26 reflection support
+  - Get it from: https://github.com/bloomberg/clang-p2996
+
+## 🔨 Compilation Commands
+
+### Quick Setup (Recommended)
+
+1. **Build cpr from source** (if not installed system-wide):
+```bash
+# From the examples directory
+mkdir -p ../deps && cd ../deps
+git clone https://github.com/libcpr/cpr.git
+cd cpr && git checkout 1.10.5
+mkdir build && cd build
+cmake .. -DCMAKE_CXX_COMPILER=clang++ -DCPR_USE_SYSTEM_CURL=ON -DBUILD_SHARED_LIBS=OFF -DCPR_ENABLE_SSL=OFF
+make -j4
+cd ../../../examples
+```
+
+2. **Compile the examples**:
+```bash
+# Legacy approach (any C++20 compiler)
+clang++ -std=c++20 \
+  -I../deps/cpr/include \
+  -I../deps/cpr/build/cpr_generated_includes \
+  -I../include -I.. \
+  github_legacy.cpp \
+  ../singleheader/simdjson.cpp \
+  ../deps/cpr/build/lib/libcpr.a \
+  -lcurl -pthread \
+  -o github_legacy_demo
+
+# Modern approach (Bloomberg clang with reflection)
+clang++ -std=c++26 -freflection \
+  -DSIMDJSON_STATIC_REFLECTION=1 \
+  -I../deps/cpr/include \
+  -I../deps/cpr/build/cpr_generated_includes \
+  -I../include -I.. \
+  github_modern.cpp \
+  ../singleheader/simdjson.cpp \
+  ../deps/cpr/build/lib/libcpr.a \
+  -lcurl -pthread \
+  -o github_modern_demo
+```
+
+### Using System-Installed cpr
+
+If cpr is installed system-wide (see [INSTALL_CPR.md](INSTALL_CPR.md)):
+
+```bash
+# Legacy approach
+clang++ -std=c++20 \
+  -I../include -I.. \
+  github_legacy.cpp \
+  -lcpr -lcurl \
+  -o github_legacy_demo
+
+# Modern approach
+clang++ -std=c++26 -freflection \
+  -DSIMDJSON_STATIC_REFLECTION=1 \
+  -I../include -I.. \
+  github_modern.cpp \
+  -lcpr -lcurl \
+  -o github_modern_demo
+```
+
+### Using simdjson Single Header
+
+```bash
+# Legacy approach
+clang++ -std=c++20 \
+  -I../singleheader \
+  github_legacy.cpp \
+  ../singleheader/simdjson.cpp \
+  -lcpr -lcurl \
+  -o github_legacy_demo
+
+# Modern approach
+clang++ -std=c++26 -freflection \
+  -DSIMDJSON_STATIC_REFLECTION=1 \
+  -I../singleheader -I../include \
+  github_modern.cpp \
+  ../singleheader/simdjson.cpp \
+  -lcpr -lcurl \
+  -o github_modern_demo
+```
+
+### Using CMake (Recommended)
+
+```bash
+# Create build directory
+mkdir build && cd build
+
+# Configure with CMake
+cmake .. -DCMAKE_CXX_COMPILER=clang++ \
+         -DCMAKE_CXX_STANDARD=26 \
+         -DCMAKE_CXX_FLAGS="-freflection -DSIMDJSON_STATIC_REFLECTION=1"
+
+# Build both examples
+make github_legacy github_modern
+```
+
+### Quick Build with simdjson Single Header
+
+```bash
+# Legacy approach
+clang++ -std=c++20 \
+  -I../singleheader \
+  github_legacy.cpp \
+  ../singleheader/simdjson.cpp \
+  -lcpr -lcurl \
+  -o github_legacy_demo
+
+# Modern approach  
+clang++ -std=c++26 -freflection \
+  -DSIMDJSON_STATIC_REFLECTION=1 \
+  -I../singleheader \
+  github_modern.cpp \
+  ../singleheader/simdjson.cpp \
+  -lcpr -lcurl \
+  -o github_modern_demo
+```
+
+## 🏃 Running the Examples
+
+```bash
+# Run legacy version
+./github_legacy_demo
+
+# Run modern version  
+./github_modern_demo
+```
+
+## 🎯 Platform-Specific Notes
+
+### Linux (x86_64)
+```bash
+-DSIMDJSON_IMPLEMENTATION_HASWELL=1
+```
+
+### Linux (ARM64)
+```bash
+-DSIMDJSON_IMPLEMENTATION_ARM64=1
+```
+
+### macOS (Apple Silicon)
+```bash
+-DSIMDJSON_IMPLEMENTATION_ARM64=1
+```
+
+### macOS (Intel)
+```bash
+-DSIMDJSON_IMPLEMENTATION_HASWELL=1
+```
+
+### Windows (MSVC)
+```cmd
+cl /std:c++20 /I..\include /I.. github_legacy.cpp /Fe:github_legacy_demo.exe
+```
+
+## 🐛 Troubleshooting
+
+### "reflection feature not available"
+- Ensure you're using the Bloomberg clang fork
+- Check version: `clang++ --version` should show bloomberg/clang-p2996
+
+### "SIMDJSON_STATIC_REFLECTION not working"
+- Make sure to define it before including headers:
+  ```cpp
+  #define SIMDJSON_STATIC_REFLECTION 1
+  #include <simdjson.h>
+  ```
+
+### Linking errors
+- Use single-header approach for simplicity
+- Or ensure simdjson library is properly built and linked
+
+### Performance issues
+- Add optimization flags: `-O3 -march=native`
+- Enable LTO: `-flto`
+
+## 📦 Creating a Portable Demo
+
+For conferences, prepare the demo environment:
+
+```bash
+# Install cpr library (if not available)
+# Ubuntu/Debian:
+sudo apt-get install libcpr-dev
+
+# macOS:
+brew install cpr
+
+# Or build from source:
+git clone https://github.com/libcpr/cpr.git
+cd cpr && mkdir build && cd build
+cmake .. && make && sudo make install
+
+# Create demo directory
+mkdir simdjson_oneliner_demo
+cd simdjson_oneliner_demo
+
+# Copy necessary files
+cp path/to/github_legacy.cpp .
+cp path/to/github_modern.cpp .
+cp -r path/to/simdjson/include .
+cp -r path/to/simdjson/singleheader .
+
+# Create build script
+cat > build_demo.sh << 'EOF'
+#!/bin/bash
+echo "🔨 Building Legacy Example..."
+clang++ -std=c++20 -O3 -I./include -I. \
+  github_legacy.cpp -lcpr -lcurl -o legacy_demo
+
+echo "🔨 Building Modern Example (C++26)..."  
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 -O3 \
+  -I./include -I. github_modern.cpp -lcpr -lcurl -o modern_demo
+
+echo "✅ Build complete!"
+echo "Run: ./legacy_demo or ./modern_demo"
+EOF
+
+chmod +x build_demo.sh
+```
+
+## 🎪 Conference Checklist
+
+- [ ] Bloomberg clang installed on demo machine
+- [ ] Both examples compile cleanly  
+- [ ] Internet connection for live API calls (or use standalone)
+- [ ] Backup: pre-recorded video of compilation and execution
+- [ ] Slides with code snippets
+- [ ] QR code for GitHub repo
+
+## 🔗 Quick Links
+
+- simdjson: https://github.com/simdjson/simdjson
+- Bloomberg Clang: https://github.com/bloomberg/clang-p2996  
+- P2996 Reflection Proposal: https://wg21.link/p2996
+- Talk Resources: [Your GitHub repo with examples]

examples/CMakeLists.txt

@@ -1 +1,23 @@
 add_subdirectory(quickstart)
+
+# Add simdjson one-liner demo examples
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/github_legacy.cpp AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/github_modern.cpp)
+    # FetchContent to download cpr
+    include(FetchContent)
+    set(CPR_ENABLE_SSL OFF CACHE BOOL "")
+    FetchContent_Declare(
+      cpr
+      GIT_REPOSITORY https://github.com/libcpr/cpr.git
+      GIT_TAG 1.10.5
+    )
+    FetchContent_MakeAvailable(cpr)
+
+    # Build the examples
+    add_executable(github_legacy github_legacy.cpp)
+    target_link_libraries(github_legacy simdjson cpr::cpr)
+
+    add_executable(github_modern github_modern.cpp)
+    target_link_libraries(github_modern simdjson cpr::cpr)
+    target_compile_options(github_modern PRIVATE -std=c++26 -freflection)
+    target_compile_definitions(github_modern PRIVATE SIMDJSON_STATIC_REFLECTION=1)
+endif()

examples/CONFERENCE_TALK.md

@@ -0,0 +1,232 @@
+# 🚀 From Boilerplate to One-Liner: The simdjson Revolution
+
+## Conference Talk: JSON Parsing in Modern C++
+
+### 📋 Talk Abstract
+Discover how simdjson's new API combined with C++26 reflection transforms JSON parsing from a tedious, error-prone task into a single line of code. This talk showcases the dramatic evolution from manual parsing to automatic struct deserialization.
+
+---
+
+## 🎯 Key Talking Points
+
+### 1. **The Problem** (2 minutes)
+- JSON is everywhere: APIs, configs, data exchange
+- C++ historically makes JSON parsing verbose
+- Show other languages: `user = json.loads(data)` in Python
+- "Why can't C++ be this simple?"
+
+### 2. **The Legacy Approach** (5 minutes)
+- Live demo: `github_legacy.cpp`
+- Walk through the boilerplate:
+  ```cpp
+  // 😓 Manual field extraction
+  user.login = std::string(doc["login"].get_string().value());
+  user.id = doc["id"].get_int64().value();
+  
+  // 😰 Handle optional fields
+  auto company_result = doc["company"];
+  if (!company_result.is_null()) {
+      user.company = std::string(company_result.get_string().value());
+  }
+  ```
+- Count the lines: ~30 lines just for parsing!
+- Error-prone: typos, missing fields, type mismatches
+
+### 3. **The Magic Moment** (3 minutes)
+- "What if I told you it could be just ONE line?"
+- Show `github_modern.cpp`
+- The magic line:
+  ```cpp
+  GitHubUser user = simdjson::from(simdjson::padded_string(json_data));
+  ```
+- Audience reaction: 🤯
+
+### 4. **How It Works** (5 minutes)
+- C++26 static reflection
+- Compile-time struct introspection
+- simdjson generates parsing code automatically
+- Zero runtime overhead - it's all compile-time!
+
+### 5. **Live Demo** (5 minutes)
+- Compile both examples
+- Run them side-by-side
+- Show identical output
+- Highlight the code difference
+- Add a new field to the struct - watch it "just work"
+
+### 6. **Deserialization Performance** (3 minutes)
+- "But is deserialization fast?"
+- Live benchmark demonstration
+- Both approaches achieve ~2.7 GB/s deserialization speed on real GitHub API data
+- Reflection adds ZERO runtime overhead to deserialization
+- "You get simplicity WITHOUT sacrificing speed!"
+- Note: We're measuring JSON → struct deserialization performance
+- Note: Performance scales with larger documents (up to 3+ GB/s)
+
+### 7. **The Future is Now** (2 minutes)
+- Bloomberg clang fork available today
+- C++26 coming soon
+- Start preparing your codebases
+- simdjson ready for the future
+
+---
+
+## 💻 Live Coding Demo Script
+
+### Setup
+```bash
+# Show the two files
+ls -la github_*.cpp
+
+# Show line count difference
+wc -l github_legacy.cpp github_modern.cpp
+```
+
+### Demo 1: The Pain of Legacy
+```bash
+# Open github_legacy.cpp in editor
+# Highlight the parse_github_user function
+# Point out each manual field extraction
+# "Look at all this code just to parse 7 fields!"
+```
+
+### Demo 2: The Modern Magic
+```bash
+# Open github_modern.cpp
+# Show the struct - "Just a plain struct!"
+# Show the one-liner
+# "That's it. That's the entire parsing code."
+```
+
+### Demo 3: Compilation and Execution
+
+**Option 1: Use the demo script (Recommended)**
+```bash
+# The script handles everything - building cpr, compiling, and running
+./conference_demo.sh
+
+# For the extended demo with serialization:
+./conference_demo_serialization.sh
+```
+
+**Option 2: Manual compilation**
+```bash
+# Build cpr first (one-time setup)
+mkdir -p ../deps && cd ../deps
+git clone https://github.com/libcpr/cpr.git
+cd cpr && git checkout 1.10.5
+mkdir build && cd build
+cmake .. -DCMAKE_CXX_COMPILER=clang++ -DCPR_USE_SYSTEM_CURL=ON \
+         -DBUILD_SHARED_LIBS=OFF -DCPR_ENABLE_SSL=OFF
+make -j4
+cd ../../../examples
+
+# Compile legacy
+clang++ -std=c++20 \
+  -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+  -I../include -I.. github_legacy.cpp ../singleheader/simdjson.cpp \
+  ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o legacy_demo
+
+# Compile modern (with reflection)
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 \
+  -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+  -I../include -I.. github_modern.cpp ../singleheader/simdjson.cpp \
+  ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o modern_demo
+
+# Run both - they fetch real GitHub data!
+./legacy_demo
+./modern_demo
+```
+
+### Demo 4: Adding a New Field (Crowd Pleaser!)
+```cpp
+// Add to struct in both files:
+std::string twitter_username;
+
+// Legacy: Must add parsing code
+else if (key == "twitter_username") 
+    user.twitter_username = field.value().get_string().value();
+
+// Modern: Nothing to add! It just works!
+```
+
+---
+
+## 🎤 Speaker Notes
+
+### Opening Hook
+"How many of you have written JSON parsing code in C++? Keep your hands up if you enjoyed it... Yeah, I thought so."
+
+### Transition to Modern
+"But what if I told you that in 2024, with simdjson and C++26, parsing JSON can be as simple as Python?"
+
+### After showing the one-liner
+"No, this isn't pseudocode. This is real, working C++ code. Let me prove it to you."
+
+### Addressing Skeptics
+- "It's not magic, it's metaprogramming"
+- "No runtime cost - it's all compile-time"
+- "Yes, it handles errors properly"
+- "Yes, it's production-ready"
+
+### Closing
+"The future of C++ is here. It's fast, it's simple, and it's beautiful. Stop writing boilerplate. Start writing the code that matters."
+
+---
+
+## 📊 Slide Suggestions
+
+### Slide 1: Title
+**From 50 Lines to 1: The simdjson Revolution**
+*Your Name - Conference 2024*
+
+### Slide 2: The Problem
+```python
+# Python
+user = json.loads(data)
+
+# JavaScript  
+const user = JSON.parse(data);
+
+# C++ ???
+// 😭 50+ lines of boilerplate
+```
+
+### Slide 3: The Solution
+```cpp
+// C++26 with simdjson
+GitHubUser user = simdjson::from(simdjson::padded_string(data));
+```
+
+### Slide 4: Performance Graph
+- Bar chart showing simdjson vs other parsers
+- "Fast AND Simple"
+
+### Slide 5: Timeline
+- 2018: simdjson introduced (fast but verbose)
+- 2024: New API design  
+- 2024: C++26 reflection support
+- Future: It's here!
+
+### Slide 6: Call to Action
+- Try it today: github.com/simdjson/simdjson
+- Bloomberg clang: github.com/bloomberg/clang-p2996
+- Join the revolution!
+
+---
+
+## 🔥 Audience Engagement
+
+### Interactive Elements
+1. **Live Poll**: "How many lines of code for parsing JSON?"
+2. **Challenge**: "Spot the bug in this manual parsing code"
+3. **Q&A Focus**: Performance, error handling, compatibility
+
+### Memorable Moments
+- The reveal of the one-liner
+- Live compilation with reflection
+- Adding a field without changing parsing code
+- Performance numbers
+
+### Takeaway Message
+"C++ doesn't have to be painful. With modern tools and modern standards, C++ can be as elegant as any language - and faster than all of them."

examples/INSTALL_CPR.md

@@ -0,0 +1,72 @@
+# Installing CPR Library
+
+The examples require the CPR library for making HTTP requests to the GitHub API.
+
+## Option 1: Install via Package Manager (Recommended)
+
+### Ubuntu/Debian
+```bash
+sudo apt-get update
+sudo apt-get install libcpr-dev
+```
+
+### macOS (Homebrew)
+```bash
+brew install cpr
+```
+
+### Arch Linux
+```bash
+sudo pacman -S cpr
+```
+
+## Option 2: Build from Source
+
+```bash
+# Clone cpr
+git clone https://github.com/libcpr/cpr.git
+cd cpr
+
+# Build and install
+mkdir build && cd build
+cmake .. -DCPR_USE_SYSTEM_CURL=ON
+make
+sudo make install
+```
+
+## Option 3: Using vcpkg
+
+```bash
+vcpkg install cpr
+```
+
+## Option 4: Using Conan
+
+```bash
+conan install cpr/1.10.5@
+```
+
+## Compilation
+
+Once cpr is installed, compile the examples:
+
+```bash
+# Legacy example
+clang++ -std=c++20 -I../include -I.. github_legacy.cpp -lcpr -lcurl -o github_legacy_demo
+
+# Modern example (requires Bloomberg clang)
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 \
+        -I../include -I.. github_modern.cpp -lcpr -lcurl -o github_modern_demo
+```
+
+## Troubleshooting
+
+If you get "cpr/cpr.h not found", check:
+- `pkg-config --cflags --libs cpr`
+- Add include path: `-I/usr/local/include`
+- Add library path: `-L/usr/local/lib`
+
+For SSL issues, ensure OpenSSL is installed:
+- Ubuntu/Debian: `sudo apt-get install libssl-dev`
+- macOS: `brew install openssl`
+- Link OpenSSL: `-lssl -lcrypto`

examples/README_ONELINER.md

@@ -0,0 +1,74 @@
+# 🚀 simdjson One-Liner Demo: From Boilerplate to Magic
+
+This demo showcases the dramatic simplification of JSON parsing in C++ using simdjson's new API combined with C++26 reflection.
+
+## Files
+
+- `github_legacy.cpp` - Traditional manual JSON parsing approach (~30 lines of parsing code)
+- `github_modern.cpp` - Modern C++26 reflection approach (1 line of parsing code!)
+- `CONFERENCE_TALK.md` - Complete conference presentation guide
+- `BUILD_INSTRUCTIONS.md` - Detailed compilation instructions
+- `conference_demo.sh` - Interactive demo script for presentations
+
+## Quick Start
+
+### Prerequisites
+- Bloomberg clang for C++26: https://github.com/bloomberg/clang-p2996
+- curl library (usually pre-installed)
+- cpr library (built automatically by demo script)
+
+### Easy Demo
+```bash
+# Just run the demo script - it handles everything!
+./conference_demo.sh
+```
+
+The script will:
+1. Build cpr if needed
+2. Compile both examples
+3. Run interactive presentation
+
+### Manual Compilation
+
+If you want to compile manually:
+
+```bash
+# Build cpr first (if not installed)
+mkdir -p ../deps && cd ../deps
+git clone https://github.com/libcpr/cpr.git
+cd cpr && git checkout 1.10.5
+mkdir build && cd build
+cmake .. -DCMAKE_CXX_COMPILER=clang++ -DCPR_USE_SYSTEM_CURL=ON -DBUILD_SHARED_LIBS=OFF -DCPR_ENABLE_SSL=OFF
+make -j4
+cd ../../../examples
+
+# Compile examples
+# Legacy
+clang++ -std=c++20 -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+        -I../include -I.. github_legacy.cpp ../singleheader/simdjson.cpp \
+        ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o legacy_demo
+
+# Modern
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 \
+        -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+        -I../include -I.. github_modern.cpp ../singleheader/simdjson.cpp \
+        ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o modern_demo
+```
+
+## The Magic ✨
+
+**Before (Legacy):**
+```cpp
+// 30+ lines of manual parsing...
+user.login = std::string(doc["login"].get_string().value());
+user.id = doc["id"].get_int64().value();
+// ... etc for each field
+```
+
+**After (Modern):**
+```cpp
+// Just ONE line!
+GitHubUser user = simdjson::from(simdjson::padded_string(response.text));
+```
+
+Both examples fetch real data from GitHub API to demonstrate real-world usage!

examples/SERIALIZATION_README.md

@@ -0,0 +1,53 @@
+# simdjson Serialization with C++26 Reflection
+
+This directory now includes examples demonstrating **both** deserialization and serialization using C++26 reflection features.
+
+## 🚀 Quick Start
+
+### Basic Round-Trip Demo
+```bash
+# Compile and run the simple round-trip demo
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 \
+    reflection_roundtrip_demo.cpp ../singleheader/simdjson.cpp \
+    -o reflection_roundtrip_demo
+./reflection_roundtrip_demo
+```
+
+### Conference Demo with Serialization
+```bash
+# Run the extended conference demo that includes serialization
+./conference_demo_serialization.sh
+```
+
+## 📝 What's New?
+
+The experimental `simdjson::builder::to_json_string()` function enables one-line serialization:
+
+```cpp
+// Deserialize JSON → Struct
+MyStruct obj = simdjson::from(json);
+
+// Serialize Struct → JSON (NEW!)
+std::string json = simdjson::builder::to_json_string(obj);
+```
+
+## 🎯 Features
+
+- **Zero boilerplate**: No need to write serialization code
+- **Automatic handling**: Optional fields, containers, nested structures
+- **Type-safe**: Compile-time checking with reflection
+- **Performant**: Optimized string building
+
+## ⚠️ Requirements
+
+- Bloomberg's clang fork (clang-p2996) with C++26 reflection support
+- Build with `-DSIMDJSON_STATIC_REFLECTION=1`
+- Include `simdjson/builder/json_builder.h`
+
+## 📊 Performance
+
+While serialization is generally slower than deserialization (due to string building vs parsing), the reflection-based approach is still highly optimized and significantly faster than manual string concatenation approaches.
+
+## 🔧 Status
+
+This serialization support is **experimental** and part of the builder API. The API may change as C++26 reflection features evolve.

examples/conference_demo.sh

@@ -0,0 +1,167 @@
+#!/bin/bash
+# Conference Demo Script - simdjson One-Liner Magic
+# Run this during your talk for a smooth demo experience
+
+# Check if cpr is built
+if [ ! -f "../deps/cpr/build/lib/libcpr.a" ]; then
+    echo "⚠️  CPR library not found. Building it first..."
+    echo ""
+    if [ ! -d "../deps/cpr" ]; then
+        mkdir -p ../deps
+        cd ../deps
+        git clone https://github.com/libcpr/cpr.git
+        cd cpr && git checkout 1.10.5
+        cd ../..
+    fi
+    cd ../deps/cpr
+    mkdir -p build && cd build
+    cmake .. -DCMAKE_CXX_COMPILER=clang++ -DCPR_USE_SYSTEM_CURL=ON -DBUILD_SHARED_LIBS=OFF -DCPR_ENABLE_SSL=OFF
+    make -j4
+    cd ../../../examples
+    echo "✅ CPR built successfully!"
+    echo ""
+fi
+
+clear
+echo "🚀 simdjson: From Boilerplate to One-Liner"
+echo "==========================================="
+echo ""
+echo "Press Enter to continue..."
+read
+
+# Show the legacy approach
+echo "📚 First, let's look at the LEGACY approach..."
+echo ""
+echo "Opening github_legacy.cpp..."
+sleep 1
+echo ""
+echo "Key points:"
+echo "  • Manual parse_github_user() function"
+echo "  • Extract each field individually"
+echo "  • Handle optional fields explicitly"
+echo "  • ~30 lines of parsing code"
+echo ""
+echo "Press Enter to see the code..."
+read
+
+# Display key parts of legacy code
+cat github_legacy.cpp | grep -A 20 "parse_github_user" | head -25
+
+echo ""
+echo "😓 That's a lot of boilerplate!"
+echo ""
+echo "Press Enter to compile and run..."
+read
+
+# Compile legacy
+echo "🔨 Compiling legacy version..."
+echo "Command: clang++ -std=c++20 -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes -I../include -I.. github_legacy.cpp ../singleheader/simdjson.cpp ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o legacy_demo"
+clang++ -std=c++20 -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes -I../include -I.. github_legacy.cpp ../singleheader/simdjson.cpp ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o legacy_demo
+echo "✅ Compiled!"
+echo ""
+echo "🏃 Running legacy demo (fetching real GitHub data)..."
+echo ""
+./legacy_demo
+
+echo ""
+echo "Press Enter to see the MODERN approach..."
+read
+
+clear
+echo "✨ Now, let's look at the MODERN approach with C++26 reflection..."
+echo ""
+echo "Opening github_modern.cpp..."
+sleep 1
+echo ""
+echo "Key points:"
+echo "  • Just declare your struct"
+echo "  • ONE line of parsing code"
+echo "  • C++26 reflection handles everything"
+echo "  • No manual field extraction!"
+echo ""
+echo "Press Enter to see the magic..."
+read
+
+# Show the struct and the one-liner
+echo "The struct (just a plain struct!):"
+echo ""
+cat github_modern.cpp | grep -A 10 "struct GitHubUser" | head -12
+echo ""
+echo "The parsing code (ONE LINE!):"
+echo ""
+echo "    GitHubUser user = simdjson::from(simdjson::padded_string(response.text));"
+echo ""
+echo "🤯 That's it! That's all the parsing code!"
+echo ""
+echo "Press Enter to compile with C++26 reflection..."
+read
+
+# Compile modern
+echo "🔨 Compiling modern version with Bloomberg clang..."
+echo "Command: clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes -I../include -I.. github_modern.cpp ../singleheader/simdjson.cpp ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o modern_demo"
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes -I../include -I.. github_modern.cpp ../singleheader/simdjson.cpp ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o modern_demo
+echo "✅ Compiled!"
+echo ""
+echo "🏃 Running modern demo (fetching real GitHub data)..."
+echo ""
+./modern_demo
+
+echo ""
+echo "Press Enter to see side-by-side comparison..."
+read
+
+clear
+echo "📊 SIDE-BY-SIDE COMPARISON"
+echo "========================="
+echo ""
+echo "Legacy Approach:                    Modern Approach (C++26):"
+echo "----------------                    ------------------------"
+echo "❌ 30+ lines of parsing code        ✅ 1 line of parsing code"
+echo "❌ Manual field extraction          ✅ Automatic with reflection"
+echo "❌ Error-prone                      ✅ Type-safe"
+echo "❌ Hard to maintain                 ✅ Just update the struct"
+echo "❌ Boilerplate for each type        ✅ Works for any struct"
+echo ""
+echo ""
+echo "Press Enter to run PERFORMANCE BENCHMARKS..."
+read
+
+clear
+echo "⚡ DESERIALIZATION PERFORMANCE BENCHMARKS"
+echo "========================================"
+echo ""
+echo "Let's measure the actual JSON → struct deserialization speed..."
+echo ""
+
+# Compile benchmarks if not exist
+if [ ! -f "./legacy_benchmark" ] || [ ! -f "./modern_benchmark" ]; then
+    echo "🔨 Compiling benchmark versions..."
+    
+    clang++ -std=c++20 -O3 -march=native \
+      -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+      -I../include -I.. github_legacy_benchmark.cpp ../singleheader/simdjson.cpp \
+      ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o legacy_benchmark 2>/dev/null
+    
+    clang++ -std=c++26 -freflection -O3 -march=native \
+      -DSIMDJSON_STATIC_REFLECTION=1 \
+      -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+      -I../include -I.. github_modern_benchmark.cpp ../singleheader/simdjson.cpp \
+      ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o modern_benchmark 2>/dev/null
+fi
+
+echo "🏃 Running legacy benchmark..."
+echo ""
+./legacy_benchmark
+
+echo ""
+echo "Press Enter to run modern benchmark..."
+read
+
+echo "🏃 Running modern benchmark..."
+echo ""
+./modern_benchmark
+
+echo ""
+echo "🎉 The future of C++ is here!"
+echo ""
+echo "Questions?"

examples/conference_demo_serialization.sh

@@ -0,0 +1,322 @@
+#!/bin/bash
+# Conference Demo Script - simdjson One-Liner Magic (WITH SERIALIZATION!)
+# Extended demo showcasing both deserialization AND serialization with C++26 reflection
+
+# Check if cpr is built
+if [ ! -f "../deps/cpr/build/lib/libcpr.a" ]; then
+    echo "⚠️  CPR library not found. Building it first..."
+    echo ""
+    if [ ! -d "../deps/cpr" ]; then
+        mkdir -p ../deps
+        cd ../deps
+        git clone https://github.com/libcpr/cpr.git
+        cd cpr && git checkout 1.10.5
+        cd ../..
+    fi
+    cd ../deps/cpr
+    mkdir -p build && cd build
+    cmake .. -DCMAKE_CXX_COMPILER=clang++ -DCPR_USE_SYSTEM_CURL=ON -DBUILD_SHARED_LIBS=OFF -DCPR_ENABLE_SSL=OFF
+    make -j4
+    cd ../../../examples
+    echo "✅ CPR built successfully!"
+    echo ""
+fi
+
+clear
+echo "🚀 simdjson: Complete JSON Round-Trip with C++26 Reflection"
+echo "============================================================"
+echo ""
+echo "Today we'll showcase BOTH deserialization AND serialization!"
+echo ""
+echo "Press Enter to continue..."
+read
+
+# Create a demo program that shows serialization
+cat > github_serialization_demo.cpp << 'EOF'
+#include <iostream>
+#include <iomanip>
+#include "simdjson.h"
+#include <cpr/cpr.h>
+
+struct GitHubUser {
+    std::string login;
+    std::optional<std::string> name;
+    std::optional<std::string> company;
+    std::optional<std::string> blog;
+    std::optional<std::string> location;
+    std::optional<std::string> email;
+    std::optional<std::string> bio;
+    int64_t public_repos;
+    int64_t followers;
+    int64_t following;
+};
+
+int main() {
+    std::cout << "🔄 C++26 Reflection: Complete JSON Round-Trip Demo\n";
+    std::cout << "================================================\n\n";
+    
+    // Step 1: Fetch real data from GitHub
+    std::cout << "📡 Fetching GitHub user data...\n";
+    auto response = cpr::Get(cpr::Url{"https://api.github.com/users/simdjson"});
+    
+    if (response.status_code != 200) {
+        std::cerr << "Error: Failed to fetch data\n";
+        return 1;
+    }
+    
+    std::cout << "✅ Received " << response.text.length() << " bytes of JSON\n\n";
+    
+    // Step 2: Deserialize with ONE LINE
+    std::cout << "📥 DESERIALIZATION (JSON → Struct)\n";
+    std::cout << "Code: GitHubUser user = simdjson::from(simdjson::padded_string(response.text));\n\n";
+    
+    GitHubUser user = simdjson::from(simdjson::padded_string(response.text));
+    
+    // Show the data we parsed
+    std::cout << "Parsed data:\n";
+    std::cout << "  • Login: " << user.login << "\n";
+    std::cout << "  • Name: " << (user.name.has_value() ? *user.name : "<not set>") << "\n";
+    std::cout << "  • Company: " << (user.company.has_value() ? *user.company : "<not set>") << "\n";
+    std::cout << "  • Location: " << (user.location.has_value() ? *user.location : "<not set>") << "\n";
+    std::cout << "  • Bio: " << (user.bio.has_value() ? *user.bio : "<not set>") << "\n";
+    std::cout << "  • Repos: " << user.public_repos << "\n";
+    std::cout << "  • Followers: " << user.followers << "\n\n";
+    
+    // Step 3: Modify the data
+    std::cout << "✏️  Modifying data...\n";
+    user.followers += 1000;  // Wishful thinking!
+    user.name = "simdjson - JSON at the speed of light";  // Set a name
+    user.bio = user.bio.value_or("") + " (Now with C++26 reflection!)";
+    std::cout << "  • Added 1000 followers (we can dream!)\n";
+    std::cout << "  • Set organization name\n";
+    std::cout << "  • Updated bio\n\n";
+    
+    // Step 4: Serialize back to JSON with ONE LINE
+    std::cout << "📤 SERIALIZATION (Struct → JSON)\n";
+    std::cout << "Code: std::string json = simdjson::builder::to_json_string(user);\n\n";
+    
+    auto json_result = simdjson::builder::to_json_string(user);
+    if (json_result.error()) {
+        std::cerr << "Serialization error!\n";
+        return 1;
+    }
+    std::string json = json_result.value();
+    
+    std::cout << "Generated JSON (" << json.length() << " bytes):\n";
+    // Pretty print first 200 chars
+    if (json.length() > 200) {
+        std::cout << json.substr(0, 200) << "...\n\n";
+    } else {
+        std::cout << json << "\n\n";
+    }
+    
+    // Step 5: Verify round-trip
+    std::cout << "🔄 ROUND-TRIP VERIFICATION\n";
+    std::cout << "Parsing our generated JSON back...\n";
+    
+    GitHubUser user2 = simdjson::from(simdjson::padded_string(json));
+    
+    std::cout << "✅ Round-trip successful!\n";
+    std::cout << "  • Original followers: " << user.followers << "\n";
+    std::cout << "  • Parsed followers: " << user2.followers << "\n";
+    std::cout << "  • Name set correctly: " << (user2.name.has_value() && *user2.name == *user.name ? "YES" : "NO") << "\n";
+    std::cout << "  • Bio preserved: " << (user2.bio.has_value() ? "YES" : "NO") << "\n\n";
+    
+    std::cout << "🎉 That's it! Two lines of code for complete JSON handling:\n";
+    std::cout << "   • Deserialization: simdjson::from(...)\n";
+    std::cout << "   • Serialization: simdjson::builder::to_json_string(...)\n";
+    
+    return 0;
+}
+EOF
+
+# Create a benchmark that includes serialization
+cat > serialization_benchmark.cpp << 'EOF'
+#include <iostream>
+#include <iomanip>
+#include <chrono>
+#include "simdjson.h"
+#include <map>
+
+struct TestData {
+    std::string name;
+    std::vector<int> numbers;
+    std::map<std::string, double> metrics;
+    bool active;
+    std::optional<std::string> description;
+};
+
+int main() {
+    std::cout << "⚡ Serialization Performance Benchmark\n";
+    std::cout << "=====================================\n\n";
+    
+    // Create test data
+    TestData data{
+        .name = "Performance Test",
+        .numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+        .metrics = {{"latency", 1.23}, {"throughput", 456.78}, {"cpu", 89.01}},
+        .active = true,
+        .description = "Testing reflection-based serialization performance"
+    };
+    
+    const int iterations = 100000;
+    
+    // Benchmark serialization
+    std::cout << "📤 Benchmarking serialization (" << iterations << " iterations)...\n";
+    
+    auto start = std::chrono::high_resolution_clock::now();
+    
+    std::string json;
+    for (int i = 0; i < iterations; i++) {
+        auto result = simdjson::builder::to_json_string(data);
+        if (i == 0 && !result.error()) {
+            json = result.value();
+        }
+    }
+    
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    std::cout << "\nResults:\n";
+    std::cout << "  • Generated JSON size: " << json.length() << " bytes\n";
+    std::cout << "  • Total time: " << duration.count() / 1000.0 << " ms\n";
+    
+    double time_per_iteration_us = duration.count() / double(iterations);
+    double time_per_iteration_s = time_per_iteration_us / 1000000.0;
+    double bytes_per_second = json.length() / time_per_iteration_s;
+    double mb_per_second = bytes_per_second / (1024.0 * 1024.0);
+    
+    std::cout << "  • Time per serialization: " << std::fixed << std::setprecision(2) << time_per_iteration_us << " μs\n";
+    std::cout << "  • Throughput: " << std::fixed << std::setprecision(2) << mb_per_second << " MB/s\n";
+    
+    std::cout << "\nGenerated JSON:\n" << json << "\n\n";
+    
+    // Benchmark deserialization for comparison
+    std::cout << "📥 Benchmarking deserialization (for comparison)...\n";
+    
+    simdjson::padded_string padded_json(json);
+    start = std::chrono::high_resolution_clock::now();
+    
+    for (int i = 0; i < iterations; i++) {
+        TestData parsed = simdjson::from(padded_json);
+    }
+    
+    end = std::chrono::high_resolution_clock::now();
+    duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    std::cout << "\nResults:\n";
+    time_per_iteration_us = duration.count() / double(iterations);
+    time_per_iteration_s = time_per_iteration_us / 1000000.0;
+    bytes_per_second = json.length() / time_per_iteration_s;
+    mb_per_second = bytes_per_second / (1024.0 * 1024.0);
+    
+    std::cout << "  • Time per deserialization: " << std::fixed << std::setprecision(2) << time_per_iteration_us << " μs\n";
+    std::cout << "  • Throughput: " << std::fixed << std::setprecision(2) << mb_per_second << " MB/s\n";
+    
+    std::cout << "\n✅ Both serialization and deserialization work with reflection!\n";
+    
+    return 0;
+}
+EOF
+
+echo "📝 First, let's see the traditional approach to serialization..."
+echo ""
+echo "Press Enter to see manual serialization code..."
+read
+
+cat > manual_serialization_example.cpp << 'EOF'
+// The OLD way - Manual serialization
+std::string serialize_github_user(const GitHubUser& user) {
+    std::string json = "{";
+    json += "\"login\":\"" + user.login + "\",";
+    json += "\"name\":\"" + user.name + "\",";
+    json += "\"company\":\"" + user.company + "\",";
+    json += "\"blog\":\"" + user.blog + "\",";
+    json += "\"location\":\"" + user.location + "\",";
+    
+    if (user.email.has_value()) {
+        json += "\"email\":\"" + *user.email + "\",";
+    }
+    if (user.bio.has_value()) {
+        json += "\"bio\":\"" + *user.bio + "\",";
+    }
+    
+    json += "\"public_repos\":" + std::to_string(user.public_repos) + ",";
+    json += "\"followers\":" + std::to_string(user.followers) + ",";
+    json += "\"following\":" + std::to_string(user.following);
+    json += "}";
+    
+    return json;
+}
+EOF
+
+cat manual_serialization_example.cpp
+echo ""
+echo "😓 That's error-prone and doesn't handle escaping!"
+echo ""
+echo "Press Enter to see the MODERN approach..."
+read
+
+clear
+echo "✨ The MODERN approach with C++26 reflection:"
+echo ""
+echo "Deserialization:"
+echo "    GitHubUser user = simdjson::from(json);"
+echo ""
+echo "Serialization:"
+echo "    std::string json = simdjson::builder::to_json_string(user);"
+echo ""
+echo "🤯 That's it! Bidirectional JSON handling in TWO lines!"
+echo ""
+echo "Press Enter to compile and run the complete demo..."
+read
+
+# Compile and run serialization demo
+echo "🔨 Compiling serialization demo..."
+clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 \
+    -I../deps/cpr/include -I../deps/cpr/build/cpr_generated_includes \
+    -I../include -I.. github_serialization_demo.cpp ../singleheader/simdjson.cpp \
+    ../deps/cpr/build/lib/libcpr.a -lcurl -pthread -o serialization_demo
+
+echo "✅ Compiled!"
+echo ""
+echo "🏃 Running complete round-trip demo..."
+echo ""
+./serialization_demo
+
+echo ""
+echo "Press Enter to run performance benchmarks..."
+read
+
+clear
+echo "⚡ PERFORMANCE BENCHMARKS"
+echo "========================"
+echo ""
+
+# Compile benchmark
+echo "🔨 Compiling performance benchmark..."
+clang++ -std=c++26 -freflection -O3 -march=native \
+    -DSIMDJSON_STATIC_REFLECTION=1 \
+    -I../include -I.. serialization_benchmark.cpp ../singleheader/simdjson.cpp \
+    -pthread -o serialization_benchmark
+
+echo "✅ Compiled!"
+echo ""
+echo "🏃 Running benchmark..."
+echo ""
+./serialization_benchmark
+
+echo ""
+echo "🎉 Summary:"
+echo "==========="
+echo "• ONE line for deserialization"
+echo "• ONE line for serialization"
+echo "• Works with complex nested structures"
+echo "• Handles optional fields automatically"
+echo "• Type-safe and performant"
+echo "• No manual parsing/building code needed!"
+echo ""
+echo "The future of C++ JSON handling is here! 🚀"
+
+# Cleanup
+rm -f manual_serialization_example.cpp

examples/github_legacy.cpp

@@ -0,0 +1,83 @@
+// Legacy approach - manual JSON parsing with simdjson
+#include <simdjson.h>
+#include <cpr/cpr.h>
+#include <iostream>
+#include <string>
+#include <optional>
+
+struct GitHubUser {
+    std::string login;
+    int64_t id;
+    std::string name;
+    std::optional<std::string> company;
+    std::optional<std::string> location;
+    int64_t public_repos;
+    int64_t followers;
+};
+
+// Legacy approach - manual parsing with lots of boilerplate
+GitHubUser parse_github_user(const std::string& json_str) {
+    GitHubUser user;
+    
+    simdjson::ondemand::parser parser;
+    simdjson::padded_string json(json_str);
+    simdjson::ondemand::document doc = parser.iterate(json);
+    
+    // Manual field extraction with error checking
+    user.login = std::string(doc["login"].get_string().value());
+    user.id = doc["id"].get_int64().value();
+    user.name = std::string(doc["name"].get_string().value());
+    
+    // Handle optional fields
+    auto company_result = doc["company"];
+    if (!company_result.is_null()) {
+        user.company = std::string(company_result.get_string().value());
+    }
+    
+    auto location_result = doc["location"];
+    if (!location_result.is_null()) {
+        user.location = std::string(location_result.get_string().value());
+    }
+    
+    user.public_repos = doc["public_repos"].get_int64().value();
+    user.followers = doc["followers"].get_int64().value();
+    
+    return user;
+}
+
+int main() {
+    std::cout << "📚 Legacy Approach - Manual JSON Parsing\n";
+    std::cout << "========================================\n\n";
+    
+    // Fetch data from GitHub API
+    auto response = cpr::Get(
+        cpr::Url{"https://api.github.com/users/lemire"},
+        cpr::Header{{"User-Agent", "simdjson-legacy-demo"}}
+    );
+    
+    if (response.status_code != 200) {
+        std::cerr << "❌ Failed to fetch data: HTTP " << response.status_code << "\n";
+        return 1;
+    }
+    
+    try {
+        // 😓 The old way - manual parsing with lots of code
+        GitHubUser user = parse_github_user(response.text);
+        
+        // Display results
+        std::cout << "GitHub User: " << user.name << " (@" << user.login << ")\n";
+        std::cout << "ID: " << user.id << "\n";
+        if (user.company) std::cout << "Company: " << *user.company << "\n";
+        if (user.location) std::cout << "Location: " << *user.location << "\n";
+        std::cout << "Public Repos: " << user.public_repos << "\n";
+        std::cout << "Followers: " << user.followers << "\n";
+        
+        std::cout << "\n⚠️  Notice all the manual parsing code required!\n";
+        
+    } catch (const simdjson::simdjson_error& e) {
+        std::cerr << "❌ Parsing error: " << e.what() << "\n";
+        return 1;
+    }
+    
+    return 0;
+}

examples/github_legacy_benchmark.cpp

@@ -0,0 +1,165 @@
+// Legacy approach with performance measurement
+#include <simdjson.h>
+#include <cpr/cpr.h>
+#include <iostream>
+#include <string>
+#include <optional>
+#include <chrono>
+#include <iomanip>
+#include <sstream>
+
+struct GitHubUser {
+    std::string login;
+    int64_t id;
+    std::string name;
+    std::optional<std::string> company;
+    std::optional<std::string> location;
+    int64_t public_repos;
+    int64_t followers;
+};
+
+// Manual parsing function (the old way)
+GitHubUser parse_github_user(const std::string& json_str) {
+    GitHubUser user;
+    
+    simdjson::ondemand::parser parser;
+    simdjson::padded_string json(json_str);
+    simdjson::ondemand::document doc = parser.iterate(json);
+    
+    // Manual field extraction with error checking
+    user.login = std::string(doc["login"].get_string().value());
+    user.id = doc["id"].get_int64().value();
+    user.name = std::string(doc["name"].get_string().value());
+    
+    // Handle optional fields
+    auto company_result = doc["company"];
+    if (!company_result.is_null()) {
+        user.company = std::string(company_result.get_string().value());
+    }
+    
+    auto location_result = doc["location"];
+    if (!location_result.is_null()) {
+        user.location = std::string(location_result.get_string().value());
+    }
+    
+    user.public_repos = doc["public_repos"].get_int64().value();
+    user.followers = doc["followers"].get_int64().value();
+    
+    return user;
+}
+
+// Manual serialization function (the old way)
+std::string serialize_github_user(const GitHubUser& user) {
+    std::ostringstream json;
+    json << "{";
+    json << "\"login\":\"" << user.login << "\",";
+    json << "\"id\":" << user.id << ",";
+    json << "\"name\":\"" << user.name << "\",";
+    
+    if (user.company.has_value()) {
+        json << "\"company\":\"" << *user.company << "\",";
+    } else {
+        json << "\"company\":null,";
+    }
+    
+    if (user.location.has_value()) {
+        json << "\"location\":\"" << *user.location << "\",";
+    } else {
+        json << "\"location\":null,";
+    }
+    
+    json << "\"public_repos\":" << user.public_repos << ",";
+    json << "\"followers\":" << user.followers;
+    json << "}";
+    
+    return json.str();
+}
+
+int main() {
+    std::cout << "📚 Legacy Approach - Deserialization Performance Benchmark\n";
+    std::cout << "=========================================================\n\n";
+    
+    // Fetch data from GitHub API
+    auto response = cpr::Get(
+        cpr::Url{"https://api.github.com/users/lemire"},
+        cpr::Header{{"User-Agent", "simdjson-benchmark"}}
+    );
+    
+    if (response.status_code != 200) {
+        std::cerr << "❌ Failed to fetch data: HTTP " << response.status_code << "\n";
+        return 1;
+    }
+    
+    // Warm up
+    for (int i = 0; i < 100; ++i) {
+        auto user = parse_github_user(response.text);
+    }
+    
+    // Benchmark
+    const int iterations = 10000;
+    auto start = std::chrono::high_resolution_clock::now();
+    
+    for (int i = 0; i < iterations; ++i) {
+        auto user = parse_github_user(response.text);
+        // Prevent optimization
+        if (i == 0) {
+            std::cout << "Parsing: " << user.name << " (@" << user.login << ")\n\n";
+        }
+    }
+    
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    // Calculate performance metrics
+    double time_per_parse = duration.count() / static_cast<double>(iterations);
+    double bytes_per_parse = response.text.size();
+    double gb_per_second = (bytes_per_parse * iterations) / (duration.count() * 1000.0);
+    
+    std::cout << "📊 Deserialization Performance Results:\n";
+    std::cout << "  • JSON size: " << bytes_per_parse << " bytes\n";
+    std::cout << "  • Iterations: " << iterations << "\n";
+    std::cout << "  • Total time: " << duration.count() / 1000.0 << " ms\n";
+    std::cout << "  • Time per deserialization: " << std::fixed << std::setprecision(2) << time_per_parse << " μs\n";
+    std::cout << "  • Deserialization speed: " << std::fixed << std::setprecision(2) << gb_per_second << " GB/s\n";
+    
+    // Now benchmark serialization
+    std::cout << "\n📝 Serialization Performance Benchmark\n";
+    std::cout << "=====================================\n\n";
+    
+    // Parse once to get a user object
+    auto user = parse_github_user(response.text);
+    
+    // Warm up serialization
+    for (int i = 0; i < 100; ++i) {
+        auto json_str = serialize_github_user(user);
+    }
+    
+    // Benchmark serialization
+    start = std::chrono::high_resolution_clock::now();
+    
+    for (int i = 0; i < iterations; ++i) {
+        auto json_str = serialize_github_user(user);
+        // Prevent optimization
+        if (i == 0) {
+            std::cout << "Serialized JSON size: " << json_str.length() << " bytes\n\n";
+        }
+    }
+    
+    end = std::chrono::high_resolution_clock::now();
+    duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    // Calculate serialization performance metrics
+    time_per_parse = duration.count() / static_cast<double>(iterations);
+    double serialized_size = serialize_github_user(user).length();
+    gb_per_second = (serialized_size * iterations) / (duration.count() * 1000.0);
+    
+    std::cout << "📊 Serialization Performance Results:\n";
+    std::cout << "  • JSON size: " << serialized_size << " bytes\n";
+    std::cout << "  • Iterations: " << iterations << "\n";
+    std::cout << "  • Total time: " << duration.count() / 1000.0 << " ms\n";
+    std::cout << "  • Time per serialization: " << std::fixed << std::setprecision(2) << time_per_parse << " μs\n";
+    std::cout << "  • Serialization speed: " << std::fixed << std::setprecision(2) << gb_per_second << " GB/s\n";
+    std::cout << "\n⚠️  Note: Manual serialization with string concatenation\n";
+    
+    return 0;
+}

examples/github_modern.cpp

@@ -0,0 +1,61 @@
+// Modern approach - C++26 reflection with simdjson
+// Compile with Bloomberg clang fork:
+// clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 ...
+#include <simdjson.h>
+#include <simdjson/convert.h>
+#include <cpr/cpr.h>
+#include <iostream>
+#include <string>
+#include <optional>
+
+// 🎯 JUST DECLARE YOUR STRUCT - THAT'S IT!
+// No serialization code needed with C++26 reflection
+struct GitHubUser {
+    std::string login;
+    int64_t id;
+    std::string name;
+    std::optional<std::string> company;
+    std::optional<std::string> location;
+    int64_t public_repos;
+    int64_t followers;
+};
+// NO BOILERPLATE CODE NEEDED! 🎉
+
+int main() {
+    std::cout << "✨ Modern Approach - C++26 Reflection\n";
+    std::cout << "=====================================\n\n";
+    
+    // Fetch data from GitHub API
+    auto response = cpr::Get(
+        cpr::Url{"https://api.github.com/users/lemire"},
+        cpr::Header{{"User-Agent", "simdjson-modern-demo"}}
+    );
+    
+    if (response.status_code != 200) {
+        std::cerr << "❌ Failed to fetch data: HTTP " << response.status_code << "\n";
+        return 1;
+    }
+    
+    try {
+        // ✨ THE MAGIC - Just one line, no boilerplate!
+        // C++26 reflection handles everything automatically
+        GitHubUser user = simdjson::from(simdjson::padded_string(response.text));
+        
+        // Display results
+        std::cout << "GitHub User: " << user.name << " (@" << user.login << ")\n";
+        std::cout << "ID: " << user.id << "\n";
+        if (user.company) std::cout << "Company: " << *user.company << "\n";
+        if (user.location) std::cout << "Location: " << *user.location << "\n";
+        std::cout << "Public Repos: " << user.public_repos << "\n";
+        std::cout << "Followers: " << user.followers << "\n";
+        
+        std::cout << "\n🚀 That's it! No manual parsing code needed!\n";
+        std::cout << "   C++26 reflection generates everything automatically.\n";
+        
+    } catch (const simdjson::simdjson_error& e) {
+        std::cerr << "❌ Parsing error: " << e.what() << "\n";
+        return 1;
+    }
+    
+    return 0;
+}

examples/github_modern_benchmark.cpp

@@ -0,0 +1,86 @@
+// Modern approach with performance measurement - C++26 reflection
+#include <simdjson.h>
+#include <simdjson/convert.h>
+#include <cpr/cpr.h>
+#include <iostream>
+#include <string>
+#include <optional>
+#include <chrono>
+#include <iomanip>
+#include <sstream>
+
+// Just declare your struct - reflection handles the rest!
+struct GitHubUser {
+    std::string login;
+    int64_t id;
+    std::string name;
+    std::optional<std::string> company;
+    std::optional<std::string> location;
+    int64_t public_repos;
+    int64_t followers;
+};
+
+int main() {
+    std::cout << "✨ Modern Approach - Deserialization Performance Benchmark (C++26)\n";
+    std::cout << "================================================================\n\n";
+    
+    // Fetch data from GitHub API
+    auto response = cpr::Get(
+        cpr::Url{"https://api.github.com/users/lemire"},
+        cpr::Header{{"User-Agent", "simdjson-benchmark"}}
+    );
+    
+    if (response.status_code != 200) {
+        std::cerr << "❌ Failed to fetch data: HTTP " << response.status_code << "\n";
+        return 1;
+    }
+    
+    // Warm up
+    for (int i = 0; i < 100; ++i) {
+        GitHubUser user = simdjson::from(simdjson::padded_string(response.text));
+    }
+    
+    // Benchmark
+    const int iterations = 10000;
+    auto start = std::chrono::high_resolution_clock::now();
+    
+    for (int i = 0; i < iterations; ++i) {
+        GitHubUser user = simdjson::from(simdjson::padded_string(response.text));
+        // Prevent optimization
+        if (i == 0) {
+            std::cout << "Parsing: " << user.name << " (@" << user.login << ")\n\n";
+        }
+    }
+    
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    // Calculate performance metrics
+    double time_per_parse = duration.count() / static_cast<double>(iterations);
+    double bytes_per_parse = response.text.size();
+    double gb_per_second = (bytes_per_parse * iterations) / (duration.count() * 1000.0);
+    
+    std::cout << "📊 Deserialization Performance Results:\n";
+    std::cout << "  • JSON size: " << bytes_per_parse << " bytes\n";
+    std::cout << "  • Iterations: " << iterations << "\n";
+    std::cout << "  • Total time: " << duration.count() / 1000.0 << " ms\n";
+    std::cout << "  • Time per deserialization: " << std::fixed << std::setprecision(2) << time_per_parse << " μs\n";
+    std::cout << "  • Deserialization speed: " << std::fixed << std::setprecision(2) << gb_per_second << " GB/s\n";
+    
+    std::cout << "\n🚀 Same performance, just ONE line of deserialization code!\n";
+    
+    // Serialization note
+    std::cout << "\n📝 Serialization with Reflection\n";
+    std::cout << "================================\n\n";
+    std::cout << "⚠️  NOTE: simdjson doesn't yet support reflection-based serialization.\n";
+    std::cout << "   The `simdjson::to` function is not yet implemented.\n";
+    std::cout << "   This is a future enhancement that would provide:\n";
+    std::cout << "   • One-line serialization: simdjson::to<std::string>(user)\n";
+    std::cout << "   • Automatic JSON generation from C++ structs\n";
+    std::cout << "   • No manual string building required\n";
+    std::cout << "\n";
+    std::cout << "   For now, serialization still requires manual implementation,\n";
+    std::cout << "   but deserialization is fully automated with reflection! 🎉\n";
+    
+    return 0;
+}

examples/github_serialization_demo.cpp

@@ -0,0 +1,95 @@
+#include <iostream>
+#include <iomanip>
+#include "simdjson.h"
+#include <cpr/cpr.h>
+
+struct GitHubUser {
+    std::string login;
+    std::optional<std::string> name;
+    std::optional<std::string> company;
+    std::optional<std::string> blog;
+    std::optional<std::string> location;
+    std::optional<std::string> email;
+    std::optional<std::string> bio;
+    int64_t public_repos;
+    int64_t followers;
+    int64_t following;
+};
+
+int main() {
+    std::cout << "🔄 C++26 Reflection: Complete JSON Round-Trip Demo\n";
+    std::cout << "================================================\n\n";
+    
+    // Step 1: Fetch real data from GitHub
+    std::cout << "📡 Fetching GitHub user data...\n";
+    auto response = cpr::Get(cpr::Url{"https://api.github.com/users/simdjson"});
+    
+    if (response.status_code != 200) {
+        std::cerr << "Error: Failed to fetch data\n";
+        return 1;
+    }
+    
+    std::cout << "✅ Received " << response.text.length() << " bytes of JSON\n\n";
+    
+    // Step 2: Deserialize with ONE LINE
+    std::cout << "📥 DESERIALIZATION (JSON → Struct)\n";
+    std::cout << "Code: GitHubUser user = simdjson::from(simdjson::padded_string(response.text));\n\n";
+    
+    GitHubUser user = simdjson::from(simdjson::padded_string(response.text));
+    
+    // Show the data we parsed
+    std::cout << "Parsed data:\n";
+    std::cout << "  • Login: " << user.login << "\n";
+    std::cout << "  • Name: " << (user.name.has_value() ? *user.name : "<not set>") << "\n";
+    std::cout << "  • Company: " << (user.company.has_value() ? *user.company : "<not set>") << "\n";
+    std::cout << "  • Location: " << (user.location.has_value() ? *user.location : "<not set>") << "\n";
+    std::cout << "  • Bio: " << (user.bio.has_value() ? *user.bio : "<not set>") << "\n";
+    std::cout << "  • Repos: " << user.public_repos << "\n";
+    std::cout << "  • Followers: " << user.followers << "\n\n";
+    
+    // Step 3: Modify the data
+    std::cout << "✏️  Modifying data...\n";
+    user.followers += 1000;  // Wishful thinking!
+    user.name = "simdjson - JSON at the speed of light";  // Set a name
+    user.bio = user.bio.value_or("") + " (Now with C++26 reflection!)";
+    std::cout << "  • Added 1000 followers (we can dream!)\n";
+    std::cout << "  • Set organization name\n";
+    std::cout << "  • Updated bio\n\n";
+    
+    // Step 4: Serialize back to JSON with ONE LINE
+    std::cout << "📤 SERIALIZATION (Struct → JSON)\n";
+    std::cout << "Code: std::string json = simdjson::builder::to_json_string(user);\n\n";
+    
+    auto json_result = simdjson::builder::to_json_string(user);
+    if (json_result.error()) {
+        std::cerr << "Serialization error!\n";
+        return 1;
+    }
+    std::string json = json_result.value();
+    
+    std::cout << "Generated JSON (" << json.length() << " bytes):\n";
+    // Pretty print first 200 chars
+    if (json.length() > 200) {
+        std::cout << json.substr(0, 200) << "...\n\n";
+    } else {
+        std::cout << json << "\n\n";
+    }
+    
+    // Step 5: Verify round-trip
+    std::cout << "🔄 ROUND-TRIP VERIFICATION\n";
+    std::cout << "Parsing our generated JSON back...\n";
+    
+    GitHubUser user2 = simdjson::from(simdjson::padded_string(json));
+    
+    std::cout << "✅ Round-trip successful!\n";
+    std::cout << "  • Original followers: " << user.followers << "\n";
+    std::cout << "  • Parsed followers: " << user2.followers << "\n";
+    std::cout << "  • Name set correctly: " << (user2.name.has_value() && *user2.name == *user.name ? "YES" : "NO") << "\n";
+    std::cout << "  • Bio preserved: " << (user2.bio.has_value() ? "YES" : "NO") << "\n\n";
+    
+    std::cout << "🎉 That's it! Two lines of code for complete JSON handling:\n";
+    std::cout << "   • Deserialization: simdjson::from(...)\n";
+    std::cout << "   • Serialization: simdjson::builder::to_json_string(...)\n";
+    
+    return 0;
+}

examples/reflection_roundtrip_demo.cpp

@@ -0,0 +1,86 @@
+// Complete JSON Round-Trip Demo with C++26 Reflection
+// Compile with: clang++ -std=c++26 -freflection -DSIMDJSON_STATIC_REFLECTION=1 reflection_roundtrip_demo.cpp ../singleheader/simdjson.cpp -o reflection_roundtrip_demo
+#include <iostream>
+#include <vector>
+#include <optional>
+#include "simdjson.h"
+
+// Define our data structure - just a plain struct!
+struct Product {
+    std::string name;
+    double price;
+    std::vector<std::string> tags;
+    std::optional<std::string> description;
+    bool in_stock;
+};
+
+int main() {
+    std::cout << "🔄 simdjson C++26 Reflection Round-Trip Demo\n";
+    std::cout << "============================================\n\n";
+    
+    // Original JSON data
+    const char* json_data = R"({
+        "name": "High-Performance JSON Parser",
+        "price": 0.0,
+        "tags": ["C++", "performance", "json", "reflection"],
+        "description": "The fastest JSON parser with C++26 reflection support",
+        "in_stock": true
+    })";
+    
+    std::cout << "📄 Original JSON:\n" << json_data << "\n\n";
+    
+    // Step 1: Deserialize JSON to struct with ONE line
+    std::cout << "📥 Deserializing JSON → Struct...\n";
+    Product product = simdjson::from(simdjson::padded_string(json_data));
+    
+    std::cout << "✅ Deserialized successfully!\n";
+    std::cout << "   • Name: " << product.name << "\n";
+    std::cout << "   • Price: $" << product.price << "\n";
+    std::cout << "   • Tags: ";
+    for (const auto& tag : product.tags) {
+        std::cout << tag << " ";
+    }
+    std::cout << "\n   • In stock: " << (product.in_stock ? "Yes" : "No") << "\n\n";
+    
+    // Step 2: Modify the data
+    std::cout << "✏️  Modifying data...\n";
+    product.price = 99.99;  // It's worth something now!
+    product.tags.push_back("C++26");
+    product.description = "Now with serialization support!";
+    std::cout << "   • Changed price to $99.99\n";
+    std::cout << "   • Added 'C++26' tag\n";
+    std::cout << "   • Updated description\n\n";
+    
+    // Step 3: Serialize struct back to JSON with ONE line
+    std::cout << "📤 Serializing Struct → JSON...\n";
+    auto json_result = simdjson::builder::to_json_string(product);
+    
+    if (json_result.error()) {
+        std::cerr << "❌ Serialization failed!\n";
+        return 1;
+    }
+    
+    std::string new_json = json_result.value();
+    std::cout << "✅ Serialized successfully!\n\n";
+    
+    std::cout << "📄 Generated JSON:\n" << new_json << "\n\n";
+    
+    // Step 4: Verify round-trip by parsing again
+    std::cout << "🔍 Verifying round-trip...\n";
+    Product product2 = simdjson::from(simdjson::padded_string(new_json));
+    
+    std::cout << "✅ Round-trip successful!\n";
+    std::cout << "   • Price preserved: $" << product2.price << "\n";
+    std::cout << "   • New tag present: " 
+              << (std::find(product2.tags.begin(), product2.tags.end(), "C++26") != product2.tags.end() ? "Yes" : "No") 
+              << "\n";
+    std::cout << "   • Description updated: " << (product2.description.has_value() ? "Yes" : "No") << "\n\n";
+    
+    std::cout << "🎉 That's it! Complete JSON handling in just 2 lines:\n";
+    std::cout << "   • Deserialize: auto obj = simdjson::from(json);\n";
+    std::cout << "   • Serialize: auto json = simdjson::builder::to_json_string(obj);\n\n";
+    
+    std::cout << "⚡ No manual parsing, no boilerplate, just pure C++26 magic!\n";
+    
+    return 0;
+}

examples/serialization_benchmark.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <iomanip>
+#include <chrono>
+#include "simdjson.h"
+#include <map>
+
+struct TestData {
+    std::string name;
+    std::vector<int> numbers;
+    std::map<std::string, double> metrics;
+    bool active;
+    std::optional<std::string> description;
+};
+
+int main() {
+    std::cout << "⚡ Serialization Performance Benchmark\n";
+    std::cout << "=====================================\n\n";
+    
+    // Create test data
+    TestData data{
+        .name = "Performance Test",
+        .numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+        .metrics = {{"latency", 1.23}, {"throughput", 456.78}, {"cpu", 89.01}},
+        .active = true,
+        .description = "Testing reflection-based serialization performance"
+    };
+    
+    const int iterations = 100000;
+    
+    // Benchmark serialization
+    std::cout << "📤 Benchmarking serialization (" << iterations << " iterations)...\n";
+    
+    auto start = std::chrono::high_resolution_clock::now();
+    
+    std::string json;
+    for (int i = 0; i < iterations; i++) {
+        auto result = simdjson::builder::to_json_string(data);
+        if (i == 0 && !result.error()) {
+            json = result.value();
+        }
+    }
+    
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    std::cout << "\nResults:\n";
+    std::cout << "  • Generated JSON size: " << json.length() << " bytes\n";
+    std::cout << "  • Total time: " << duration.count() / 1000.0 << " ms\n";
+    
+    double time_per_iteration_us = duration.count() / double(iterations);
+    double time_per_iteration_s = time_per_iteration_us / 1000000.0;
+    double bytes_per_second = json.length() / time_per_iteration_s;
+    double mb_per_second = bytes_per_second / (1024.0 * 1024.0);
+    
+    std::cout << "  • Time per serialization: " << std::fixed << std::setprecision(2) << time_per_iteration_us << " μs\n";
+    std::cout << "  • Throughput: " << std::fixed << std::setprecision(2) << mb_per_second << " MB/s\n";
+    
+    std::cout << "\nGenerated JSON:\n" << json << "\n\n";
+    
+    // Benchmark deserialization for comparison
+    std::cout << "📥 Benchmarking deserialization (for comparison)...\n";
+    
+    simdjson::padded_string padded_json(json);
+    start = std::chrono::high_resolution_clock::now();
+    
+    for (int i = 0; i < iterations; i++) {
+        TestData parsed = simdjson::from(padded_json);
+    }
+    
+    end = std::chrono::high_resolution_clock::now();
+    duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+    
+    std::cout << "\nResults:\n";
+    time_per_iteration_us = duration.count() / double(iterations);
+    time_per_iteration_s = time_per_iteration_us / 1000000.0;
+    bytes_per_second = json.length() / time_per_iteration_s;
+    mb_per_second = bytes_per_second / (1024.0 * 1024.0);
+    
+    std::cout << "  • Time per deserialization: " << std::fixed << std::setprecision(2) << time_per_iteration_us << " μs\n";
+    std::cout << "  • Throughput: " << std::fixed << std::setprecision(2) << mb_per_second << " MB/s\n";
+    
+    std::cout << "\n✅ Both serialization and deserialization work with reflection!\n";
+    
+    return 0;
+}

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

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

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/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,123 +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>
-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 simdjson_result<T>() noexcept(is_nothrow_gettable<T>) {
-  return result<T>();
-}
-
-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};
-}
-} // namespace internal
-} // namespace convert
-} // namespace simdjson
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
-#endif // SIMDJSON_CONVERT_INL_H

include/simdjson/convert.h

@@ -1,111 +1,307 @@
-
 #ifndef SIMDJSON_CONVERT_H
 #define SIMDJSON_CONVERT_H
+#if __cpp_concepts
 
 #include "simdjson/ondemand.h"
 #include <optional>
-
-#if SIMDJSON_SUPPORTS_CONCEPTS
-
+#ifdef __cpp_lib_ranges
+#include <ranges>
+#endif
 
 namespace simdjson {
-namespace convert {
-namespace internal {
+
+struct [[nodiscard]] auto_iterator_end {};
 
 /**
- * A utility class for automatically parsing JSON documents.
- * This template is NOT part of our public API.
- * It is subject to changes.
- * @private
+ * A Wrapper for simdjson_result<ondemand::array_iterator> in order to make it
+ * compatible with ranges (to satisfy std::ranges::input_range).
  */
-template <typename parser_type = ondemand::parser*>
-struct auto_parser {
+struct [[nodiscard]] auto_iterator {
+  using iterator_category = std::forward_iterator_tag;
+  using type = simdjson_result<ondemand::array_iterator>;
+  using value_type = simdjson_result<ondemand::value>; // type::value_type
+  using reference = value_type &;
+  using const_reference = const value_type &;
+  using difference_type = std::ptrdiff_t;
+
+  struct auto_iterator_storage {
+    type m_iter{};
+    mutable value_type m_value{};
+  };
+
 private:
-	parser_type m_parser;
-	ondemand::document m_doc;
-	error_code m_error{SUCCESS};
+  auto_iterator_storage *m_storage = nullptr;
 
-	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;
+  constexpr auto_iterator() noexcept = default;
+  explicit auto_iterator(auto_iterator_storage &storage) noexcept
+      : m_storage{&storage} {};
+  auto_iterator(auto_iterator const &) = default;
+  auto_iterator(auto_iterator &&) = default;
+  auto_iterator &operator=(auto_iterator const &) = default;
+  auto_iterator &operator=(auto_iterator &&) noexcept = default;
+  ~auto_iterator() = default;
 
-	simdjson_warn_unused std::remove_pointer_t<parser_type> &parser() noexcept;
+  reference operator*() const noexcept { return m_storage->m_value; }
+  reference operator*() noexcept { return m_storage->m_value; }
 
-	template <typename T>
-	simdjson_warn_unused simdjson_inline simdjson_result<T> result() noexcept(is_nothrow_gettable<T>);
+  auto_iterator &operator++() noexcept {
+    ++m_storage->m_iter;
+    m_storage->m_value =
+        m_storage->m_iter.at_end() || m_storage->m_iter.error() != SUCCESS
+            ? value_type{}
+            : *m_storage->m_iter;
+    return *this;
+  }
+  auto_iterator operator++(int) noexcept {
+    auto_iterator const tmp = *this;
+    operator++();
+    return tmp;
+  }
 
-	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;
+  [[nodiscard]] bool operator==(auto_iterator const &other) const noexcept {
+    return m_storage == other.m_storage &&
+           m_storage->m_iter == other.m_storage->m_iter;
+  }
 
-	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>);
+  [[nodiscard]] bool operator==(auto_iterator_end) const noexcept {
+    return m_storage != nullptr && m_storage->m_iter.at_end();
+  }
 };
 
+template <typename ParserType = ondemand::parser>
+struct [[nodiscard]] auto_parser
+#if __cpp_lib_ranges
+    : std::ranges::view_interface<auto_parser<ParserType>>
+#endif
+{
+  using value_type = simdjson_result<ondemand::value>;
+  using size_type = size_t;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type *;
+  using const_pointer = const value_type *;
+  using reference = value_type &;
+  using const_reference = const value_type &;
+  using iterator = auto_iterator;
+  using const_iterator = auto_iterator; // auto_iterator is already const
+
+private:
+  ParserType m_parser;
+  ondemand::document m_doc;
+  error_code m_error{SUCCESS};
+
+  // Caching the iterator here:
+  iterator::auto_iterator_storage iter_storage{};
+
+  template <typename T>
+  static constexpr bool is_nothrow_gettable = requires(ondemand::document doc) {
+    { doc.get<T>() } noexcept;
+  };
+
+public:
+  // non-pointer constructors:
+  explicit auto_parser(ParserType &&parser, ondemand::document &&doc) noexcept
+    requires(!std::is_pointer_v<ParserType>)
+      : m_parser{std::move(parser)}, m_doc{std::move(doc)} {}
+
+  explicit auto_parser(ParserType &&parser,
+                       padded_string_view const str) noexcept
+    requires(!std::is_pointer_v<ParserType>)
+      : m_parser{std::move(parser)}, m_doc{}, m_error{SUCCESS} {
+    m_error = m_parser.iterate(str).get(m_doc);
+  }
+
+  explicit auto_parser(padded_string_view const str) noexcept
+    requires(!std::is_pointer_v<ParserType>)
+      : auto_parser{ParserType{}, str} {}
+
+  // pointer constructors:
+  explicit auto_parser(std::remove_pointer_t<ParserType> &parser,
+                       ondemand::document &&doc) noexcept
+    requires(std::is_pointer_v<ParserType>)
+      : m_parser{&parser}, m_doc{std::move(doc)} {}
+
+  explicit auto_parser(std::remove_pointer_t<ParserType> &parser,
+                       padded_string_view const str) noexcept
+    requires(std::is_pointer_v<ParserType>)
+      : m_parser{&parser}, m_doc{}, m_error{SUCCESS} {
+    m_error = m_parser->iterate(str).get(m_doc);
+  }
+
+  explicit auto_parser(ParserType parser, ondemand::document &&doc) noexcept
+    requires(std::is_pointer_v<ParserType>)
+      : auto_parser{*parser, std::move(doc)} {}
+
+  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;
+
+  /// Get the parser
+  [[nodiscard]] std::remove_pointer_t<ParserType> &parser() noexcept {
+    if constexpr (std::is_pointer_v<ParserType>) {
+      return *m_parser;
+    } else {
+      return m_parser;
+    }
+  }
+
+  template <typename T>
+  [[nodiscard]] simdjson_inline simdjson_result<T>
+  result() noexcept(is_nothrow_gettable<T>) {
+    if (m_error != SUCCESS) {
+      return m_error;
+    }
+    // For array and object types, we need to be at the start of the document
+    return m_doc.get<T>();
+  }
+
+  [[nodiscard]] simdjson_inline simdjson_result<ondemand::array>
+  array() noexcept {
+    return result<ondemand::array>();
+  }
+
+  [[nodiscard]] simdjson_inline simdjson_result<ondemand::object>
+  object() noexcept {
+    return result<ondemand::object>();
+  }
+
+  [[nodiscard]] simdjson_inline simdjson_result<ondemand::number>
+  number() noexcept {
+    return result<ondemand::number>();
+  }
+
+  template <typename T>
+  [[nodiscard]] simdjson_inline explicit(false)
+  operator simdjson_result<T>() noexcept(is_nothrow_gettable<T>) {
+    return result<T>();
+  }
+
+  template <typename T>
+  [[nodiscard]] simdjson_inline explicit(false) operator T() noexcept(false) {
+    if (m_error != SUCCESS) {
+      throw simdjson_error(m_error);
+    }
+    return m_doc.get<T>();
+  }
+
+  // We can't have "operator std::optional<T>" because it would create an
+  // ambiguity for the compiler.
+  // We also cannot have "operator T*" without manual memory management.
+  // We also cannot have "operator T&" without manual memory management either.
+
+  template <typename T>
+  [[nodiscard]] simdjson_inline std::optional<T>
+  optional() noexcept(is_nothrow_gettable<T>) {
+    if (m_error != SUCCESS) {
+      return std::nullopt;
+    }
+    T value;
+    // For std::optional<T>
+    if (m_doc.get<T>().get(value)) [[unlikely]] {
+      return std::nullopt;
+    }
+    return {std::move(value)};
+  }
+
+  simdjson_inline auto_iterator begin() noexcept {
+    if (m_error != SUCCESS) {
+      // Create an iterator with the error
+      iter_storage.m_iter = iterator::type(m_error);
+      iter_storage.m_value = value_type{};
+      return auto_iterator{iter_storage};
+    }
+    if (iter_storage.m_iter.error() != SUCCESS &&
+        !iter_storage.m_iter.at_end()) {
+      // Try to get the document as an array
+      ondemand::array arr;
+      if(auto error = m_doc.get_array().get(arr); error == SUCCESS) {
+        iter_storage = {.m_iter = iterator::type{arr.begin()},
+                        .m_value = iterator::value_type{
+                            iter_storage.m_iter.at_end() ||
+                                    iter_storage.m_iter.error() != SUCCESS
+                                ? value_type{}
+                                : *iter_storage.m_iter}};
+      } else {
+        // If it's not an array, create an error iterator
+        iter_storage.m_iter = iterator::type(error);
+        iter_storage.m_value = value_type{};
+      }
+    }
+    return auto_iterator{iter_storage};
+  }
+  simdjson_inline auto_iterator_end end() noexcept { return {}; }
+};
+
+#ifdef __cpp_lib_ranges
+
+// For C++20, we implement our own pipe operator since range_adaptor_closure is C++23
+static constexpr struct [[nodiscard]] no_errors_adaptor {
+
+  [[nodiscard]] bool
+  operator()(simdjson_result<ondemand::value> const &val) const noexcept {
+    return val.error() == SUCCESS;
+  }
+
+  template <std::ranges::range Range>
+  auto operator()(Range &&rng) const noexcept {
+    return std::forward<Range>(rng) | std::views::filter(*this);
+  }
+} no_errors;
 
-/**
- * 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;
-};
-} // namespace internal
-} // namespace convert
+struct [[nodiscard]] to_adaptor {
 
-/**
- * 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{};
+  /// Convert to T
+  [[nodiscard]] T
+  operator()(simdjson_result<ondemand::value> &val) const noexcept {
+    return val.get<T>();
+  }
+
+  /// Make it an adaptor
+  template <std::ranges::range Range>
+  auto operator()(Range &&rng) const noexcept {
+    return std::forward<Range>(rng) | no_errors | std::views::transform(*this);
+  }
+
+  /**
+   * Parse input string into any object if possible.
+   */
+  auto operator()(padded_string_view const str) const noexcept {
+    return auto_parser{str};
+  }
+
+  /**
+   * Parse the input using the specified parser into any object if possible.
+   */
+  auto operator()(ondemand::parser &parser,
+                            padded_string_view const str) const noexcept {
+    return auto_parser<ondemand::parser *>{parser, str};
+  }
+};
+
+template <typename T> static constexpr to_adaptor<T> to{};
+
+static constexpr to_adaptor<> from{};
+
+template <typename T = void>
+using as = to_adaptor<T>;
+
+// For C++20 ranges without range_adaptor_closure, we need to define pipe operators
+template <std::ranges::range Range>
+inline auto operator|(Range&& range, const no_errors_adaptor& adaptor) {
+  return adaptor(std::forward<Range>(range));
+}
+
+template <std::ranges::range Range, typename T>
+inline auto operator|(Range&& range, const to_adaptor<T>& adaptor) {
+  return adaptor(std::forward<Range>(range));
+}
+
+#endif // __cpp_lib_ranges
 
 } // namespace simdjson
 
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
-#endif // SIMDJSON_CONVERT_H
+#endif // __cpp_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(std::string_view path) &&  = delete ;
+  inline simdjson_result<element> load(const std::string &path) & noexcept;
+  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, std::string_view path) && =delete;
+  inline simdjson_result<element> load_into_document(document& doc, const std::string &path) & noexcept;
+  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/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_result<T>::get(T &value) && noexcept {
+simdjson_warn_unused simdjson_inline error_code 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 {
-    static_assert(std::is_same<U, std::string_view>::value, "SFINAE");
-    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;
-  }
-
+  simdjson_warn_unused simdjson_inline error_code get(std::string &value) && noexcept
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
+  requires (!std::is_same_v<T, std::string>)
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
+  ;
   /**
    * 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/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);
 
   /**

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.h

@@ -62,7 +62,7 @@ public:
   /**
    * Check if the array is at the end.
    */
-  simdjson_warn_unused simdjson_inline bool at_end() const noexcept;
+  [[nodiscard]] simdjson_inline bool at_end() const noexcept;
 
 private:
   value_iterator iter{};
@@ -95,7 +95,7 @@ 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 simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array_iterator> &operator++() noexcept;
 
-  simdjson_warn_unused simdjson_inline bool at_end() const noexcept;
+  [[nodiscard]] 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
@@ -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.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 */
@@ -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.
-   * 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.
+   * @error TAPE_ERROR when the JSON value is a bad token like "}" "," or "alse".
    */
   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

@@ -89,6 +89,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 +106,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 +143,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));
-  template for (constexpr auto enum_val : enumerators) {
-    constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));
+  std::string_view result = "<unnamed>";
+  [:expand(std::meta::enumerators_of(^^T)):] >> [&]<auto enum_val>{
     if (e == [:enum_val:]) {
-      b.append_raw(enum_str);
-      return;
+      result = std::meta::identifier_of(enum_val);
     }
   };
-  // Fallback to integer if enum value not found
-  atom(b, static_cast<std::underlying_type_t<T>>(e));
+
+  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 +241,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:]);
@@ -294,7 +302,6 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   return SIMDJSON_IMPLEMENTATION::builder::to_json_string(z, initial_capacity);
 }
 } // namespace simdjson
-
 #endif // SIMDJSON_STATIC_REFLECTION
 
 #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",
-    "\\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"};
+    "\\x0000", "\\x0001", "\\x0002", "\\x0003", "\\x0004", "\\x0005", "\\x0006",
+    "\\x0007", "\\x0008", "\\t",     "\\n",     "\\x000b", "\\f",     "\\r",
+    "\\x000e", "\\x000f", "\\x0010", "\\x0011", "\\x0012", "\\x0013", "\\x0014",
+    "\\x0015", "\\x0016", "\\x0017", "\\x0018", "\\x0019", "\\x001a", "\\x001b",
+    "\\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),
@@ -491,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) {
@@ -630,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,

include/simdjson/generic/ondemand/json_string_builder.h

@@ -118,23 +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
-  // 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.
@@ -227,22 +210,6 @@ private:
 
 }
 }
-
-
-#if !SIMDJSON_STATIC_REFLECTION
-// fallback implementation until we have static reflection
-template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
-  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);
-}
-#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 {
-  if (!s.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
   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);
-}
-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);
+  return iterate_many(s.data(), s.length(), 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
-      The string instance might be have its capacity extended. Note that this can still
-      result in AddressSanitizer: container-overflow in some cases. */
+  /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */
   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)
-    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;
+  inline simdjson_result<document_stream> iterate_many(const std::string &&s, size_t batch_size, bool allow_comma_separated = false) = delete;// unsafe
   /** @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 {
-  return reinterpret_cast<const char *>(buf);
-}
+simdjson_inline const char * raw_json_string::raw() const noexcept { 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
@@ -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;
@@ -275,6 +276,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 {
@@ -285,8 +312,9 @@ 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()))) {
-        if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
+
+  [: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
       // as long we are succesful or the field is not found, we continue
@@ -305,15 +333,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) {
-    if (str == std::meta::identifier_of(enum_val)) {
+
+  bool found = false;
+  [: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;
@@ -553,4 +582,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,13 +66,13 @@ 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>) {
@@ -97,7 +97,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. "
@@ -817,22 +817,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.
-   * 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.
+   * Get the type of this JSON value.
    *
    * 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/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
+#endif // SIMDJSON_JSONPATHUTIL_H

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_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;
-  for (size_t i = s.size(); i > 0; i--) {
-    char c = s[i - 1];
-    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());
+  const auto len = s.size();
+  s.append(SIMDJSON_PADDING, ' ');
+  return padded_string_view(s.data(), len, 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/simdjson_version.h

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.0.1"
+#define SIMDJSON_VERSION "4.0.0"
 
 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 0
 };
 } // namespace simdjson
 

p2996/README.md

@@ -78,36 +78,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
@@ -483,42 +480,11 @@ 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():
-    """Scan include/simdjson/*/implementation.h and compare with IMPLEMENTATIONS list."""
-    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')
 

singleheader/simdjson.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2025-09-12 19:26:22 -0400. version 4.0.1 Do not edit! */
+/* auto-generated on 2025-08-05 16:29:59 +0000. version 4.0.0 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -108,38 +108,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
@@ -193,22 +179,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)
@@ -1069,9 +1039,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:
@@ -2590,10 +2560,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
@@ -2654,27 +2620,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.
    *
@@ -2708,42 +2655,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;
 
@@ -2758,7 +2675,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.
    */
@@ -2790,33 +2706,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 {
-    static_assert(std::is_same<U, std::string_view>::value, "SFINAE");
-    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;
-  }
-
+  simdjson_warn_unused simdjson_inline error_code get(std::string &value) && noexcept
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
+  requires (!std::is_same_v<T, std::string>)
+#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
+  ;
   /**
    * 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.
    *
@@ -2887,7 +2794,7 @@ inline const std::string error_message(int error) noexcept;
 /* begin file simdjson/concepts.h */
 #ifndef SIMDJSON_CONCEPTS_H
 #define SIMDJSON_CONCEPTS_H
-#if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_DESERIALIZATION
 
 #include <concepts>
 #include <type_traits>
@@ -2919,9 +2826,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*>;
@@ -3015,65 +2920,9 @@ 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
 /* end file simdjson/concepts.h */
-/* including simdjson/constevalutil.h: #include "simdjson/constevalutil.h" */
-/* begin file simdjson/constevalutil.h */
-#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
-/* end file simdjson/constevalutil.h */
 
 /**
  * @brief The top level simdjson namespace, containing everything the library provides.
@@ -4801,38 +4650,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()); }
@@ -4857,7 +4676,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;
@@ -4893,11 +4711,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_result<T>::get(T &value) && noexcept {
+simdjson_warn_unused simdjson_inline error_code 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();
@@ -9288,11 +9122,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
 
   /**
@@ -9300,16 +9129,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);
 
   /**
@@ -10728,37 +10547,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()); }
@@ -15772,11 +15562,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
 
   /**
@@ -15784,16 +15569,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);
 
   /**
@@ -17212,37 +16987,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()); }
@@ -22111,11 +21857,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
 
   /**
@@ -22123,16 +21864,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);
 
   /**
@@ -23551,37 +23282,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()); }
@@ -28607,11 +28309,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
 
   /**
@@ -28619,16 +28316,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);
 
   /**
@@ -30047,37 +29734,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()); }
@@ -35462,11 +35120,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
 
   /**
@@ -35474,16 +35127,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);
 
   /**
@@ -36902,37 +36545,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()); }
@@ -42139,11 +41753,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
 
   /**
@@ -42151,16 +41760,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);
 
   /**
@@ -43579,37 +43178,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()); }
@@ -48262,11 +47832,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
 
   /**
@@ -48274,16 +47839,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);
 
   /**
@@ -49702,37 +49257,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()); }
@@ -53977,11 +53503,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
 
   /**
@@ -53989,16 +53510,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);
 
   /**
@@ -55417,37 +54928,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()); }

tests/builder/builder_string_builder_tests.cpp

@@ -1,8 +1,6 @@
 #include "simdjson.h"
 #include "test_builder.h"
 #include <string_view>
-#include <string>
-#include <map>
 
 using namespace simdjson;
 
@@ -16,66 +14,6 @@ struct Car {
 namespace builder_tests {
   using namespace std;
 
-    bool allchar_test() {
-        TEST_START();
-        auto get_utf8_codepoints = []() -> std::string {
-            std::string result;
-            for (char32_t cp = 0; cp <= 0x10FFFF; ++cp) {
-                if ((cp >= 0xD800 && cp <= 0xDFFF) || cp > 0x10FFFF) {
-                    continue; // Skip surrogate pairs and invalid codepoints
-                }
-                if (cp < 0x80) {
-                    result += static_cast<char>(cp);
-                } else if (cp < 0x800) {
-                    result += static_cast<char>(0xC0 | (cp >> 6));
-                    result += static_cast<char>(0x80 | (cp & 0x3F));
-                } else if (cp < 0x10000) {
-                    result += static_cast<char>(0xE0 | (cp >> 12));
-                    result += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-                    result += static_cast<char>(0x80 | (cp & 0x3F));
-                } else {
-                    result += static_cast<char>(0xF0 | (cp >> 18));
-                    result += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
-                    result += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-                    result += static_cast<char>(0x80 | (cp & 0x3F));
-                }
-            }
-            return result;
-        };
-        auto allutf8 = get_utf8_codepoints();
-        simdjson::builder::string_builder sb;
-        sb.start_object();
-        sb.append_key_value("input", allutf8);
-        sb.end_object();
-        std::string_view p;
-        ASSERT_TRUE(sb.validate_unicode());
-        auto result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        simdjson::padded_string output = p;
-        simdjson::ondemand::parser parser;
-        simdjson::ondemand::document doc;
-        ASSERT_SUCCESS(parser.iterate(output).get(doc));
-        std::string_view recovered;
-        ASSERT_SUCCESS(doc["input"].get(recovered));
-        ASSERT_EQUAL(recovered, allutf8);
-        simdjson::dom::parser domparser;
-        simdjson::dom::element elem;
-        ASSERT_SUCCESS(domparser.parse(output).get(elem));
-        ASSERT_SUCCESS(elem["input"].get(recovered));
-        ASSERT_EQUAL(recovered, allutf8);
-        TEST_SUCCEED();
-    }
-
-    bool bad_utf8_test() {
-        TEST_START();
-        std::string bad_utf8 = "\xFF";
-        simdjson::builder::string_builder sb;
-        sb.start_object();
-        sb.append_key_value("input", bad_utf8);
-        sb.end_object();
-        ASSERT_FALSE(sb.validate_unicode())
-        TEST_SUCCEED();
-    }
     #if SIMDJSON_EXCEPTIONS
     bool string_convertion_except() {
         TEST_START();
@@ -369,7 +307,6 @@ namespace builder_tests {
         builder.end_object();
     }
 
-
     bool car_test() {
         TEST_START();
         simdjson::builder::string_builder sb;
@@ -381,120 +318,6 @@ namespace builder_tests {
         ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
         TEST_SUCCEED();
     }
-    #if SIMDJSON_SUPPORTS_CONCEPTS
-    bool serialize_optional() {
-        TEST_START();
-        simdjson::builder::string_builder sb;
-        std::optional<std::string> optional_string = "Hello, World!";
-        sb.append(optional_string);
-        std::string_view p;
-        auto result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        ASSERT_EQUAL(p, "\"Hello, World!\"");
-        sb.clear();
-        std::optional<std::string> optional_string_null = std::nullopt;
-        sb.append(optional_string_null);
-        result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        ASSERT_EQUAL(p, "null");
-        TEST_SUCCEED();
-    }
-    #endif
-
-    #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
-    void serialize_car_simple(const Car& car, simdjson::builder::string_builder& builder) {
-        builder.start_object();
-        builder.append_key_value("make", car.make);
-        builder.append_comma();
-        builder.append_key_value("model", car.model);
-        builder.append_comma();
-        builder.append_key_value("year", car.year);
-        builder.append_comma();
-        builder.append_key_value("tire_pressure", car.tire_pressure);
-        builder.end_object();
-    }
-    bool car_test_simple() {
-        TEST_START();
-        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;
-        auto result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
-        TEST_SUCCEED();
-    }
-
-    bool car_test_simple_complete() {
-        TEST_START();
-        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;
-        auto result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
-        TEST_SUCCEED();
-    }
-
-    bool map_test() {
-        TEST_START();
-        std::map<std::string,double> c = {{"key1", 1}, {"key2", 1}};
-        simdjson::builder::string_builder sb;
-        sb.append(c);
-        std::string_view p;
-        auto result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        ASSERT_EQUAL(p, "{\"key1\":1.0,\"key2\":1.0}");
-                std::string s;
-
-        ASSERT_SUCCESS(simdjson::to_json(c).get(s));
-        ASSERT_EQUAL(s, "{\"key1\":1.0,\"key2\":1.0}");
-        TEST_SUCCEED();
-    }
-    bool double_double_test() {
-        TEST_START();
-        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;
-        auto result = sb.view().get(p);
-        ASSERT_SUCCESS(result);
-        ASSERT_EQUAL(p, "[[1.0,2.0],[3.0,4.0]]");
-        std::string s;
-        ASSERT_SUCCESS(simdjson::to_json(c).get(s));
-        ASSERT_EQUAL(s, "[[1.0,2.0],[3.0,4.0]]");
-        TEST_SUCCEED();
-    }
-    #if SIMDJSON_EXCEPTIONS
-    bool car_test_simple_complete_exceptions() {
-        TEST_START();
-        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();
-        ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
-        TEST_SUCCEED();
-    }
-    #endif // SIMDJSON_EXCEPTIONS
-    #endif // SIMDJSONS_SUPPORT_RANGES
-
 
     #if SIMDJSON_EXCEPTIONS
     bool car_test_exception() {
@@ -509,8 +332,6 @@ namespace builder_tests {
     #endif
     bool run() {
         return
-            allchar_test() &&
-            bad_utf8_test() &&
             various_integers() &&
             various_unsigned_integers() &&
             car_test_long() &&
@@ -518,18 +339,6 @@ namespace builder_tests {
     #if SIMDJSON_EXCEPTIONS
             car_test_exception() &&
             string_convertion_except() &&
-    #endif
-    #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
-            map_test() &&
-            double_double_test() &&
-            car_test_simple() &&
-            car_test_simple_complete() &&
-        #if SIMDJSON_EXCEPTIONS
-            car_test_simple_complete_exceptions() &&
-        #endif
-    #endif
-    #if SIMDJSON_SUPPORTS_CONCEPTS
-           serialize_optional() &&
     #endif
             append_char() &&
             append_integer() &&

tests/builder/static_reflection_enum_tests.cpp

@@ -131,7 +131,6 @@ namespace builder_tests {
 
     // Deserialize
     ondemand::parser parser;
-    std::cout << json << std::endl;
     auto doc_result = parser.iterate(pad(json));
     ASSERT_SUCCESS(doc_result);
 

tests/dom/basictests.cpp

@@ -1795,18 +1795,6 @@ namespace validate_tests {
     return true;
   }
 
-  bool shall_not_parse() {
-    std::cout << "Running " << __func__ << std::endl;
-    auto test = "{\"joe\":\"\xf0\x8f\xbf\xbf\"}"_padded;
-    simdjson::dom::parser parser;
-    simdjson::dom::element doc;
-    auto error = parser.parse(test).get(doc);
-    if(error) {
-      return true; // expected
-    }
-    return false;
-  }
-
   bool test_validate() {
     std::cout << "Running " << __func__ << std::endl;
     const std::string test = R"({ "foo" : 1, "bar" : [ 1, 2, 3 ], "baz": { "a": 1, "b": 2, "c": 3 } })";
@@ -1872,7 +1860,6 @@ namespace validate_tests {
   }
   bool run() {
     return issue1187() &&
-           shall_not_parse() &&
            test_range() &&
            test_issue1169_long() &&
            test_issue1169() &&

tests/dom/json_path_tests.cpp

@@ -294,158 +294,6 @@ bool json_path_invalidation() {
   }
   TEST_SUCCEED();
 }
-
-bool json_path_with_wildcard() {
-  TEST_START();
-
-  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",
-          "0123-4567-8887"
-        ]
-      },
-      {
-        "type"  : "home",
-        "numbers": [
-          "0123-4567-8910",
-          "0123-4267-8910",
-          "0103-4567-8910"
-        ]
-      },
-      { },
-      {
-        "type": "office",
-        "numbers": [ ]
-      }
-    ],
-    "empty_object": { },
-    "empty_array": [ ]
-  })"_padded;
-
-  dom::parser parser;
-  dom::element parsed_json;
-  ASSERT_SUCCESS(parser.parse(json_string).get(parsed_json));
-  std::vector<dom::element> values;
-
-
-  std::string_view string_value;
-  std::uint64_t num_value;
-  dom::object obj;
-  ASSERT_EQUAL(parsed_json.at_path_with_wildcard("$").error(), INVALID_JSON_POINTER);
-  ASSERT_EQUAL(parsed_json.at_path_with_wildcard("1").error(), INVALID_JSON_POINTER);
-  ASSERT_EQUAL(parsed_json.at_path_with_wildcard("2").error(), INVALID_JSON_POINTER);
-  ASSERT_EQUAL(parsed_json.at_path_with_wildcard("a").error(), INVALID_JSON_POINTER);
-  ASSERT_EQUAL(parsed_json.at_path_with_wildcard("$2").error(), INVALID_JSON_POINTER);
-  ASSERT_EQUAL(parsed_json.at_path_with_wildcard("$a").error(), INVALID_JSON_POINTER);
-  // $.*
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.*").get(values));
-
-  ASSERT_SUCCESS(values[0].get(string_value));
-  ASSERT_EQUAL(string_value, "John");
-
-  ASSERT_SUCCESS(values[1].get(string_value));
-  ASSERT_EQUAL(string_value, "doe");
-
-  ASSERT_SUCCESS(values[2].get(num_value));
-  ASSERT_EQUAL(num_value, 26);
-
-  ASSERT_SUCCESS(values[3].get(obj));
-  ASSERT_SUCCESS(obj["streetAddress"].get(string_value));
-  ASSERT_EQUAL(string_value, "naist street");
-
-  ASSERT_SUCCESS(obj["city"].get(string_value));
-  ASSERT_EQUAL(string_value, "Nara");
-
-  // $[*]
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$[*]").get(values));
-
-  ASSERT_SUCCESS(values[0].get(string_value));
-  ASSERT_EQUAL(string_value, "John");
-
-  ASSERT_SUCCESS(values[1].get(string_value));
-  ASSERT_EQUAL(string_value, "doe");
-
-  ASSERT_SUCCESS(values[2].get(num_value));
-  ASSERT_EQUAL(num_value, 26);
-
-  ASSERT_SUCCESS(values[3].get(obj));
-  ASSERT_SUCCESS(obj["streetAddress"].get(string_value));
-  ASSERT_EQUAL(string_value, "naist street");
-
-  ASSERT_SUCCESS(obj["city"].get(string_value));
-  ASSERT_EQUAL(string_value, "Nara");
-
-  // $.address.*
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.address.*").get(values));
-
-  std::vector<std::string> expected = {"naist street", "Nara", "630-0192"};
-  for (int i = 0; i < 3; i++) {
-    ASSERT_SUCCESS(values[i].get(string_value));
-    ASSERT_EQUAL(string_value, expected[i]);
-  }
-
-  // $.*.streetAddress
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.*.streetAddress").get(values));
-
-  ASSERT_SUCCESS(values[0].get(string_value));
-  ASSERT_EQUAL(string_value, "naist street");
-
-  // $.phoneNumbers[*].numbers[*]
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values));
-
-  std::vector<std::string> expected_numbers = {
-    "0123-4567-8888",
-    "0123-4567-8788",
-    "0123-4567-8887",
-    "0123-4567-8910",
-    "0123-4267-8910",
-    "0103-4567-8910"
-  };
-
-  for (int i = 0; i < 6; i++) {
-    ASSERT_SUCCESS(values[i].get(string_value));
-    ASSERT_EQUAL(string_value, expected_numbers[i]);
-  }
-
-  // $.phoneNumbers[*].numbers[1]
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.phoneNumbers[*].numbers[1]").get(values));
-
-  ASSERT_SUCCESS(values[0].get(string_value));
-  ASSERT_EQUAL(string_value, expected_numbers[1]);
-
-  ASSERT_SUCCESS(values[1].get(string_value));
-  ASSERT_EQUAL(string_value, expected_numbers[4]);
-
-  // $.empty_object.*
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.empty_object.*").get(values));
-
-  ASSERT_EQUAL(values.size(), 0);
-
-  // $.empty_array.*
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.empty_array.*").get(values));
-  ASSERT_EQUAL(values.size(), 0);
-
-  // $.phoneNumbers.*.numbers[3]
-  ASSERT_SUCCESS(parsed_json.at_path_with_wildcard("$.phoneNumbers.*.numbers[3]").get(values));
-
-  ASSERT_EQUAL(values.size(), 0);
-
-  TEST_SUCCEED();
-}
-
 // for 0.5 version and following (standard compliant)
 bool modern_support() {
 #if SIMDJSON_EXCEPTIONS
@@ -468,7 +316,7 @@ bool modern_support() {
 }
 
 int main() {
-  if (true && json_path_with_wildcard() && demo() && modern_support() &&
+  if (true && demo() && modern_support() &&
       run_success_test(TEST_RFC_JSON, "$.foo", "[\"bar\",\"baz\"]") &&
       run_success_test(TEST_RFC_JSON, "$.foo[0]", "\"bar\"") &&
       run_success_test(TEST_RFC_JSON, "$.", "0") &&