update

This is the bare minimum implementation of this idea.

.github/workflows/aarch64.yml

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

.github/workflows/cifuzz.yml

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

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

@@ -24,7 +24,7 @@ jobs:
              echo "no trailing whitespace found, good!"
           fi
       - name: Archive whitespace patch
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
         if: always()
         with:
           name: whitespace-patch

.github/workflows/msys2.yml

@@ -22,7 +22,7 @@ jobs:
           - msystem: "MINGW64"
             install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
             type: Debug
-          - msystem: "MINGW64"
+            - msystem: "MINGW64"
             install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
             type: RelWithDebInfo
     env:

.github/workflows/ppc64.yml

@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/riscv64.yml

@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/s390x.yml

@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/ubuntu24-cxx20.yml

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

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

@@ -10,6 +10,7 @@ jobs:
        fail-fast: false
        matrix:
          include:
+           - {arch: ARM}
            - {arch: ARM64}
            - {arch: ARM64EC}
      steps:
@@ -18,4 +19,4 @@ jobs:
        - name: Use cmake
          run: |
            cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
-           cmake --build build --verbose
+           cmake --build build --verbose

.github/workflows/vs17-ci.yml

@@ -26,15 +26,15 @@ jobs:
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
     - name: Build Debug
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
+      run: cmake --build build --config ${{build_type}} --verbose
     - name: Run tests
       run: |
         cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
+        ctest -C ${{build_type}}  -LE explicitonly  --output-on-failure
     - name: Install
       run: |
-        cmake --install build --config ${{matrix.build_type}}
+        cmake --install build --config ${{build_type}}
     - name: Test Installation
       run: |
         cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
+        cmake --build build_install_test --config ${{build_type}}

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

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

.vscode/settings.json

@@ -109,23 +109,11 @@
         "numbers": "cpp",
         "semaphore": "cpp",
         "stop_token": "cpp",
-        "cfenv": "cpp",
+        "cfenv": "cpp"
-        "format": "cpp",
+    },
-        "xlocmes": "cpp",
+    "cmake.configureSettings": {
-        "xlocmon": "cpp",
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "YES",
-        "xlocnum": "cpp",
+        "SIMDJSON_DEVELOPER_MODE": "ON",
-        "xloctime": "cpp",
+        "SIMDJSON_SINGLEHEADER": "OFF"
-        "xutility": "cpp",
-        "coroutine": "cpp",
-        "xfacet": "cpp",
-        "xhash": "cpp",
-        "xiosbase": "cpp",
-        "xlocale": "cpp",
-        "xlocbuf": "cpp",
-        "xlocinfo": "cpp",
-        "xmemory": "cpp",
-        "xstring": "cpp",
-        "xtr1common": "cpp",
-        "xtree": "cpp"
     }
 }

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 3.11.0
+    VERSION 3.10.1
     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 "24.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_VERSION "23.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "24" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_SOVERSION "23" 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)
@@ -287,7 +287,6 @@ enable_testing()
 add_custom_target(all_tests)
 
 add_subdirectory(windows)
-include(cmake/CPM.cmake)
 add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
 add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
 

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "3.11.0"
+PROJECT_NUMBER         = "3.10.1"
 
 # 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

README.md

@@ -31,7 +31,6 @@ Table of Contents
 * [Documentation](#documentation)
 * [Godbolt](#godbolt)
 * [Performance results](#performance-results)
-* [Packages](#packages)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
@@ -144,9 +143,6 @@ speed for [synthetic files over various sizes generated with a script](https://g
 For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).
 
 
-Packages
-------------------------------
-[![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)
 
 
 Bindings and Ports of simdjson

benchmark/find_tweet/nlohmann_json.h

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

benchmark/kostya/simdjson_ondemand.h

@@ -24,6 +24,35 @@ struct simdjson_ondemand {
 
 BENCHMARK_TEMPLATE(kostya, simdjson_ondemand)->UseManualTime();
 
+
+#if SIMDJSON_SUPPORTS_EXTRACT
+using namespace simdjson::ondemand;
+
+struct simdjson_ondemand_extract {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    for (ondemand::object object_point : doc.find_field("coordinates")) {
+      point p;
+      auto error = object_point.extract(
+        to{"x", p.x},
+        to{"y", p.y},
+        to{"z", p.z}
+      );
+      if(error) { return false; }
+      result.push_back(p);
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, simdjson_ondemand_extract)->UseManualTime();
+
+#endif // SIMDJSON_SUPPORTS_EXTRACT
+
 } // namespace kostya
 
 #endif // SIMDJSON_EXCEPTIONS

benchmark/partial_tweets/simdjson_ondemand.h

@@ -9,7 +9,7 @@ namespace partial_tweets {
 using namespace simdjson;
 
 struct simdjson_ondemand {
-  using StringType=std::string_view;
+  using StringType = std::string_view;
 
   ondemand::parser parser{};
 
@@ -43,6 +43,48 @@ struct simdjson_ondemand {
 
 BENCHMARK_TEMPLATE(partial_tweets, simdjson_ondemand)->UseManualTime();
 
+
+#if SIMDJSON_SUPPORTS_EXTRACT
+
+using namespace simdjson::ondemand;
+
+struct simdjson_ondemand_extract {
+  using StringType = std::string_view;
+  ondemand::parser parser{};
+  bool run(simdjson::padded_string &json, std::vector<tweet<std::string_view>> &result) {
+    // Walk the document, parsing the tweets as we go
+    auto doc = parser.iterate(json);
+    for (ondemand::object tweet_object : doc.find_field("statuses")) {
+      tweet<std::string_view> t;
+      auto error = tweet_object.extract(
+        to{"created_at", t.created_at},
+        to{"id", t.id},
+        to{"text", t.result},
+        to{"in_reply_to_status_id", [&t](auto val) {
+          if(val.is_null()) {
+            t.in_reply_to_status_id = 0;
+          } else {
+            t.in_reply_to_status_id = val;
+          }
+         }},
+        to{"user", sub{
+          to{"id", t.user.id},
+          to{"screen_name", t.user.screen_name},
+        }},
+        to{"retweet_count", t.retweet_count},
+        to{"favorite_count", t.favorite_count});
+        if(error) { return false; }
+        result.push_back(t);
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(partial_tweets, simdjson_ondemand_extract)->UseManualTime();
+
+
+#endif
+
 } // namespace partial_tweets
 
 #endif // SIMDJSON_EXCEPTIONS

benchmark/top_tweet/nlohmann_json.h

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

cmake/CPM.cmake

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

dependencies/CMakeLists.txt

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

dependencies/import.cmake

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

doc/basics.md

@@ -17,8 +17,6 @@ An overview of what you need to know to use simdjson, with examples.
   - [Using the parsed JSON](#using-the-parsed-json)
     - [Using the parsed JSON: additional examples](#using-the-parsed-json-additional-examples)
   - [Adding support for custom types](#adding-support-for-custom-types)
-    - [1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)](#1-specialize-simdjsonondemandvalueget-to-get-custom-types-pre-c20)
-    - [2. Use `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20)
   - [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
   - [UTF-8 validation (alone)](#utf-8-validation-alone)
   - [JSON Pointer](#json-pointer)
@@ -209,25 +207,6 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 
-You can then parse the JSON data from the `simdjson::padded_string` instance:
-
-
-```c++
-ondemand::document doc = parser.iterate(my_padded_data);
-```
-
-Whenever you pass an `std::string` reference to `parser::iterate`,
-the parser will access the bytes beyond the end of
-the string but before the end of the allocated memory (`std::string::capacity()`).
-If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
-container-overflow checks, you may encounter sanitizer warnings.
-You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
-string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
-
-```c++
-std::string json = "[1]";
-ondemand::document doc = parser.iterate(simdjson::pad(json));
-```
 
 We recommend against creating many `std::string` or many `std::padding_string` instances in your application to store your JSON data.
 Consider reusing the same buffers and limiting memory allocations.
@@ -268,7 +247,7 @@ documents.
 For code safety, you should keep (1) the `parser` instance, (2) the input string and (3) the document instance alive throughout your parsing. Additionally, you should follow the following rules:
 
 - A `parser` may have at most one document open at a time, since it holds allocated memory used for the parsing.
-- By design, you should only have one `document` instance per JSON document. Thus, if you must pass a document instance to a function, you should avoid passing it by value: choose to pass it by reference instance to avoid the copy. In any case, the `document` class does not have a copy constructor.
+- By design, you should only have one `document` instance per JSON document. Thus, if you must pass a document instance to a function, you should avoid passing it by value: choose to pass it by reference instance to avoid the copy. (We also provide a `document_reference` class if you need to pass by value.)
 
 During the `iterate` call, the original JSON text is never modified--only read. After you are done
 with the document, the source (whether file or string) can be safely discarded.
@@ -547,7 +526,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   double value;
   auto doc = parser.iterate(abstract_json);
   auto error = doc["str"]["123"]["abc"].get(value);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   cout << value << endl; // Prints 3.14
   ```
   This examples also show how we can string several operations and only check for the error once, a strategy we call  *error chaining*.
@@ -557,7 +536,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   For this purpose, `array` instances have a `count_elements` method. Users should be
   aware that the `count_elements` method can be costly since it requires scanning the
   whole array. You should only call `count_elements` as a last resort as it may
-  require scanning the document twice or more. In the spirit of On-Demand, the `count_elements` function does not validate the values in the array. You may use it as follows if your document is itself an array:
+  require scanning the document twice or more. You may use it as follows if your document is itself an array:
 
   ```C++
   auto cars_json = R"( [ 40.1, 39.9, 37.7, 40.4 ] )"_padded;
@@ -809,18 +788,6 @@ for (ondemand::object points : parser.iterate(points_json)) {
 Adding support for custom types
 ----------------------
 
-There are 2 main ways provided by simdjson to deserialize a value into a custom type:
-
-1. Provide a [**template specialization** for member functions](https://en.cppreference.com/w/cpp/language/template_specialization#Members_of_specializations)
-   1. Specialize `simdjson::ondemand::document::get` for the whole document
-   2. Specialize `simdjson::ondemand::value::get` for each value
-2. Using `tag_invoke` *(the recommended way if your system supports C++20 or better)*
-
-We describe both of them in the following sections. Most users who have systems compatible with
-C++20 or better should skip ahead to [using `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20) as it is more powerful and simpler.
-
-### 1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)
-
 Suppose you have your own types, such as a `Car` struct:
 
 ```C++
@@ -854,15 +821,9 @@ 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
+We may start by providing a definition for `std::vector<double>` as follows:
-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_DESERIALIZATION
-// The code is unnecessary with C++20:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
 simdjson::ondemand::value::get() noexcept {
@@ -878,7 +839,6 @@ simdjson::ondemand::value::get() noexcept {
   }
   return vec;
 }
-#endif
 ```
 
 We may then provide support for our `Car` struct:
@@ -890,10 +850,26 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
   auto error = get_object().get(obj);
   if (error) { return error; }
   Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
+    error = field.key().get(key);
+    if (error) { return error; }
+    if (key == "make") {
+      error = field.value().get_string(car.make);
+      if (error) { return error; }
+    } else if (key == "model") {
+      error = field.value().get_string(car.model);
+      if (error) { return error; }
+    } else if (key == "year") {
+      error = field.value().get_int64().get(car.year);
+      if (error) { return error; }
+    } else if (key == "tire_pressure") {
+      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
+      if (auto  error) { return error; }
+    }
+  }
   return car;
 }
 ```
@@ -917,8 +893,6 @@ struct Car {
   std::vector<double> tire_pressure;
 };
 
-#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>>
 simdjson::ondemand::value::get() noexcept {
@@ -934,7 +908,7 @@ simdjson::ondemand::value::get() noexcept {
   }
   return vec;
 }
-#endif
+
 
 template <>
 simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
@@ -942,10 +916,26 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
   auto error = get_object().get(obj);
   if (error) { return error; }
   Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
+    error = field.key().get(key);
+    if (error) { return error; }
+    if (key == "make") {
+      error = field.value().get_string(car.make);
+      if (error) { return error; }
+    } else if (key == "model") {
+      error = field.value().get_string(car.model);
+      if (error) { return error; }
+    } else if (key == "year") {
+      error = field.value().get_int64().get(car.year);
+      if (error) { return error; }
+    } else if (key == "tire_pressure") {
+      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
+      if (error) { return error; }
+    }
+  }
   return car;
 }
 
@@ -960,14 +950,15 @@ int main(void) {
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
   for (auto val : doc) {
-    Car c(val); // an exception may be thrown
+    Car c(val);
     std::cout << c.make << std::endl;
   }
+  direct();
   return EXIT_SUCCESS;
 }
 ```
 
-Observe that we require an explicit cast (`Car c(val)` instead of `for (Car c : doc) {`): it is by design. We require explicit casting.
+Observe that we require an explicit cast (`Car c(val)` instead of `for (Car c : doc) {`): it is by design.
 
 If you prefer to avoid exceptions, you may modify the `main` function as follows:
 
@@ -983,11 +974,11 @@ int main(void) {
   ondemand::parser parser;
   ondemand::document doc;
   auto error = parser.iterate(json).get(doc);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   for (auto val : doc) {
     Car c;
     error = val.get<Car>().get(c);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+    if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
     std::cout << c.make << std::endl;
   }
   return EXIT_SUCCESS;
@@ -1018,49 +1009,49 @@ struct Car {
   std::vector<double> tire_pressure;
 };
 
-#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>>
 simdjson::ondemand::value::get() noexcept {
   ondemand::array array;
-  auto error = get_array().get(array);
+  if (auto error = get_array().get(array); error) { return error; }
-  if (error) { return error; }
   std::vector<double> vec;
   for (auto v : array) {
     double val;
-    error = v.get_double().get(val);
+    if (auto error = v.get_double().get(val); error) { return error; }
-    if (error) { return error; }
     vec.push_back(val);
   }
   return vec;
 }
-#endif
+
 
 template <>
 simdjson_inline simdjson_result<Car> simdjson::ondemand::document::get() & noexcept {
   ondemand::object obj;
   auto error = get_object().get(obj);
-  if (error) { return error; }
+  if (error) {
+    return error;
+  }
   Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
-  return car;
+    error = field.key().get(key);
-}
+    if (error) { return error; }
-
+    if (key == "make") {
-
+      error = field.value().get_string(car.make);
-template <>
+      if (error) { return error; }
-simdjson_inline simdjson_result<Car> simdjson::ondemand::document::get() noexcept {
+    } else if (key == "model") {
-  ondemand::object obj;
+      error = field.value().get_string(car.model);
-  auto error = get_object().get(obj);
+      if (error) { return error; }
-  if (error) { return error; }
+    } else if (key == "year") {
-  Car car;
+      error = field.value().get_int64().get(car.year);
-  if((error = obj["make"].get_string(car.make))) { return error; }
+      if (error) { return error; }
-  if((error = obj["model"].get_string(car.model))) { return error; }
+    } else if (key == "tire_pressure") {
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+      if (error) { return error; }
+    }
+  }
   return car;
 }
 
@@ -1075,219 +1066,6 @@ int main(void) {
 }
 ```
 
-### 2. Use `tag_invoke` for custom types (C++20)
-
-In C++20, the standard introduced the notion of *customization point*.
-A customization point is a function or function object that can be customized for different types. It allows library authors to provide default behavior while giving users the ability to override this behavior for specific types.
-
-A tag_invoke function serves as a mechanism for customization points. It is not directly part of the C++ standard library but is often used in libraries that implement customization points.
-The tag_invoke function is typically a generic function that takes a tag type and additional arguments.
-The first argument is usually a tag type (often an empty struct) that uniquely identifies the customization point (e.g., deserialization of custom types in simdjson). Users or library providers can specialize tag_invoke for their types by defining it in the appropriate namespace, often inline namespace.
-
-
-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_DESERIALIZATION` macro
-to 1, otherwise it is set to 0.
-
-Consider a custom class `Car`:
-
-```C++
-struct Car {
-  std::string make;
-  std::string model;
-  int year;
-  std::vector<float> tire_pressure;
-};
-```
-
-Observe how we defined the class to use types that simdjson does not directly support (`float`, `int`).
-With C++20 support, the library grabs from the JSON the generic type (`double`, `int`) and then it
-casts it automatically.
-
-You may support deserializing directly from a JSON value or document to your own `Car` instance
-by defining a single `tag_invoke` function:
-
-
-```C++
-namespace simdjson {
-// This tag_invoke MUST be inside simdjson namespace
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
-  ondemand::object obj;
-  auto error = val.get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get(car.year))) {
-    return error;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
-           car.tire_pressure))) {
-    return error;
-  }
-  return simdjson::SUCCESS;
-}
-} // namespace simdjson
-```
-
-Observe how we call `get<std::vector<float>>()` even though we never defined support
-for `std::vector<float>` in the simdjson library: it is all automated thanks to C++20 concepts.
-
-Importantly, the `tag_invoke` function must be inside the `simdjson` namespace.
-Let us explain each argument of `tag_invoke` function.
-
-- `simdjson::deserialize_tag`: it is the tag for Customization Point Object (CPO). You may often ignore this parameter. It is used to indicate that you mean to provide a deserialization function for simdjson.
-- `var`: It receives automatically a `simdjson` value type (document, value, document_reference).
-- The third parameter is an instance of the type that you want to support.
-
-You can use it like so:
-
-```cpp
-  simdjson::padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  Car c(doc);
-  std::cout << c.make << std::endl;
-```
-
-Observe how we first get an instance of `document` and then we cast.
-
-You can also handle errors explicitly:
-
-```cpp
-  Car c;
-  auto error = doc.get(c);
-  if(error) { std::cerr << simdjson::error_message(error); return false; }
-  std::cout << c.make << std::endl;
-```
-
-You can also read instances of `Car` from an array or an object:
-```cpp
-  simdjson::padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  for (auto val : doc) {
-    Car c(val); // an exception may be thrown
-    std::cout << c.year << std::endl;
-  }
-```
-
-Observe how we first get a generic (`val`) which we cast to `Car`. It is by design: we require
-explicit casting. The cast may throw an exception.
-
-Once more, you can handle errors explicitly:
-
-```cpp
-  for (auto val : doc) {
-    Car c;
-    auto error = val.get(c);
-    if(error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
-  }
-```
-
-You can also use the custom `Car` type as part of a template such as `std::vector`:
-
-```cpp
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  std::vector<Car> cars(doc);
-  // visual studio users need an explicit call:
-  //   std::vector<Car> cars = doc.get<std::vector<Car>>();
-  // because the compiler does not know whether to convert
-  // doc to an unsigned int or to a vector.
-  for(Car& c : cars) {
-    std::cout << c.year << std::endl;
-  }
-```
-
-By default, we support a wide range of standard templates such as
-`std::vector`,  `std::list`, `std::set`, `std::stack`, `std:queue`,
-`std:deque`, `std::priority_queue`, `std::unordered_set`, `std::multiset`,
-`std::unordered_multiset`, `std::unique_ptr`, `std::shared_ptr`, `std::optional`,
-etc. They are handled automatically.
-
-E.g., you can recover an `std::unique_ptr<Car>` like so:
-```C++
-int main() {
-  auto const json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  std::unique_ptr<Car> c(doc);
-  std::cout << c->make << std::endl;
-  return EXIT_SUCCESS;
-}
-```
-
-You may also conditionally fill in `std::optional` values.
-
-```C++
-
-  padded_string json =
-      R"( { "car1": { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-})"_padded;
-  ondemand::parser parser;
-  ondemand::document doc = parser.iterate(json);
-  std::optional<Car> car;
-  error = doc["key not found"].get<std::optional<Car>>().get(car);
-  // car has no value, error != simdjson::SUCCESS
-  error = doc["car1"].get<std::optional<Car>>().get(car);
-  // car has value Car{"Toyota", "Camry", 2018, {40.1f, 39.9f}}
-  // error is simdjson::SUCCESS
-```
-
-And so forth.
-
-Advanced users may want to overwrite the defaults provided by the simdjson library.
-Suppose for example that you want to construct an instance of `std::list<Car>`, but
-you also want to filter out any car made by Toyota. You may provide your own
-`tag_invoke` function:
-
-```c++
-namespace simdjson {
-// suppose we want to filter out all Toyotas
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, std::list<Car>& car) {
-  ondemand::array arr;
-  auto error = val.get_array().get(arr);
-  if (error) {
-    return error;
-  }
-  for (auto v : arr) {
-    Car c;
-    if ((error = v.get<Car>().get(c))) {
-      return error;
-    }
-    if(c.make != "Toyota") {
-      car.push_back(c);
-    }
-  }
-  return simdjson::SUCCESS;
-}
-}
-```
-
-With this code, deserializing an `std::list<Car>` instance would capture only the cars
-that are not made by Toyota.
-
 
 Minifying JSON strings without parsing
 ----------------------
@@ -1303,7 +1081,6 @@ In some cases, you may have valid JSON strings that you do not wish to parse but
   std::unique_ptr<char[]> buffer{new char[length]};
   size_t new_length{}; // It will receive the minified length.
   auto error = simdjson::minify(some_string, length, buffer.get(), new_length);
-  if(error) { std::cerr << simdjson::error_message(error); }
   // The buffer variable now has "[1,2,3,4]" and new_length has value 9.
 ```
 
@@ -1447,11 +1224,9 @@ be represented as `value` instances. You can check that a document is a scalar w
 JSONPath
 ------------
 
-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library now supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
 
-This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of
+This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of [`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects and arrays: make sure to consume the values between each call to `at_path`.
-[`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects
- and arrays: make sure to consume the values between each call to `at_path`.
 
 Consider the following example:
 
@@ -1492,18 +1267,6 @@ doc.at_path(".\\u00E9") == 123; // true
 doc.at_path((const char*)u8".\u00E9") // returns an error (NO_SUCH_FIELD)
 ```
 
-
-We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
-
-```c++
-auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-ondemand::parser parser;
-ondemand::document doc = parser.iterate(json);
-ondemand::object obj = doc.get_object();
-int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
-x = obj.at_path("$.d.foo2.a.2"); // 30
-```
-
 Error handling
 --------------
 
@@ -1515,7 +1278,7 @@ pair. You can retrieve the value with .get() without generating an exception, li
 ```c++
 ondemand::document doc;
 auto error = parser.iterate(json).get(doc);
-if(error) { std::cerr << simdjson::error_message(error); exit(1); }
+if (error) { cerr << error << endl; exit(1); }
 ```
 
 When there is no error, the error code `simdjson::SUCCESS`is returned: it evaluates as false as a Boolean.
@@ -1546,7 +1309,7 @@ bool simple_error_example() {
     auto error = doc["bad number"].get_double().get(x);
     // returns "simdjson::NUMBER_ERROR"
     if (error != SUCCESS) {
-      std::cerr << simdjson::error_message(error) << std::endl;
+      std::cout << error << std::endl;
       return false;
     }
     std::cout << "Got " << x << std::endl;
@@ -1580,7 +1343,7 @@ Notice how we can retrieve the exact error condition (in this instance `simdjson
 from the exception.
 
 We can write a "quick start" example where we attempt to parse the following JSON file and access some data, without triggering exceptions:
-```JSON
+```JavaScript
 {
   "statuses": [
     {
@@ -1599,6 +1362,7 @@ We can write a "quick start" example where we attempt to parse the following JSO
 Our program loads the file, selects value corresponding to key `"search_metadata"` which expected to be an object, and then
 it selects the key `"count"` within that object.
 
+
 ```C++
 #include <iostream>
 #include "simdjson.h"
@@ -1606,10 +1370,10 @@ it selects the key `"count"` within that object.
 int main(void) {
   simdjson::ondemand::parser parser;
   auto error = padded_string::load("twitter.json").get(json);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   simdjson::ondemand::document tweets;
   error = parser.iterate(json).get(tweets);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   simdjson::ondemand::value res;
   error = tweets["search_metadata"]["count"].get(res);
   if (error != SUCCESS) {
@@ -1640,12 +1404,12 @@ int main(void) {
   simdjson::ondemand::document tweets;
   padded_string json;
   auto error = padded_string::load("twitter.json").get(json);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   error = parser.iterate(json).get(tweets);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   uint64_t identifier;
   error = tweets["statuses"].at(0)["id"].get(identifier);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
   std::cout << identifier << std::endl;
 }
 ```
@@ -1669,40 +1433,40 @@ bool parse() {
 
   // Iterating through an array of objects
   auto error = parser.iterate(cars_json).get(doc);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+  if (error) { std::cerr << error << std::endl; return false; }
   ondemand::array cars; // invalid until the get() succeeds
   error = doc.get_array().get(cars);
 
   for (auto car_value : cars) {
     ondemand::object car; // invalid until the get() succeeds
     error = car_value.get_object().get(car);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
 
     // Accessing a field by name
     std::string_view make;
     std::string_view model;
     error = car["make"].get(make);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
     error = car["model"].get(model);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
 
     cout << "Make/Model: " << make << "/" << model << endl;
 
     // Casting a JSON element to an integer
     uint64_t year{};
     error = car["year"].get(year);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
     cout << "- This car is " << 2020 - year << " years old." << endl;
 
     // Iterating through an array of floats
     double total_tire_pressure = 0;
     ondemand::array pressures;
     error = car["tire_pressure"].get_array().get(pressures);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
     for (auto tire_pressure_value : pressures) {
       double tire_pressure;
       error = tire_pressure_value.get_double().get(tire_pressure);
-      if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+      if (error) { std::cerr << error << std::endl; return false; }
       total_tire_pressure += tire_pressure;
     }
     cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;
@@ -1824,7 +1588,7 @@ auto doc = parser.iterate(broken_json);
 int64_t i;
 auto error = doc["integer"].get_int64().get(i);    // Expect to get integer from "integer" key, but get TAPE_ERROR
 if (error) {
-  std::cerr << simdjson::error_message(error) << std::endl;    // Prints TAPE_ERROR error message
+  std::cout << error << std::endl;    // Prints TAPE_ERROR error message
   // Recover a pointer to the location of the first error:
   const char * ptr;
   doc.current_location().get(ptr);
@@ -1861,7 +1625,7 @@ auto doc = parser.iterate(json);
 int64_t i;
 auto error = doc["integer"].get_int64().get(i);    // Incorrect call on array, INCORRECT_TYPE error
 if (error) {
-  std::cerr << simdjson::error_message(error) << std::endl;     // Prints INCORRECT_TYPE error message
+  std::cout << error << std::endl;     // Prints INCORRECT_TYPE error message
   std::cout<< doc.current_location() << std::endl;  // Prints "[1,2,3] " (location of INCORRECT_TYPE error)
 }
 ```
@@ -2034,7 +1798,7 @@ for (auto doc: stream) {
     error = doc.at_pointer("/4").get(val);
     // error == simdjson::CAPACITY
     if (error) {
-      std::cerr << simdjson::error_message(error) << std::endl;
+      std::cerr << error << std::endl;
       // We left 293 bytes unprocessed at the tail end of the input.
       std::cout << " unprocessed bytes at the end: " << stream.truncated_bytes() << std::endl;
       break;
@@ -2909,7 +2673,6 @@ Performance tips
 	std::string_view year = data["year"];
 	std::string_view rating = data["rating"];
   ```
-- You will get better performance if you seek the keys in the order in which they appear in the document. So if processing `{"a":1, "b":2, "c":3}`, do `value1 = data["a"]; value2 = data["b"]; value3 data["c"];` and not `value2 = data["b"]; value1 = data["a"]; value3 data["c"];`. Of course, it is not always possible to know for sure in which order the keys appear.
 
 
 

doc/dom.md

@@ -8,7 +8,6 @@ An overview of what you need to know to use simdjson, with examples.
 * [Using the Parsed JSON](#using-the-parsed-json)
 * [C++17 Support](#c17-support)
 * [JSON Pointer](#json-pointer)
-* [JSONPath](#jsonpath)
 * [Error Handling](#error-handling)
   * [Error Handling Example](#error-handling-example)
   * [Exceptions](#exceptions)
@@ -60,26 +59,6 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 
-You can then parse the JSON document from the `simdjson::padded_string` instance:
-
-```cpp
-simdjson::dom::parser parser;
-simdjson::dom::element doc = parser.parse(my_padded_data);
-```
-
-Whenever you pass an `std::string` reference to `parser::parse`,
-the parser will access the bytes beyond the end of
-the string but before the end of the allocated memory (`std::string::capacity()`).
-If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
-container-overflow checks, you may encounter sanitizer warnings.
-You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
-string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
-
-```c++
-std::string json = "[1]";
-dom::element doc = parser.parse(simdjson::pad(json));
-```
-
 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
 You cannot copy a `parser` instance, you may only move it.
 
@@ -278,49 +257,6 @@ for (dom::element car_element : cars) {
 }
 ```
 
-JSONPath
-------------
-
-
-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
-
-Consider the following example:
-
-```c++
-auto cars_json = R"( [
-  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-] )"_padded;
-dom::parser parser;
-dom::element doc;
-auto error = parser.parse(cars_json).get(doc);
-if(error) { /*won't happen*/ }
-double p;
-error = doc.at_path("[0].tire_pressure[1]").get(p);
-if(error) { /*won't happen*/ }
-cout << p << endl; // Prints 39.9
-```
-
-
-We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
-
-```c++
-auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-dom::parser parser;
-dom::element doc;
-auto error = parser.parse(json).get(doc);
-if(error) { /*won't happen*/ }
-dom::object obj;
-error = doc.get_object().get(obj);
-if(error) { /*won't happen*/ }
-int64_t x;
-error = obj.at_path("$[3].foo.a[1]").get(x);
-if(error) { /*won't happen*/ }
-if(x != 20) { /*won't happen*/ }
-x = obj.at_path("$.d.foo2.a.2");
-if(error) { /*won't happen*/ }
-```
 
 
 Error Handling

doc/iterate_many.md

@@ -25,7 +25,6 @@ Contents
 - [Use cases](#use-cases)
 - [Tracking your position](#tracking-your-position)
 - [Incomplete streams](#incomplete-streams)
-- [C++20 features](#c20-features)
 
 Motivation
 -----------
@@ -103,12 +102,7 @@ remove almost entirely its cost and replaces it by the overhead of a thread, whi
 cheaper. Ain't that awesome!
 
 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
-to the library. Otherwise the library runs in single-thread mode.
-
-You should be consistent. If you link against the simdjson library built for multithreading
-(i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
-system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
 
 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
 
@@ -294,111 +288,3 @@ string
 object
 array
 ```
-
-
-C++20 features
---------------------
-
-In C++20, the standard introduced the notion of *customization point*.
-A customization point is a function or function object that can be customized for different types. It allows library authors to provide default behavior while giving users the ability to override this behavior for specific types.
-
-A tag_invoke function serves as a mechanism for customization points. It is not directly part of the C++ standard library but is often used in libraries that implement customization points.
-The tag_invoke function is typically a generic function that takes a tag type and additional arguments.
-The first argument is usually a tag type (often an empty struct) that uniquely identifies the customization point (e.g., deserialization of custom types in simdjson). Users or library providers can specialize tag_invoke for their types by defining it in the appropriate namespace, often inline namespace.
-
-
-
-You can deserialize you own data structures conveniently if your system supports C++20.
-When it is the case, the macro `SIMDJSON_SUPPORTS_DESERIALIZATION` will be set to 1 by
-the simdjson library.
-
-Consider a custom class `Car`:
-
-```C++
-struct Car {
-  std::string make;
-  std::string model;
-  int year;
-  std::vector<float> tire_pressure;
-};
-```
-
-
-You may support deserializing directly from a JSON value or document to your own `Car` instance
-by defining a single `tag_invoke` function:
-
-
-```C++
-namespace simdjson {
-// This tag_invoke MUST be inside simdjson namespace
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
-  ondemand::object obj;
-  auto error = val.get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get(car.year))) {
-    return error;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
-           car.tire_pressure))) {
-    return error;
-  }
-  return simdjson::SUCCESS;
-}
-} // namespace simdjson
-```
-
-Importantly, the `tag_invoke` function must be inside the `simdjson` namespace.
-Let us explain each argument of `tag_invoke` function.
-
-- `simdjson::deserialize_tag`: it is the tag for Customization Point Object (CPO). You may often ignore this parameter. It is used to indicate that you mean to provide a deserialization function for simdjson.
-- `var`: It receives automatically a `simdjson` value type (document, value, document_reference).
-- The third parameter is an instance of the type that you want to support.
-
-Please see our main documentation (`basics.md`) under
-"Use `tag_invoke` for custom types (C++20)" for details about
-tag_invoke functions.
-
-Given a stream of JSON documents, you can add them to a data struture
-such as a `std::vector<Car>` like so if you support exceptions:
-
-```C++
-  padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] }
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-)"_padded;
-  ondemand::parser parser;
-  ondemand::document_stream stream;
-  [[maybe_unused]] auto error = parser.iterate_many(json).get(stream);
-  std::vector<Car> cars;
-  for(auto doc : stream) {
-    cars.push_back((Car)doc); // an exception may be thrown
-  }
-```
-
-Otherwise you may use this longer version for explicit handling of errors:
-
-
-```C++
-  std::vector<Car> cars;
-  for(auto doc : stream) {
-    Car c;
-    if ((error = doc.get<Car>().get(c))) {
-      std::cerr << simdjson::error_message(error); << std::endl;
-      return EXIT_FAILURE;
-    }
-    cars.push_back(c);
-  }
-```

doc/parse_many.md

@@ -103,12 +103,7 @@ cases, remove almost entirely its cost and replaces it by the overhead of a thre
 of magnitude cheaper. Ain't that awesome!
 
 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
-to the library. Otherwise the library runs in single-thread mode.
-
-You should be consistent. If you link against the simdjson library built for multithreading
-(i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
-system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
 
 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
 You should expect the main thread to be fully occupied while the worker thread is partially busy

doc/performance.md

@@ -241,8 +241,8 @@ long page_size() {
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
-  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size()) <
-    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
+          simdjson::SIMDJSON_PADDING);
 }
 
 simdjson::padded_string_view

include/simdjson.h

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

include/simdjson/arm64/bitmanipulation.h

@@ -19,7 +19,7 @@ SIMDJSON_NO_SANITIZE_UNDEFINED
 // See issue https://github.com/simdjson/simdjson/issues/1965
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_inline int trailing_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   unsigned long ret;
   // Search the mask data from least significant bit (LSB)
   // to the most significant bit (MSB) for a set bit (1).
@@ -35,15 +35,9 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
   return input_num & (input_num-1);
 }
 
-// We sometimes call leading_zeroes on inputs that are zero,
-// but the algorithms do not end up using the returned value.
-// Sadly, sanitizers are not smart enough to figure it out.
-// Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
-// (See below.)
-SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   unsigned long leading_zero = 0;
   // Search the mask data from most significant bit (MSB)
   // to least significant bit (LSB) for a set bit (1).
@@ -96,7 +90,7 @@ simdjson_inline uint64_t zero_leading_bit(uint64_t rev_bits, int leading_zeroes)
 #endif
 
 simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2, uint64_t *result) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   *result = value1 + value2;
   return *result < value1;
 #else

include/simdjson/arm64/numberparsing_defs.h

@@ -51,12 +51,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H

include/simdjson/arm64/simd.h

@@ -12,7 +12,7 @@ namespace arm64 {
 namespace {
 namespace simd {
 
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
 namespace {
 // Start of private section with Visual Studio workaround
 
@@ -121,7 +121,7 @@ namespace {
     // We return uint32_t instead of uint16_t because that seems to be more efficient for most
     // purposes (cutting it down to uint16_t costs performance in some compilers).
     simdjson_inline uint32_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       const uint8x16_t bit_mask =  simdjson_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
                                                    0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
 #else
@@ -152,7 +152,7 @@ namespace {
     // Splat constructor
     simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
     // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
     simdjson_inline simd8(
       uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
       uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
@@ -246,7 +246,7 @@ namespace {
       uint64x2_t shufmask64 = {thintable_epi8[mask1], thintable_epi8[mask2]};
       uint8x16_t shufmask = vreinterpretq_u8_u64(shufmask64);
       // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       uint8x16_t inc = simdjson_make_uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
       uint8x16_t inc = {0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -276,7 +276,7 @@ namespace {
       uint8x8_t compactmask1 = vcreate_u8(thintable_epi8[mask1]);
       uint8x8_t compactmask2 = vcreate_u8(thintable_epi8[mask2]);
       // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       uint8x8_t inc = simdjson_make_uint8x8_t(0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
       uint8x8_t inc = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -328,7 +328,7 @@ namespace {
     // Array constructor
     simdjson_inline simd8(const int8_t* values) : simd8(load(values)) {}
     // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
     simdjson_inline simd8(
       int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3, int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
       int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
@@ -449,7 +449,7 @@ namespace {
     }
 
     simdjson_inline uint64_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       const uint8x16_t bit_mask = simdjson_make_uint8x16_t(
         0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
         0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80

include/simdjson/base.h

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

include/simdjson/compiler_check.h

@@ -50,16 +50,4 @@
 #endif
 #endif
 
-#ifdef __has_include
-#if __has_include(<version>)
-#include <version>
-#endif
-#endif
-
-#ifdef __cpp_concepts
-#include <utility>
-#define SIMDJSON_SUPPORTS_DESERIALIZATION 1
-#else // __cpp_concepts
-#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
-#endif
 #endif // SIMDJSON_COMPILER_CHECK_H

include/simdjson/concepts.h

@@ -1,113 +0,0 @@
-#ifndef SIMDJSON_CONCEPTS_H
-#define SIMDJSON_CONCEPTS_H
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-
-#include <concepts>
-#include <type_traits>
-
-namespace simdjson {
-namespace concepts {
-
-namespace details {
-#define SIMDJSON_IMPL_CONCEPT(name, method)                                    \
-  template <typename T>                                                        \
-  concept supports_##name = !std::is_const_v<T> && requires {                  \
-    typename std::remove_cvref_t<T>::value_type;                               \
-    requires requires(typename std::remove_cvref_t<T>::value_type &&val,       \
-                      T obj) {                                                 \
-      obj.method(std::move(val));                                              \
-      requires !requires { obj = std::move(val); };                            \
-    };                                                                         \
-  };
-
-SIMDJSON_IMPL_CONCEPT(emplace_back, emplace_back);
-SIMDJSON_IMPL_CONCEPT(emplace, emplace);
-SIMDJSON_IMPL_CONCEPT(push_back, push_back);
-SIMDJSON_IMPL_CONCEPT(add, add);
-SIMDJSON_IMPL_CONCEPT(push, push);
-SIMDJSON_IMPL_CONCEPT(append, append);
-SIMDJSON_IMPL_CONCEPT(insert, insert);
-SIMDJSON_IMPL_CONCEPT(op_append, operator+=);
-
-#undef SIMDJSON_IMPL_CONCEPT
-} // namespace details
-
-/// Check if T is a container that we can append to, including:
-///   std::vector, std::deque, std::list, std::string, ...
-template <typename T>
-concept appendable_containers =
-    details::supports_emplace_back<T> || details::supports_emplace<T> ||
-    details::supports_push_back<T> || details::supports_push<T> ||
-    details::supports_add<T> || details::supports_append<T> ||
-    details::supports_insert<T>;
-
-/// Insert into the container however possible
-template <appendable_containers T, typename... Args>
-constexpr decltype(auto) emplace_one(T &vec, Args &&...args) {
-  if constexpr (details::supports_emplace_back<T>) {
-    return vec.emplace_back(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_emplace<T>) {
-    return vec.emplace(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_push_back<T>) {
-    return vec.push_back(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_push<T>) {
-    return vec.push(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_add<T>) {
-    return vec.add(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_append<T>) {
-    return vec.append(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_insert<T>) {
-    return vec.insert(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_op_append<T> && sizeof...(Args) == 1) {
-    return vec.operator+=(std::forward<Args>(args)...);
-  } else {
-    static_assert(!sizeof(T *),
-                  "We don't know how to add things to this container");
-  }
-}
-
-/// This checks if the container will return a reference to the newly added
-/// element after an insert which for example `std::vector::emplace_back` does
-/// since C++17; this will allow some optimizations.
-template <typename T>
-concept returns_reference = appendable_containers<T> && requires {
-  typename std::remove_cvref_t<T>::reference;
-  requires requires(typename std::remove_cvref_t<T>::value_type &&val, T obj) {
-    {
-      emplace_one(obj, std::move(val))
-    } -> std::same_as<typename std::remove_cvref_t<T>::reference>;
-  };
-};
-
-template <typename T>
-concept smart_pointer = requires(std::remove_cvref_t<T> ptr) {
-  // Check if T has a member type named element_type
-  typename std::remove_cvref_t<T>::element_type;
-
-  // Check if T has a get() member function
-  {
-    ptr.get()
-  } -> std::same_as<typename std::remove_cvref_t<T>::element_type *>;
-
-  // Check if T can be dereferenced
-  { *ptr } -> std::same_as<typename std::remove_cvref_t<T>::element_type &>;
-};
-
-template <typename T>
-concept optional_type = requires(std::remove_cvref_t<T> obj) {
-  typename std::remove_cvref_t<T>::value_type;
-  { obj.value() } -> std::same_as<typename std::remove_cvref_t<T>::value_type&>;
-  requires requires(typename std::remove_cvref_t<T>::value_type &&val) {
-    obj.emplace(std::move(val));
-    obj = std::move(val);
-    {
-      obj.value_or(val)
-    } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
-  };
-  { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
-};
-
-} // namespace concepts
-} // namespace simdjson
-#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
-#endif // SIMDJSON_CONCEPTS_H

include/simdjson/dom/array-inl.h

@@ -7,7 +7,6 @@
 #include "simdjson/dom/array.h"
 #include "simdjson/dom/element.h"
 #include "simdjson/error-inl.h"
-#include "simdjson/jsonpathutil.h"
 #include "simdjson/internal/tape_ref-inl.h"
 
 #include <limits>
@@ -45,13 +44,6 @@ inline simdjson_result<dom::element> simdjson_result<dom::array>::at_pointer(std
   if (error()) { return error(); }
   return first.at_pointer(json_pointer);
 }
-
- inline simdjson_result<dom::element> simdjson_result<dom::array>::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; }
-  return at_pointer(json_pointer);
- }
-
 inline simdjson_result<dom::element> simdjson_result<dom::array>::at(size_t index) const noexcept {
   if (error()) { return error(); }
   return first.at(index);
@@ -121,12 +113,6 @@ inline simdjson_result<element> array::at_pointer(std::string_view json_pointer)
   return child;
 }
 
-inline simdjson_result<element> array::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; }
-  return at_pointer(json_pointer);
-}
-
 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;

include/simdjson/dom/array.h

@@ -108,21 +108,6 @@ public:
    */
   inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
 
-  /**
-   * Get the value associated with the given JSONPath expression. We only support
-   * JSONPath queries that trivially convertible to JSON Pointer queries: key
-   * names and array indices.
-   *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
-   *
-   * @return The value associated with the given JSONPath expression, or:
-   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
-   *         - NO_SUCH_FIELD if a field does not exist in an object
-   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
-   *         - INCORRECT_TYPE if a non-integer is used to access an array
-  */
-  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
-
   /**
    * Get the value at the given index. This function has linear-time complexity and
    * is equivalent to the following:
@@ -167,7 +152,6 @@ 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 simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
   inline simdjson_result<dom::element> at(size_t index) const noexcept;
 
 #if SIMDJSON_EXCEPTIONS

include/simdjson/dom/element-inl.h

@@ -9,7 +9,6 @@
 
 #include "simdjson/dom/object-inl.h"
 #include "simdjson/error-inl.h"
-#include "simdjson/jsonpathutil.h"
 
 #include <ostream>
 #include <limits>
@@ -123,11 +122,6 @@ simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_
   if (error()) { return error(); }
   return first.at_pointer(json_pointer);
 }
-simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_path(const 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; }
-  return at_pointer(json_pointer);
-}
 #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 {
@@ -418,11 +412,6 @@ inline simdjson_result<element> element::at_pointer(std::string_view json_pointe
     }
   }
 }
-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; }
-  return at_pointer(json_pointer);
-}
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
 [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
 inline simdjson_result<element> element::at(std::string_view json_pointer) const noexcept {

include/simdjson/dom/element.h

@@ -372,8 +372,6 @@ public:
    *         - INCORRECT_TYPE if this is not an object
    */
   inline simdjson_result<element> operator[](const char *key) const noexcept;
-  simdjson_result<element> operator[](int) const noexcept = delete;
-
 
   /**
    * Get the value associated with the given JSON pointer.  We use the RFC 6901
@@ -399,21 +397,6 @@ public:
    */
   inline simdjson_result<element> at_pointer(const std::string_view json_pointer) const noexcept;
 
-  /**
-   * Get the value associated with the given JSONPath expression. We only support
-   * JSONPath queries that trivially convertible to JSON Pointer queries: key
-   * names and array indices.
-   *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
-   *
-   * @return The value associated with the given JSONPath expression, or:
-   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
-   *         - NO_SUCH_FIELD if a field does not exist in an object
-   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
-   *         - INCORRECT_TYPE if a non-integer is used to access an array
-  */
-  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
-
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
   /**
    *
@@ -542,9 +525,7 @@ public:
 
   simdjson_inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
   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<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;
   simdjson_inline simdjson_result<dom::element> at(size_t index) const noexcept;

include/simdjson/dom/object-inl.h

@@ -7,7 +7,6 @@
 
 #include "simdjson/dom/element-inl.h"
 #include "simdjson/error-inl.h"
-#include "simdjson/jsonpathutil.h"
 
 #include <cstring>
 
@@ -35,11 +34,6 @@ inline simdjson_result<dom::element> simdjson_result<dom::object>::at_pointer(st
   if (error()) { return error(); }
   return first.at_pointer(json_pointer);
 }
-inline simdjson_result<dom::element> simdjson_result<dom::object>::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; }
-  return at_pointer(json_pointer);
-}
 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);
@@ -137,12 +131,6 @@ inline simdjson_result<element> object::at_pointer(std::string_view json_pointer
   return child;
 }
 
-inline simdjson_result<element> object::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; }
-  return at_pointer(json_pointer);
-}
-
 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) {

include/simdjson/dom/object.h

@@ -145,7 +145,6 @@ public:
    *         - INCORRECT_TYPE if this is not an object
    */
   inline simdjson_result<element> operator[](const char *key) const noexcept;
-  simdjson_result<element> operator[](int) const noexcept = delete;
 
   /**
    * Get the value associated with the given JSON pointer. We use the RFC 6901
@@ -172,21 +171,6 @@ public:
    */
   inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
 
-  /**
-   * Get the value associated with the given JSONPath expression. We only support
-   * JSONPath queries that trivially convertible to JSON Pointer queries: key
-   * names and array indices.
-   *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
-   *
-   * @return The value associated with the given JSONPath expression, or:
-   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
-   *         - NO_SUCH_FIELD if a field does not exist in an object
-   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
-   *         - INCORRECT_TYPE if a non-integer is used to access an array
-  */
-  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
-
   /**
    * Get the value associated with the given key.
    *
@@ -259,9 +243,7 @@ public:
 
   inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
   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 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 simdjson_result<dom::element> at_key_case_insensitive(std::string_view key) const noexcept;
 

include/simdjson/dom/parser.h

@@ -202,22 +202,6 @@ public:
    *   simdjson::dom::parser parser;
    *   simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len, false);
    *
-   * ### std::string references
-   *
-   * If you pass a mutable std::string reference (std::string&), the parser will seek to extend
-   * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.
-   *
-   * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of
-   * the string but before the end of the allocated memory (std::string::capacity()).
-   * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's
-   * container-overflow checks, you may encounter sanitizer warnings.
-   * You can safely ignore these warnings. Or you can call simdjson::pad(std::string&) to pad the
-   * string with SIMDJSON_PADDING spaces: this function returns a simdjson::padding_string_view
-   * which can be be passed to the parser's parse function:
-   *
-   *    std::string json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )";
-   *    element doc = parser.parse(simdjson::pad(json));
-   *
    * ### Parser Capacity
    *
    * If the parser's current capacity is less than len, it will allocate enough capacity
@@ -565,14 +549,9 @@ public:
   /**
    * The parser instance can use threads when they are available to speed up some
    * operations. It is enabled by default. Changing this attribute will change the
-   * behavior of the parser for future operations. Set to true by default.
+   * behavior of the parser for future operations.
    */
   bool threaded{true};
-#else
-  /**
-   * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
-   */
-  bool threaded{false};
 #endif
   /** @private Use the new DOM API instead */
   class Iterator;

include/simdjson/fallback/numberparsing_defs.h

@@ -75,12 +75,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H

include/simdjson/generic/dependencies.h

@@ -16,4 +16,5 @@
 #include "simdjson/internal/jsoncharutils_tables.h"
 #include "simdjson/internal/numberparsing_tables.h"
 #include "simdjson/internal/simdprune_tables.h"
+
 #endif // SIMDJSON_GENERIC_DEPENDENCIES_H

include/simdjson/generic/numberparsing.h

@@ -574,6 +574,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //

include/simdjson/generic/ondemand/amalgamated.h

@@ -4,7 +4,6 @@
 
 // Stuff other things depend on
 #include "simdjson/generic/ondemand/base.h"
-#include "simdjson/generic/ondemand/deserialize.h"
 #include "simdjson/generic/ondemand/value_iterator.h"
 #include "simdjson/generic/ondemand/value.h"
 #include "simdjson/generic/ondemand/logger.h"
@@ -24,13 +23,9 @@
 #include "simdjson/generic/ondemand/object_iterator.h"
 #include "simdjson/generic/ondemand/serialization.h"
 
-// Deserialization for standard types
-#include "simdjson/generic/ondemand/std_deserialize.h"
-
 // Inline definitions
 #include "simdjson/generic/ondemand/array-inl.h"
 #include "simdjson/generic/ondemand/array_iterator-inl.h"
-#include "simdjson/generic/ondemand/value-inl.h"
 #include "simdjson/generic/ondemand/document-inl.h"
 #include "simdjson/generic/ondemand/document_stream-inl.h"
 #include "simdjson/generic/ondemand/field-inl.h"
@@ -43,6 +38,5 @@
 #include "simdjson/generic/ondemand/raw_json_string-inl.h"
 #include "simdjson/generic/ondemand/serialization-inl.h"
 #include "simdjson/generic/ondemand/token_iterator-inl.h"
+#include "simdjson/generic/ondemand/value-inl.h"
 #include "simdjson/generic/ondemand/value_iterator-inl.h"
-
-

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

@@ -2,7 +2,6 @@
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_INL_H
-#include "simdjson/jsonpathutil.h"
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/ondemand/array.h"
 #include "simdjson/generic/ondemand/array_iterator-inl.h"
@@ -164,6 +163,53 @@ inline simdjson_result<value> array::at_pointer(std::string_view json_pointer) n
   return child;
 }
 
+inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
+  if (json_path.empty() || (json_path.front() != '.' &&
+      json_path.front() != '[')) {
+    return "-1"; // This is just a sentinel value, the caller should check for this and return an error.
+  }
+
+  std::string result;
+  // Reserve space to reduce allocations, adjusting for potential increases due
+  // to escaping.
+  result.reserve(json_path.size() * 2);
+
+  size_t i = 0;
+
+  while (i < json_path.length()) {
+    if (json_path[i] == '.') {
+      result += '/';
+    } else if (json_path[i] == '[') {
+      result += '/';
+      ++i; // Move past the '['
+      while (i < json_path.length() && json_path[i] != ']') {
+          if (json_path[i] == '~') {
+            result += "~0";
+          } else if (json_path[i] == '/') {
+            result += "~1";
+          } else {
+            result += json_path[i];
+          }
+          ++i;
+      }
+      if (i == json_path.length() || json_path[i] != ']') {
+          return "-1"; // Using sentinel value that will be handled as an error by the caller.
+      }
+    } else {
+      if (json_path[i] == '~') {
+          result += "~0";
+      } else if (json_path[i] == '/') {
+          result += "~1";
+      } else {
+          result += json_path[i];
+      }
+    }
+    ++i;
+  }
+
+  return result;
+}
+
 inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
   auto json_pointer = json_path_to_pointer_conversion(json_path);
   if (json_pointer == "-1") { return INVALID_JSON_POINTER; }

include/simdjson/generic/ondemand/array.h

@@ -44,8 +44,7 @@ public:
    * calling this function, if successful, the array is 'rewinded' at its
    * beginning as if it had never been accessed. If the JSON is malformed (e.g.,
    * there is a missing comma), then an error is returned and it is no longer
-   * safe to continue. Note that count_elements() does not validate the JSON values,
+   * safe to continue.
-   * only the structure of the array.
    *
    * To check that an array is empty, it is more performant to use
    * the is_empty() method.

include/simdjson/generic/ondemand/dependencies.h

@@ -13,6 +13,5 @@
 #include "simdjson/padded_string.h"
 #include "simdjson/padded_string_view.h"
 #include "simdjson/internal/dom_parser_implementation.h"
-#include "simdjson/jsonpathutil.h"
 
 #endif // SIMDJSON_GENERIC_ONDEMAND_DEPENDENCIES_H

include/simdjson/generic/ondemand/deserialize.h

@@ -1,123 +0,0 @@
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-
-#ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_ONDEMAND_DESERIALIZE_H
-#include "simdjson/generic/ondemand/base.h"
-#include "simdjson/generic/ondemand/array.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#include <concepts>
-namespace simdjson {
-
-namespace tag_invoke_fn_ns {
-void tag_invoke();
-
-struct tag_invoke_fn {
-  template <typename Tag, typename... Args>
-    requires requires(Tag tag, Args &&...args) {
-      tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-    }
-  constexpr auto operator()(Tag tag, Args &&...args) const
-      noexcept(noexcept(tag_invoke(std::forward<Tag>(tag),
-                                   std::forward<Args>(args)...)))
-          -> decltype(tag_invoke(std::forward<Tag>(tag),
-                                 std::forward<Args>(args)...)) {
-    return tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-  }
-};
-} // namespace tag_invoke_fn_ns
-
-inline namespace tag_invoke_ns {
-inline constexpr tag_invoke_fn_ns::tag_invoke_fn tag_invoke = {};
-} // namespace tag_invoke_ns
-
-template <typename Tag, typename... Args>
-concept tag_invocable = requires(Tag tag, Args... args) {
-  tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-};
-
-template <typename Tag, typename... Args>
-concept nothrow_tag_invocable =
-    tag_invocable<Tag, Args...> && requires(Tag tag, Args... args) {
-      {
-        tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...)
-      } noexcept;
-    };
-
-template <typename Tag, typename... Args>
-using tag_invoke_result =
-    std::invoke_result<decltype(tag_invoke), Tag, Args...>;
-
-template <typename Tag, typename... Args>
-using tag_invoke_result_t =
-    std::invoke_result_t<decltype(tag_invoke), Tag, Args...>;
-
-template <auto &Tag> using tag_t = std::decay_t<decltype(Tag)>;
-
-
-struct deserialize_tag;
-
-/// These types are deserializable in a built-in way
-template <typename> struct is_builtin_deserializable : std::false_type {};
-template <> struct is_builtin_deserializable<int64_t> : std::true_type {};
-template <> struct is_builtin_deserializable<uint64_t> : std::true_type {};
-template <> struct is_builtin_deserializable<double> : std::true_type {};
-template <> struct is_builtin_deserializable<bool> : std::true_type {};
-template <> struct is_builtin_deserializable<SIMDJSON_IMPLEMENTATION::ondemand::array> : std::true_type {};
-template <> struct is_builtin_deserializable<SIMDJSON_IMPLEMENTATION::ondemand::object> : std::true_type {};
-template <> struct is_builtin_deserializable<SIMDJSON_IMPLEMENTATION::ondemand::value> : std::true_type {};
-template <> struct is_builtin_deserializable<SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string> : std::true_type {};
-template <> struct is_builtin_deserializable<std::string_view> : std::true_type {};
-
-template <typename T>
-concept is_builtin_deserializable_v = is_builtin_deserializable<T>::value;
-
-template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
-concept custom_deserializable = tag_invocable<deserialize_tag, ValT&, T&>;
-
-template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
-concept deserializable = custom_deserializable<T, ValT> || is_builtin_deserializable_v<T>;
-
-template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
-concept nothrow_custom_deserializable = nothrow_tag_invocable<deserialize_tag, ValT&, T&>;
-
-// built-in types are noexcept and if an error happens, the value simply gets ignored and the error is returned.
-template <typename T, typename ValT = SIMDJSON_IMPLEMENTATION::ondemand::value>
-concept nothrow_deserializable = nothrow_custom_deserializable<T, ValT> || is_builtin_deserializable_v<T>;
-
-/// Deserialize Tag
-inline constexpr struct deserialize_tag {
-  using value_type = SIMDJSON_IMPLEMENTATION::ondemand::value;
-  using document_type = SIMDJSON_IMPLEMENTATION::ondemand::document;
-  using document_reference_type = SIMDJSON_IMPLEMENTATION::ondemand::document_reference;
-
-  // Customization Point for value
-  template <typename T>
-    requires 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>
-  [[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>
-  [[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);
-  }
-
-
-} deserialize{};
-
-} // namespace simdjson
-
-#endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
-#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
-

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

@@ -8,12 +8,10 @@
 #include "simdjson/generic/ondemand/json_type.h"
 #include "simdjson/generic/ondemand/raw_json_string.h"
 #include "simdjson/generic/ondemand/value.h"
-#include "simdjson/generic/ondemand/value-inl.h"
 #include "simdjson/generic/ondemand/array-inl.h"
 #include "simdjson/generic/ondemand/json_iterator-inl.h"
 #include "simdjson/generic/ondemand/object-inl.h"
 #include "simdjson/generic/ondemand/value_iterator-inl.h"
-#include "simdjson/generic/ondemand/deserialize.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
 namespace simdjson {
@@ -167,16 +165,6 @@ template<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept {
 template<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }
 
-template<> simdjson_inline error_code document::get(array& out) & noexcept { return get_array().get(out); }
-template<> simdjson_inline error_code document::get(object& out) & noexcept { return get_object().get(out); }
-template<> simdjson_inline error_code document::get(raw_json_string& out) & noexcept { return get_raw_json_string().get(out); }
-template<> simdjson_inline error_code document::get(std::string_view& out) & noexcept { return get_string(false).get(out); }
-template<> simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }
-template<> simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }
-template<> simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }
-template<> simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }
-template<> simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }
-
 template<> simdjson_deprecated simdjson_inline simdjson_result<raw_json_string> document::get() && noexcept { return get_raw_json_string(); }
 template<> simdjson_deprecated simdjson_inline simdjson_result<std::string_view> document::get() && noexcept { return get_string(false); }
 template<> simdjson_deprecated simdjson_inline simdjson_result<double> document::get() && noexcept { return std::forward<document>(*this).get_double(); }
@@ -185,6 +173,13 @@ template<> simdjson_deprecated simdjson_inline simdjson_result<int64_t> document
 template<> simdjson_deprecated simdjson_inline simdjson_result<bool> document::get() && noexcept { return std::forward<document>(*this).get_bool(); }
 template<> simdjson_deprecated simdjson_inline simdjson_result<value> document::get() && noexcept { return get_value(); }
 
+template<typename T> simdjson_inline error_code document::get(T &out) & noexcept {
+  return get<T>().get(out);
+}
+template<typename T> simdjson_deprecated simdjson_inline error_code document::get(T &out) && noexcept {
+  return std::forward<document>(*this).get<T>().get(out);
+}
+
 #if SIMDJSON_EXCEPTIONS
 template <class T>
 simdjson_deprecated simdjson_inline document::operator T() && noexcept(false) { return get<T>(); }
@@ -823,26 +818,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::o
   if (error()) { return error(); }
   return first.is_null();
 }
-template<typename T>
-simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get() & noexcept {
-  if (error()) { return error(); }
-  return first.get<T>();
-}
-template<typename T>
-simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get() && noexcept {
-  if (error()) { return error(); }
-  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>(first).get<T>();
-}
-template <class T>
-simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(T &out) & noexcept {
-  if (error()) { return error(); }
-  return first.get<T>(out);
-}
-template <class T>
-simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(T &out) && noexcept {
-  if (error()) { return error(); }
-  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>(first).get<T>(out);
-}
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::type() noexcept {
   if (error()) { return error(); }
   return first.type();
@@ -855,18 +830,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::o
   if (error()) { return error(); }
   return first.is_string();
 }
-template <>
-simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(SIMDJSON_IMPLEMENTATION::ondemand::document_reference &out) & noexcept {
-  if (error()) { return error(); }
-  out = first;
-  return SUCCESS;
-}
-template <>
-simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(SIMDJSON_IMPLEMENTATION::ondemand::document_reference &out) && noexcept {
-  if (error()) { return error(); }
-  out = first;
-  return SUCCESS;
-}
 simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::is_negative() noexcept {
   if (error()) { return error(); }
   return first.is_negative();
@@ -884,12 +847,10 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::number> simdj
   return first.get_number();
 }
 #if SIMDJSON_EXCEPTIONS
-template <class T>
+template <class T, typename std::enable_if<std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::value == false>::type>
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator T() noexcept(false) {
-  static_assert(std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::value == false, "You should not call get<T> when T is a document");
-  static_assert(std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document>::value == false, "You should not call get<T> when T is a document");
   if (error()) { throw simdjson_error(error()); }
-  return first.get<T>();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }

include/simdjson/generic/ondemand/document.h

@@ -4,11 +4,8 @@
 #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_H
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/ondemand/json_iterator.h"
-#include "simdjson/generic/ondemand/deserialize.h"
-#include "simdjson/generic/ondemand/value.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
-
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -181,39 +178,24 @@ public:
    * @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>
+  template<typename T> simdjson_inline simdjson_result<T> get() & noexcept {
-  simdjson_inline simdjson_result<T> get() &
+    // Unless the simdjson library or the user provides an inline implementation, calling this method should
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
+    // immediately fail.
-    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
+    static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
-#else
+      "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
-    noexcept
+      "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
-#endif
+      " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
-  {
+      " You may also add support for custom types, see our documentation.");
-    static_assert(std::is_default_constructible<T>::value, "Cannot initialize the specified type.");
-    T out{};
-    SIMDJSON_TRY(get<T>(out));
-    return out;
   }
-  /**
+  /** @overload template<typename T> simdjson_result<T> get() & noexcept */
-   * @overload template<typename T> simdjson_result<T> get() & noexcept
+  template<typename T> simdjson_deprecated simdjson_inline simdjson_result<T> get() && noexcept {
-   *
+    // Unless the simdjson library or the user provides an inline implementation, calling this method should
-   * We disallow the use tag_invoke CPO on a moved document; it may create UB
+    // immediately fail.
-   * if user uses `ondemand::array` or `ondemand::object` in their custom type.
+    static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
-   *
+      "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
-   * The member function is still remains specialize-able for compatibility
+      "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
-   * reasons, but we completely disallow its use when a tag_invoke customization
+      " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
-   * is provided.
+      " You may also add support for custom types, see our documentation.");
-   */
-  template<typename T>
-  simdjson_inline simdjson_result<T> get() &&
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
-#else
-    noexcept
-#endif
-  {
-      static_assert(!std::is_same<T, array>::value && !std::is_same<T, object>::value, "You should never hold either an ondemand::array or ondemand::object without a corresponding ondemand::document being alive; that would be Undefined Behaviour.");
-      return static_cast<document&>(*this).get<T>();
   }
 
   /**
@@ -227,32 +209,7 @@ public:
    * @returns INCORRECT_TYPE If the JSON value is not an object.
    * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
    */
-  template<typename T>
+  template<typename T> simdjson_inline error_code get(T &out) & noexcept;
-  simdjson_inline error_code get(T &out) &
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
-#else
-    noexcept
-#endif
-  {
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    if constexpr (custom_deserializable<T, document>) {
-        return deserialize(*this, out);
-    } else {
-#endif // 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. "
-        "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
-        "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
-        " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
-        " You may also add support for custom types, see our documentation.");
-      static_cast<void>(out); // to get rid of unused errors
-      return UNINITIALIZED;
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    }
-#endif
-  }
   /** @overload template<typename T> error_code get(T &out) & noexcept */
   template<typename T> simdjson_deprecated simdjson_inline error_code get(T &out) && noexcept;
 
@@ -354,8 +311,7 @@ public:
    * calling this function, if successful, the array is 'rewinded' at its
    * beginning as if it had never been accessed. If the JSON is malformed (e.g.,
    * there is a missing comma), then an error is returned and it is no longer
-   * safe to continue. Note that count_elements() does not validate the JSON values,
+   * safe to continue.
-   * only the structure of the array.
    */
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
    /**
@@ -467,7 +423,6 @@ public:
   simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
   /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */
   simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;
- simdjson_result<value> operator[](int) & noexcept = delete;
 
   /**
    * Get the type of this JSON value. It does not validate or consume the value.
@@ -736,11 +691,6 @@ protected:
 
 /**
  * A document_reference is a thin wrapper around a document reference instance.
- * The document_reference instances are used primarily/solely for streams of JSON
- * documents. They differ from document instances when parsing a scalar value
- * (a document that is not an array or an object). In the case of a document,
- * we expect the document to be fully consumed. In the case of a document_reference,
- * we allow trailing content.
  */
 class document_reference {
 public:
@@ -766,70 +716,7 @@ public:
   simdjson_inline simdjson_result<value> get_value() noexcept;
 
   simdjson_inline simdjson_result<bool> is_null() noexcept;
-  template <typename T>
+  template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;
-  simdjson_inline simdjson_result<T> get() &
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
-#else
-    noexcept
-#endif
-  {
-    static_assert(std::is_default_constructible<T>::value, "Cannot initialize the specified type.");
-    T out{};
-    SIMDJSON_TRY(get<T>(out));
-    return out;
-  }
-  template<typename T>
-  simdjson_inline simdjson_result<T> get() &&
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
-#else
-    noexcept
-#endif
-  {
-      static_assert(!std::is_same<T, array>::value && !std::is_same<T, object>::value, "You should never hold either an ondemand::array or ondemand::object without a corresponding ondemand::document_reference being alive; that would be Undefined Behaviour.");
-      return static_cast<document&>(*this).get<T>();
-  }
-
-  /**
-   * Get this value as the given type.
-   *
-   * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool, value
-   *
-   * Be mindful that the document instance must remain in scope while you are accessing object, array and value instances.
-   *
-   * @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.
-   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
-   */
-  template<typename T>
-  simdjson_inline error_code get(T &out) &
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document_reference> : true)
-#else
-    noexcept
-#endif
-  {
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    if constexpr (custom_deserializable<T, document_reference>) {
-        return deserialize(*this, out);
-    } else {
-#endif // 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. "
-        "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
-        "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
-        " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
-        " You may also add support for custom types, see our documentation.");
-      static_cast<void>(out); // to get rid of unused errors
-      return UNINITIALIZED;
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    }
-#endif
-  }
-  /** @overload template<typename T> error_code get(T &out) & noexcept */
-  template<typename T> simdjson_inline error_code get(T &out) && noexcept;
   simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
   simdjson_inline operator document&() const noexcept;
 #if SIMDJSON_EXCEPTIONS
@@ -854,7 +741,6 @@ public:
   simdjson_inline simdjson_result<value> find_field(const char *key) & noexcept;
   simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
   simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;
-  simdjson_result<value> operator[](int) & noexcept = delete;
   simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;
   simdjson_inline simdjson_result<value> find_field_unordered(const char *key) & noexcept;
 
@@ -933,7 +819,6 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(const char *key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) & noexcept;
-  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) & noexcept = delete;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(const char *key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
@@ -983,14 +868,8 @@ public:
   simdjson_inline simdjson_result<bool> get_bool() noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> get_value() noexcept;
   simdjson_inline simdjson_result<bool> is_null() noexcept;
-
-  template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;
-  template<typename T> simdjson_inline simdjson_result<T> get() && noexcept;
-
-  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
-  template <class T>
+  template <class T, typename std::enable_if<std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::value == false>::type>
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
@@ -1011,7 +890,6 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(const char *key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) & noexcept;
-  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) & noexcept = delete;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(const char *key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;

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

@@ -152,6 +152,7 @@ simdjson_inline document_stream::iterator::iterator(document_stream* _stream, bo
 }
 
 simdjson_inline simdjson_result<ondemand::document_reference> document_stream::iterator::operator*() noexcept {
+  //if(stream->error) { return stream->error; }
   return simdjson_result<ondemand::document_reference>(stream->doc, stream->error);
 }
 

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

@@ -15,6 +15,134 @@ namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
 
+
+#ifdef SIMDJSON_SUPPORTS_EXTRACT
+
+template <endpoint ...Funcs>
+simdjson_inline error_code object::extract(Funcs&&... endpoints)
+#ifndef _MSC_VER // msvc thinks noexcept is not the same in definition
+ noexcept((nothrow_endpoint<Funcs> && ...))
+#endif
+{
+  raw_json_string field_key;
+  error_code error = SUCCESS;
+  for(auto pair : *this) {
+    if (error = pair.key().get(field_key); error) {
+      break;
+    }
+    std::ignore = ((field_key.unsafe_is_equal(endpoints.key()) ? (error = endpoints(pair.value())) == SUCCESS : true) && ...);
+    if (error) {
+      break;
+    }
+  }
+  return error;
+}
+
+template <typename T>
+struct to {
+private:
+  T *pointer;
+  std::string_view m_key;
+
+public:
+  constexpr explicit(false)
+      to(std::string_view const inp_key, T &obj_ref) noexcept
+      : pointer{std::addressof(obj_ref)}, m_key{inp_key} {}
+
+  constexpr to(to const &) = default;
+  constexpr to(to &&) noexcept = default;
+  constexpr to &operator=(to const &) = default;
+  constexpr to &operator=(to &&) noexcept = default;
+  constexpr ~to() = default;
+
+  [[nodiscard]] constexpr std::string_view key() const noexcept {
+    return m_key;
+  }
+
+  [[nodiscard]] constexpr error_code operator()(simdjson_result<value> val) noexcept(
+      std::is_nothrow_assignable_v<T, simdjson_result<value>>) {
+    return val.get<T>(*pointer);
+  }
+};
+
+template <typename Func>
+  requires(std::is_invocable_v<Func, simdjson_result<value>>)
+struct to<Func> {
+private:
+  Func func;
+  std::string_view m_key;
+
+public:
+  constexpr explicit(false)
+      to(std::string_view const inp_key,
+         Func &&inp_func) noexcept(std::is_nothrow_copy_assignable_v<Func>)
+      : func{std::forward<Func>(inp_func)}, m_key{inp_key} {}
+
+  constexpr to(to const &) = default;
+  constexpr to(to &&) noexcept = default;
+  constexpr to& operator=(to const &) = default;
+  constexpr to& operator=(to &&) noexcept = default;
+  constexpr ~to() = default;
+
+  [[nodiscard]] constexpr std::string_view key() const noexcept {
+    return m_key;
+  }
+
+  [[nodiscard]] constexpr error_code operator()(simdjson_result<value> val) noexcept(
+      std::is_nothrow_invocable_v<Func, simdjson_result<value>>) {
+    if constexpr (std::is_invocable_r_v<error_code, Func, simdjson_result<value>>) {
+      return func(val);
+    } else {
+      static_cast<void>(func(val));
+      return SUCCESS;
+    }
+  }
+};
+
+template <typename Func>
+  requires(std::is_invocable_v<Func, simdjson_result<value>>)
+to(std::string_view, Func &&) -> to<Func>;
+
+template <typename T>
+to(std::string_view, T&) -> to<T>;
+
+template <endpoint... Tos>
+struct sub {
+private:
+  using tuple_type = std::tuple<Tos...>;
+  tuple_type tos;
+
+public:
+
+  // double templating to make perfect forwarding work
+  template <typename ...T>
+    requires ((std::same_as<T, Tos> && ...))
+  explicit constexpr sub(T&&...inp_tos) noexcept(std::is_nothrow_constructible_v<tuple_type, T...>)
+      : tos{std::forward<T>(inp_tos)...} {}
+
+  constexpr sub(sub const &) = default;
+  constexpr sub(sub &&) noexcept = default;
+  constexpr sub &operator=(sub const &) = default;
+  constexpr sub &operator=(sub &&) = default;
+  constexpr ~sub() = default;
+
+  [[nodiscard]] constexpr error_code operator()(simdjson_result<value> val) noexcept((nothrow_endpoint<Tos> && ...)) {
+    object obj;
+    if (auto const err = val.get_object().get(obj); err) {
+      return err;
+    }
+    return std::apply([&obj]<typename... T>(T &&...app_tos) {
+      return obj.extract(std::forward<T>(app_tos)...);
+    }, tos);
+  }
+};
+
+template <endpoint... Tos>
+sub(Tos&&...) -> sub<Tos...>;
+
+#endif
+
+
 simdjson_inline simdjson_result<value> object::find_field_unordered(const std::string_view key) & noexcept {
   bool has_value;
   SIMDJSON_TRY( iter.find_field_unordered_raw(key).get(has_value) );

include/simdjson/generic/ondemand/object.h

@@ -11,6 +11,20 @@ namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
 
+#if defined(__cpp_concepts) && defined(__cpp_consteval)
+#define SIMDJSON_SUPPORTS_EXTRACT 1
+
+template <typename T>
+concept endpoint = std::is_invocable_r_v<error_code, T, simdjson_result<value>> &&
+                   std::is_copy_constructible_v<T> && requires(T to) {
+                     { to.key() } noexcept -> std::convertible_to<std::string_view>;
+                   };
+
+template <typename T>
+concept nothrow_endpoint = endpoint<T> && std::is_nothrow_invocable_r_v<error_code, T, simdjson_result<value>>;
+
+#endif
+
 /**
  * A forward-only JSON object field iterator.
  */
@@ -65,6 +79,21 @@ public:
   /** @overload simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept; */
   simdjson_inline simdjson_result<value> find_field(std::string_view key) && noexcept;
 
+#ifdef SIMDJSON_SUPPORTS_EXTRACT
+  /**
+   * Extract all the fields in one go
+   * Funcs are invocables that take a simdjson_result<value> as input.
+   */
+  template <endpoint ...Funcs>
+  simdjson_inline error_code extract(Funcs&&... endpoints)
+#ifndef _MSC_VER // msvc thinks noexcept is not the same in definition
+ noexcept((nothrow_endpoint<Funcs> && ...))
+#endif
+ ;
+#endif
+
+
+
   /**
    * Look up a field by name on an object, without regard to key order.
    *

include/simdjson/generic/ondemand/parser.h

@@ -84,22 +84,6 @@ public:
    * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the
    * SIMDJSON_PADDING bytes to avoid runtime warnings.
    *
-   * ### std::string references
-   *
-   * If you pass a mutable std::string reference (std::string&), the parser will seek to extend
-   * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.
-   *
-   * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of
-   * the string but before the end of the allocated memory (std::string::capacity()).
-   * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's
-   * container-overflow checks, you may encounter sanitizer warnings.
-   * You can safely ignore these warnings. Or you can call simdjson::pad(std::string&) to pad the
-   * string with SIMDJSON_PADDING spaces: this function returns a simdjson::padding_string_view
-   * which can be be passed to the parser's iterate function:
-   *
-   *    std::string json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )";
-   *    document doc = parser.iterate(simdjson::pad(json));
-   *
    * @param json The JSON to parse.
    * @param len The length of the JSON.
    * @param capacity The number of bytes allocated in the JSON (must be at least len+SIMDJSON_PADDING).
@@ -294,12 +278,8 @@ public:
    * behavior of the parser for future operations.
    */
   bool threaded{true};
-  #else
-  /**
-   * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
-   */
-  bool threaded{false};
   #endif
+
   /**
    * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer.
    * The result must be valid UTF-8.

include/simdjson/generic/ondemand/std_deserialize.h

@@ -1,166 +0,0 @@
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-
-#ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_ONDEMAND_DESERIALIZE_H
-#include "simdjson/generic/ondemand/array.h"
-#include "simdjson/generic/ondemand/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#include <concepts>
-#include <limits>
-
-namespace simdjson {
-template <typename T>
-constexpr bool require_custom_serialization = false;
-
-//////////////////////////////
-// Number deserialization
-//////////////////////////////
-
-template <std::unsigned_integral T>
-  requires(!require_custom_serialization<T>)
-error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
-  using limits = std::numeric_limits<T>;
-
-  uint64_t x;
-  SIMDJSON_TRY(val.get_uint64().get(x));
-  if (x > (limits::max)()) {
-    return NUMBER_OUT_OF_RANGE;
-  }
-  out = static_cast<T>(x);
-  return SUCCESS;
-}
-
-template <std::floating_point T>
-  requires(!require_custom_serialization<T>)
-error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
-  double x;
-  SIMDJSON_TRY(val.get_double().get(x));
-  out = static_cast<T>(x);
-  return SUCCESS;
-}
-
-template <std::signed_integral T>
-  requires(!require_custom_serialization<T>)
-error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
-  using limits = std::numeric_limits<T>;
-
-  int64_t x;
-  SIMDJSON_TRY(val.get_int64().get(x));
-  if (x > (limits::max)() || x < (limits::min)()) {
-    return NUMBER_OUT_OF_RANGE;
-  }
-  out = static_cast<T>(x);
-  return SUCCESS;
-}
-
-/**
- * STL containers have several constructors including one that takes a single
- * size argument. Thus, some compilers (Visual Studio) will not be able to
- * disambiguate between the size and container constructor. Users should
- * explicitly specify the type of the container as needed: e.g.,
- * doc.get<std::vector<int>>().
- */
-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(
-      deserializable<value_type, ValT>,
-      "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;
-  SIMDJSON_TRY(val.get_array().get(arr));
-  for (auto v : arr) {
-    if constexpr (concepts::returns_reference<T>) {
-      if (auto const err = v.get<value_type>().get(concepts::emplace_one(out));
-          err) {
-        // If an error occurs, the empty element that we just inserted gets
-        // removed. We're not using a temp variable because if T is a heavy
-        // type, we want the valid path to be the fast path and the slow path be
-        // the path that has errors in it.
-        if constexpr (requires { out.pop_back(); }) {
-          static_cast<void>(out.pop_back());
-        }
-        return err;
-      }
-    } else {
-      value_type temp;
-      if (auto const err = v.get<value_type>().get(temp); err) {
-        return err;
-      }
-      concepts::emplace_one(out, std::move(temp));
-    }
-  }
-  return SUCCESS;
-}
-
-
-
-/**
- * This CPO (Customization Point Object) will help deserialize into
- * smart pointers.
- *
- * If constructing T is nothrow, this conversion should be nothrow as well since
- * we return MEMALLOC if we're not able to allocate memory instead of throwing
- * the error message.
- *
- * @tparam T The type inside the smart pointer
- * @tparam ValT document/value type
- * @param val document/value
- * @param out a reference to the smart pointer
- * @return status of the conversion
- */
-template <concepts::smart_pointer T, typename ValT>
-  requires(!require_custom_serialization<T>)
-error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::element_type, ValT>) {
-  using element_type = typename std::remove_cvref_t<T>::element_type;
-
-  // For better error messages, don't use these as constraints on
-  // the tag_invoke CPO.
-  static_assert(
-      deserializable<element_type, ValT>,
-      "The specified type inside the unique_ptr must itself be deserializable");
-  static_assert(
-      std::is_default_constructible_v<element_type>,
-      "The specified type inside the unique_ptr must default constructible.");
-
-  auto ptr = new (std::nothrow) element_type();
-  if (ptr == nullptr) {
-    return MEMALLOC;
-  }
-  SIMDJSON_TRY(val.template get<element_type>(*ptr));
-  out.reset(ptr);
-  return SUCCESS;
-}
-
-/**
- * This CPO (Customization Point Object) will help deserialize into optional types.
- */
-template <concepts::optional_type T, typename ValT>
-  requires(!require_custom_serialization<T>)
-error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::value_type, ValT>) {
-  using value_type = typename std::remove_cvref_t<T>::value_type;
-
-  static_assert(
-      deserializable<value_type, ValT>,
-      "The specified type inside the unique_ptr must itself be deserializable");
-  static_assert(
-      std::is_default_constructible_v<value_type>,
-      "The specified type inside the unique_ptr must default constructible.");
-
-  if (!out) {
-    out.emplace();
-  }
-  SIMDJSON_TRY(val.template get<value_type>(out.value()));
-  return SUCCESS;
-}
-
-} // namespace simdjson
-
-#endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
-#endif // SIMDJSON_SUPPORTS_DESERIALIZATION

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

@@ -78,7 +78,6 @@ simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
 simdjson_inline simdjson_result<bool> value::is_null() noexcept {
   return iter.is_null();
 }
-
 template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
 template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
 template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
@@ -89,16 +88,9 @@ template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { ret
 template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
 template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
 
-
+template<typename T> simdjson_inline error_code value::get(T &out) noexcept {
-template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+  return get<T>().get(out);
-template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+}
-template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
-template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
-template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
-template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
-template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
-template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
-template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
 
 #if SIMDJSON_EXCEPTIONS
 template <class T>
@@ -422,12 +414,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::o
   return first.is_null();
 }
 
-template<> simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>(SIMDJSON_IMPLEMENTATION::ondemand::value &out) noexcept {
-  if (error()) { return error(); }
-  out = first;
-  return SUCCESS;
-}
-
 template<typename T> simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get() noexcept {
   if (error()) { return error(); }
   return first.get<T>();
@@ -441,6 +427,11 @@ template<> simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::va
   if (error()) { return error(); }
   return std::move(first);
 }
+template<> simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>(SIMDJSON_IMPLEMENTATION::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
 
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::type() noexcept {
   if (error()) { return error(); }
@@ -474,7 +465,7 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::number> simdj
 template <class T>
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get<T>();
+  return static_cast<T>(first);
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::operator SIMDJSON_IMPLEMENTATION::ondemand::array() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }

include/simdjson/generic/ondemand/value.h

@@ -5,15 +5,12 @@
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/implementation_simdjson_result_base.h"
 #include "simdjson/generic/ondemand/value_iterator.h"
-#include "simdjson/generic/ondemand/deserialize.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
-#include <type_traits>
-
 namespace simdjson {
-
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
+
 /**
  * An ephemeral JSON value returned during iteration. It is only valid for as long as you do
  * not access more data in the JSON document.
@@ -38,21 +35,16 @@ public:
    * @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>
+  template<typename T> simdjson_inline simdjson_result<T> get() noexcept {
-  simdjson_inline simdjson_result<T> get()
+    // Unless the simdjson library or the user provides an inline implementation, calling this method should
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
+    // immediately fail.
-    noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
+    static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
-#else
+      "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
-    noexcept
+      "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
-#endif
+      " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
-  {
+      " You may also add support for custom types, see our documentation.");
-    static_assert(std::is_default_constructible<T>::value, "The specified type is not default constructible.");
-    T out{};
-    SIMDJSON_TRY(get<T>(out));
-    return out;
   }
 
-
   /**
    * Get this value as the given type.
    *
@@ -62,32 +54,7 @@ public:
    * @returns INCORRECT_TYPE If the JSON value is not an object.
    * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
    */
-  template <typename T>
+  template<typename T> simdjson_inline error_code get(T &out) noexcept;
-  simdjson_inline error_code get(T &out)
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
-#else
-    noexcept
-#endif
- {
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    if constexpr (custom_deserializable<T, value>) {
-      return deserialize(*this, out);
-    } else {
-#endif // 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. "
-        "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
-        "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
-        " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
-        " You may also add support for custom types, see our documentation.");
-      static_cast<void>(out); // to get rid of unused errors
-      return UNINITIALIZED;
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-    }
-#endif
-  }
 
   /**
    * Cast this JSON value to an array.
@@ -163,17 +130,6 @@ public:
    * Important: a value should be consumed once. Calling get_string() twice on the same value
    * is an error.
    *
-   * In some instances, you may want to allow replacement of invalid Unicode sequences.
-   * You may do so by passing the allow_replacement parameter as true. In the following
-   * example, the string "431924697b\udff0L\u0001Y" is not valid Unicode. By passing true
-   * to get_string, we allow the replacement of the invalid Unicode sequences with the Unicode
-   * replacement character (U+FFFD).
-   *
-   *   simdjson::ondemand::parser parser;
-   *   auto json = R"({"deviceId":"431924697b\udff0L\u0001Y"})"_padded;
-   *   simdjson::ondemand::document doc = parser.iterate(json);
-   *   auto view = doc["deviceId"].get_string(true);
-   *
    * @returns An UTF-8 string. The string is stored in the parser and will be invalidated the next
    *          time it parses a document or when it is destroyed.
    * @returns INCORRECT_TYPE if the JSON value is not a string.
@@ -425,7 +381,6 @@ public:
   simdjson_inline simdjson_result<value> operator[](std::string_view key) noexcept;
   /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) noexcept; */
   simdjson_inline simdjson_result<value> operator[](const char *key) noexcept;
-  simdjson_result<value> operator[](int) noexcept = delete;
 
   /**
    * Get the type of this JSON value. It does not validate or consume the value.
@@ -793,7 +748,6 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) noexcept;
   /** @overload simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) noexcept; */
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) noexcept;
-  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) noexcept = delete;
 
   /**
    * Get the type of this JSON value.

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

@@ -799,8 +799,6 @@ simdjson_inline simdjson_result<bool> value_iterator::is_root_null(bool check_tr
   if(result) { // we have something that looks like a null.
     if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }
     advance_root_scalar("null");
-  } else if (json[0] == 'n') {
-    return incorrect_type_error("Not a null but starts with n");
   }
   return result;
 }

include/simdjson/haswell/begin.h

@@ -4,14 +4,8 @@
 #include "simdjson/haswell/intrinsics.h"
 
 #if !SIMDJSON_CAN_ALWAYS_RUN_HASWELL
-// We enable bmi2 only if LLVM/clang is used, because GCC may not
-// make good use of it. See https://github.com/simdjson/simdjson/pull/2243
-#if defined(__clang__)
-SIMDJSON_TARGET_REGION("avx2,bmi,bmi2,pclmul,lzcnt,popcnt")
-#else
 SIMDJSON_TARGET_REGION("avx2,bmi,pclmul,lzcnt,popcnt")
 #endif
-#endif
 
 #include "simdjson/haswell/bitmanipulation.h"
 #include "simdjson/haswell/bitmask.h"

include/simdjson/jsonpathutil.h

@@ -1,64 +0,0 @@
-#ifndef SIMDJSON_JSONPATHUTIL_H
-#define SIMDJSON_JSONPATHUTIL_H
-
-#include <string>
-#include <string_view>
-
-namespace simdjson {
-/**
- * Converts JSONPath to JSON Pointer.
- * @param json_path The JSONPath string to be converted.
- * @return A string containing the equivalent JSON Pointer.
- */
-inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
-  size_t i = 0;
-
-  // if JSONPath starts with $, skip it
-  if (!json_path.empty() && json_path.front() == '$') {
-    i = 1;
-  }
-  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.
-  }
-
-  std::string result;
-  // Reserve space to reduce allocations, adjusting for potential increases due
-  // to escaping.
-  result.reserve(json_path.size() * 2);
-
-  while (i < json_path.length()) {
-    if (json_path[i] == '.') {
-      result += '/';
-    } else if (json_path[i] == '[') {
-      result += '/';
-      ++i; // Move past the '['
-      while (i < json_path.length() && json_path[i] != ']') {
-          if (json_path[i] == '~') {
-            result += "~0";
-          } else if (json_path[i] == '/') {
-            result += "~1";
-          } else {
-            result += json_path[i];
-          }
-          ++i;
-      }
-      if (i == json_path.length() || json_path[i] != ']') {
-          return "-1"; // Using sentinel value that will be handled as an error by the caller.
-      }
-    } else {
-      if (json_path[i] == '~') {
-          result += "~0";
-      } else if (json_path[i] == '/') {
-          result += "~1";
-      } else {
-          result += json_path[i];
-      }
-    }
-    ++i;
-  }
-
-  return result;
-}
-} // namespace simdjson
-#endif // SIMDJSON_JSONPATHUTIL_H

include/simdjson/lasx/numberparsing_defs.h

@@ -36,12 +36,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H

include/simdjson/lsx/numberparsing_defs.h

@@ -36,12 +36,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H

include/simdjson/padded_string_view-inl.h

@@ -53,11 +53,6 @@ inline bool padded_string_view::remove_utf8_bom() noexcept {
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string_view> &s) noexcept(false) { return out << s.value(); }
 #endif
 
-inline padded_string_view pad(std::string& s) noexcept {
-  const auto len = s.size();
-  s.append(SIMDJSON_PADDING, ' ');
-  return padded_string_view(s.data(), len, s.size());
-}
 } // namespace simdjson
 
 

include/simdjson/padded_string_view.h

@@ -83,15 +83,6 @@ public:
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string_view> &s) noexcept(false);
 #endif
 
-/**
- * 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.
- *
- * @param s The string.
- * @return The padded string.
- */
-inline padded_string_view pad(std::string& s) noexcept;
 } // namespace simdjson
 
 #endif // SIMDJSON_PADDED_STRING_VIEW_H

include/simdjson/portability.h

@@ -201,43 +201,4 @@ using std::size_t;
 
 #endif
 
-
-
-#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#elif defined _WIN32
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <machine/endian.h>
-#elif defined(sun) || defined(__sun)
-#include <sys/byteorder.h>
-#elif defined(__MVS__)
-#include <sys/endian.h>
-#else
-#ifdef __has_include
-#if __has_include(<endian.h>)
-#include <endian.h>
-#endif //__has_include(<endian.h>)
-#endif //__has_include
-#endif
-#
-#ifndef __BYTE_ORDER__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#ifndef __ORDER_LITTLE_ENDIAN__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#define SIMDJSON_IS_BIG_ENDIAN 1
-#endif
-#endif
-
-
 #endif // SIMDJSON_PORTABILITY_H

include/simdjson/ppc64/numberparsing_defs.h

@@ -60,12 +60,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace ppc64
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_PPC64_NUMBERPARSING_DEFS_H

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 "3.11.0"
+#define SIMDJSON_VERSION "3.10.1"
 
 namespace simdjson {
 enum {
@@ -15,11 +15,11 @@ enum {
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 11,
+  SIMDJSON_VERSION_MINOR = 10,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 0
+  SIMDJSON_VERSION_REVISION = 1
 };
 } // namespace simdjson
 

singleheader/amalgamate.py

@@ -323,10 +323,6 @@ class Amalgamator:
             for line in fid2:
                 line = line.rstrip('\n')
 
-                # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
-                if re.search(r'^#pragma once$', line):
-                    continue
-
                 # Ignore lines inside #ifndef SIMDJSON_CONDITIONAL_INCLUDE
                 if re.search(r'^#ifndef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line):
                     assert file.is_conditional_include, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE but is not an amalgamated file!"

singleheader/simdjson.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2024-12-02 20:24:24 -0500. Do not edit! */
+/* auto-generated on 2024-08-26 09:37:03 -0400. Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -77,18 +77,6 @@
 #endif
 #endif
 
-#ifdef __has_include
-#if __has_include(<version>)
-#include <version>
-#endif
-#endif
-
-#ifdef __cpp_concepts
-#include <utility>
-#define SIMDJSON_SUPPORTS_DESERIALIZATION 1
-#else // __cpp_concepts
-#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
-#endif
 #endif // SIMDJSON_COMPILER_CHECK_H
 /* end file simdjson/compiler_check.h */
 /* including simdjson/portability.h: #include "simdjson/portability.h" */
@@ -296,45 +284,6 @@ using std::size_t;
 
 #endif
 
-
-
-#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#elif defined _WIN32
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <machine/endian.h>
-#elif defined(sun) || defined(__sun)
-#include <sys/byteorder.h>
-#elif defined(__MVS__)
-#include <sys/endian.h>
-#else
-#ifdef __has_include
-#if __has_include(<endian.h>)
-#include <endian.h>
-#endif //__has_include(<endian.h>)
-#endif //__has_include
-#endif
-#
-#ifndef __BYTE_ORDER__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#ifndef __ORDER_LITTLE_ENDIAN__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#define SIMDJSON_IS_BIG_ENDIAN 1
-#endif
-#endif
-
-
 #endif // SIMDJSON_PORTABILITY_H
 /* end file simdjson/portability.h */
 
@@ -600,6 +549,7 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#pragma once
 
 #ifndef NONSTD_SV_LITE_H_INCLUDED
 #define NONSTD_SV_LITE_H_INCLUDED
@@ -2712,122 +2662,6 @@ inline const std::string error_message(int error) noexcept;
 #endif // SIMDJSON_ERROR_H
 /* end file simdjson/error.h */
 /* skipped duplicate #include "simdjson/portability.h" */
-/* including simdjson/concepts.h: #include "simdjson/concepts.h" */
-/* begin file simdjson/concepts.h */
-#ifndef SIMDJSON_CONCEPTS_H
-#define SIMDJSON_CONCEPTS_H
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-
-#include <concepts>
-#include <type_traits>
-
-namespace simdjson {
-namespace concepts {
-
-namespace details {
-#define SIMDJSON_IMPL_CONCEPT(name, method)                                    \
-  template <typename T>                                                        \
-  concept supports_##name = !std::is_const_v<T> && requires {                  \
-    typename std::remove_cvref_t<T>::value_type;                               \
-    requires requires(typename std::remove_cvref_t<T>::value_type &&val,       \
-                      T obj) {                                                 \
-      obj.method(std::move(val));                                              \
-      requires !requires { obj = std::move(val); };                            \
-    };                                                                         \
-  };
-
-SIMDJSON_IMPL_CONCEPT(emplace_back, emplace_back);
-SIMDJSON_IMPL_CONCEPT(emplace, emplace);
-SIMDJSON_IMPL_CONCEPT(push_back, push_back);
-SIMDJSON_IMPL_CONCEPT(add, add);
-SIMDJSON_IMPL_CONCEPT(push, push);
-SIMDJSON_IMPL_CONCEPT(append, append);
-SIMDJSON_IMPL_CONCEPT(insert, insert);
-SIMDJSON_IMPL_CONCEPT(op_append, operator+=);
-
-#undef SIMDJSON_IMPL_CONCEPT
-} // namespace details
-
-/// Check if T is a container that we can append to, including:
-///   std::vector, std::deque, std::list, std::string, ...
-template <typename T>
-concept appendable_containers =
-    details::supports_emplace_back<T> || details::supports_emplace<T> ||
-    details::supports_push_back<T> || details::supports_push<T> ||
-    details::supports_add<T> || details::supports_append<T> ||
-    details::supports_insert<T>;
-
-/// Insert into the container however possible
-template <appendable_containers T, typename... Args>
-constexpr decltype(auto) emplace_one(T &vec, Args &&...args) {
-  if constexpr (details::supports_emplace_back<T>) {
-    return vec.emplace_back(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_emplace<T>) {
-    return vec.emplace(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_push_back<T>) {
-    return vec.push_back(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_push<T>) {
-    return vec.push(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_add<T>) {
-    return vec.add(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_append<T>) {
-    return vec.append(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_insert<T>) {
-    return vec.insert(std::forward<Args>(args)...);
-  } else if constexpr (details::supports_op_append<T> && sizeof...(Args) == 1) {
-    return vec.operator+=(std::forward<Args>(args)...);
-  } else {
-    static_assert(!sizeof(T *),
-                  "We don't know how to add things to this container");
-  }
-}
-
-/// This checks if the container will return a reference to the newly added
-/// element after an insert which for example `std::vector::emplace_back` does
-/// since C++17; this will allow some optimizations.
-template <typename T>
-concept returns_reference = appendable_containers<T> && requires {
-  typename std::remove_cvref_t<T>::reference;
-  requires requires(typename std::remove_cvref_t<T>::value_type &&val, T obj) {
-    {
-      emplace_one(obj, std::move(val))
-    } -> std::same_as<typename std::remove_cvref_t<T>::reference>;
-  };
-};
-
-template <typename T>
-concept smart_pointer = requires(std::remove_cvref_t<T> ptr) {
-  // Check if T has a member type named element_type
-  typename std::remove_cvref_t<T>::element_type;
-
-  // Check if T has a get() member function
-  {
-    ptr.get()
-  } -> std::same_as<typename std::remove_cvref_t<T>::element_type *>;
-
-  // Check if T can be dereferenced
-  { *ptr } -> std::same_as<typename std::remove_cvref_t<T>::element_type &>;
-};
-
-template <typename T>
-concept optional_type = requires(std::remove_cvref_t<T> obj) {
-  typename std::remove_cvref_t<T>::value_type;
-  { obj.value() } -> std::same_as<typename std::remove_cvref_t<T>::value_type&>;
-  requires requires(typename std::remove_cvref_t<T>::value_type &&val) {
-    obj.emplace(std::move(val));
-    obj = std::move(val);
-    {
-      obj.value_or(val)
-    } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
-  };
-  { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
-};
-
-} // namespace concepts
-} // namespace simdjson
-#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
-#endif // SIMDJSON_CONCEPTS_H
-/* end file simdjson/concepts.h */
 
 /**
  * @brief The top level simdjson namespace, containing everything the library provides.
@@ -6613,6 +6447,7 @@ extern SIMDJSON_DLLIMPORTEXPORT const uint64_t thintable_epi8[256];
 
 #endif // SIMDJSON_INTERNAL_SIMDPRUNE_TABLES_H
 /* end file simdjson/internal/simdprune_tables.h */
+
 #endif // SIMDJSON_GENERIC_DEPENDENCIES_H
 /* end file simdjson/generic/dependencies.h */
 /* including generic/dependencies.h: #include <generic/dependencies.h> */
@@ -7788,7 +7623,7 @@ SIMDJSON_NO_SANITIZE_UNDEFINED
 // See issue https://github.com/simdjson/simdjson/issues/1965
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_inline int trailing_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   unsigned long ret;
   // Search the mask data from least significant bit (LSB)
   // to the most significant bit (MSB) for a set bit (1).
@@ -7804,15 +7639,9 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
   return input_num & (input_num-1);
 }
 
-// We sometimes call leading_zeroes on inputs that are zero,
-// but the algorithms do not end up using the returned value.
-// Sadly, sanitizers are not smart enough to figure it out.
-// Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
-// (See below.)
-SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   unsigned long leading_zero = 0;
   // Search the mask data from most significant bit (MSB)
   // to least significant bit (LSB) for a set bit (1).
@@ -7865,7 +7694,7 @@ simdjson_inline uint64_t zero_leading_bit(uint64_t rev_bits, int leading_zeroes)
 #endif
 
 simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2, uint64_t *result) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   *result = value1 + value2;
   return *result < value1;
 #else
@@ -7982,13 +7811,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H
 /* end file simdjson/arm64/numberparsing_defs.h */
@@ -8008,7 +7831,7 @@ namespace arm64 {
 namespace {
 namespace simd {
 
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
 namespace {
 // Start of private section with Visual Studio workaround
 
@@ -8117,7 +7940,7 @@ namespace {
     // We return uint32_t instead of uint16_t because that seems to be more efficient for most
     // purposes (cutting it down to uint16_t costs performance in some compilers).
     simdjson_inline uint32_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       const uint8x16_t bit_mask =  simdjson_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
                                                    0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
 #else
@@ -8148,7 +7971,7 @@ namespace {
     // Splat constructor
     simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
     // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
     simdjson_inline simd8(
       uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
       uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
@@ -8242,7 +8065,7 @@ namespace {
       uint64x2_t shufmask64 = {thintable_epi8[mask1], thintable_epi8[mask2]};
       uint8x16_t shufmask = vreinterpretq_u8_u64(shufmask64);
       // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       uint8x16_t inc = simdjson_make_uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
       uint8x16_t inc = {0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -8272,7 +8095,7 @@ namespace {
       uint8x8_t compactmask1 = vcreate_u8(thintable_epi8[mask1]);
       uint8x8_t compactmask2 = vcreate_u8(thintable_epi8[mask2]);
       // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       uint8x8_t inc = simdjson_make_uint8x8_t(0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
       uint8x8_t inc = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -8324,7 +8147,7 @@ namespace {
     // Array constructor
     simdjson_inline simd8(const int8_t* values) : simd8(load(values)) {}
     // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
     simdjson_inline simd8(
       int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3, int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
       int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
@@ -8445,7 +8268,7 @@ namespace {
     }
 
     simdjson_inline uint64_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       const uint8x16_t bit_mask = simdjson_make_uint8x16_t(
         0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
         0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
@@ -9605,6 +9428,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -10555,7 +10379,7 @@ SIMDJSON_NO_SANITIZE_UNDEFINED
 // See issue https://github.com/simdjson/simdjson/issues/1965
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_inline int trailing_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   unsigned long ret;
   // Search the mask data from least significant bit (LSB)
   // to the most significant bit (MSB) for a set bit (1).
@@ -10571,15 +10395,9 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
   return input_num & (input_num-1);
 }
 
-// We sometimes call leading_zeroes on inputs that are zero,
-// but the algorithms do not end up using the returned value.
-// Sadly, sanitizers are not smart enough to figure it out.
-// Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
-// (See below.)
-SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   unsigned long leading_zero = 0;
   // Search the mask data from most significant bit (MSB)
   // to least significant bit (LSB) for a set bit (1).
@@ -10632,7 +10450,7 @@ simdjson_inline uint64_t zero_leading_bit(uint64_t rev_bits, int leading_zeroes)
 #endif
 
 simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2, uint64_t *result) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
   *result = value1 + value2;
   return *result < value1;
 #else
@@ -10749,13 +10567,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H
 /* end file simdjson/arm64/numberparsing_defs.h */
@@ -10775,7 +10587,7 @@ namespace arm64 {
 namespace {
 namespace simd {
 
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
 namespace {
 // Start of private section with Visual Studio workaround
 
@@ -10884,7 +10696,7 @@ namespace {
     // We return uint32_t instead of uint16_t because that seems to be more efficient for most
     // purposes (cutting it down to uint16_t costs performance in some compilers).
     simdjson_inline uint32_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       const uint8x16_t bit_mask =  simdjson_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
                                                    0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
 #else
@@ -10915,7 +10727,7 @@ namespace {
     // Splat constructor
     simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
     // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
     simdjson_inline simd8(
       uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
       uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
@@ -11009,7 +10821,7 @@ namespace {
       uint64x2_t shufmask64 = {thintable_epi8[mask1], thintable_epi8[mask2]};
       uint8x16_t shufmask = vreinterpretq_u8_u64(shufmask64);
       // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       uint8x16_t inc = simdjson_make_uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
       uint8x16_t inc = {0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -11039,7 +10851,7 @@ namespace {
       uint8x8_t compactmask1 = vcreate_u8(thintable_epi8[mask1]);
       uint8x8_t compactmask2 = vcreate_u8(thintable_epi8[mask2]);
       // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       uint8x8_t inc = simdjson_make_uint8x8_t(0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
       uint8x8_t inc = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -11091,7 +10903,7 @@ namespace {
     // Array constructor
     simdjson_inline simd8(const int8_t* values) : simd8(load(values)) {}
     // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
     simdjson_inline simd8(
       int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3, int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
       int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
@@ -11212,7 +11024,7 @@ namespace {
     }
 
     simdjson_inline uint64_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
       const uint8x16_t bit_mask = simdjson_make_uint8x16_t(
         0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
         0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
@@ -14303,14 +14115,8 @@ static_assert(sizeof(__m256i) <= simdjson::SIMDJSON_PADDING, "insufficient paddi
 /* end file simdjson/haswell/intrinsics.h */
 
 #if !SIMDJSON_CAN_ALWAYS_RUN_HASWELL
-// We enable bmi2 only if LLVM/clang is used, because GCC may not
-// make good use of it. See https://github.com/simdjson/simdjson/pull/2243
-#if defined(__clang__)
-SIMDJSON_TARGET_REGION("avx2,bmi,bmi2,pclmul,lzcnt,popcnt")
-#else
 SIMDJSON_TARGET_REGION("avx2,bmi,pclmul,lzcnt,popcnt")
 #endif
-#endif
 
 /* including simdjson/haswell/bitmanipulation.h: #include "simdjson/haswell/bitmanipulation.h" */
 /* begin file simdjson/haswell/bitmanipulation.h */
@@ -15964,6 +15770,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -16941,14 +16748,8 @@ static_assert(sizeof(__m256i) <= simdjson::SIMDJSON_PADDING, "insufficient paddi
 /* end file simdjson/haswell/intrinsics.h */
 
 #if !SIMDJSON_CAN_ALWAYS_RUN_HASWELL
-// We enable bmi2 only if LLVM/clang is used, because GCC may not
-// make good use of it. See https://github.com/simdjson/simdjson/pull/2243
-#if defined(__clang__)
-SIMDJSON_TARGET_REGION("avx2,bmi,bmi2,pclmul,lzcnt,popcnt")
-#else
 SIMDJSON_TARGET_REGION("avx2,bmi,pclmul,lzcnt,popcnt")
 #endif
-#endif
 
 /* including simdjson/haswell/bitmanipulation.h: #include "simdjson/haswell/bitmanipulation.h" */
 /* begin file simdjson/haswell/bitmanipulation.h */
@@ -22183,6 +21984,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -26948,13 +26750,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace ppc64
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_PPC64_NUMBERPARSING_DEFS_H
 /* end file simdjson/ppc64/numberparsing_defs.h */
@@ -28558,6 +28354,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -29697,13 +29494,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace ppc64
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_PPC64_NUMBERPARSING_DEFS_H
 /* end file simdjson/ppc64/numberparsing_defs.h */
@@ -35299,6 +35090,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -40384,13 +40176,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lsx/numberparsing_defs.h */
@@ -41864,6 +41650,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -42918,13 +42705,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lsx/numberparsing_defs.h */
@@ -46378,13 +46159,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lasx/numberparsing_defs.h */
@@ -47874,6 +47649,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -48928,13 +48704,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lasx/numberparsing_defs.h */
@@ -52418,13 +52188,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H
 /* end file simdjson/fallback/numberparsing_defs.h */
@@ -53483,6 +53247,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
   //
   // Check for minus sign
   //
@@ -54557,13 +54322,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson
 
-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif
 
 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H
 /* end file simdjson/fallback/numberparsing_defs.h */

tests/dom/CMakeLists.txt

@@ -12,7 +12,6 @@ add_cpp_test(errortests                 LABELS dom acceptance per_implementation
 add_cpp_test(extracting_values_example  LABELS dom acceptance per_implementation)
 add_cpp_test(integer_tests              LABELS dom acceptance per_implementation)
 add_cpp_test(jsoncheck                  LABELS dom acceptance per_implementation)
-add_cpp_test(json_path_tests            LABELS dom acceptance per_implementation)
 add_cpp_test(minefieldcheck             LABELS dom acceptance per_implementation)
 add_cpp_test(numberparsingcheck         LABELS dom acceptance per_implementation) # https://tools.ietf.org/html/rfc6901
 add_cpp_test(parse_many_test            LABELS dom acceptance per_implementation)

tests/dom/json_path_tests.cpp

@@ -1,350 +0,0 @@
-/**
- * refer to pathcheck.cpp
- */
-
-#include <iostream>
-#include <string>
-using namespace std::string_literals;
-
-#include "simdjson.h"
-#include "test_macros.h"
-
-// we define our own asserts to get around NDEBUG
-#ifndef ASSERT
-#define ASSERT(x)                                                              \
-  {                                                                            \
-    if (!(x)) {                                                                \
-      std::cerr << "Failed assertion " << #x << std::endl;                     \
-      return false;                                                            \
-    }                                                                          \
-  }
-#endif
-
-using namespace simdjson;
-
-bool demo() {
-#if SIMDJSON_EXCEPTIONS
-  std::cout << "demo test" << std::endl;
-  auto cars_json = R"( [
-  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-] )"_padded;
-  dom::parser parser;
-  dom::element cars = parser.parse(cars_json);
-  double x = cars.at_path("$[0].tire_pressure[1]");
-  if (x != 39.9)
-    return false;
-  // Iterating through an array of objects
-  std::vector<double> measured;
-  for (dom::element car_element : cars) {
-    dom::object car;
-    simdjson::error_code error;
-    if ((error = car_element.get(car))) {
-      std::cerr << error << std::endl;
-      return false;
-    }
-    double x3 = car.at_path("$.tire_pressure[1]");
-    measured.push_back(x3);
-  }
-  std::vector<double> expected = {39.9, 31, 30};
-  if (measured != expected) {
-    return false;
-  }
-#endif
-  return true;
-}
-
-const padded_string TEST_JSON = R"(
-  {
-    "/~01abc": [
-      0,
-      {
-        "\\\" 0": [
-          "value0",
-          "value1"
-        ]
-      }
-    ],
-    "0": "0 ok",
-    "01": "01 ok",
-    "": "empty ok",
-    "arr": []
-  }
-)"_padded;
-
-const padded_string TEST_RFC_JSON = R"(
-   {
-      "foo": ["bar", "baz"],
-      "": 0,
-      "a/b": 1,
-      "c%d": 2,
-      "e^f": 3,
-      "g|h": 4,
-      "i\\j": 5,
-      "k\"l": 6,
-      " ": 7,
-      "m~n": 8
-   }
-)"_padded;
-
-bool run_success_test(const padded_string &source, const char *json_path,
-                      std::string_view expected_value) {
-  std::cout << "Running successful JSONPath test '" << json_path << "' ..."
-            << std::endl;
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(source).get(doc);
-  if (error) {
-    std::cerr << "cannot parse: " << error << std::endl;
-    return false;
-  }
-  dom::element answer;
-  error = doc.at_path(json_path).get(answer);
-  if (error) {
-    std::cerr << "cannot access pointer: " << error << std::endl;
-    return false;
-  }
-  std::string str_answer = simdjson::minify(answer);
-  if (str_answer != expected_value) {
-    std::cerr << "They differ!!!" << std::endl;
-    std::cerr << "   found    '" << str_answer << "'" << std::endl;
-    std::cerr << "   expected '" << expected_value << "'" << std::endl;
-  }
-  ASSERT_EQUAL(str_answer, expected_value);
-  return true;
-}
-
-bool run_failure_test(const padded_string &source, const char *json_path,
-                      error_code expected_error) {
-  std::cout << "Running invalid JSONPath test '" << json_path << "' ..."
-            << std::endl;
-  dom::parser parser;
-  ASSERT_ERROR(parser.parse(source).at_path(json_path).error(), expected_error);
-  return true;
-}
-
-bool demo_relative_path() {
-  TEST_START();
-  auto cars_json = R"( [
-        { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-        { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-        { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-        ] )"_padded;
-
-  dom::parser parser;
-  dom::element cars;
-  std::vector<double> measured;
-  auto error = parser.parse(cars_json).get(cars);
-  if (error) {
-    std::cerr << "cannot parse: " << error << std::endl;
-    return false;
-  }
-  dom::array cars_array;
-  error = cars.get(cars_array);
-  if (error) {
-    std::cerr << "cannot get array: " << error << std::endl;
-    return false;
-  }
-  for (auto car_element : cars_array) {
-    double x;
-    ASSERT_SUCCESS(car_element.at_path(".tire_pressure[1]").get(x));
-    measured.push_back(x);
-  }
-
-  std::vector<double> expected = {39.9, 31, 30};
-  if (measured != expected) {
-    return false;
-  }
-  TEST_SUCCEED();
-}
-
-bool many_json_paths() {
-  TEST_START();
-  auto cars_json = R"( [
-        { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-        { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-        { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-        ] )"_padded;
-
-  dom::parser parser;
-  dom::element cars;
-  std::vector<double> measured;
-  ASSERT_SUCCESS(parser.parse(cars_json).get(cars));
-  for (int i = 0; i < 3; i++) {
-    double x;
-    std::string json_path = std::string("$[") + std::to_string(i) +
-                            std::string("].tire_pressure[1]");
-    ASSERT_SUCCESS(cars.at_path(json_path).get(x));
-    measured.push_back(x);
-  }
-
-  std::vector<double> expected = {39.9, 31, 30};
-  if (measured != expected) {
-    return false;
-  }
-  TEST_SUCCEED();
-}
-
-bool many_json_paths_object_array() {
-  TEST_START();
-  auto dogcatpotato =
-      R"( { "dog" : [1,2,3], "cat" : [5, 6, 7], "potato" : [1234]})"_padded;
-
-  dom::parser parser;
-  dom::element doc;
-  ASSERT_SUCCESS(parser.parse(dogcatpotato).get(doc));
-  dom::object obj;
-  ASSERT_SUCCESS(doc.get_object().get(obj));
-  int64_t x;
-  ASSERT_SUCCESS(obj.at_path("$.dog[1]").get(x));
-  ASSERT_EQUAL(x, 2);
-  ASSERT_SUCCESS(obj.at_path("$.potato[0]").get(x));
-  ASSERT_EQUAL(x, 1234);
-  TEST_SUCCEED();
-}
-bool many_json_paths_object() {
-  TEST_START();
-  auto cfoofoo2 =
-      R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-  dom::parser parser;
-  dom::element doc;
-  ASSERT_SUCCESS(parser.parse(cfoofoo2).get(doc));
-  dom::object obj;
-  ASSERT_SUCCESS(doc.get_object().get(obj));
-  int64_t x;
-  ASSERT_SUCCESS(obj.at_path("$.c.foo.a[1]").get(x));
-  ASSERT_EQUAL(x, 20);
-  ASSERT_SUCCESS(obj.at_path("$.d.foo2.a.2").get(x));
-  ASSERT_EQUAL(x, 30);
-  ASSERT_SUCCESS(obj.at_path("$.e").get(x));
-  ASSERT_EQUAL(x, 120);
-  TEST_SUCCEED();
-}
-bool many_json_paths_array() {
-  TEST_START();
-  auto cfoofoo2 =
-      R"( [ 111, 2, 3, { "foo": { "a": [ 10, 20, 33 ] }}, { "foo2": { "a": [ 10, 20, 30 ] }}, 1001 ])"_padded;
-  dom::parser parser;
-  dom::element doc;
-  ASSERT_SUCCESS(parser.parse(cfoofoo2).get(doc));
-  dom::array arr;
-  ASSERT_SUCCESS(doc.get_array().get(arr));
-  int64_t x;
-  ASSERT_SUCCESS(arr.at_path("$[3].foo.a[1]").get(x));
-  ASSERT_EQUAL(x, 20);
-  TEST_SUCCEED();
-}
-struct car_type {
-  std::string make;
-  std::string model;
-  uint64_t year;
-  std::vector<double> tire_pressure;
-  car_type(std::string_view _make, std::string_view _model, uint64_t _year,
-           std::vector<double> &&_tire_pressure)
-      : make{_make}, model{_model}, year(_year), tire_pressure(_tire_pressure) {
-  }
-};
-
-bool json_path_invalidation() {
-  TEST_START();
-  auto cars_json = R"( [
-        { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-        { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-        { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-        ] )"_padded;
-
-  dom::parser parser;
-  dom::element cars;
-  std::vector<double> measured;
-  ASSERT_SUCCESS(parser.parse(cars_json).get(cars));
-  std::vector<car_type> content;
-  for (int i = 0; i < 3; i++) {
-    dom::object obj;
-    std::string json_path =
-        std::string("$[") + std::to_string(i) + std::string("]");
-    // Each successive at_path call invalidates
-    // previously parsed values, strings, objects and array.
-    ASSERT_SUCCESS(cars.at_path(json_path).get(obj));
-    // We materialize the object.
-    std::string_view make;
-    ASSERT_SUCCESS(obj["make"].get(make));
-    std::string_view model;
-    ASSERT_SUCCESS(obj["model"].get(model));
-    uint64_t year;
-    ASSERT_SUCCESS(obj["year"].get(year));
-    // We materialize the array.
-    dom::array arr;
-    ASSERT_SUCCESS(obj["tire_pressure"].get(arr));
-    std::vector<double> values;
-    for (auto x : arr) {
-      double value_double;
-      ASSERT_SUCCESS(x.get(value_double));
-      values.push_back(value_double);
-    }
-    content.emplace_back(make, model, year, std::move(values));
-  }
-  std::string expected[] = {"Toyota", "Kia", "Toyota"};
-  int i = 0;
-  for (car_type c : content) {
-    std::cout << c.make << " " << c.model << " " << c.year << "\n";
-    ASSERT_EQUAL(expected[i++], c.make);
-  }
-  TEST_SUCCEED();
-}
-// for 0.5 version and following (standard compliant)
-bool modern_support() {
-#if SIMDJSON_EXCEPTIONS
-  std::cout << "modern test" << std::endl;
-  auto example_json = R"({"key": "value", "array": [0, 1, 2]})"_padded;
-  dom::parser parser;
-  dom::element example = parser.parse(example_json);
-  std::string_view value_str = example.at_path("$.key");
-  ASSERT_EQUAL(value_str, "value");
-  int64_t array0 = example.at_path("$.array[0]");
-  ASSERT_EQUAL(array0, 0);
-  array0 = example.at_path("$.array").at_path("$[0]");
-  ASSERT_EQUAL(array0, 0);
-  ASSERT_ERROR(example.at_path("$.no_such_key").error(), NO_SUCH_FIELD);
-  ASSERT_ERROR(example.at_path("$.array[9]").error(), INDEX_OUT_OF_BOUNDS);
-  ASSERT_ERROR(example.at_path("$.array.not_a_num").error(), INCORRECT_TYPE);
-  ASSERT_ERROR(example.at_path("$.array.").error(), INVALID_JSON_POINTER);
-#endif
-  return true;
-}
-
-int main() {
-  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") &&
-      run_success_test(TEST_RFC_JSON, "$.a/b", "1") &&
-      run_success_test(TEST_RFC_JSON, "$.c%d", "2") &&
-      run_success_test(TEST_RFC_JSON, "$.e^f", "3") &&
-      run_success_test(TEST_RFC_JSON, "$.g|h", "4") &&
-      run_success_test(TEST_RFC_JSON, "$.i\\j", "5") &&
-      run_success_test(TEST_RFC_JSON, "$.k\"l", "6") &&
-      run_success_test(TEST_RFC_JSON, "$. ", "7") &&
-      run_success_test(TEST_RFC_JSON, "$.m~n", "8") &&
-      run_success_test(TEST_JSON, "$./~01abc",
-                       R"([0,{"\\\" 0":["value0","value1"]}])") &&
-      run_success_test(TEST_JSON, "$./~01abc[1]",
-                       R"({"\\\" 0":["value0","value1"]})") &&
-      run_success_test(TEST_JSON, "$./~01abc[1].\\\" 0",
-                       R"(["value0","value1"])") &&
-      run_success_test(TEST_JSON, "$.arr", R"([])") // get array
-      &&
-      run_failure_test(TEST_JSON, R"($./~01abc[1].\\\" 0[2])", NO_SUCH_FIELD) &&
-      run_failure_test(TEST_JSON, "$.arr[0]", INDEX_OUT_OF_BOUNDS) &&
-      run_failure_test(TEST_JSON, "/~01abc", INVALID_JSON_POINTER) &&
-      run_failure_test(TEST_JSON, ".~1abc", NO_SUCH_FIELD) &&
-      run_failure_test(TEST_JSON, "./~01abc.01", INVALID_JSON_POINTER) &&
-      run_failure_test(TEST_JSON, "./~01abc.", INVALID_JSON_POINTER) &&
-      run_failure_test(TEST_JSON, "./~01abc.-", INDEX_OUT_OF_BOUNDS)) {
-    std::cout << "Success!" << std::endl;
-    return 0;
-  } else {
-    std::cerr << "Failed!" << std::endl;
-    return 1;
-  }
-}

tests/dom/readme_examples.cpp

@@ -461,52 +461,7 @@ void parse_documentation_lowlevel() {
   (void)element;
 }
 
-void simplepad() {
-  std::string json = "[1]";
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(simdjson::pad(json)).get(doc);
-  if(error) { exit(-1); }
-}
-
-void jsondollar() {
-  dom::parser parser;
-  auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-  dom::element doc;
-  auto error = parser.parse(json).get(doc);
-  if(error) { exit(-1); }
-  dom::object obj;
-  error = doc.get_object().get(obj);
-  if(error) { exit(-1); }
-  int64_t x = 0; // initialization to silence unwarranted compiler warning
-  error = obj.at_path("$[3].foo.a[1]").get(x);
-  if(error) { exit(-1); }
-  if(x != 20) { exit(-1); }
-  x = obj.at_path("$.d.foo2.a.2");
-  if(x != 30) { exit(-1); }
-  if(error) { exit(-1); }
-}
-
-void jsonpath() {
-  auto cars_json = R"( [
-    { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-    { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-    { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-  ] )"_padded;
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(cars_json).get(doc);
-  if(error) { exit(-1); }
-  double p = 0.0; // initialization to silence unwarranted compiler warning
-  error = doc.at_path("[0].tire_pressure[1]").get(p);
-  if(error) { exit(-1); }
-  if(p != 39.9) { exit(-1); }
-}
-
 int main() {
-  simplepad();
-  jsonpath();
-  jsondollar();
   basics_dom_1();
   basics_dom_2();
   basics_dom_3();

tests/ondemand/CMakeLists.txt

@@ -2,37 +2,33 @@
 link_libraries(simdjson)
 include_directories(..)
 add_subdirectory(compilation_failure_tests)
-add_cpp_test(ondemand_car_tag_invoke_deserialization LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_log_tests              LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_car_deserialization            LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_log_error_tests        LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_log_tests                      LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_tostring_tests         LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_log_error_tests                LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_active_tests           LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_tostring_tests                 LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_array_tests            LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_active_tests                   LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_array_error_tests      LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_array_tests                    LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_compilation_tests      LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_array_error_tests              LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_document_stream_tests  LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_compilation_tests              LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_error_tests            LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_document_stream_tests          LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_error_location_tests   LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_error_tests                    LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_json_pointer_tests     LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_error_location_tests           LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_json_path_tests        LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_json_pointer_tests             LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_key_string_tests       LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_json_path_tests                LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_misc_tests             LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_key_string_tests               LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_number_tests           LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_misc_tests                     LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_number_in_string_tests LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_number_tests                   LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_object_tests           LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_number_in_string_tests         LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_object_error_tests     LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_object_tests                   LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_ordering_tests         LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_object_error_tests             LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_parse_api_tests        LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_ordering_tests                 LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_readme_examples        LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_parse_api_tests                LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_scalar_tests           LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_readme_examples                LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_to_string              LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_scalar_tests                   LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_twitter_tests          LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_to_string                      LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_wrong_type_error_tests LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_twitter_tests                  LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_iterate_many_csv       LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_wrong_type_error_tests         LABELS ondemand acceptance per_implementation)
+add_cpp_test(ondemand_extract_tests          LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_iterate_many_csv               LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_custom_types_tests             LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_custom_types_document_tests    LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_stl_types_tests                LABELS ondemand acceptance per_implementation)
 if(NOT SIMDJSON_SANITIZE)
   add_cpp_test(ondemand_cacheline              LABELS ondemand acceptance per_implementation)
 endif()

tests/ondemand/ondemand_cacheline.cpp

@@ -21,24 +21,8 @@ long page_size() {
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
-  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size()) <
-    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
+          simdjson::SIMDJSON_PADDING);
-}
-
-bool check_need_allocation() {
-  long ps = page_size();
-  std::vector<std::tuple<uintptr_t,size_t,bool>> test_cases = {
-    {2*ps, 5, false}, {2*ps, ps, true}, {2*ps, 100, false},
-  };
-  for(auto t : test_cases) {
-    uintptr_t buf = std::get<0>(t);
-    size_t len = std::get<1>(t);
-    bool expected = std::get<2>(t);
-    if(need_allocation(reinterpret_cast<const char *>(buf), len) != expected) {
-      return false;
-    }
-  }
-  return true;
 }
 
 simdjson::padded_string_view
@@ -55,10 +39,6 @@ get_padded_string_view(const char *buf, size_t len,
 
 int main() {
   printf("page_size: %ld\n", page_size());
-  if(!check_need_allocation()) {
-    printf("Bug in the need_allocation function.\n");
-    return EXIT_FAILURE;
-  }
   const char *jsonpoiner = R"(
         {
             "key": "value"

tests/ondemand/ondemand_car_deserialization.cpp

@@ -1,263 +0,0 @@
-#include "simdjson.h"
-#include "test_ondemand.h"
-#include <iostream>
-#include <vector>
-
-using namespace simdjson;
-
-/**
- * A custom type that we want to parse.
- */
-struct Car {
-  std::string make{};
-  std::string model{};
-  int64_t year{};
-  std::vector<double> tire_pressure{};
-  bool operator==(const Car &other) const {
-    return make == other.make && model == other.model && year == other.year &&
-           tire_pressure == other.tire_pressure;
-  }
-};
-
-std::ostream &operator<<(std::ostream &os, const Car &c) {
-  os << c.make << " " << c.model << " " << c.year << " ";
-  for (auto p : c.tire_pressure) {
-    os << p << " ";
-  }
-  return os;
-}
-
-#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>>
-simdjson::ondemand::value::get() noexcept {
-  ondemand::array array;
-  auto error = get_array().get(array);
-  if (error) {
-    return error;
-  }
-  std::vector<double> vec;
-  for (auto v : array) {
-    double val;
-    error = v.get_double().get(val);
-    if (error) {
-      return error;
-    }
-    vec.push_back(val);
-  }
-  return vec;
-}
-#endif
-
-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;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<double>>().get(
-           car.tire_pressure))) {
-    return error;
-  }
-  return car;
-}
-
-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;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<double>>().get(
-           car.tire_pressure))) {
-    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;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<double>>().get(
-           car.tire_pressure))) {
-    return error;
-  }
-  return car;
-}
-
-int main_should_compile(void) {
-  padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-  for (auto val : doc) {
-#if SIMDJSON_EXCEPTIONS
-    Car c(val); // an exception may be thrown
-#else
-    Car c;
-    if (auto error = val.get<Car>().get(c)) {
-      std::cerr << error << std::endl;
-      return EXIT_FAILURE;
-    }
-#endif
-  }
-  return EXIT_SUCCESS;
-}
-
-namespace car_error_tests {
-bool car_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-  std::vector<Car> cars;
-  for (auto val : doc) {
-#if SIMDJSON_EXCEPTIONS
-    Car c(val); // an exception may be thrown
-#else
-    Car c;
-    if (auto error = val.get<Car>().get(c)) {
-      std::cerr << error << std::endl;
-      return EXIT_FAILURE;
-    }
-#endif
-    cars.push_back(c);
-    std::cout << c.make << std::endl;
-  }
-  std::vector<Car> expected = {{"Toyota", "Camry", 2018, {40.1, 39.9}},
-                               {"Kia", "Soul", 2012, {30.1, 31.0}},
-                               {"Toyota", "Tercel", 1999, {29.8, 30.0}}};
-  ASSERT_EQUAL(cars.size(), expected.size());
-  for (size_t i = 0; i < cars.size(); i++) {
-    ASSERT_EQUAL(cars[i], expected[i]);
-  }
-  TEST_SUCCEED();
-}
-
-bool car_doc_deserialize() {
-  TEST_START();
-  padded_string json = R"(  { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-)"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-#if SIMDJSON_EXCEPTIONS
-  Car c(doc);   // an exception may be thrown
-#else
-  Car c;
-  if (auto error = doc.get<Car>().get(c)) {
-    std::cerr << error << std::endl;
-    return EXIT_FAILURE;
-  }
-#endif
-  Car expected = {"Toyota", "Camry", 2018, {40.1, 39.9}};
-  ASSERT_EQUAL(c, expected);
-  TEST_SUCCEED();
-}
-
-bool car_stream_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] }
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-)"_padded;
-  ondemand::parser parser;
-  ondemand::document_stream stream;
-  auto error = parser.iterate_many(json).get(stream);
-  if(error) {
-    std::cerr << error << std::endl;
-    return EXIT_FAILURE;
-  }
-  std::vector<Car> cars;
-
-#if SIMDJSON_EXCEPTIONS
-  for(ondemand::document_reference doc : stream) {
-    //Car c(doc);   // an exception may be thrown
-    cars.push_back(Car(doc)); // an exception may be thrown
-  }
-#else
-  for(auto doc : stream) {
-    Car c;
-    if ((error = doc.get<Car>().get(c))) {
-      std::cerr << error << std::endl;
-      return EXIT_FAILURE;
-    }
-    cars.push_back(c);
-  }
-#endif
-  std::vector<Car> expected = {{"Toyota", "Camry", 2018, {40.1, 39.9}},
-                               {"Kia", "Soul", 2012, {30.1, 31.0}},
-                               {"Toyota", "Tercel", 1999, {29.8, 30.0}}};
-  ASSERT_EQUAL(cars.size(), expected.size());
-  for (size_t i = 0; i < cars.size(); i++) {
-    ASSERT_EQUAL(cars[i], expected[i]);
-  }
-  TEST_SUCCEED();
-}
-
-bool run() { return car_stream_deserialize() && car_doc_deserialize() && car_deserialize(); }
-} // namespace car_error_tests
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, car_error_tests::run);
-}

tests/ondemand/ondemand_car_tag_invoke_deserialization.cpp

@@ -1,335 +0,0 @@
-#include "simdjson.h"
-#include "test_ondemand.h"
-#include <cstdlib>
-#include <iostream>
-#include <vector>
-#include <list>
-#include <optional>
-
-using namespace simdjson;
-
-#if !SIMDJSON_SUPPORTS_DESERIALIZATION
-
-int main(void) {
-  printf("This test is only relevant when SIMDJSON_SUPPORTS_DESERIALIZATION is true (C++20)\n");
-  return EXIT_SUCCESS;
-}
-#else
-
-/**
- * A custom type that we want to parse.
- */
-struct Car {
-  std::string make{};
-  std::string model{};
-  int year{};
-  std::vector<float> tire_pressure{};
-  bool operator==(const Car &other) const {
-    return make == other.make && model == other.model && year == other.year &&
-           tire_pressure == other.tire_pressure;
-  }
-};
-
-std::ostream &operator<<(std::ostream &os, const Car &c) {
-  os << c.make << " " << c.model << " " << c.year << " ";
-  for (auto p : c.tire_pressure) {
-    os << p << " ";
-  }
-  return os;
-}
-
-
-
-namespace simdjson {
-// This tag_invoke MUST be inside simdjson namespace
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
-  ondemand::object obj;
-  auto error = val.get_object().get(obj);
-  if (error) {
-    return error;
-  }
-  if ((error = obj["make"].get_string(car.make))) {
-    return error;
-  }
-  if ((error = obj["model"].get_string(car.model))) {
-    return error;
-  }
-  if ((error = obj["year"].get(car.year))) {
-    return error;
-  }
-  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
-           car.tire_pressure))) {
-    return error;
-  }
-  return simdjson::SUCCESS;
-}
-
-// suppose we want to filter out all Toyotas
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, std::list<Car>& car) {
-  ondemand::array arr;
-  auto error = val.get_array().get(arr);
-  if (error) {
-    return error;
-  }
-  for (auto v : arr) {
-    Car c;
-    if ((error = v.get<Car>().get(c))) {
-      return error;
-    }
-    if(c.make != "Toyota") {
-      car.push_back(c);
-    }
-  }
-  return simdjson::SUCCESS;
-}
-} // namespace simdjson
-
-
-int main_should_compile(void) {
-  padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-  for (auto val : doc) {
-#if SIMDJSON_EXCEPTIONS
-    Car c(val); // an exception may be thrown
-#else
-    Car c;
-    if (auto error = val.get<Car>().get(c)) {
-      std::cerr << error << std::endl;
-      return EXIT_FAILURE;
-    }
-#endif
-  }
-  return EXIT_SUCCESS;
-}
-
-namespace car_error_tests {
-bool car_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-  std::vector<Car> cars;
-  for (auto val : doc) {
-#if SIMDJSON_EXCEPTIONS
-    Car c(val); // an exception may be thrown
-#else
-    Car c;
-    if (auto error = val.get<Car>().get(c)) {
-      std::cerr << error << std::endl;
-      return EXIT_FAILURE;
-    }
-#endif
-    cars.push_back(c);
-    std::cout << c.make << std::endl;
-  }
-  std::vector<Car> expected = {{"Toyota", "Camry", 2018, {40.1f, 39.9f}},
-                               {"Kia", "Soul", 2012, {30.1f, 31.0f}},
-                               {"Toyota", "Tercel", 1999, {29.8f, 30.0f}}};
-  ASSERT_EQUAL(cars.size(), expected.size());
-  for (size_t i = 0; i < cars.size(); i++) {
-    ASSERT_EQUAL(cars[i], expected[i]);
-  }
-  TEST_SUCCEED();
-}
-
-bool vector_car_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-#if SIMDJSON_EXCEPTIONS
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
-  std::vector<Car> cars = doc.get<std::vector<Car>>();  // an exception may be thrown
-#else
-  std::vector<Car> cars(doc); // an exception may be thrown
-#endif
-#else
-  std::vector<Car> cars;
-  if (auto error = doc.get<std::vector<Car>>().get(cars)) {
-    std::cerr << error << std::endl;
-    return EXIT_FAILURE;
-  }
-#endif
-  std::vector<Car> expected = {{"Toyota", "Camry", 2018, {40.1f, 39.9f}},
-                               {"Kia", "Soul", 2012, {30.1f, 31.0f}},
-                               {"Toyota", "Tercel", 1999, {29.8f, 30.0f}}};
-  ASSERT_EQUAL(cars.size(), expected.size());
-  for (size_t i = 0; i < cars.size(); i++) {
-    ASSERT_EQUAL(cars[i], expected[i]);
-  }
-  TEST_SUCCEED();
-}
-
-
-bool list_car_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-#if SIMDJSON_EXCEPTIONS
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
-  std::list<Car> cars = doc.get<std::list<Car>>();  // an exception may be thrown
-#else
-  std::list<Car> cars(doc); // an exception may be thrown
-#endif
-#else
-  std::list<Car> cars;
-  if (auto error = doc.get<std::list<Car>>().get(cars)) {
-    std::cerr << error << std::endl;
-    return EXIT_FAILURE;
-  }
-#endif
-  std::list<Car> expected = {{"Kia", "Soul", 2012, {30.1f, 31.0f}}};
-  ASSERT_EQUAL(cars.size(), expected.size());
-  ASSERT_EQUAL(cars.front(), expected.front());
-  TEST_SUCCEED();
-}
-
-bool optional_car_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( { "car1": { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-})"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto error = parser.iterate(json).get(doc);
-  std::optional<Car> car;
-  error = doc["key not found"].get<std::optional<Car>>().get(car);
-  ASSERT_TRUE(!car);
-  error = doc["car1"].get<std::optional<Car>>().get(car);
-  std::optional<Car> expected = Car{"Toyota", "Camry", 2018, {40.1f, 39.9f}};
-  ASSERT_TRUE(car == expected);
-  TEST_SUCCEED();
-}
-
-bool car_doc_deserialize() {
-  TEST_START();
-  padded_string json = R"(  { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-)"_padded;
-  ondemand::parser parser;
-  ondemand::document doc;
-  [[maybe_unused]] auto doc_error = parser.iterate(json).get(doc);
-#if SIMDJSON_EXCEPTIONS
-  Car c(doc);   // an exception may be thrown
-#else
-  Car c;
-  if (auto error = doc.get<Car>().get(c)) {
-    std::cerr << error << std::endl;
-    return EXIT_FAILURE;
-  }
-#endif
-  Car expected = {"Toyota", "Camry", 2018, {40.1f, 39.9f}};
-  ASSERT_EQUAL(c, expected);
-  TEST_SUCCEED();
-}
-
-
-bool car_stream_deserialize() {
-  TEST_START();
-  padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] }
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] }
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-)"_padded;
-  ondemand::parser parser;
-  ondemand::document_stream stream;
-  [[maybe_unused]] auto error = parser.iterate_many(json).get(stream);
-  std::vector<Car> cars;
-
-#if SIMDJSON_EXCEPTIONS
-  for(auto doc : stream) {
-    cars.push_back((Car)doc); // an exception may be thrown
-  }
-#else
-  for(auto doc : stream) {
-    Car c;
-    if ((error = doc.get<Car>().get(c))) {
-      std::cerr << error << std::endl;
-      return EXIT_FAILURE;
-    }
-    cars.push_back(c);
-  }
-#endif
-  std::vector<Car> expected = {{"Toyota", "Camry", 2018, {40.1f, 39.9f}},
-                               {"Kia", "Soul", 2012, {30.1f, 31.0f}},
-                               {"Toyota", "Tercel", 1999, {29.8f, 30.0f}}};
-  ASSERT_EQUAL(cars.size(), expected.size());
-  for (size_t i = 0; i < cars.size(); i++) {
-    ASSERT_EQUAL(cars[i], expected[i]);
-  }
-  TEST_SUCCEED();
-}
-
-bool car_unique_ptr_deserialize() {
-  TEST_START();
-  auto const json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc;
-  [[maybe_unused]] auto error = parser.iterate(json).get(doc);
-#if SIMDJSON_EXCEPTIONS
-  std::unique_ptr<Car> c(doc);
-#else
-  std::unique_ptr<Car> c;
-  if ((error = doc.get<std::unique_ptr<Car>>().get(c))) {
-    std::cerr << error << std::endl;
-    return EXIT_FAILURE;
-  }
-#endif
-  ASSERT_EQUAL(c->make, "Toyota");
-  TEST_SUCCEED();
-}
-
-bool run() { return list_car_deserialize()
-                    && optional_car_deserialize()
-                    && car_unique_ptr_deserialize()
-                    && vector_car_deserialize()
-                    && car_stream_deserialize()
-                    && car_doc_deserialize()
-                    && car_deserialize(); }
-} // namespace car_error_tests
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, car_error_tests::run);
-}
-#endif // SIMDJSON_SUPPORTS_DESERIALIZATION

tests/ondemand/ondemand_custom_types_document_tests.cpp

@@ -1,178 +0,0 @@
-#include "simdjson.h"
-#include "test_ondemand.h"
-
-#include <string>
-#include <vector>
-
-
-namespace doc_custom_types_tests {
-#if SIMDJSON_EXCEPTIONS && defined(__cpp_concepts)
-struct Car {
-  std::string make{};
-  std::string model{};
-  int64_t year{};
-  std::vector<double> tire_pressure{};
-
-  friend error_code tag_invoke(simdjson::deserialize_tag,
-                                         auto &val, Car& car) {
-    simdjson::ondemand::object obj;
-    if (auto const error = val.get_object().get(obj)) {
-      return error;
-    }
-    // Instead of repeatedly obj["something"], we iterate through the object
-    // which we expect to be faster.
-    for (auto field : obj) {
-      simdjson::ondemand::raw_json_string key;
-      if (auto const error = field.key().get(key)) {
-        return error;
-      }
-      if (key == "make") {
-        if (auto const error = field.value().get_string(car.make)) {
-          return error;
-        }
-      } else if (key == "model") {
-        if (auto const error = field.value().get_string(car.model)) {
-          return error;
-        }
-      } else if (key == "year") {
-        if (auto const error = field.value().get_int64().get(car.year)) {
-          return error;
-        }
-      } else if (key == "tire_pressure") {
-        if (auto const error = field.value().get<std::vector<double>>().get(
-                car.tire_pressure)) {
-          return error;
-        }
-      }
-    }
-    return error_code::SUCCESS;
-  }
-};
-
-static_assert(simdjson::custom_deserializable<std::unique_ptr<Car>, simdjson::ondemand::value>, "It should be invocable");
-static_assert(simdjson::custom_deserializable<std::unique_ptr<Car>, simdjson::ondemand::document>, "Tag_invoke should work with document as well.");
-static_assert(simdjson::custom_deserializable<std::vector<Car>, simdjson::ondemand::value>, "It should be invocable");
-static_assert(simdjson::custom_deserializable<std::vector<Car>, simdjson::ondemand::document>, "Tag_invoke should work with document as well.");
-
-bool custom_test() {
-  TEST_START();
-  auto const json = R"( {
-      "make": "Toyota",
-      "model": "Camry",
-      "year": 2018,
-      "tire_pressure": [ 40.1, 39.9 ]
- } )"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-
-  // creating car directly from "doc":
-  const std::unique_ptr<Car> car(doc);
-  if (car->make != "Toyota") {
-    return false;
-  }
-  if (car->model != "Camry") {
-    return false;
-  }
-  if (car->year != 2018) {
-    return false;
-  }
-  if (car->tire_pressure.size() != 2) {
-    return false;
-  }
-  TEST_SUCCEED();
-}
-
-bool readme_test() {
-  TEST_START();
-  auto const json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  std::unique_ptr<Car> c(doc);
-  std::cout << c->make << std::endl;
-  TEST_SUCCEED();
-}
-
-
-bool simple_document_test() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  Car c(doc);
-  std::cout << c.make << std::endl;
-  ASSERT_EQUAL(c.make, "Toyota");
-  TEST_SUCCEED();
-}
-
-bool custom_test_crazier() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
-  std::vector<Car> cars = doc.get<std::vector<Car>>();
-#else
-  std::vector<Car> cars(doc);
-#endif
-  for(Car& c : cars) {
-    std::cout << c.year << std::endl;
-    if (c.make != "Toyota" && c.make != "Kia") {
-      return false;
-    }
-    if (c.model != "Camry" && c.model != "Soul" && c.model != "Tercel") {
-      return false;
-    }
-    if (c.year != 2018 && c.year != 2012 && c.year != 1999) {
-      return false;
-    }
-    if (c.tire_pressure.size() != 2) {
-      return false;
-    }
-  }
-  TEST_SUCCEED();
-}
-
-bool simple_document_test_no_except() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  Car c;
-  auto error = doc.get(c);
-  if(error) { std::cerr << simdjson::error_message(error); return false; }
-  std::cout << c.make << std::endl;
-  ASSERT_EQUAL(c.make, "Toyota");
-  TEST_SUCCEED();
-}
-#endif // SIMDJSON_EXCEPTIONS
-bool run() {
-  return
-#if SIMDJSON_EXCEPTIONS && defined(__cpp_concepts)
-      readme_test() &&
-      custom_test() &&
-      simple_document_test() &&
-      simple_document_test_no_except() &&
-      custom_test_crazier() &&
-#endif // SIMDJSON_EXCEPTIONS
-      true;
-}
-
-} // namespace doc_custom_types_tests
-
-int main(const int argc, char *argv[]) {
-  return test_main(argc, argv, doc_custom_types_tests::run);
-}

tests/ondemand/ondemand_custom_types_tests.cpp

@@ -1,195 +0,0 @@
-#include "simdjson.h"
-#include "test_ondemand.h"
-
-#include <string>
-#include <vector>
-
-
-namespace custom_types_tests {
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_DESERIALIZATION
-struct Car {
-  std::string make{};
-  std::string model{};
-  int year{};
-  std::vector<double> tire_pressure{};
-
-  friend simdjson::error_code tag_invoke(simdjson::deserialize_tag, auto &val, Car& car) {
-    simdjson::ondemand::object obj;
-    auto error = val.get_object().get(obj);
-    if (error) {
-      return error;
-    }
-    // Instead of repeatedly obj["something"], we iterate through the object
-    // which we expect to be faster.
-    for (auto field : obj) {
-      simdjson::ondemand::raw_json_string key;
-      error = field.key().get(key);
-      if (error) {
-        return error;
-      }
-      if (key == "make") {
-        error = field.value().get_string(car.make);
-        if (error) {
-          return error;
-        }
-      } else if (key == "model") {
-        error = field.value().get_string(car.model);
-        if (error) {
-          return error;
-        }
-      } else if (key == "year") {
-        error = field.value().get(car.year);
-        if (error) {
-          return error;
-        }
-      } else if (key == "tire_pressure") {
-        error = field.value().get(car.tire_pressure);
-        if (error) {
-          return error;
-        }
-      }
-    }
-    return simdjson::SUCCESS;
-  }
-};
-
-static_assert(simdjson::custom_deserializable<std::unique_ptr<Car>>, "It should be deserializable");
-
-bool custom_uniqueptr_test() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  for (auto val : doc) {
-    std::unique_ptr<Car> c(val);
-    if (c->make != "Toyota" && c->make != "Kia") {
-      return false;
-    }
-    if (c->model != "Camry" && c->model != "Soul" && c->model != "Tercel") {
-      return false;
-    }
-    if (c->year != 2018 && c->year != 2012 && c->year != 1999) {
-      return false;
-    }
-    if (c->tire_pressure.size() != 2) {
-      return false;
-    }
-  }
-
-  TEST_SUCCEED();
-}
-
-
-
-bool custom_test() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  for (auto val : doc) {
-    Car c(val);
-    if (c.make != "Toyota" && c.make != "Kia") {
-      return false;
-    }
-    if (c.model != "Camry" && c.model != "Soul" && c.model != "Tercel") {
-      return false;
-    }
-    if (c.year != 2018 && c.year != 2012 && c.year != 1999) {
-      return false;
-    }
-    if (c.tire_pressure.size() != 2) {
-      return false;
-    }
-  }
-
-  TEST_SUCCEED();
-}
-
-
-
-bool custom_test_crazy() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  for (auto val : doc) {
-    Car c(val);
-    std::cout << c.year << std::endl;
-    if (c.make != "Toyota" && c.make != "Kia") {
-      return false;
-    }
-    if (c.model != "Camry" && c.model != "Soul" && c.model != "Tercel") {
-      return false;
-    }
-    if (c.year != 2018 && c.year != 2012 && c.year != 1999) {
-      return false;
-    }
-    if (c.tire_pressure.size() != 2) {
-      return false;
-    }
-  }
-
-  TEST_SUCCEED();
-}
-
-bool custom_no_except() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-       "tire_pressure": [ 40.1, 39.9 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012,
-       "tire_pressure": [ 30.1, 31.0 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999,
-       "tire_pressure": [ 29.8, 30.0 ] }
-])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  for (auto val : doc) {
-    Car c;
-    auto error = val.get(c);
-    if(error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
-  }
-
-  TEST_SUCCEED();
-}
-#endif // SIMDJSON_EXCEPTIONS
-bool run() {
-  return
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_DESERIALIZATION
-      custom_test() &&
-      custom_uniqueptr_test() &&
-      custom_no_except() &&
-#endif // SIMDJSON_EXCEPTIONS
-      true;
-}
-
-} // namespace custom_types_tests
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, custom_types_tests::run);
-}

tests/ondemand/ondemand_extract_tests.cpp

@@ -0,0 +1,116 @@
+#include "simdjson.h"
+#include "test_ondemand.h"
+
+using namespace simdjson;
+
+namespace multi_get_tests {
+#ifdef __cpp_concepts
+struct Car {
+  std::string_view make;
+  std::string_view model;
+  std::int64_t year = 0;
+  struct wheel_size_type {
+    std::int64_t front = 0;
+    std::int64_t back = 0;
+  } wheels;
+
+  static simdjson_result<Car> create(auto& value) {
+    using ondemand::to;
+    using ondemand::sub;
+
+    simdjson::ondemand::object obj;
+    auto error = value.get_object().get(obj);
+    if (error) {
+      return error;
+    }
+    Car car{};
+    // Instead of this:
+    //     for (auto field : obj) {
+    //       simdjson::ondemand::raw_json_string key;
+    //       error = field.key().get(key);
+    //       if (error) {
+    //         return error;
+    //       }
+    //       if (key == "make") {
+    //         error = field.value().get_string(car.make);
+    //         if (error) {
+    //           return error;
+    //         }
+    //       } else if (key == "model") {
+    //         error = field.value().get_string(car.model);
+    //         if (error) {
+    //           return error;
+    //         }
+    //       } else if (key == "year") {
+    //         error = field.value().get(car.year);
+    //         if (error) {
+    //           return error;
+    //         }
+    //     }
+    //
+    // we can do this now:
+    error = obj.extract(
+      to{"wheels", sub{
+        to{"front", car.wheels.front},
+        to{"back", car.wheels.back},
+      }},
+      to{"make", car.make},
+      to{"model", car.model},
+      to{"year", [&car](auto val) {
+        car.year = val;
+      }});
+    if (error) {
+      return error;
+    }
+    return car;
+  }
+};
+
+bool car_example() {
+  TEST_START();
+  simdjson::padded_string json =
+      R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
+       "tire_pressure": [ 40.1, 39.9 ], "wheels": { "front": 10, "back": 10 } },
+  { "make": "Kia",    "model": "Soul",   "year": 2012,
+       "tire_pressure": [ 30.1, 31.0 ], "wheels": { "front": 10, "back": 10 } },
+  { "make": "Toyota", "model": "Tercel", "year": 1999,
+       "tire_pressure": [ 29.8, 30.0 ], "wheels": { "front": 10, "back": 10 } }
+])"_padded;
+
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc = parser.iterate(json);
+  for (auto val : doc) {
+    auto car = Car::create(val);
+    ASSERT_EQUAL(car.error(), SUCCESS);
+    Car const c(car.value());
+    if (c.make != "Toyota" && c.make != "Kia") {
+      return false;
+    }
+    if (c.model != "Camry" && c.model != "Soul" && c.model != "Tercel") {
+      return false;
+    }
+    if (c.year != 2018 && c.year != 2012 && c.year != 1999) {
+      return false;
+    }
+    if (c.wheels.front != 10 || c.wheels.back != 10) {
+      return false;
+    }
+  }
+
+  TEST_SUCCEED();
+}
+
+#endif
+bool run() {
+  return
+#ifdef __cpp_concepts
+      car_example() &&
+#endif
+      true;
+}
+
+} // namespace multi_get_tests
+
+int main(int argc, char *argv[]) {
+  return test_main(argc, argv, multi_get_tests::run);
+}

tests/ondemand/ondemand_json_path_tests.cpp

@@ -346,54 +346,6 @@ namespace json_path_tests {
         TEST_SUCCEED();
     }
 
-    bool many_json_paths_with_prefix() {
-        TEST_START();
-        // object
-        {
-            auto cfoofoo2 = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-            ondemand::parser parser;
-            ondemand::document doc;
-            ASSERT_SUCCESS(parser.iterate(cfoofoo2).get(doc));
-            ondemand::object obj;
-            ASSERT_SUCCESS(doc.get_object().get(obj));
-            int64_t x;
-            ASSERT_SUCCESS(obj.at_path("$.c.foo.a[1]").get(x));
-            ASSERT_EQUAL(x, 20);
-            ASSERT_SUCCESS(obj.at_path("$.d.foo2.a.2").get(x));
-            ASSERT_EQUAL(x, 30);
-            ASSERT_SUCCESS(obj.at_path("$.e").get(x));
-            ASSERT_EQUAL(x, 120);
-        }
-        // array
-        {
-            auto cfoofoo2 = R"( [ 111, 2, 3, { "foo": { "a": [ 10, 20, 33 ] }}, { "foo2": { "a": [ 10, 20, 30 ] }}, 1001 ])"_padded;
-            ondemand::parser parser;
-            ondemand::document doc;
-            ASSERT_SUCCESS(parser.iterate(cfoofoo2).get(doc));
-            ondemand::array arr;
-            ASSERT_SUCCESS(doc.get_array().get(arr));
-            int64_t x;
-            ASSERT_SUCCESS(arr.at_path("$[3].foo.a[1]").get(x));
-            ASSERT_EQUAL(x, 20);
-        }
-        // onject array
-        {
-            auto dogcatpotato = R"( { "dog" : [1,2,3], "cat" : [5, 6, 7], "potato" : [1234]})"_padded;
-
-            ondemand::parser parser;
-            ondemand::document doc;
-            ASSERT_SUCCESS(parser.iterate(dogcatpotato).get(doc));
-            ondemand::object obj;
-            ASSERT_SUCCESS(doc.get_object().get(obj));
-            int64_t x;
-            ASSERT_SUCCESS(obj.at_path("$.dog[1]").get(x));
-            ASSERT_EQUAL(x, 2);
-            ASSERT_SUCCESS(obj.at_path("$.potato[0]").get(x));
-            ASSERT_EQUAL(x, 1234);
-        }
-        TEST_SUCCEED();
-    }
-
 #if SIMDJSON_EXCEPTIONS
     bool json_path_invalidation_exceptions() {
         TEST_START();
@@ -440,7 +392,6 @@ namespace json_path_tests {
                 many_json_paths_array() &&
                 many_json_paths_object() &&
                 many_json_paths_object_array() &&
-                many_json_paths_with_prefix() &&
                 run_broken_tests() &&
                 json_path_invalidation() &&
                 demo_test() &&

tests/ondemand/ondemand_readme_examples.cpp

@@ -8,15 +8,7 @@
 #endif
 using namespace std;
 using namespace simdjson;
-using error_code = simdjson::error_code;
+using error_code=simdjson::error_code;
-
-bool simplepad() {
-  std::string json = "[1]";
-  ondemand::parser parser;
-  ondemand::document doc;
-  auto error = parser.iterate(simdjson::pad(json)).get(doc);
-  return error == SUCCESS;
-}
 
 bool string1() {
   const char * data = "my data"; // 7 bytes
@@ -57,7 +49,6 @@ struct Car {
   std::vector<double> tire_pressure;
 };
 
-#ifndef __cpp_concepts
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
 simdjson::ondemand::value::get() noexcept {
@@ -75,7 +66,7 @@ simdjson::ondemand::value::get() noexcept {
   }
   return vec;
 }
-#endif
+
 
 
 template <>
@@ -84,13 +75,29 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
   auto error = get_object().get(obj);
   if (error) { return error; }
   Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
+    if (error = field.key().get(key); error) { return error; }
+    if (key == "make") {
+      error = field.value().get_string(car.make);
+      if(error) { return error; }
+    } else if (key == "model") {
+      error = field.value().get_string(car.model);
+      if(error) { return error; }
+    } else if (key == "year") {
+      error = field.value().get_int64().get(car.year);
+      if(error) { return error; }
+    } else if (key == "tire_pressure") {
+      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
+      if (error) { return error; }
+    }
+  }
   return car;
 }
 
+
 int custom_type_without_exceptions() {
   padded_string json = R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] },
@@ -186,8 +193,8 @@ int custom_type_with_exceptions() {
 ])"_padded;
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
-  for (auto value : doc) {
+  for (auto val : doc) {
-    Car c(value);
+    Car c(val);
     std::cout << c.make << std::endl;
   }
   return 0;
@@ -229,19 +236,6 @@ bool gen_raw2() {
   TEST_SUCCEED();
 }
 
-bool jsondollar() {
-  TEST_START();
-  auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-  ondemand::parser parser;
-  ondemand::document doc = parser.iterate(json);
-  ondemand::object obj = doc.get_object();
-  int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
-  ASSERT_EQUAL(x, 20);
-  x = obj.at_path("$.d.foo2.a.2"); // 30
-  ASSERT_EQUAL(x, 30);
-  TEST_SUCCEED();
-}
-
 bool gen_raw3() {
   TEST_START();
   simdjson::ondemand::parser parser;
@@ -1897,7 +1891,6 @@ bool run() {
 #if SIMDJSON_CPLUSPLUS17
     && big_int_array()
 #endif // SIMDJSON_CPLUSPLUS17
-    && jsondollar()
     && big_int_array_as_double()
     && key_raw_json_token()
     && to_optional()
@@ -1926,7 +1919,6 @@ bool run() {
     && using_the_parsed_json_4()
     && using_the_parsed_json_5()
 #endif
-    && simplepad()
     && using_the_parsed_json_6()
     && json_pointer_simple()
     && json_pointer_unicode()

tests/ondemand/ondemand_scalar_tests.cpp

@@ -369,24 +369,15 @@ namespace scalar_tests {
     ondemand::parser parser;
     ondemand::document doc;
     ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    ASSERT_ERROR(doc.is_null(), INCORRECT_TYPE);
+    bool x;
-    TEST_SUCCEED();
+    ASSERT_SUCCESS(doc.is_null().get(x));
-  }
+    ASSERT_TRUE(!x);
-
-  bool nul() {
-    TEST_START();
-    auto json = R"( nul )"_padded;
-    ondemand::parser parser;
-    ondemand::document doc;
-    ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    ASSERT_ERROR(doc.is_null(), INCORRECT_TYPE);
     TEST_SUCCEED();
   }
 
   bool run() {
     return
            nully() &&
-           nul() &&
            string_with_trailing() &&
            uint64_with_trailing() &&
            int64_with_trailing() &&

tests/ondemand/ondemand_stl_types_tests.cpp

@@ -1,257 +0,0 @@
-#include "simdjson.h"
-#include "test_ondemand.h"
-
-#include <string>
-#include <vector>
-#include <list>
-#include <set>
-#include <stack>
-#include <queue>
-#include <deque>
-#include <unordered_set>
-#include <optional>
-
-#if SIMDJSON_SUPPORTS_DESERIALIZATION
-class Array : public std::vector<float> {};
-static_assert(simdjson::concepts::appendable_containers<Array>, "Array must be appendable_containers");
-static_assert(!simdjson::require_custom_serialization<Array>);
-namespace simdjson {
-// This tag_invoke MUST be inside simdjson namespace
-template <typename simdjson_value>
-auto tag_invoke(deserialize_tag, simdjson_value &val, Array& out) {
-    simdjson::ondemand::array arr;
-    SIMDJSON_TRY(val.get_array().get(arr));
-    for (auto v : arr) {
-      float temp;
-      if (auto const err = v.get<float>().get(temp); err) {
-        return err;
-      }
-      out.push_back(temp);
-      out.push_back(temp); // adding it twice
-    }
-    return error_code::SUCCESS;
-}
-} // namespace simdjson
-
-// require_custom_serialization
-#endif // SIMDJSON_SUPPORTS_DESERIALIZATION
-
-namespace stl_types {
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_DESERIALIZATION
-
-bool basic_general_madness() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "codes": [1,2,3,4,18,19] },
-            { "codes": [1,3,4,111,1111] } ])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  std::vector<uint16_t> codes;
-  for (auto val : doc) {
-    simdjson::ondemand::object obj;
-    SIMDJSON_TRY(val.get_object().get(obj));
-    obj["codes"].get(codes); // append to it
-  }
-
-  if (codes.size() != 11) {
-    return false;
-  }
-  if (codes[5] != 19 || codes[7] != 3 || codes[9] != 111) {
-    return false;
-  }
-
-  TEST_SUCCEED();
-}
-
-bool basic_general_madness_vector() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "codes": [1.2, 3.4, 5.6, 7.8, 9.0] },
-            { "codes": [2.2, 4.4, 6.6, 8.8, 10.0] } ])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  std::vector<float> codes;
-  for (auto val : doc) {
-    simdjson::ondemand::object obj;
-    SIMDJSON_TRY(val.get_object().get(obj));
-    obj["codes"].get(codes); // append to it
-  }
-
-  if (codes.size() != 10) {
-    return false;
-  }
-  if (codes[5] != 2.2f || codes[7] != 6.6f || codes[9] != 10.0f) {
-    return false;
-  }
-
-  TEST_SUCCEED();
-}
-
-bool basic_general_madness_list() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "codes": [1.2, 3.4, 5.6, 7.8, 9.0] },
-            { "codes": [2.2, 4.4, 6.6, 8.8, 10.0] } ])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  std::list<float> codes;
-  for (auto val : doc) {
-    simdjson::ondemand::object obj;
-    SIMDJSON_TRY(val.get_object().get(obj));
-    obj["codes"].get(codes); // append to it
-  }
-
-  if (codes.size() != 10) {
-    return false;
-  }
-  if (codes.back() != 10.0f || codes.front() != 1.2f) {
-    return false;
-  }
-
-  TEST_SUCCEED();
-}
-
-
-
-bool basic_general_madness_Array() {
-  TEST_START();
-  simdjson::padded_string json =
-      R"( [ { "codes": [1.2, 3.4, 5.6, 7.8, 9.0] },
-            { "codes": [2.2, 4.4, 6.6, 8.8, 10.0] } ])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  Array codes;
-  for (auto val : doc) {
-    simdjson::ondemand::object obj;
-    SIMDJSON_TRY(val.get_object().get(obj));
-    obj["codes"].get(codes); // append to it
-  }
-  ASSERT_EQUAL(codes.size(), 20);
-  TEST_SUCCEED();
-}
-
-
-template <template <typename...> typename Container, typename ValT = float>
-bool basic_general_madness_container() {
-  TYPED_TEST_START(Container<ValT>);
-
-  simdjson::padded_string json =
-      R"( [ { "codes": [1.0, 3.4, 5.6, 7.8, 9.0] },
-            { "codes": [2.2, 4.4, 6.6, 8.8, 10.0] } ])"_padded;
-
-  simdjson::ondemand::parser parser;
-  simdjson::ondemand::document doc = parser.iterate(json);
-  Container<ValT> codes;
-  for (auto val : doc) {
-    simdjson::ondemand::object obj;
-    SIMDJSON_TRY(val.get_object().get(obj));
-    obj["codes"].get(codes); // append to it
-  }
-
-  if (codes.size() != 10) {
-    return false;
-  }
-
-
-  if constexpr (requires {codes.front();}) {
-    if constexpr (requires {*codes.front();}) {
-      if (*codes.front() != 1.0) {
-        return false;
-      }
-    } else {
-      if (codes.front() != 1.0) {
-        return false;
-      }
-    }
-  }
-  if constexpr (requires {codes.back();} ) {
-    if constexpr (requires {*codes.back();}) {
-      if (*codes.back() != 10.0) {
-        return false;
-      }
-    } else {
-      if (codes.back() != 10.0) {
-        return false;
-      }
-    }
-  }
-
-  TEST_SUCCEED();
-}
-
-
-#endif // SIMDJSON_EXCEPTIONS
-bool run() {
-  return
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_DESERIALIZATION
-      basic_general_madness() &&
-      basic_general_madness_vector() &&
-      basic_general_madness_list() &&
-      basic_general_madness_Array() &&
-      basic_general_madness_container<std::vector>() &&
-      basic_general_madness_container<std::list>() &&
-      basic_general_madness_container<std::set>() &&
-      basic_general_madness_container<std::stack>() &&
-      basic_general_madness_container<std::queue>() &&
-      basic_general_madness_container<std::deque>() &&
-      basic_general_madness_container<std::priority_queue>() &&
-      basic_general_madness_container<std::unordered_set>() &&
-      basic_general_madness_container<std::multiset>() &&
-      basic_general_madness_container<std::unordered_multiset>() &&
-        // double:
-      basic_general_madness_container<std::vector, double>() &&
-      basic_general_madness_container<std::list, double>() &&
-      basic_general_madness_container<std::set, double>() &&
-      basic_general_madness_container<std::stack, double>() &&
-      basic_general_madness_container<std::queue, double>() &&
-      basic_general_madness_container<std::deque, double>() &&
-      basic_general_madness_container<std::priority_queue, double>() &&
-      basic_general_madness_container<std::unordered_set, double>() &&
-      basic_general_madness_container<std::multiset, double>() &&
-      basic_general_madness_container<std::unordered_multiset, double>() &&
-        // unique_ptr<double>:
-      basic_general_madness_container<std::vector, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::list, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::set, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::stack, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::deque, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::queue, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::priority_queue, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::unordered_set, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::multiset, std::unique_ptr<double>>() &&
-      basic_general_madness_container<std::unordered_multiset, std::unique_ptr<double>>() &&
-        // shared_ptr<double>:
-      basic_general_madness_container<std::vector, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::list, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::set, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::stack, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::deque, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::queue, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::priority_queue, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::unordered_set, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::multiset, std::shared_ptr<double>>() &&
-      basic_general_madness_container<std::unordered_multiset, std::shared_ptr<double>>() &&
-        // optional<double>:
-      basic_general_madness_container<std::vector, std::optional<double>>() &&
-      basic_general_madness_container<std::list, std::optional<double>>() &&
-      basic_general_madness_container<std::set, std::optional<double>>() &&
-      basic_general_madness_container<std::stack, std::optional<double>>() &&
-      basic_general_madness_container<std::deque, std::optional<double>>() &&
-      basic_general_madness_container<std::queue, std::optional<double>>() &&
-      basic_general_madness_container<std::priority_queue, std::optional<double>>() &&
-      basic_general_madness_container<std::unordered_set, std::optional<double>>() &&
-      basic_general_madness_container<std::multiset, std::optional<double>>() &&
-      basic_general_madness_container<std::unordered_multiset, std::optional<double>>() &&
-#endif // SIMDJSON_EXCEPTIONS
-      true;
-}
-
-} // namespace stl_types
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, stl_types::run);
-}

tests/test_macros.h

@@ -110,7 +110,6 @@ simdjson_inline bool assert_iterate_error(T &arr, simdjson::error_code expected,
   return assert_equal( count, 1, operation );
 }
 #define TEST_START()                    do { std::cout << "> Running " << __func__ << " ..." << std::endl; } while(0);
-#define TYPED_TEST_START(T)             do { std::cout << "> Running " << __func__ << "<" << typeid(T).name() << "> ..." << std::endl; } while(0);
 #define SUBTEST(NAME, TEST)             do { std::cout << " - Subtest " << (NAME) << " ..." << std::endl; if (!(TEST)) { return false; } } while (0);
 #define ASSERT_EQUAL(ACTUAL, EXPECTED)  do { if (!::assert_equal  ((ACTUAL), (EXPECTED), #ACTUAL)) { return false; } } while (0);
 #define ASSERT_RESULT(ACTUAL, EXPECTED) do { if (!::assert_result ((ACTUAL), (EXPECTED), #ACTUAL)) { return false; } } while (0);