Merge branch 'master' into parse_string_if_needed

.github/ISSUE_TEMPLATE/bug_report.md

@@ -29,9 +29,6 @@ We accept the identification of an issue by a sanitizer or some checker tool (e.
 
 We recommend that you run your tests using different optimization levels. In particular, we recommend your run tests with the simdjson library and you code compiled in debug mode. The simdjson then sets the SIMDJSON_DEVELOPMENT_CHECKS macro to 1, and this triggers additional checks on your code and on the internals of the library. If possible, we recommend that you run tests with sanitizers (e.g., see [No more leaks with sanitize flags in gcc and clang](https://lemire.me/blog/2016/04/20/no-more-leaks-with-sanitize-flags-in-gcc-and-clang/)).  You can compile the library with sanitizers for debugging purposes (e.g., set SIMDJSON_SANITIZE to ON using CMake), but you should also turn on sanitizers on your own code. You may also use tools like valgrind or the commercial equivalent.
 
-Mixing debug and release simdjson code is unsafe: you either build all your code using simdjson in
-release mode or all of it in debug mode.
-
 Before reporting a bug, please ensure that you have read our documentation.
 
 **To Reproduce**
@@ -58,7 +55,6 @@ We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux syste
 * We do not support unreleased or experimental compilers. If you encounter an issue with a
 pre-release version of a compiler, do not report it as a bug to simdjson. However, we always
 invite contributions either in the form an analysis or of a code contribution.
-* Vendors (e.g., Apple and Microsoft) stop supporting old systems. Once a compiler system is no longer supported by its vendor, we no longer support it. We will gladly accept code contributions, but we do not consider it a *bug* if you have issues with an obsolete compiler systems. This policy extends to obsolete standard libraries, linkers and other build tools. Please do not report it as an issue. If you cannot resolve the issue yourself, we encourage you to reach out to the vendor for legacy support.
 
 Under Windows, we support Visual Studio (both with LLVM and without). We do not support MinGW and other alternate compiler systems. Windows users should be aware that there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).
 

.github/pull_request_template.md

@@ -20,7 +20,7 @@ How to verify / test
 Please read before contributing:
 - CONTRIBUTING: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 - HACKING: https://github.com/simdjson/simdjson/blob/master/HACKING.md
-- AI Usage Policy: https://github.com/simdjson/simdjson/blob/master/AI_USAGE_POLICY.md
+
 
 
 If you can, we recommend running our tests with the sanitizers turned on.

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

@@ -19,11 +19,11 @@ jobs:
         sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-18
     - name: Build
       run: |
-        CC=clang-18 CXX=clang++-18 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" CXXFLAGS="${CFLAGS}" \
+        CXX=clang++-18 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc) --config Release
+        cmake --build build/ -j$(nproc)
     - name: Test VLEN=1024
       run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
         ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

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

@@ -19,6 +19,11 @@ jobs:
         sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-17
     - name: Build
       run: |
-        CC=clang-17 CXX=clang++-17 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        CXX=clang++-17 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc) --config Release
+        cmake --build build/ -j$(nproc)
+    - name: Test VLEN=128
+      run: |
+        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
+        export QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
+        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

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

@@ -1,39 +0,0 @@
-name: Ubuntu rvv VLEN=128 (clang 20)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-20
-    - name: Build
-      run: |
-        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
-    - name: Test VLEN=128
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
-    - name: Build VLS
-      run: |
-        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl128b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
-        cmake --build build-vls/ -j$(nproc) --config Release
-    - name: Test VLEN=128 VLS
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

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

@@ -19,21 +19,11 @@ jobs:
         sudo apt-get install -y cmake make g++-14-riscv64-linux-gnu qemu-user-static
     - name: Build
       run: |
-        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS=-march=rv64gcv CXXFLAGS="${CFLAGS}" \
+        CXX=riscv64-linux-gnu-g++-14 CXXFLAGS=-march=rv64gcv \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc) --config Release
+        cmake --build build/ -j$(nproc)
     - name: Test VLEN=256
       run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
         ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
-    - name: Build VLS
-      run: |
-        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS="-march=rv64gcv_zvl256b -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
-        cmake --build build-vls/ -j$(nproc) --config Release
-    - name: Test VLEN=256 VLS
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

.github/workflows/rvv-512-clang-19.yml

@@ -1,39 +0,0 @@
-name: Ubuntu rvv VLEN=512 (clang 19)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install packages
-      run: |
-        sudo apt-get update -q -y
-        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-19
-    - name: Build
-      run: |
-        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
-        cmake --build build/ -j$(nproc) --config Release
-    - name: Test VLEN=512
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
-    - name: Build VLS
-      run: |
-        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl512b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
-        cmake --build build-vls/ -j$(nproc) --config Release
-    - name: Test VLEN=512 VLS
-      run: |
-        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
-        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
-        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

.github/workflows/ubuntu24-checkperf.yml

@@ -1,4 +1,4 @@
-name: Performance check on Ubuntu 24.04 CI (GCC 13)
+name: Performance check on Ubuntu 20.04 CI (GCC 9)
 
 on:
   push:

.github/workflows/ubuntu24-noexcept.yml

@@ -1,4 +1,4 @@
-name: Ubuntu 24.04 CI (GCC 13) without exceptions
+name: Ubuntu 20.04 CI (GCC 9) without exceptions
 
 on: [push, pull_request]
 
@@ -24,7 +24,7 @@ jobs:
           cd .. &&
           mkdir build &&
           cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           make install  &&

.github/workflows/ubuntu24-nothread.yml

@@ -1,4 +1,4 @@
-name: Ubuntu 24.04 CI (GCC 13) Without Threads
+name: Ubuntu 20.04 CI (GCC 9) Without Threads
 
 on: [push, pull_request]
 

.github/workflows/ubuntu24-sani.yml

@@ -1,9 +1,9 @@
-name: Ubuntu 24.04 CI (GCC 13) With Memory Sanitizer
+name: Ubuntu 20.04 CI (GCC 9) With Memory Sanitizer
 
 on: [push, pull_request]
 
 jobs:
-  ubuntu-build-address-sanitizer:
+  ubuntu-build-address-sanitizier:
     if: >-
       ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')

AI_USAGE_POLICY.md

@@ -1,56 +0,0 @@
-# AI Usage Policy
-
-Contributors can use whatever tools they would like to
-craft their contributions, but there must be a **human in the loop**.
-**Contributors must read and review all LLM-generated code or text before they
-ask other project members to review it.** The contributor is always the author
-and is fully accountable for their contributions. Contributors should be
-sufficiently confident that the contribution is high enough quality that asking
-for a review is a good use of scarce maintainer time, and they should be **able
-to answer questions about their work** during review.
-
-We expect that new contributors will be less confident in their contributions,
-and our guidance to them is to **start with small contributions** that they can
-fully understand to build confidence. We aspire to be a welcoming community
-that helps new contributors grow their expertise, but learning involves taking
-small steps, getting feedback, and iterating. Passing maintainer feedback to an
-LLM doesn't help anyone grow, and does not sustain our community.
-
-This policy includes, but is not limited to, the following kinds of
-contributions:
-
-- Code, usually in the form of a pull request
-- Issues or security vulnerabilities
-- Comments and feedback on pull requests
-
-## Extractive Contributions
-
-The reason for our "human-in-the-loop" contribution policy is that processing
-patches, PRs, RFCs, and comments is not free -- it takes a lot of
-maintainer time and energy to review those contributions! Sending the
-unreviewed output of an LLM to open source project maintainers *extracts* work
-from them in the form of design and code review, so we call this kind of
-contribution an "extractive contribution".
-
-## Transparency
-
-For contributions involving significant AI assistance, we encourage you to disclose
-its use and explain your process. If a submission appears to rely heavily on AI
-without disclosure, we may doubt that the **human-in-the-loop** requirement has
-been met. Please show awareness of your use of AI.
-
-## Copyright
-
-Artificial intelligence systems raise many questions around copyright that have
-yet to be answered. Our policy on AI tools is similar to our copyright policy:
-Contributors are responsible for ensuring that they have the right to
-contribute code under the terms of our license, typically meaning that either
-they, their employer, or their collaborators hold the copyright. Using AI tools
-to regenerate copyrighted material does not remove the copyright, and
-contributors are responsible for ensuring that such material does not appear in
-their contributions. Contributions found to violate this policy will be removed
-just like any other offending contribution.
-
-## Reference
-
-- [LLVM AI Tool Use Policy](https://discourse.llvm.org/t/rfc-llvm-ai-tool-policy-human-in-the-loop/89159)

CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.5.0
+    VERSION 4.2.4
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -29,8 +29,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "32.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_VERSION "29.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "32" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_SOVERSION "29" 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)
@@ -92,16 +92,13 @@ add_library(simdjson ${SIMDJSON_SOURCES})
 add_library(simdjson::simdjson ALIAS simdjson)
 set(SIMDJSON_LIBRARIES simdjson)
 
-# Check for <bit> header compatibility
-include(CheckIncludeFileCXX)
-check_include_file_cxx(bit SIMDJSON_HAS_BIT_HEADER)
-
 # Enable precompiled headers for faster builds
 if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-  set(SIMDJSON_PRECOMPILE_HEADERS
+  target_precompile_headers(simdjson PRIVATE
     <algorithm>
     <array>
     <atomic>
+    <bit>
     <cassert>
     <cctype>
     <cerrno>
@@ -114,12 +111,6 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
     <utility>
     <vector>
   )
-
-  if(SIMDJSON_HAS_BIT_HEADER)
-    list(APPEND SIMDJSON_PRECOMPILE_HEADERS <bit>)
-  endif()
-
-  target_precompile_headers(simdjson PRIVATE ${SIMDJSON_PRECOMPILE_HEADERS})
 endif()
 
 if(SIMDJSON_BUILD_STATIC_LIB)

CONTRIBUTING.md

@@ -101,10 +101,3 @@ Getting Started Hacking
 
 An overview of simdjson's directory structure, with pointers to architecture and design
 considerations and other helpful notes, can be found at [HACKING.md](HACKING.md).
-
-
-
-AI Usage Policy
----------------
-
-Please also review our [AI Usage Policy](AI_USAGE_POLICY.md).

Doxyfile

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

@@ -64,8 +64,6 @@ Real-world usage
 - [RonDB](https://github.com/logicalclocks/rondb)
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
 - [mamba](https://github.com/mamba-org/mamba)
-- [Ladybird Browser](https://ladybird.org)
-- [SereneDB](https://github.com/serenedb/serenedb)
 
 
 If you are planning to use simdjson in a product, please work from one of our releases.
@@ -189,7 +187,6 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [JSON::SIMD](https://metacpan.org/pod/JSON::SIMD): Perl bindings; fully-featured JSON module that uses simdjson for decoding.
 - [gemmaJSON](https://github.com/sainttttt/gemmaJSON): Nim JSON parser based on simdjson bindings.
 - [simdjson-java](https://github.com/simdjson/simdjson-java): Java port.
-- [mruby-fast-json](https://github.com/Asmod4n/mruby-fast-json): mruby binding with high API coverage.
 
 About simdjson
 --------------
@@ -212,16 +209,10 @@ We have an in-depth paper focused on the UTF-8 validation:
 
 We also have an informal [blog post providing some background and context](https://branchfree.org/2019/02/25/paper-parsing-gigabytes-of-json-per-second/).
 
-For the video inclined, we had a talk at QCon San Francisco 2019<br />
+For the video inclined, <br />
 [![simdjson at QCon San Francisco 2019](http://img.youtube.com/vi/wlvKAT7SZIQ/0.jpg)](http://www.youtube.com/watch?v=wlvKAT7SZIQ)<br />
 (It was the best voted talk, we're kinda proud of it.)
 
-We also had a CppCon 2025 talk. We show how C++26 reflection allows for one-line serialization (to_json(player)) or deserialization—without invasive macros or manual mapping—using nothing but the C++ standard library. Whether you’re a performance junkie or simply interested in the roadmap for the next decade of C++ development, watch our full talk!
-
-[![simdjson at CppCon 2025](http://img.youtube.com/vi/Mcgk3CxHYMs/0.jpg)](http://www.youtube.com/watch?v=Mcgk3CxHYMs)<br />
-
-
-
 Citing this work
 -----------------
 

benchmark/static_reflect/CMakeLists.txt

@@ -8,7 +8,7 @@ CPMAddPackage(
 
 option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)
 
-if(SIMDJSON_USE_RUST)
+if(SIMDJSON_USER_RUST)
   if(NOT WIN32)
   # We want the check whether Rust is available before trying to build a crate.
   CPMAddPackage(
@@ -39,9 +39,9 @@ if(SIMDJSON_USE_RUST)
       message(STATUS "curl https://sh.rustup.rs -sSf | sh")
     endif()
   endif()
-else(SIMDJSON_USE_RUST)
+else(SIMDJSON_USER_RUST)
   message(STATUS "We will not benchmark serde-benchmark." )
-endif(SIMDJSON_USE_RUST)
+endif(SIMDJSON_USER_RUST)
 
 # Add the benchmark executable targets
 add_subdirectory(twitter_benchmark)

benchmark/static_reflect/citm_catalog_benchmark/CMakeLists.txt

@@ -1,5 +1,4 @@
 add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
-add_executable(benchmark_parsing_citm benchmark_parsing_citm.cpp)
 
 # Link with Rust benchmarking code if available
 if(TARGET serde-benchmark)
@@ -12,29 +11,4 @@ target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::sim
 target_link_libraries(benchmark_serialization_citm_catalog PRIVATE reflectcpp)
 target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
 
-if(TARGET yyjson)
-    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE yyjson)
-    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
 target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
-
-# Configuration for parsing benchmark
-if(TARGET serde-benchmark)
-    target_link_libraries(benchmark_parsing_citm PRIVATE serde-benchmark)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
-endif()
-
-target_link_libraries(benchmark_parsing_citm PRIVATE simdjson::simdjson nlohmann_json)
-
-if(TARGET rapidjson)
-    target_link_libraries(benchmark_parsing_citm PRIVATE rapidjson)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
-endif()
-
-if(TARGET yyjson)
-    target_link_libraries(benchmark_parsing_citm PRIVATE yyjson)
-    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_YYJSON)
-endif()
-
-target_compile_definitions(benchmark_parsing_citm PRIVATE JSON_FILE="${BENCH_CITM_JSON}")

benchmark/static_reflect/citm_catalog_benchmark/benchmark_parsing_citm.cpp

@@ -1,563 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "citm_catalog_data.h"
-#include "nlohmann_citm_catalog_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-#include "rapidjson_citm_catalog_data.h"
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_citm_catalog_data.h"
-#endif
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rust_parsing",
-               bench([&json_str, &result]() {
-                 serde_benchmark::CitmCatalog *catalog = serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
-                 result = (catalog != nullptr);
-                 if (catalog) {
-                   serde_benchmark::free_citm(catalog);
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-template <class T> void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  std::string mutable_json = json_str;
-  simdjson::pad(mutable_json);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
-               bench([&mutable_json, &result]() {
-                 simdjson::ondemand::parser parser;
-                 simdjson::ondemand::document doc;
-                 if(parser.iterate(mutable_json).get(doc)) {
-                   result = false;
-                   return;
-                 }
-                 T my_struct;
-                 if(doc.get<T>().get(my_struct)) {
-                   result = false;
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-template <class T> void bench_simdjson_from_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
-               bench([&padded, &result]() {
-                 T my_struct;
-                 auto err = simdjson::from(padded).get(my_struct);
-                  if (err) {
-                    result = false;
-                    printf("parse error: %s\n", simdjson::error_message(err));
-                    return;
-                  }
-               }));
-}
-#endif
-
-// nlohmann::json deserialization functions
-void from_json(const nlohmann::json &j, CITMPrice &p) {
-    j.at("amount").get_to(p.amount);
-    j.at("audienceSubCategoryId").get_to(p.audienceSubCategoryId);
-    j.at("seatCategoryId").get_to(p.seatCategoryId);
-}
-
-void from_json(const nlohmann::json &j, CITMArea &a) {
-    j.at("areaId").get_to(a.areaId);
-    j.at("blockIds").get_to(a.blockIds);
-}
-
-void from_json(const nlohmann::json &j, CITMSeatCategory &s) {
-    j.at("areas").get_to(s.areas);
-    j.at("seatCategoryId").get_to(s.seatCategoryId);
-}
-
-void from_json(const nlohmann::json &j, CITMPerformance &p) {
-    j.at("id").get_to(p.id);
-    j.at("eventId").get_to(p.eventId);
-    if (j.contains("logo") && !j["logo"].is_null()) {
-        p.logo = j["logo"].get<std::string>();
-    }
-    if (j.contains("name") && !j["name"].is_null()) {
-        p.name = j["name"].get<std::string>();
-    }
-    j.at("prices").get_to(p.prices);
-    j.at("seatCategories").get_to(p.seatCategories);
-    if (j.contains("seatMapImage") && !j["seatMapImage"].is_null()) {
-        p.seatMapImage = j["seatMapImage"].get<std::string>();
-    }
-    j.at("start").get_to(p.start);
-    j.at("venueCode").get_to(p.venueCode);
-}
-
-void from_json(const nlohmann::json &j, CITMEvent &e) {
-    j.at("id").get_to(e.id);
-    j.at("name").get_to(e.name);
-    if (j.contains("description") && !j["description"].is_null()) {
-        e.description = j["description"].get<std::string>();
-    }
-    if (j.contains("logo") && !j["logo"].is_null()) {
-        e.logo = j["logo"].get<std::string>();
-    }
-    j.at("subTopicIds").get_to(e.subTopicIds);
-    if (j.contains("subjectCode") && !j["subjectCode"].is_null()) {
-        e.subjectCode = j["subjectCode"].get<std::string>();
-    }
-    if (j.contains("subtitle") && !j["subtitle"].is_null()) {
-        e.subtitle = j["subtitle"].get<std::string>();
-    }
-    j.at("topicIds").get_to(e.topicIds);
-}
-
-void from_json(const nlohmann::json &j, CitmCatalog &c) {
-    j.at("events").get_to(c.events);
-    j.at("performances").get_to(c.performances);
-}
-
-CitmCatalog nlohmann_deserialize(const std::string &json_str) {
-    nlohmann::json j = nlohmann::json::parse(json_str);
-    return j.get<CitmCatalog>();
-}
-
-void bench_nlohmann_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_nlohmann_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = nlohmann_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-CitmCatalog rapidjson_deserialize(const std::string &json_str) {
-    rapidjson::Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    CitmCatalog catalog;
-
-    // Parse events
-    if (doc.HasMember("events") && doc["events"].IsObject()) {
-        for (auto& m : doc["events"].GetObject()) {
-            CITMEvent event;
-            const auto& e = m.value;
-
-            event.id = e["id"].GetUint64();
-            event.name = e["name"].GetString();
-            if (e.HasMember("description") && !e["description"].IsNull()) {
-                event.description = e["description"].GetString();
-            }
-            if (e.HasMember("logo") && !e["logo"].IsNull()) {
-                event.logo = e["logo"].GetString();
-            }
-
-            event.subTopicIds.clear();
-            for (auto& id : e["subTopicIds"].GetArray()) {
-                event.subTopicIds.push_back(id.GetUint64());
-            }
-
-            if (e.HasMember("subjectCode") && !e["subjectCode"].IsNull()) {
-                event.subjectCode = e["subjectCode"].GetString();
-            }
-            if (e.HasMember("subtitle") && !e["subtitle"].IsNull()) {
-                event.subtitle = e["subtitle"].GetString();
-            }
-
-            event.topicIds.clear();
-            for (auto& id : e["topicIds"].GetArray()) {
-                event.topicIds.push_back(id.GetUint64());
-            }
-
-            catalog.events[m.name.GetString()] = event;
-        }
-    }
-
-    // Parse performances
-    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
-        for (auto& p : doc["performances"].GetArray()) {
-            CITMPerformance perf;
-
-            perf.id = p["id"].GetUint64();
-            perf.eventId = p["eventId"].GetUint64();
-            if (p.HasMember("logo") && !p["logo"].IsNull()) {
-                perf.logo = p["logo"].GetString();
-            }
-            if (p.HasMember("name") && !p["name"].IsNull()) {
-                perf.name = p["name"].GetString();
-            }
-
-            // Parse prices
-            for (auto& price : p["prices"].GetArray()) {
-                CITMPrice pr;
-                pr.amount = price["amount"].GetUint64();
-                pr.audienceSubCategoryId = price["audienceSubCategoryId"].GetUint64();
-                pr.seatCategoryId = price["seatCategoryId"].GetUint64();
-                perf.prices.push_back(pr);
-            }
-
-            // Parse seat categories
-            for (auto& sc : p["seatCategories"].GetArray()) {
-                CITMSeatCategory seatCat;
-                seatCat.seatCategoryId = sc["seatCategoryId"].GetUint64();
-
-                for (auto& area : sc["areas"].GetArray()) {
-                    CITMArea ar;
-                    ar.areaId = area["areaId"].GetUint64();
-                    for (auto& block : area["blockIds"].GetArray()) {
-                        ar.blockIds.push_back(block.GetUint64());
-                    }
-                    seatCat.areas.push_back(ar);
-                }
-                perf.seatCategories.push_back(seatCat);
-            }
-
-            if (p.HasMember("seatMapImage") && !p["seatMapImage"].IsNull()) {
-                perf.seatMapImage = p["seatMapImage"].GetString();
-            }
-            perf.start = p["start"].GetUint64();
-            perf.venueCode = p["venueCode"].GetString();
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    return catalog;
-}
-
-void bench_rapidjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rapidjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = rapidjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-CitmCatalog yyjson_deserialize(const std::string &json_str) {
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("YYJson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    CitmCatalog catalog;
-
-    // Parse events
-    yyjson_val *events = yyjson_obj_get(root, "events");
-    if (events) {
-        size_t idx, max;
-        yyjson_val *key, *val;
-        yyjson_obj_foreach(events, idx, max, key, val) {
-            CITMEvent event;
-
-            event.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
-            const char* name = yyjson_get_str(yyjson_obj_get(val, "name"));
-            if (name) event.name = name;
-
-            yyjson_val *desc = yyjson_obj_get(val, "description");
-            if (desc && !yyjson_is_null(desc)) {
-                const char* str = yyjson_get_str(desc);
-                if (str) event.description = str;
-            }
-
-            yyjson_val *logo = yyjson_obj_get(val, "logo");
-            if (logo && !yyjson_is_null(logo)) {
-                const char* str = yyjson_get_str(logo);
-                if (str) event.logo = str;
-            }
-
-            yyjson_val *subTopics = yyjson_obj_get(val, "subTopicIds");
-            if (subTopics) {
-                size_t sidx, smax;
-                yyjson_val *sval;
-                yyjson_arr_foreach(subTopics, sidx, smax, sval) {
-                    event.subTopicIds.push_back(yyjson_get_uint(sval));
-                }
-            }
-
-            yyjson_val *subjectCode = yyjson_obj_get(val, "subjectCode");
-            if (subjectCode && !yyjson_is_null(subjectCode)) {
-                const char* str = yyjson_get_str(subjectCode);
-                if (str) event.subjectCode = str;
-            }
-
-            yyjson_val *subtitle = yyjson_obj_get(val, "subtitle");
-            if (subtitle && !yyjson_is_null(subtitle)) {
-                const char* str = yyjson_get_str(subtitle);
-                if (str) event.subtitle = str;
-            }
-
-            yyjson_val *topics = yyjson_obj_get(val, "topicIds");
-            if (topics) {
-                size_t tidx, tmax;
-                yyjson_val *tval;
-                yyjson_arr_foreach(topics, tidx, tmax, tval) {
-                    event.topicIds.push_back(yyjson_get_uint(tval));
-                }
-            }
-
-            const char* keyStr = yyjson_get_str(key);
-            if (keyStr) {
-                catalog.events[keyStr] = event;
-            }
-        }
-    }
-
-    // Parse performances
-    yyjson_val *performances = yyjson_obj_get(root, "performances");
-    if (performances) {
-        size_t idx, max;
-        yyjson_val *val;
-        yyjson_arr_foreach(performances, idx, max, val) {
-            CITMPerformance perf;
-
-            perf.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
-            perf.eventId = yyjson_get_uint(yyjson_obj_get(val, "eventId"));
-
-            yyjson_val *logo = yyjson_obj_get(val, "logo");
-            if (logo && !yyjson_is_null(logo)) {
-                const char* str = yyjson_get_str(logo);
-                if (str) perf.logo = str;
-            }
-
-            yyjson_val *name = yyjson_obj_get(val, "name");
-            if (name && !yyjson_is_null(name)) {
-                const char* str = yyjson_get_str(name);
-                if (str) perf.name = str;
-            }
-
-            // Parse prices
-            yyjson_val *prices = yyjson_obj_get(val, "prices");
-            if (prices) {
-                size_t pidx, pmax;
-                yyjson_val *pval;
-                yyjson_arr_foreach(prices, pidx, pmax, pval) {
-                    CITMPrice price;
-                    price.amount = yyjson_get_uint(yyjson_obj_get(pval, "amount"));
-                    price.audienceSubCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "audienceSubCategoryId"));
-                    price.seatCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "seatCategoryId"));
-                    perf.prices.push_back(price);
-                }
-            }
-
-            // Parse seat categories
-            yyjson_val *seatCats = yyjson_obj_get(val, "seatCategories");
-            if (seatCats) {
-                size_t scidx, scmax;
-                yyjson_val *scval;
-                yyjson_arr_foreach(seatCats, scidx, scmax, scval) {
-                    CITMSeatCategory seatCat;
-                    seatCat.seatCategoryId = yyjson_get_uint(yyjson_obj_get(scval, "seatCategoryId"));
-
-                    yyjson_val *areas = yyjson_obj_get(scval, "areas");
-                    if (areas) {
-                        size_t aidx, amax;
-                        yyjson_val *aval;
-                        yyjson_arr_foreach(areas, aidx, amax, aval) {
-                            CITMArea area;
-                            area.areaId = yyjson_get_uint(yyjson_obj_get(aval, "areaId"));
-
-                            yyjson_val *blocks = yyjson_obj_get(aval, "blockIds");
-                            if (blocks) {
-                                size_t bidx, bmax;
-                                yyjson_val *bval;
-                                yyjson_arr_foreach(blocks, bidx, bmax, bval) {
-                                    area.blockIds.push_back(yyjson_get_uint(bval));
-                                }
-                            }
-                            seatCat.areas.push_back(area);
-                        }
-                    }
-                    perf.seatCategories.push_back(seatCat);
-                }
-            }
-
-            yyjson_val *seatMapImage = yyjson_obj_get(val, "seatMapImage");
-            if (seatMapImage && !yyjson_is_null(seatMapImage)) {
-                const char* str = yyjson_get_str(seatMapImage);
-                if (str) perf.seatMapImage = str;
-            }
-
-            perf.start = yyjson_get_uint(yyjson_obj_get(val, "start"));
-            const char* venueCode = yyjson_get_str(yyjson_obj_get(val, "venueCode"));
-            if (venueCode) perf.venueCode = venueCode;
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    yyjson_doc_free(doc);
-    return catalog;
-}
-
-void bench_yyjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_yyjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   CitmCatalog data = yyjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename);
-  stream.exceptions(std::ios_base::badbit);
-
-  if (!stream) {
-    std::cerr << "Error: Failed to open file " << filename << std::endl;
-    exit(EXIT_FAILURE);
-  }
-
-  std::string out;
-  auto buf = std::string(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char *argv[]) {
-  // Get the JSON file path from preprocessor or use default
-  std::string filename;
-#ifdef JSON_FILE
-  filename = JSON_FILE;
-#else
-  filename = "jsonexamples/citm_catalog.json";
-#endif
-
-  std::string json_str = read_file(filename);
-
-  // Parse command-line arguments for filter
-  std::string filter;
-  for (int i = 1; i < argc; i++) {
-    std::string arg = argv[i];
-    if (arg == "-f" && i + 1 < argc) {
-      filter = argv[i + 1];
-      printf("# Filter: %s\n", filter.c_str());
-      i++;
-    }
-  }
-
-  // If no filter provided, run all benchmarks
-  if (filter.empty()) {
-    printf("# Running all benchmarks (use -f <filter> to run specific ones)\n");
-  }
-
-  // Benchmarking the parsing
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann_parsing(json_str);
-  }
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-  if (matches_filter("rapidjson", filter)) {
-    bench_rapidjson_parsing(json_str);
-  }
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson_parsing(json_str);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection_parsing<CitmCatalog>(json_str);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_from", filter)) {
-    bench_simdjson_from_parsing<CitmCatalog>(json_str);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# Note: Rust/Serde parsing test\n");
-    bench_rust_parsing(json_str);
-  }
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog.cpp

@@ -11,10 +11,6 @@
 #include "nlohmann_citm_catalog_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
 
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_citm_catalog_data.h"
-#endif
-
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
@@ -39,15 +35,20 @@ void bench_reflect_cpp(CitmCatalog &data) {
 #include "../serde-benchmark/serde_benchmark.h"
 
 void bench_rust(serde_benchmark::CitmCatalog *data) {
-  serde_benchmark::set_citm_data(data);
+  const char * output = serde_benchmark::str_from_citm(data);
-  size_t output_volume = serde_benchmark::serialize_citm_to_string();
+  size_t output_volume = strlen(output);
   printf("# output volume: %zu bytes\n", output_volume);
-
   volatile size_t measured_volume = 0;
   pretty_print(1, output_volume, "bench_rust",
-               bench([&measured_volume, &output_volume]() {
+               bench([&data, &measured_volume, &output_volume]() {
-                 measured_volume = serde_benchmark::serialize_citm_to_string();
+                 const char * output = serde_benchmark::str_from_citm(data);
+                 measured_volume = strlen(output);
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+                 serde_benchmark::free_str(const_cast<char*>(output));
                }));
+  serde_benchmark::free_str(const_cast<char*>(output));
 }
 #endif // SIMDJSON_RUST_VERSION
 
@@ -67,55 +68,7 @@ void bench_nlohmann(CitmCatalog &data) {
                }));
 }
 
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson(CitmCatalog &data) {
-  std::string output = yyjson_serialize_citm(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize_citm(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
 void bench_simdjson_static_reflection(CitmCatalog &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses buffer across iterations (shows API potential)
-void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
   simdjson::builder::string_builder sb;
   simdjson::builder::append(sb, data);
   std::string_view p;
@@ -127,7 +80,7 @@ void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
                bench([&data, &measured_volume, &output_volume, &sb]() {
                  sb.clear();
                  simdjson::builder::append(sb, data);
@@ -142,97 +95,25 @@ void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
                }));
 }
 
-#if SIMDJSON_STATIC_REFLECTION
+std::string read_file(const std::string &file_path, size_t read_size = 65536) {
-// Fair allocation variant: allocates fresh string each iteration
-void bench_simdjson_to(CitmCatalog &data) {
-  // First run to determine size
-  std::string output_init;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output_init); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 std::string output;
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses pre-allocated string
-void bench_simdjson_to_reuse(CitmCatalog &data) {
-  std::string output;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  // Pre-allocate string with sufficient capacity to avoid reallocation
-  output.reserve(output_volume * 2);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
-               bench([&data, &measured_volume, &output_volume, &output]() {
-                 // Reuse the pre-allocated string - avoids allocation
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
-simdjson::padded_string read_file(const std::string &file_path, size_t read_size = 65536) {
   std::ifstream stream(file_path, std::ios::binary);
   if(!stream) {
     std::cerr << "Could not open file '" << file_path << "'" << std::endl;
     exit(EXIT_FAILURE);
   }
   stream.exceptions(std::ios_base::badbit);
-  simdjson::padded_string_builder builder;
+  std::string out;
   std::string buf(read_size, '\0');
   while (stream.read(&buf[0], read_size)) {
-    builder.append(buf.data(), size_t(stream.gcount()));
+    out.append(buf, 0, size_t(stream.gcount()));
   }
-  builder.append(buf.data(), size_t(stream.gcount()));
+  out.append(buf, 0, size_t(stream.gcount()));
-  return builder.convert();
+  return out;
 }
 
-// Function to check if benchmark name matches any of the comma-separated filters
+// Function to check if benchmark name contains filter substring
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
+  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
 }
 
 int main(int argc, char* argv[]) {
@@ -250,12 +131,12 @@ int main(int argc, char* argv[]) {
       }
   }
   // Testing correctness of round-trip (serialization + deserialization)
-  simdjson::padded_string json_str = read_file(JSON_FILE);
+  std::string json_str = read_file(JSON_FILE);
 
   // Loading up the data into a structure.
   simdjson::ondemand::parser parser;
   simdjson::ondemand::document doc;
-  if(parser.iterate(json_str).get(doc)) {
+  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
     std::cerr << "Error loading the document!" << std::endl;
     return EXIT_FAILURE;
   }
@@ -266,37 +147,18 @@ int main(int argc, char* argv[]) {
   }
 
   // Benchmarking the serialization
-  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
-  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
-  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
-
   if (matches_filter("nlohmann", filter)) {
     bench_nlohmann(my_struct);
   }
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson(my_struct);
-  }
-#endif
   if (matches_filter("simdjson_static_reflection", filter)) {
     bench_simdjson_static_reflection(my_struct);
   }
-  if (matches_filter("simdjson_reuse", filter)) {
-    bench_simdjson_static_reflection_reuse(my_struct);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_to", filter)) {
-    bench_simdjson_to(my_struct);
-  }
-  if (matches_filter("simdjson_to_reuse", filter)) {
-    bench_simdjson_to_reuse(my_struct);
-  }
-#endif
 #ifdef SIMDJSON_RUST_VERSION
   if (matches_filter("rust", filter)) {
+    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
     // Create a Rust-compatible CitmCatalog structure from the JSON string
     serde_benchmark::CitmCatalog* rust_data =
-      serde_benchmark::citm_from_str(json_str.data(), json_str.size());
+      serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
 
     if (rust_data == nullptr) {
       printf("# Failed to initialize Rust data structure\n");

benchmark/static_reflect/citm_catalog_benchmark/citm_catalog_data.h

@@ -4,65 +4,79 @@
 #include <string>
 #include <vector>
 #include <map>
-#include <optional>
-#include <cstdint>
 
-// Price structure - field names must match JSON keys for reflection
+struct Area {
-struct CITMPrice {
+  int64_t id;
-    uint64_t amount;
-    uint64_t audienceSubCategoryId;
-    uint64_t seatCategoryId;
-    bool operator==(const CITMPrice&) const = default;
-};
-
-struct CITMArea {
-    uint64_t areaId;
-    std::vector<uint64_t> blockIds;
-    bool operator==(const CITMArea&) const = default;
-};
-
-struct CITMSeatCategory {
-    std::vector<CITMArea> areas;
-    uint64_t seatCategoryId;
-    bool operator==(const CITMSeatCategory&) const = default;
-};
-
-struct CITMPerformance {
-    uint64_t id;
-    uint64_t eventId;
-    std::optional<std::string> logo;
-    std::optional<std::string> name;
-    std::vector<CITMPrice> prices;
-    std::vector<CITMSeatCategory> seatCategories;
-    std::optional<std::string> seatMapImage;
-    uint64_t start;
-    std::string venueCode;
-    bool operator==(const CITMPerformance&) const = default;
-};
-
-struct CITMEvent {
-    uint64_t id;
   std::string name;
-    std::optional<std::string> description;
+  int64_t parent;
-    std::optional<std::string> logo;
+  std::vector<int64_t> childAreas;
-    std::vector<uint64_t> subTopicIds;
+  bool operator==(const Area &other) const = default;
-    std::optional<std::string> subjectCode;
+};
-    std::optional<std::string> subtitle;
+
-    std::vector<uint64_t> topicIds;
+struct AudienceSubCategory {
-    bool operator==(const CITMEvent&) const = default;
+  int64_t id;
+  std::string name;
+  int64_t parent;
+  bool operator==(const AudienceSubCategory &other) const = default;
+};
+
+struct Event {
+  int64_t id;
+  std::string name;
+  std::string description;
+  int64_t subTopic;
+  int64_t topic;
+  std::vector<int64_t> audience;
+  bool operator==(const Event &other) const = default;
+};
+
+struct Performance {
+  int64_t id;
+  std::string name;
+  int64_t event;
+  std::string start;
+  int64_t venueCode;
+  bool operator==(const Performance &other) const = default;
+};
+
+struct SeatCategory {
+  int64_t id;
+  std::string name;
+  std::vector<int64_t> areas;
+  bool operator==(const SeatCategory &other) const = default;
+};
+
+struct SubTopic {
+  int64_t id;
+  std::string name;
+  int64_t parent;
+  bool operator==(const SubTopic &other) const = default;
+};
+
+struct Topic {
+  int64_t id;
+  std::string name;
+  bool operator==(const Topic &other) const = default;
+};
+
+struct Venue {
+  int64_t id;
+  std::string name;
+  int64_t address;
+  bool operator==(const Venue &other) const = default;
 };
 
 struct CitmCatalog {
-    std::map<std::string, CITMEvent> events;
+  std::map<std::string, Area> areas;
-    std::vector<CITMPerformance> performances;
+  std::map<std::string, AudienceSubCategory> audienceSubCategory;
-    bool operator==(const CitmCatalog&) const = default;
+  std::map<std::string, Event> events;
+  std::map<std::string, Performance> performances;
+  std::map<std::string, SeatCategory> seatCategory;
+  std::map<std::string, SubTopic> subTopic;
+  std::map<std::string, Topic> topic;
+  std::map<std::string, Venue> venue;
+
+  bool operator==(const CitmCatalog &other) const = default;
 };
 
-// Type aliases
-using Event = CITMEvent;
-using Performance = CITMPerformance;
-using Price = CITMPrice;
-using SeatArea = CITMArea;
-using SeatCategoryInfo = CITMSeatCategory;
-
 #endif

benchmark/static_reflect/citm_catalog_benchmark/nlohmann_citm_catalog_data.h

@@ -8,72 +8,164 @@
 
 using json = nlohmann::json;
 
-// ---- CITMPrice ----
+// ---- Area ----
-inline void to_json(json &j, const CITMPrice &p) {
+inline void to_json(json &j, const Area &a) {
     j = json{
-      {"amount", p.amount},
+      {"id", a.id},
-      {"audienceSubCategoryId", p.audienceSubCategoryId},
+      {"name", a.name},
-      {"seatCategoryId", p.seatCategoryId}
+      {"parent", a.parent},
+      {"childAreas", a.childAreas}
     };
 }
-
+inline void from_json(const json &j, Area &a) {
-// ---- CITMArea ----
+    j.at("id").get_to(a.id);
-inline void to_json(json &j, const CITMArea &a) {
+    j.at("name").get_to(a.name);
-    j = json{
+    j.at("parent").get_to(a.parent);
-      {"areaId", a.areaId},
+    j.at("childAreas").get_to(a.childAreas);
-      {"blockIds", a.blockIds}
-    };
 }
 
-// ---- CITMSeatCategory ----
+// ---- AudienceSubCategory ----
-inline void to_json(json &j, const CITMSeatCategory &s) {
+inline void to_json(json &j, const AudienceSubCategory &asc) {
     j = json{
-      {"areas", s.areas},
+      {"id", asc.id},
-      {"seatCategoryId", s.seatCategoryId}
+      {"name", asc.name},
+      {"parent", asc.parent}
     };
 }
-
+inline void from_json(const json &j, AudienceSubCategory &asc) {
-// ---- CITMPerformance ----
+    j.at("id").get_to(asc.id);
-inline void to_json(json &j, const CITMPerformance &p) {
+    j.at("name").get_to(asc.name);
-    j = json{
+    j.at("parent").get_to(asc.parent);
-      {"id", p.id},
-      {"eventId", p.eventId},
-      {"logo", p.logo},
-      {"name", p.name},
-      {"prices", p.prices},
-      {"seatCategories", p.seatCategories},
-      {"seatMapImage", p.seatMapImage},
-      {"start", p.start},
-      {"venueCode", p.venueCode}
-    };
 }
 
-// ---- CITMEvent ----
+// ---- Event ----
-inline void to_json(json &j, const CITMEvent &e) {
+inline void to_json(json &j, const Event &e) {
     j = json{
       {"id", e.id},
       {"name", e.name},
       {"description", e.description},
-      {"logo", e.logo},
+      {"subTopic", e.subTopic},
-      {"subTopicIds", e.subTopicIds},
+      {"topic", e.topic},
-      {"subjectCode", e.subjectCode},
+      {"audience", e.audience}
-      {"subtitle", e.subtitle},
-      {"topicIds", e.topicIds}
     };
 }
+inline void from_json(const json &j, Event &e) {
+    j.at("id").get_to(e.id);
+    j.at("name").get_to(e.name);
+    j.at("description").get_to(e.description);
+    j.at("subTopic").get_to(e.subTopic);
+    j.at("topic").get_to(e.topic);
+    j.at("audience").get_to(e.audience);
+}
+
+// ---- Performance ----
+inline void to_json(json &j, const Performance &p) {
+    j = json{
+      {"id", p.id},
+      {"name", p.name},
+      {"event", p.event},
+      {"start", p.start},
+      {"venueCode", p.venueCode}
+    };
+}
+inline void from_json(const json &j, Performance &p) {
+    j.at("id").get_to(p.id);
+    j.at("name").get_to(p.name);
+    j.at("event").get_to(p.event);
+    j.at("start").get_to(p.start);
+    j.at("venueCode").get_to(p.venueCode);
+}
+
+// ---- SeatCategory ----
+inline void to_json(json &j, const SeatCategory &sc) {
+    j = json{
+      {"id", sc.id},
+      {"name", sc.name},
+      {"areas", sc.areas}
+    };
+}
+inline void from_json(const json &j, SeatCategory &sc) {
+    j.at("id").get_to(sc.id);
+    j.at("name").get_to(sc.name);
+    j.at("areas").get_to(sc.areas);
+}
+
+// ---- SubTopic ----
+inline void to_json(json &j, const SubTopic &st) {
+    j = json{
+      {"id", st.id},
+      {"name", st.name},
+      {"parent", st.parent}
+    };
+}
+inline void from_json(const json &j, SubTopic &st) {
+    j.at("id").get_to(st.id);
+    j.at("name").get_to(st.name);
+    j.at("parent").get_to(st.parent);
+}
+
+// ---- Topic ----
+inline void to_json(json &j, const Topic &t) {
+    j = json{
+      {"id", t.id},
+      {"name", t.name}
+    };
+}
+inline void from_json(const json &j, Topic &t) {
+    j.at("id").get_to(t.id);
+    j.at("name").get_to(t.name);
+}
+
+// ---- Venue ----
+inline void to_json(json &j, const Venue &v) {
+    j = json{
+      {"id", v.id},
+      {"name", v.name},
+      {"address", v.address}
+    };
+}
+inline void from_json(const json &j, Venue &v) {
+    j.at("id").get_to(v.id);
+    j.at("name").get_to(v.name);
+    j.at("address").get_to(v.address);
+}
 
 // ---- CitmCatalog ----
 inline void to_json(json &j, const CitmCatalog &c) {
     j = json{
+      {"areas", c.areas},
+      {"audienceSubCategory", c.audienceSubCategory},
       {"events", c.events},
-      {"performances", c.performances}
+      {"performances", c.performances},
+      {"seatCategory", c.seatCategory},
+      {"subTopic", c.subTopic},
+      {"topic", c.topic},
+      {"venue", c.venue}
     };
 }
+inline void from_json(const json &j, CitmCatalog &c) {
+    j.at("areas").get_to(c.areas);
+    j.at("audienceSubCategory").get_to(c.audienceSubCategory);
+    j.at("events").get_to(c.events);
+    j.at("performances").get_to(c.performances);
+    j.at("seatCategory").get_to(c.seatCategory);
+    j.at("subTopic").get_to(c.subTopic);
+    j.at("topic").get_to(c.topic);
+    j.at("venue").get_to(c.venue);
+}
 
-// Serialization function
+// Optional convenience functions for benchmarking
 inline std::string nlohmann_serialize(const CitmCatalog &catalog) {
     json j = catalog;
     return j.dump();
 }
+inline bool nlohmann_deserialize(const std::string &json_in, CitmCatalog &catalog) {
+    try {
+        catalog = json::parse(json_in);
+        return false; // success
+    } catch(...) {
+        return true;  // failure
+    }
+}
 
 #endif // NLOHMANN_CITM_CATALOG_DATA_H

benchmark/static_reflect/citm_catalog_benchmark/rapidjson_citm_catalog_data.h

@@ -1,189 +0,0 @@
-#ifndef RAPIDJSON_CITM_CATALOG_DATA_H
-#define RAPIDJSON_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <rapidjson/document.h>
-#include <rapidjson/writer.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/error/en.h>
-
-using namespace rapidjson;
-
-// RapidJSON deserialization for CITM Catalog data
-CitmCatalog rapidjson_deserialize_citm(const std::string& json_str) {
-    Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    CitmCatalog catalog;
-
-    // Parse events
-    if (doc.HasMember("events") && doc["events"].IsObject()) {
-        const Value& events = doc["events"];
-        for (auto it = events.MemberBegin(); it != events.MemberEnd(); ++it) {
-            Event event;
-            const Value& ev = it->value;
-
-            if (ev.HasMember("description") && ev["description"].IsString())
-                event.description = ev["description"].GetString();
-            if (ev.HasMember("id") && ev["id"].IsUint64())
-                event.id = ev["id"].GetUint64();
-            if (ev.HasMember("logo") && ev["logo"].IsString())
-                event.logo = ev["logo"].GetString();
-            if (ev.HasMember("name") && ev["name"].IsString())
-                event.name = ev["name"].GetString();
-            if (ev.HasMember("subjectCode") && ev["subjectCode"].IsString())
-                event.subjectCode = ev["subjectCode"].GetString();
-            if (ev.HasMember("subtitle") && ev["subtitle"].IsString())
-                event.subtitle = ev["subtitle"].GetString();
-
-            if (ev.HasMember("topicIds") && ev["topicIds"].IsArray()) {
-                const Value& topics = ev["topicIds"];
-                for (SizeType j = 0; j < topics.Size(); j++) {
-                    if (topics[j].IsUint64())
-                        event.topicIds.push_back(topics[j].GetUint64());
-                }
-            }
-
-            if (ev.HasMember("subTopicIds") && ev["subTopicIds"].IsArray()) {
-                const Value& subtopics = ev["subTopicIds"];
-                for (SizeType j = 0; j < subtopics.Size(); j++) {
-                    if (subtopics[j].IsUint64())
-                        event.subTopicIds.push_back(subtopics[j].GetUint64());
-                }
-            }
-
-            catalog.events[it->name.GetString()] = event;
-        }
-    }
-
-    // Parse performances
-    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
-        const Value& performances = doc["performances"];
-        for (SizeType i = 0; i < performances.Size(); i++) {
-            Performance perf;
-            const Value& p = performances[i];
-
-            if (p.HasMember("id") && p["id"].IsUint64())
-                perf.id = p["id"].GetUint64();
-            if (p.HasMember("eventId") && p["eventId"].IsUint64())
-                perf.eventId = p["eventId"].GetUint64();
-            if (p.HasMember("start") && p["start"].IsUint64())
-                perf.start = p["start"].GetUint64();
-            if (p.HasMember("venueCode") && p["venueCode"].IsString())
-                perf.venueCode = p["venueCode"].GetString();
-            if (p.HasMember("name") && p["name"].IsString())
-                perf.name = p["name"].GetString();
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    // Parse other string maps
-    auto parseStringMap = [&doc](const char* key, std::map<std::string, std::string>& target) {
-        if (doc.HasMember(key) && doc[key].IsObject()) {
-            const Value& obj = doc[key];
-            for (auto it = obj.MemberBegin(); it != obj.MemberEnd(); ++it) {
-                if (it->value.IsString()) {
-                    target[it->name.GetString()] = it->value.GetString();
-                }
-            }
-        }
-    };
-
-    return catalog;
-}
-
-// RapidJSON serialization for CITM Catalog data
-std::string rapidjson_serialize_citm(const CitmCatalog& catalog) {
-    Document doc;
-    doc.SetObject();
-    Document::AllocatorType& allocator = doc.GetAllocator();
-
-    // Serialize events
-    Value events_obj(kObjectType);
-    for (const auto& [key, event] : catalog.events) {
-        Value event_obj(kObjectType);
-
-        if (event.description) {
-            Value desc;
-            desc.SetString(event.description->c_str(), allocator);
-            event_obj.AddMember("description", desc, allocator);
-        }
-
-        event_obj.AddMember("id", event.id, allocator);
-
-        if (event.logo) {
-            Value logo;
-            logo.SetString(event.logo->c_str(), allocator);
-            event_obj.AddMember("logo", logo, allocator);
-        }
-
-        Value name;
-        name.SetString(event.name.c_str(), allocator);
-        event_obj.AddMember("name", name, allocator);
-
-        if (event.subjectCode) {
-            Value subject;
-            subject.SetString(event.subjectCode->c_str(), allocator);
-            event_obj.AddMember("subjectCode", subject, allocator);
-        }
-
-        if (event.subtitle) {
-            Value subtitle;
-            subtitle.SetString(event.subtitle->c_str(), allocator);
-            event_obj.AddMember("subtitle", subtitle, allocator);
-        }
-
-        Value topicIds(kArrayType);
-        for (uint64_t id : event.topicIds) {
-            topicIds.PushBack(id, allocator);
-        }
-        event_obj.AddMember("topicIds", topicIds, allocator);
-
-        Value subTopicIds(kArrayType);
-        for (uint64_t id : event.subTopicIds) {
-            subTopicIds.PushBack(id, allocator);
-        }
-        event_obj.AddMember("subTopicIds", subTopicIds, allocator);
-
-        Value key_val;
-        key_val.SetString(key.c_str(), allocator);
-        events_obj.AddMember(key_val, event_obj, allocator);
-    }
-    doc.AddMember("events", events_obj, allocator);
-
-    // Serialize performances
-    Value performances_array(kArrayType);
-    for (const auto& perf : catalog.performances) {
-        Value perf_obj(kObjectType);
-        perf_obj.AddMember("id", perf.id, allocator);
-        perf_obj.AddMember("eventId", perf.eventId, allocator);
-        perf_obj.AddMember("start", perf.start, allocator);
-
-        Value venue;
-        venue.SetString(perf.venueCode.c_str(), allocator);
-        perf_obj.AddMember("venueCode", venue, allocator);
-
-        if (perf.name) {
-            Value name;
-            name.SetString(perf.name->c_str(), allocator);
-            perf_obj.AddMember("name", name, allocator);
-        }
-
-
-        performances_array.PushBack(perf_obj, allocator);
-    }
-    doc.AddMember("performances", performances_array, allocator);
-
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    return buffer.GetString();
-}
-
-#endif // RAPIDJSON_CITM_CATALOG_DATA_H

benchmark/static_reflect/citm_catalog_benchmark/yyjson_citm_catalog_data.h

@@ -1,231 +0,0 @@
-#ifndef YYJSON_CITM_CATALOG_DATA_H
-#define YYJSON_CITM_CATALOG_DATA_H
-
-#include "citm_catalog_data.h"
-#include <yyjson.h>
-#include <string>
-#include <stdexcept>
-
-// yyjson deserialization for CITM Catalog data
-// Matches C++ CitmCatalog struct (only events + performances)
-CitmCatalog yyjson_deserialize_citm(const std::string &json_str) {
-    CitmCatalog catalog;
-
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("yyjson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    if (!root) {
-        yyjson_doc_free(doc);
-        return catalog;
-    }
-
-    // Parse events
-    yyjson_val *events_val = yyjson_obj_get(root, "events");
-    if (events_val && yyjson_is_obj(events_val)) {
-        size_t idx, max;
-        yyjson_val *key, *val;
-        yyjson_obj_foreach(events_val, idx, max, key, val) {
-            CITMEvent event;
-
-            yyjson_val *v;
-            v = yyjson_obj_get(val, "description");
-            if (v && yyjson_is_str(v)) event.description = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "id");
-            if (v && yyjson_is_uint(v)) event.id = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(val, "logo");
-            if (v && yyjson_is_str(v)) event.logo = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "name");
-            if (v && yyjson_is_str(v)) event.name = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "subjectCode");
-            if (v && yyjson_is_str(v)) event.subjectCode = yyjson_get_str(v);
-
-            v = yyjson_obj_get(val, "subtitle");
-            if (v && yyjson_is_str(v)) event.subtitle = yyjson_get_str(v);
-
-            // Parse topicIds array
-            v = yyjson_obj_get(val, "topicIds");
-            if (v && yyjson_is_arr(v)) {
-                size_t arr_idx, arr_max;
-                yyjson_val *arr_val;
-                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
-                    if (yyjson_is_uint(arr_val))
-                        event.topicIds.push_back(yyjson_get_uint(arr_val));
-                }
-            }
-
-            // Parse subTopicIds array
-            v = yyjson_obj_get(val, "subTopicIds");
-            if (v && yyjson_is_arr(v)) {
-                size_t arr_idx, arr_max;
-                yyjson_val *arr_val;
-                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
-                    if (yyjson_is_uint(arr_val))
-                        event.subTopicIds.push_back(yyjson_get_uint(arr_val));
-                }
-            }
-
-            if (yyjson_is_str(key))
-                catalog.events[yyjson_get_str(key)] = event;
-        }
-    }
-
-    // Parse performances (simplified - full parsing would need prices/seatCategories)
-    yyjson_val *performances_val = yyjson_obj_get(root, "performances");
-    if (performances_val && yyjson_is_arr(performances_val)) {
-        size_t idx, max;
-        yyjson_val *perf_val;
-        yyjson_arr_foreach(performances_val, idx, max, perf_val) {
-            CITMPerformance perf;
-
-            yyjson_val *v;
-            v = yyjson_obj_get(perf_val, "id");
-            if (v && yyjson_is_uint(v)) perf.id = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "eventId");
-            if (v && yyjson_is_uint(v)) perf.eventId = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "start");
-            if (v && yyjson_is_uint(v)) perf.start = yyjson_get_uint(v);
-
-            v = yyjson_obj_get(perf_val, "venueCode");
-            if (v && yyjson_is_str(v)) perf.venueCode = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "name");
-            if (v && yyjson_is_str(v)) perf.name = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "logo");
-            if (v && yyjson_is_str(v)) perf.logo = yyjson_get_str(v);
-
-            v = yyjson_obj_get(perf_val, "seatMapImage");
-            if (v && yyjson_is_str(v)) perf.seatMapImage = yyjson_get_str(v);
-
-            // Note: prices and seatCategories parsing omitted for brevity
-            // The serialization benchmark uses data loaded by simdjson
-
-            catalog.performances.push_back(perf);
-        }
-    }
-
-    yyjson_doc_free(doc);
-    return catalog;
-}
-
-// Helper to add optional string field
-static inline void yyjson_add_optional_str(yyjson_mut_doc *doc, yyjson_mut_val *obj,
-                                           const char *key, const std::optional<std::string> &val) {
-    if (val.has_value()) {
-        yyjson_mut_obj_add_str(doc, obj, key, val->c_str());
-    } else {
-        yyjson_mut_obj_add_null(doc, obj, key);
-    }
-}
-
-// yyjson serialization for CITM Catalog data
-// Matches C++ CitmCatalog struct exactly (only events + performances)
-std::string yyjson_serialize_citm(const CitmCatalog &catalog) {
-    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
-    yyjson_mut_val *root = yyjson_mut_obj(doc);
-    yyjson_mut_doc_set_root(doc, root);
-
-    // Create events object
-    yyjson_mut_val *events_obj = yyjson_mut_obj(doc);
-    for (const auto& [key, event] : catalog.events) {
-        yyjson_mut_val *event_obj = yyjson_mut_obj(doc);
-
-        yyjson_add_optional_str(doc, event_obj, "description", event.description);
-        yyjson_mut_obj_add_uint(doc, event_obj, "id", event.id);
-        yyjson_add_optional_str(doc, event_obj, "logo", event.logo);
-        // name is not optional in CITMEvent
-        yyjson_mut_obj_add_str(doc, event_obj, "name", event.name.c_str());
-
-        // Add subTopicIds array
-        yyjson_mut_val *subtopic_ids = yyjson_mut_arr(doc);
-        for (uint64_t id : event.subTopicIds) {
-            yyjson_mut_arr_add_uint(doc, subtopic_ids, id);
-        }
-        yyjson_mut_obj_add_val(doc, event_obj, "subTopicIds", subtopic_ids);
-
-        yyjson_add_optional_str(doc, event_obj, "subjectCode", event.subjectCode);
-        yyjson_add_optional_str(doc, event_obj, "subtitle", event.subtitle);
-
-        // Add topicIds array
-        yyjson_mut_val *topic_ids = yyjson_mut_arr(doc);
-        for (uint64_t id : event.topicIds) {
-            yyjson_mut_arr_add_uint(doc, topic_ids, id);
-        }
-        yyjson_mut_obj_add_val(doc, event_obj, "topicIds", topic_ids);
-
-        yyjson_mut_obj_add_val(doc, events_obj, key.c_str(), event_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "events", events_obj);
-
-    // Create performances array
-    yyjson_mut_val *performances_array = yyjson_mut_arr(doc);
-    for (const auto& perf : catalog.performances) {
-        yyjson_mut_val *perf_obj = yyjson_mut_obj(doc);
-
-        yyjson_mut_obj_add_uint(doc, perf_obj, "eventId", perf.eventId);
-        yyjson_mut_obj_add_uint(doc, perf_obj, "id", perf.id);
-        yyjson_add_optional_str(doc, perf_obj, "logo", perf.logo);
-        yyjson_add_optional_str(doc, perf_obj, "name", perf.name);
-
-        // Add prices array
-        yyjson_mut_val *prices_array = yyjson_mut_arr(doc);
-        for (const auto& price : perf.prices) {
-            yyjson_mut_val *price_obj = yyjson_mut_obj(doc);
-            yyjson_mut_obj_add_uint(doc, price_obj, "amount", price.amount);
-            yyjson_mut_obj_add_uint(doc, price_obj, "audienceSubCategoryId", price.audienceSubCategoryId);
-            yyjson_mut_obj_add_uint(doc, price_obj, "seatCategoryId", price.seatCategoryId);
-            yyjson_mut_arr_append(prices_array, price_obj);
-        }
-        yyjson_mut_obj_add_val(doc, perf_obj, "prices", prices_array);
-
-        // Add seatCategories array
-        yyjson_mut_val *seat_cats_array = yyjson_mut_arr(doc);
-        for (const auto& seatCat : perf.seatCategories) {
-            yyjson_mut_val *seat_cat_obj = yyjson_mut_obj(doc);
-
-            // Add areas array
-            yyjson_mut_val *areas_array = yyjson_mut_arr(doc);
-            for (const auto& area : seatCat.areas) {
-                yyjson_mut_val *area_obj = yyjson_mut_obj(doc);
-                yyjson_mut_obj_add_uint(doc, area_obj, "areaId", area.areaId);
-
-                yyjson_mut_val *block_ids = yyjson_mut_arr(doc);
-                for (uint64_t blockId : area.blockIds) {
-                    yyjson_mut_arr_add_uint(doc, block_ids, blockId);
-                }
-                yyjson_mut_obj_add_val(doc, area_obj, "blockIds", block_ids);
-                yyjson_mut_arr_append(areas_array, area_obj);
-            }
-            yyjson_mut_obj_add_val(doc, seat_cat_obj, "areas", areas_array);
-            yyjson_mut_obj_add_uint(doc, seat_cat_obj, "seatCategoryId", seatCat.seatCategoryId);
-            yyjson_mut_arr_append(seat_cats_array, seat_cat_obj);
-        }
-        yyjson_mut_obj_add_val(doc, perf_obj, "seatCategories", seat_cats_array);
-
-        yyjson_add_optional_str(doc, perf_obj, "seatMapImage", perf.seatMapImage);
-        yyjson_mut_obj_add_uint(doc, perf_obj, "start", perf.start);
-        yyjson_mut_obj_add_str(doc, perf_obj, "venueCode", perf.venueCode.c_str());
-
-        yyjson_mut_arr_append(performances_array, perf_obj);
-    }
-    yyjson_mut_obj_add_val(doc, root, "performances", performances_array);
-
-    // Write to string
-    char *json_output = yyjson_mut_write(doc, 0, NULL);
-    std::string result(json_output);
-    free(json_output);
-    yyjson_mut_doc_free(doc);
-
-    return result;
-}
-
-#endif // YYJSON_CITM_CATALOG_DATA_H

benchmark/static_reflect/serde-benchmark/lib.rs

@@ -5,40 +5,137 @@ extern crate libc;
 use libc::{c_char, size_t};
 use serde::{Serialize, Deserialize};
 use std::{collections::HashMap, ffi::CString, ptr, slice};
+use serde::de::{self, Deserializer};
+/******************************************************/
+/******************************************************/
+/**
+ * Warning: the C++ code may not generate the same JSON.
+ */
+ /******************************************************/
+ /******************************************************/
 
-//==============================================================================
+// This has no equivalent in C++:
-// Twitter Benchmark Structures
+#[derive(Serialize, Deserialize)]
-// These match the C++ TwitterData structures exactly
+pub struct Metadata {
-//==============================================================================
+    result_type: String,
+    iso_language_code: String,
+}
 
 #[derive(Serialize, Deserialize)]
 pub struct User {
-    id: u64,
+    id: i64,
+    id_str: String,
     name: String,
     screen_name: String,
     location: String,
     description: String,
+    // C++ does not have those:
+    // url: Option<String>,
+    //protected: bool,
+    //listed_count: i64,
+    //created_at: String,
+    //favourites_count: i64,
+    //utc_offset: Option<i64>,
+    //time_zone: Option<String>,
+    //geo_enabled: bool,
     verified: bool,
-    followers_count: u64,
+    followers_count: i64,
-    friends_count: u64,
+    friends_count: i64,
-    statuses_count: u64,
+    statuses_count: i64,
+    // C++ does not have those:
+    //lang: String,
+    //profile_background_color: String,
+    //profile_background_image_url: String,
+    //profile_background_image_url_https: String,
+    //profile_background_tile: bool,
+    //profile_image_url: String,
+    //profile_image_url_https: String,
+    //profile_banner_url: Option<String>,
+    //profile_link_color: String,
+    //profile_sidebar_border_color: String,
+    //profile_sidebar_fill_color: String,
+    //profile_text_color: String,
+    //profile_use_background_image: bool,
+    //default_profile: bool,
+    //default_profile_image: bool,
+    //following: bool,
+    //follow_request_sent: bool,
+    //notifications: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Hashtag {
+    text: String,
+
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Url {
+    url: String,
+    expanded_url: String,
+    display_url: String,
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct UserMention {
+    id: i64,
+    name: String,
+    screen_name: String,
+    // Not in the C++ equivalent:
+    //id_str: String,
+    //indices: Vec<i64>,
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Entities {
+    hashtags: Vec<Hashtag>,
+    urls: Vec<Url>,
+    user_mentions: Vec<UserMention>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Status {
     created_at: String,
-    id: u64,
+    id: i64,
     text: String,
     user: User,
-    retweet_count: u64,
+    entities: Entities,
-    favorite_count: u64,
+    retweet_count: i64,
+    favorite_count: i64,
+    favorited: bool,
+    retweeted: bool,
+    // None of these are in the C++ equivalent:
+    /*
+    metadata: Metadata,
+    id_str: String,
+    source: String,
+    truncated: bool,
+    in_reply_to_status_id: Option<i64>,
+    in_reply_to_status_id_str: Option<String>,
+    in_reply_to_user_id: Option<i64>,
+    in_reply_to_user_id_str: Option<String>,
+    in_reply_to_screen_name: Option<String>,
+    geo: Option<String>,
+    coordinates: Option<String>,
+    place: Option<String>,
+    contributors: Option<String>,
+    lang: String,
+    */
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct TwitterData {
     statuses: Vec<Status>,
 }
-static mut TWITTER_DATA: *mut TwitterData = std::ptr::null_mut();
 
 #[no_mangle]
 pub unsafe extern "C" fn  twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
@@ -50,120 +147,263 @@ pub unsafe extern "C" fn twitter_from_str(raw_input: *const c_char, raw_input_le
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn set_twitter_data(raw: *mut TwitterData) {
+pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
-    TWITTER_DATA = raw;
+  let twitter_thing = { &*raw };
+  let serialized = serde_json::to_string(&twitter_thing).unwrap();
+  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn serialize_twitter_to_string() -> usize {
-    if TWITTER_DATA.is_null() {
-        return 0;
-    }
-    let data = &*TWITTER_DATA;
-    serde_json::to_string(data).unwrap().len()
-}
 
 #[no_mangle]
 pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
   if raw.is_null() {
     return;
   }
+
   drop(Box::from_raw(raw))
 }
 
+
 #[no_mangle]
 pub unsafe extern fn free_string(ptr: *const c_char) {
     let _ = std::ffi::CString::from_raw(ptr as *mut _);
 }
 
-//==============================================================================
+// Functions associated with the CitmCatalog benchmark
-// CITM Catalog Benchmark Structures
-// These match the C++ CitmCatalog structures EXACTLY for fair comparison
-//==============================================================================
 
-/// Matches C++ CITMPrice struct exactly
+#[derive(Serialize, Deserialize)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Area {
-pub struct CITMPrice {
+    pub id: i64,
-    pub amount: u64,
+    pub name: Option<String>,  // Changed to Option
-    #[serde(rename = "audienceSubCategoryId")]
+    pub parent: i64,
-    pub audience_sub_category_id: u64,
+    #[serde(rename = "childAreas")]
-    #[serde(rename = "seatCategoryId")]
+    pub child_areas: Vec<i64>,
-    pub seat_category_id: u64,
 }
 
-/// Matches C++ CITMArea struct exactly
+#[derive(Serialize, Deserialize)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct AudienceSubCategory {
-pub struct CITMArea {
+    pub id: i64,
-    #[serde(rename = "areaId")]
+    pub name: Option<String>,  // Changed to Option
-    pub area_id: u64,
+    pub parent: i64,
-    #[serde(rename = "blockIds")]
-    pub block_ids: Vec<u64>,
 }
 
-/// Matches C++ CITMSeatCategory struct exactly
+#[derive(Serialize, Deserialize, Debug)]
-#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Event {
-pub struct CITMSeatCategory {
-    pub areas: Vec<CITMArea>,
-    #[serde(rename = "seatCategoryId")]
-    pub seat_category_id: u64,
-}
-
-/// Matches C++ CITMPerformance struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMPerformance {
-    pub id: u64,
-    #[serde(rename = "eventId")]
-    pub event_id: u64,
-    #[serde(default)]
-    pub logo: Option<String>,
-    #[serde(default)]
-    pub name: Option<String>,
-    pub prices: Vec<CITMPrice>,
-    #[serde(rename = "seatCategories")]
-    pub seat_categories: Vec<CITMSeatCategory>,
-    #[serde(default)]
-    #[serde(rename = "seatMapImage")]
-    pub seat_map_image: Option<String>,
-    pub start: u64,
-    #[serde(rename = "venueCode")]
-    pub venue_code: String,
-}
-
-/// Matches C++ CITMEvent struct exactly
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CITMEvent {
-    pub id: u64,
-    #[serde(default)]
-    pub name: Option<String>,
     #[serde(default)]
     pub description: Option<String>,
+    pub id: i64,
     #[serde(default)]
     pub logo: Option<String>,
     #[serde(default)]
-    #[serde(rename = "subTopicIds")]
+    pub name: Option<String>,
-    pub sub_topic_ids: Vec<u64>,
     #[serde(default)]
-    #[serde(rename = "subjectCode")]
+    pub subTopicIds: Vec<i64>,
-    pub subject_code: Option<String>,
+    #[serde(default)]
+    pub subjectCode: Option<String>,
     #[serde(default)]
     pub subtitle: Option<String>,
     #[serde(default)]
-    #[serde(rename = "topicIds")]
+    pub topicIds: Vec<i64>,
-    pub topic_ids: Vec<u64>,
+    // Add a catch-all for any other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Performance {
+    #[serde(default)]
+    pub id: i64,
+
+    #[serde(default)]
+    pub name: Option<String>,
+
+    #[serde(default)]
+    pub event: i64,
+
+    // This is the key fix - accept any JSON value type for timestamps
+    // This allows both string dates and integer timestamps (line 3511)
+    #[serde(default)]
+    pub start: serde_json::Value,
+
+    #[serde(rename = "venueCode")]
+    pub venue_code: String,
+
+    // Add a catch-all for any other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SeatCategory {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub areas: Vec<i64>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SubTopic {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Topic {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Venue {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub address: i64,
+}
+
+// Custom deserializers
+fn deserialize_string_to_area<'de, D>(deserializer: D) -> Result<HashMap<String, Area>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), Area {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+            child_areas: Vec::new(),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_audience_subcategory<'de, D>(deserializer: D) -> Result<HashMap<String, AudienceSubCategory>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), AudienceSubCategory {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_seat_category<'de, D>(deserializer: D) -> Result<HashMap<String, SeatCategory>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), SeatCategory {
+            id: id_num,
+            name: Some(name),
+            areas: Vec::new(),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_subtopic<'de, D>(deserializer: D) -> Result<HashMap<String, SubTopic>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), SubTopic {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_topic<'de, D>(deserializer: D) -> Result<HashMap<String, Topic>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), Topic {
+            id: id_num,
+            name: Some(name),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_venue<'de, D>(deserializer: D) -> Result<HashMap<String, Venue>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        result.insert(id.clone(), Venue {
+            id: 0,
+            name: Some(name),
+            address: 0,
+        });
+    }
+
+    Ok(result)
 }
 
-/// Matches C++ CitmCatalog struct exactly - ONLY events and performances
-/// This is the key fix: we serialize only what C++ serializes
 #[derive(Serialize, Deserialize, Debug)]
 pub struct CitmCatalog {
-    pub events: HashMap<String, CITMEvent>,
+    #[serde(rename = "areaNames")]
-    pub performances: Vec<CITMPerformance>,
+    pub area_names: HashMap<String, String>,
+
+    #[serde(rename = "audienceSubCategoryNames")]
+    pub audience_subcategory_names: HashMap<String, String>,
+
+    #[serde(default)]
+    #[serde(rename = "blockNames")]
+    pub block_names: HashMap<String, String>,
+
+    pub events: HashMap<String, Event>,
+
+    #[serde(default)]
+    pub performances: Vec<Performance>,
+
+    #[serde(rename = "seatCategoryNames")]
+    pub seat_category_names: HashMap<String, String>,
+
+    #[serde(rename = "subTopicNames")]
+    pub subtopic_names: HashMap<String, String>,
+
+    #[serde(default)]
+    #[serde(rename = "subjectNames")]
+    pub subject_names: HashMap<String, String>,
+
+    #[serde(rename = "topicNames")]
+    pub topic_names: HashMap<String, String>,
+
+    #[serde(rename = "topicSubTopics")]
+    pub topic_subtopics: HashMap<String, Vec<i64>>,
+
+    #[serde(rename = "venueNames")]
+    pub venue_names: HashMap<String, String>,
+
+    // Catch-all for other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
 }
 
-static mut CITM_DATA: *mut CitmCatalog = std::ptr::null_mut();
-
 /// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
-/// Only extracts events and performances to match C++ behavior.
 #[no_mangle]
 pub unsafe extern "C" fn citm_from_str(
     raw_input: *const c_char,
@@ -174,6 +414,7 @@ pub unsafe extern "C" fn citm_from_str(
         return ptr::null_mut();
     }
 
+    // Convert the raw pointer + length into a Rust slice
     let bytes = slice::from_raw_parts(raw_input as *const u8, raw_input_length);
     let input_str = match std::str::from_utf8(bytes) {
         Ok(s) => s,
@@ -183,23 +424,12 @@ pub unsafe extern "C" fn citm_from_str(
         }
     };
 
-    // Parse the full JSON to extract only events and performances
+    // Try deserializing the input string into CitmCatalog
-    match serde_json::from_str::<serde_json::Value>(input_str) {
+    match serde_json::from_str::<CitmCatalog>(input_str) {
-        Ok(full_json) => {
+        Ok(catalog) => Box::into_raw(Box::new(catalog)),
-            // Extract only the fields we need (matching C++ behavior)
-            let events: HashMap<String, CITMEvent> = full_json.get("events")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default();
-
-            let performances: Vec<CITMPerformance> = full_json.get("performances")
-                .and_then(|v| serde_json::from_value(v.clone()).ok())
-                .unwrap_or_default();
-
-            let catalog = CitmCatalog { events, performances };
-            Box::into_raw(Box::new(catalog))
-        },
         Err(e) => {
             eprintln!("Error deserializing JSON: {}", e);
+            eprintln!("JSON snippet (first 200 chars): {:.200}...", input_str);
             ptr::null_mut()
         }
     }
@@ -207,17 +437,30 @@ pub unsafe extern "C" fn citm_from_str(
 
 /// Serializes a CitmCatalog into a JSON string (UTF-8).
 #[no_mangle]
-pub unsafe extern "C" fn set_citm_data(raw: *mut CitmCatalog) {
+pub unsafe extern "C" fn str_from_citm(raw_catalog: *mut CitmCatalog) -> *mut c_char {
-    CITM_DATA = raw;
+    if raw_catalog.is_null() {
+        eprintln!("Error: Catalog pointer is null");
+        return ptr::null_mut();
     }
 
-#[no_mangle]
+    // Fix: Actually serialize the catalog
-pub unsafe extern "C" fn serialize_citm_to_string() -> usize {
+    let catalog = &*raw_catalog;
-    if CITM_DATA.is_null() {
+
-        return 0;
+    match serde_json::to_string(catalog) {
+        Ok(serialized) => {
+            match CString::new(serialized) {
+                Ok(cstr) => cstr.into_raw(),
+                Err(e) => {
+                    eprintln!("Error creating CString: {}", e);
+                    ptr::null_mut()
+                }
+            }
+        },
+        Err(e) => {
+            eprintln!("Error serializing catalog to JSON: {}", e);
+            ptr::null_mut()
+        }
     }
-    let data = &*CITM_DATA;
-    return serde_json::to_string(data).unwrap().len();
 }
 
 /// Frees the CitmCatalog pointer.
@@ -232,120 +475,8 @@ pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
 pub extern "C" fn free_str(ptr: *mut c_char) {
     if !ptr.is_null() {
         unsafe {
+            // Convert back into a CString, which automatically frees the memory
             let _ = CString::from_raw(ptr);
         }
     }
 }
-
-//==============================================================================
-// FFI Overhead Measurement Functions
-// These allow measuring the actual FFI overhead vs pure Rust serialization
-//==============================================================================
-
-/// Result structure for FFI overhead measurement
-#[repr(C)]
-pub struct FfiOverheadResult {
-    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
-    pub pure_serde_ns: u64,
-    /// Time in nanoseconds for serde + CString conversion
-    pub serde_plus_cstring_ns: u64,
-    /// Number of iterations performed
-    pub iterations: u64,
-    /// Output size in bytes (for verification)
-    pub output_size: u64,
-}
-
-/// Prevents compiler from optimizing away the value
-/// Works on stable Rust (unlike std::hint::black_box which is unstable)
-#[inline(never)]
-fn black_box<T>(dummy: T) -> T {
-    unsafe {
-        let ret = std::ptr::read_volatile(&dummy);
-        std::mem::forget(dummy);
-        ret
-    }
-}
-
-/// Measures FFI overhead for Twitter serialization.
-/// Performs `iterations` serializations entirely in Rust and returns timing data.
-/// This allows comparing against per-call FFI overhead.
-#[no_mangle]
-pub unsafe extern "C" fn measure_twitter_ffi_overhead(
-    raw: *mut TwitterData,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-
-    let twitter_data = &*raw;
-    let output_size: u64;
-
-    // Warm-up run
-    let warmup = serde_json::to_string(&twitter_data).unwrap();
-    output_size = warmup.len() as u64;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        // Prevent optimization from eliminating the work
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion (but not FFI return)
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&twitter_data).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        // Prevent optimization from eliminating the work
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult {
-        pure_serde_ns,
-        serde_plus_cstring_ns,
-        iterations,
-        output_size,
-    }
-}
-
-/// Measures FFI overhead for CITM serialization.
-#[no_mangle]
-pub unsafe extern "C" fn measure_citm_ffi_overhead(
-    raw: *mut CitmCatalog,
-    iterations: u64
-) -> FfiOverheadResult {
-    use std::time::Instant;
-
-    let catalog = &*raw;
-    let output_size: u64;
-
-    // Warm-up run
-    let warmup = serde_json::to_string(&catalog).unwrap();
-    output_size = warmup.len() as u64;
-
-    // Measure pure serde_json::to_string() - no CString conversion
-    let start_pure = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&catalog).unwrap();
-        black_box(&serialized);
-    }
-    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
-
-    // Measure serde + CString conversion
-    let start_cstring = Instant::now();
-    for _ in 0..iterations {
-        let serialized = serde_json::to_string(&catalog).unwrap();
-        let cstring = CString::new(serialized).unwrap();
-        black_box(&cstring);
-    }
-    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
-
-    FfiOverheadResult {
-        pure_serde_ns,
-        serde_plus_cstring_ns,
-        iterations,
-        output_size,
-    }
-}

benchmark/static_reflect/serde-benchmark/serde_benchmark.h

@@ -4,7 +4,6 @@
 /* Generated with cbindgen:0.28.0 */
 
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
-/* Note: FfiOverheadResult and measurement functions added manually */
 
 #include <cstdarg>
 #include <cstdint>
@@ -18,25 +17,11 @@ struct CitmCatalog;
 
 struct TwitterData;
 
-/// Result structure for FFI overhead measurement
-struct FfiOverheadResult {
-    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
-    uint64_t pure_serde_ns;
-    /// Time in nanoseconds for serde + CString conversion
-    uint64_t serde_plus_cstring_ns;
-    /// Number of iterations performed
-    uint64_t iterations;
-    /// Output size in bytes (for verification)
-    uint64_t output_size;
-};
-
 extern "C" {
 
 TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
 
-void set_twitter_data(TwitterData *raw);
+const char *str_from_twitter(TwitterData *raw);
-
-size_t serialize_twitter_to_string();
 
 void free_twitter(TwitterData *raw);
 
@@ -45,22 +30,14 @@ void free_string(const char *ptr);
 /// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
 CitmCatalog *citm_from_str(const char *raw_input, uintptr_t raw_input_length);
 
-void set_citm_data(CitmCatalog *raw);
+/// Serializes a CitmCatalog into a JSON string (UTF-8).
-
+char *str_from_citm(CitmCatalog *raw_catalog);
-size_t serialize_citm_to_string();
 
 /// Frees the CitmCatalog pointer.
 void free_citm(CitmCatalog *raw_catalog);
 
 void free_str(char *ptr);
 
-/// Measures FFI overhead for Twitter serialization.
-/// Performs `iterations` serializations entirely in Rust and returns timing data.
-FfiOverheadResult measure_twitter_ffi_overhead(TwitterData *raw, uint64_t iterations);
-
-/// Measures FFI overhead for CITM serialization.
-FfiOverheadResult measure_citm_ffi_overhead(CitmCatalog *raw, uint64_t iterations);
-
 }  // extern "C"
 
 }  // namespace serde_benchmark

benchmark/static_reflect/serde-benchmark/src/main.rs

@@ -1,31 +0,0 @@
-use std::fs;
-
-// Include the lib.rs content directly
-include!("../lib.rs");
-
-fn main() {
-    // Read the Twitter JSON file
-    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
-        .expect("Failed to read file");
-
-    // Parse it
-    let data: TwitterData = serde_json::from_str(&json_str)
-        .expect("Failed to parse JSON");
-
-    // Serialize it back
-    let output = serde_json::to_string(&data)
-        .expect("Failed to serialize");
-
-    // Write to file for comparison
-    fs::write("rust_output.json", &output)
-        .expect("Failed to write output");
-
-    println!("Output size: {} bytes", output.len());
-    println!("Written to rust_output.json");
-
-    // Also write pretty version for easier inspection
-    let pretty = serde_json::to_string_pretty(&data)
-        .expect("Failed to serialize pretty");
-    fs::write("rust_output_pretty.json", &pretty)
-        .expect("Failed to write pretty output");
-}

benchmark/static_reflect/serde-benchmark/src/test_output.rs

@@ -1,36 +0,0 @@
-use std::fs;
-
-// Import from the parent lib.rs
-include!("../lib.rs");
-
-fn main() {
-    // Read the Twitter JSON file
-    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
-        .expect("Failed to read file");
-
-    // Parse it
-    let data: TwitterData = serde_json::from_str(&json_str)
-        .expect("Failed to parse JSON");
-
-    // Serialize it back (compact)
-    let output = serde_json::to_vec(&data)
-        .expect("Failed to serialize");
-    
-    let output_str = String::from_utf8(output.clone()).unwrap();
-
-    // Write to file for comparison
-    fs::write("rust_output_test.json", &output)
-        .expect("Failed to write output");
-
-    println!("Output size: {} bytes", output.len());
-    
-    // Count statuses
-    println!("Number of statuses: {}", data.statuses.len());
-    
-    // Check what fields are in the first status
-    if let Some(first) = data.statuses.first() {
-        // Let's serialize just the first status to see what fields are included
-        let first_json = serde_json::to_string_pretty(first).unwrap();
-        println!("First status (pretty):\n{}", first_json);
-    }
-}

benchmark/static_reflect/twitter_benchmark/CMakeLists.txt

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

benchmark/static_reflect/twitter_benchmark/benchmark_parsing_twitter.cpp

@@ -1,232 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <ctime>
-#include <format>
-#include <fstream>
-#include <iostream>
-#include <nlohmann/json.hpp>
-#include <simdjson.h>
-#include <string>
-#include "twitter_data.h"
-#include "nlohmann_twitter_data.h"
-#include "../benchmark_utils/benchmark_helper.h"
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-#include "rapidjson_twitter_data.h"
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_twitter_data.h"
-#endif
-
-#ifdef SIMDJSON_RUST_VERSION
-#include "../serde-benchmark/serde_benchmark.h"
-
-void bench_rust_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rust_parsing",
-               bench([&json_str, &result]() {
-                 serde_benchmark::TwitterData *td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
-                 result = (td != nullptr);
-                 if (td) {
-                   serde_benchmark::free_twitter(td);
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-// OPTIMIZED VERSION: Reuses parser across iterations
-template <class T>
-void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  // CRITICAL: Create parser OUTSIDE the loop for reuse
-  simdjson::ondemand::parser parser;
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
-               bench([&padded, &result, &parser]() {
-                 // Reuse the same parser instance
-                 simdjson::ondemand::document doc;
-                 if(parser.iterate(padded).get(doc)) {
-                   result = false;
-                   return;
-                 }
-                 T my_struct;
-                 if(doc.get<T>().get(my_struct)) {
-                   result = false;
-                 }
-                 if (!result) {
-                   printf("parse error\n");
-                 }
-               }));
-}
-
-#if SIMDJSON_STATIC_REFLECTION
-template <class T>
-void bench_simdjson_from_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  // Pre-allocate padded buffer outside the benchmark loop
-  simdjson::padded_string padded = simdjson::padded_string(json_str);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
-               bench([&padded, &result]() {
-                 T my_struct;
-                 auto err = simdjson::from(padded).get(my_struct);
-                  if (err) {
-                    result = false;
-                    printf("parse error: %s\n", simdjson::error_message(err));
-                    return;
-                  }
-               }));
-}
-#endif
-
- void bench_nlohmann_parsing(const std::string &json_str) {
-   size_t input_volume = json_str.size();
-   printf("# input volume: %zu bytes\n", input_volume);
-
-   volatile bool result = true;
-   pretty_print(1, input_volume, "bench_nlohmann_parsing",
-                bench([&json_str, &result]() {
-                  try {
-                    TwitterData data = nlohmann_deserialize(json_str);
-                    result = true;
-                  } catch (...) {
-                    result = false;
-                    printf("parse error\n");
-                  }
-                }));
-}
-
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-void bench_rapidjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_rapidjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   TwitterData data = rapidjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson_parsing(const std::string &json_str) {
-  size_t input_volume = json_str.size();
-  printf("# input volume: %zu bytes\n", input_volume);
-
-  volatile bool result = true;
-  pretty_print(1, input_volume, "bench_yyjson_parsing",
-               bench([&json_str, &result]() {
-                 try {
-                   TwitterData data = yyjson_deserialize(json_str);
-                   result = true;
-                 } catch (...) {
-                   result = false;
-                   printf("parse error\n");
-                 }
-               }));
-}
-#endif
-
-std::string read_file(std::string filename) {
-  printf("# Reading file %s\n", filename.c_str());
-  constexpr size_t read_size = 4096;
-  auto stream = std::ifstream(filename.c_str());
-  stream.exceptions(std::ios_base::badbit);
-  std::string out;
-  std::string buf(read_size, '\0');
-  while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
-  }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
-}
-
-// Function to check if benchmark name matches any of the comma-separated filters
-bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
-}
-
-int main(int argc, char* argv[]) {
-  std::string filter;
-
-  // Parse command-line arguments
-  for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
-          if (i + 1 < argc) {
-              filter = argv[++i];
-          } else {
-              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
-              return EXIT_FAILURE;
-          }
-      }
-  }
-
-  // Load the JSON data
-  std::string json_str = read_file(JSON_FILE);
-
-  // Benchmarking the parsing
-  if (matches_filter("nlohmann", filter)) {
-    bench_nlohmann_parsing(json_str);
-  }
-#ifdef SIMDJSON_COMPETITION_RAPIDJSON
-  if (matches_filter("rapidjson", filter)) {
-    bench_rapidjson_parsing(json_str);
-  }
-#endif
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson_parsing(json_str);
-  }
-#endif
-  if (matches_filter("simdjson_static_reflection", filter)) {
-    bench_simdjson_static_reflection_parsing<TwitterData>(json_str);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_from", filter)) {
-    bench_simdjson_from_parsing<TwitterData>(json_str);
-  }
-#endif
-#ifdef SIMDJSON_RUST_VERSION
-  if (matches_filter("rust", filter)) {
-    printf("# Note: Rust/Serde parsing test\n");
-    bench_rust_parsing(json_str);
-  }
-#endif
-  return EXIT_SUCCESS;
-}

benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter.cpp

@@ -1,5 +1,4 @@
 #include <cassert>
-#include <chrono>
 #include <cstdlib>
 #include <ctime>
 #include <format>
@@ -11,9 +10,6 @@
 #include "twitter_data.h"
 #include "nlohmann_twitter_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
-#ifdef SIMDJSON_COMPETITION_YYJSON
-#include "yyjson_twitter_data.h"
-#endif
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
@@ -39,49 +35,19 @@ void bench_reflect_cpp(TwitterData &data) {
 
 
 void bench_rust(serde_benchmark::TwitterData *data) {
-  serde_benchmark::set_twitter_data(data);
+  const char * output = serde_benchmark::str_from_twitter(data);
-  size_t output_volume = serde_benchmark::serialize_twitter_to_string();
+  size_t output_volume = strlen(output);
   printf("# output volume: %zu bytes\n", output_volume);
-
   volatile size_t measured_volume = 0;
   pretty_print(1, output_volume, "bench_rust",
-               bench([&measured_volume, &output_volume]() {
+               bench([&data, &measured_volume, &output_volume]() {
-                 measured_volume = serde_benchmark::serialize_twitter_to_string();
+                 const char * output = serde_benchmark::str_from_twitter(data);
+                 serde_benchmark::free_string(output);
                }));
 }
 #endif
 
-// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
 template <class T> void bench_simdjson_static_reflection(T &data) {
-  // First run to determine expected size
-  simdjson::builder::string_builder sb_init;
-  simdjson::builder::append(sb_init, data);
-  std::string_view p_init;
-  if(sb_init.view().get(p_init)) {
-    std::cerr << "Error!" << std::endl;
-  }
-  size_t output_volume = p_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 simdjson::builder::string_builder sb;
-                 simdjson::builder::append(sb, data);
-                 std::string_view p;
-                 if(sb.view().get(p)) {
-                   std::cerr << "Error!" << std::endl;
-                 }
-                 measured_volume = sb.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses buffer across iterations (shows API potential)
-template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
   simdjson::builder::string_builder sb;
   simdjson::builder::append(sb, data);
   std::string_view p;
@@ -93,7 +59,7 @@ template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
                bench([&data, &measured_volume, &output_volume, &sb]() {
                  sb.clear();
                  simdjson::builder::append(sb, data);
@@ -108,63 +74,6 @@ template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
                }));
 }
 
-#if SIMDJSON_STATIC_REFLECTION
-// Fair allocation variant: allocates fresh string each iteration
-template <class T> void bench_simdjson_to(T &data) {
-  // First run to determine size
-  std::string output_init;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output_init); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output_init.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
-               bench([&data, &measured_volume, &output_volume]() {
-                 // Fresh allocation each iteration - fair comparison
-                 std::string output;
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-
-// Optimized variant: reuses pre-allocated string
-template <class T> void bench_simdjson_to_reuse(T &data) {
-  std::string output;
-  if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
-    return;
-  }
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  // Pre-allocate string with sufficient capacity to avoid reallocation
-  output.reserve(output_volume * 2);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
-               bench([&data, &measured_volume, &output_volume, &output]() {
-                 // Reuse the pre-allocated string - avoids allocation
-                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
-                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
-                   return;
-                 }
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
 void bench_nlohmann(TwitterData &data) {
   std::string output = nlohmann_serialize(data);
   size_t output_volume = output.size();
@@ -181,61 +90,28 @@ void bench_nlohmann(TwitterData &data) {
                }));
 }
 
-#ifdef SIMDJSON_COMPETITION_YYJSON
-void bench_yyjson(TwitterData &data) {
-  std::string output = yyjson_serialize(data);
-  size_t output_volume = output.size();
-  printf("# output volume: %zu bytes\n", output_volume);
-
-  volatile size_t measured_volume = 0;
-  pretty_print(1, output_volume, "bench_yyjson",
-               bench([&data, &measured_volume, &output_volume]() {
-                 std::string output = yyjson_serialize(data);
-                 measured_volume = output.size();
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-               }));
-}
-#endif
-
 size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
   ((std::string *)userp)->append((char *)contents, size * nmemb);
   return size * nmemb;
 }
 
-simdjson::padded_string read_file(std::string filename) {
+std::string read_file(std::string filename) {
   printf("# Reading file %s\n", filename.c_str());
   constexpr size_t read_size = 4096;
   auto stream = std::ifstream(filename.c_str());
   stream.exceptions(std::ios_base::badbit);
-  simdjson::padded_string_builder builder;
+  std::string out;
   std::string buf(read_size, '\0');
   while (stream.read(&buf[0], read_size)) {
-    builder.append(buf.data(), size_t(stream.gcount()));
+    out.append(buf, 0, size_t(stream.gcount()));
   }
-  builder.append(buf.data(), size_t(stream.gcount()));
+  out.append(buf, 0, size_t(stream.gcount()));
-  return builder.convert();
+  return out;
 }
 
-// Function to check if benchmark name matches any of the comma-separated filters
+// Function to check if benchmark name contains filter substring
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  if (filter.empty()) return true;
+  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
-
-  // Split filter by comma
-  size_t start = 0;
-  size_t end = filter.find(',');
-  while (end != std::string::npos) {
-    std::string token = filter.substr(start, end - start);
-    if (benchmark_name.find(token) != std::string::npos) {
-      return true;
-    }
-    start = end + 1;
-    end = filter.find(',', start);
-  }
-  // Check last token
-  std::string token = filter.substr(start);
-  return benchmark_name.find(token) != std::string::npos;
 }
 
 int main(int argc, char* argv[]) {
@@ -253,12 +129,12 @@ int main(int argc, char* argv[]) {
       }
   }
   // Testing correctness of round-trip (serialization + deserialization)
-  simdjson::padded_string json_str = read_file(JSON_FILE);
+  std::string json_str = read_file(JSON_FILE);
 
   // Loading up the data into a structure.
   simdjson::ondemand::parser parser;
   simdjson::ondemand::document doc;
-  if(parser.iterate(json_str).get(doc)) {
+  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
     std::cerr << "Error loading the document!" << std::endl;
     return EXIT_FAILURE;
   }
@@ -269,42 +145,19 @@ int main(int argc, char* argv[]) {
   }
 
   // Benchmarking the serialization
-  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
-  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
-  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
-
   if (matches_filter("nlohmann", filter)) {
     bench_nlohmann(my_struct);
   }
-#ifdef SIMDJSON_COMPETITION_YYJSON
-  if (matches_filter("yyjson", filter)) {
-    bench_yyjson(my_struct);
-  }
-#endif
   if (matches_filter("simdjson_static_reflection", filter)) {
     bench_simdjson_static_reflection(my_struct);
   }
-  if (matches_filter("simdjson_reuse", filter)) {
-    bench_simdjson_static_reflection_reuse(my_struct);
-  }
-#if SIMDJSON_STATIC_REFLECTION
-  if (matches_filter("simdjson_to", filter)) {
-    bench_simdjson_to(my_struct);
-  }
-  if (matches_filter("simdjson_to_reuse", filter)) {
-    bench_simdjson_to_reuse(my_struct);
-  }
-#endif
 #ifdef SIMDJSON_RUST_VERSION
   if (matches_filter("rust", filter)) {
-    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.data(), json_str.size());
+    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
-    if (td == nullptr) {
+    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
-      printf("# Failed to parse Twitter data for Rust benchmark\n");
-    } else {
     bench_rust(td);
     serde_benchmark::free_twitter(td);
   }
-  }
 #endif
 #if SIMDJSON_BENCH_CPP_REFLECT
   if (matches_filter("reflect_cpp", filter)) {

benchmark/static_reflect/twitter_benchmark/nlohmann_twitter_data.h

@@ -4,7 +4,6 @@
 #include "twitter_data.h"
 #include <nlohmann/json.hpp>
 
-// Serialization functions for nlohmann
 void to_json(nlohmann::json &j, const User &u) {
   j = nlohmann::json{{"id", u.id},
                      {"name", u.name},
@@ -17,54 +16,101 @@ void to_json(nlohmann::json &j, const User &u) {
                      {"statuses_count", u.statuses_count}};
 }
 
+void to_json(nlohmann::json &j, const Hashtag &h) {
+  j = nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Url &u) {
+  j = nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const UserMention &um) {
+  j = nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Entities &e) {
+  j = nlohmann::json{{"hashtags", e.hashtags},
+                     {"urls", e.urls},
+                     {"user_mentions", e.user_mentions}};
+}
+
 void to_json(nlohmann::json &j, const Status &s) {
   j = nlohmann::json{{"created_at", s.created_at},
                      {"id", s.id},
                      {"text", s.text},
                      {"user", s.user},
+                     {"entities", s.entities},
                      {"retweet_count", s.retweet_count},
-                     {"favorite_count", s.favorite_count}};
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}};
+}
+
+
+std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Hashtag & h : v) {
+    a.push_back(nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<Url>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Url & u : v) {
+    a.push_back(nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<UserMention>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const UserMention & um : v) {
+    a.push_back(nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}});
+  }
+  return a.dump();
+}
+
+std::string nlohmann_serialize(const std::vector<Status>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Status & s : v) {
+    a.push_back(nlohmann::json{{"created_at", s.created_at},
+                     {"id", s.id},
+                     {"text", s.text},
+                     {"user", s.user},
+                     {"entities", s.entities},
+                     {"retweet_count", s.retweet_count},
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}});
+  }
+  return a.dump();
 }
 
 void to_json(nlohmann::json &j, const TwitterData &t) {
   j = nlohmann::json{{"statuses", t.statuses}};
 }
 
-// Deserialization functions for nlohmann
-void from_json(const nlohmann::json &j, User &u) {
-  j.at("id").get_to(u.id);
-  j.at("name").get_to(u.name);
-  j.at("screen_name").get_to(u.screen_name);
-  j.at("location").get_to(u.location);
-  j.at("description").get_to(u.description);
-  j.at("verified").get_to(u.verified);
-  j.at("followers_count").get_to(u.followers_count);
-  j.at("friends_count").get_to(u.friends_count);
-  j.at("statuses_count").get_to(u.statuses_count);
-}
-
-void from_json(const nlohmann::json &j, Status &s) {
-  j.at("created_at").get_to(s.created_at);
-  j.at("id").get_to(s.id);
-  j.at("text").get_to(s.text);
-  j.at("user").get_to(s.user);
-  j.at("retweet_count").get_to(s.retweet_count);
-  j.at("favorite_count").get_to(s.favorite_count);
-}
-
-void from_json(const nlohmann::json &j, TwitterData &t) {
-  j.at("statuses").get_to(t.statuses);
-}
-
-// Helper functions for benchmarking
 std::string nlohmann_serialize(const TwitterData &data) {
-  nlohmann::json j = data;
+  return nlohmann_serialize(data.statuses);
-  return j.dump();
-}
-
-TwitterData nlohmann_deserialize(const std::string &json_str) {
-  nlohmann::json j = nlohmann::json::parse(json_str);
-  return j.get<TwitterData>();
 }
 
 #endif // NLOHMANN_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/rapidjson_twitter_data.h

@@ -1,142 +0,0 @@
-#ifndef RAPIDJSON_TWITTER_DATA_H
-#define RAPIDJSON_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <rapidjson/document.h>
-#include <rapidjson/writer.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/error/en.h>
-
-using namespace rapidjson;
-
-// RapidJSON deserialization for simplified Twitter data
-TwitterData rapidjson_deserialize(const std::string& json_str) {
-    Document doc;
-    doc.Parse(json_str.c_str());
-
-    if (doc.HasParseError()) {
-        throw std::runtime_error("RapidJSON parse error");
-    }
-
-    TwitterData data;
-
-    if (!doc.HasMember("statuses") || !doc["statuses"].IsArray()) {
-        return data;
-    }
-
-    const Value& statuses = doc["statuses"];
-    data.statuses.reserve(statuses.Size());
-
-    for (SizeType i = 0; i < statuses.Size(); i++) {
-        const Value& status_json = statuses[i];
-        Status status;
-
-        // Parse status fields
-        if (status_json.HasMember("created_at") && status_json["created_at"].IsString())
-            status.created_at = status_json["created_at"].GetString();
-        if (status_json.HasMember("id") && status_json["id"].IsUint64())
-            status.id = status_json["id"].GetUint64();
-        if (status_json.HasMember("text") && status_json["text"].IsString())
-            status.text = status_json["text"].GetString();
-        if (status_json.HasMember("retweet_count") && status_json["retweet_count"].IsUint64())
-            status.retweet_count = status_json["retweet_count"].GetUint64();
-        if (status_json.HasMember("favorite_count") && status_json["favorite_count"].IsUint64())
-            status.favorite_count = status_json["favorite_count"].GetUint64();
-
-        // Parse user
-        if (status_json.HasMember("user") && status_json["user"].IsObject()) {
-            const Value& user_json = status_json["user"];
-            User user;
-
-            if (user_json.HasMember("id") && user_json["id"].IsUint64())
-                user.id = user_json["id"].GetUint64();
-            if (user_json.HasMember("name") && user_json["name"].IsString())
-                user.name = user_json["name"].GetString();
-            if (user_json.HasMember("screen_name") && user_json["screen_name"].IsString())
-                user.screen_name = user_json["screen_name"].GetString();
-            if (user_json.HasMember("location") && user_json["location"].IsString())
-                user.location = user_json["location"].GetString();
-            if (user_json.HasMember("description") && user_json["description"].IsString())
-                user.description = user_json["description"].GetString();
-            if (user_json.HasMember("verified") && user_json["verified"].IsBool())
-                user.verified = user_json["verified"].GetBool();
-            if (user_json.HasMember("followers_count") && user_json["followers_count"].IsUint64())
-                user.followers_count = user_json["followers_count"].GetUint64();
-            if (user_json.HasMember("friends_count") && user_json["friends_count"].IsUint64())
-                user.friends_count = user_json["friends_count"].GetUint64();
-            if (user_json.HasMember("statuses_count") && user_json["statuses_count"].IsUint64())
-                user.statuses_count = user_json["statuses_count"].GetUint64();
-
-            status.user = user;
-        }
-
-        data.statuses.push_back(status);
-    }
-
-    return data;
-}
-
-// RapidJSON serialization for simplified Twitter data
-std::string rapidjson_serialize(const TwitterData& data) {
-    Document doc;
-    doc.SetObject();
-    Document::AllocatorType& allocator = doc.GetAllocator();
-
-    Value statuses_array(kArrayType);
-
-    for (const auto& status : data.statuses) {
-        Value status_obj(kObjectType);
-
-        Value created_at;
-        created_at.SetString(status.created_at.c_str(), allocator);
-        status_obj.AddMember("created_at", created_at, allocator);
-
-        status_obj.AddMember("id", status.id, allocator);
-
-        Value text;
-        text.SetString(status.text.c_str(), allocator);
-        status_obj.AddMember("text", text, allocator);
-
-        // Add user
-        Value user_obj(kObjectType);
-        user_obj.AddMember("id", status.user.id, allocator);
-
-        Value name;
-        name.SetString(status.user.name.c_str(), allocator);
-        user_obj.AddMember("name", name, allocator);
-
-        Value screen_name;
-        screen_name.SetString(status.user.screen_name.c_str(), allocator);
-        user_obj.AddMember("screen_name", screen_name, allocator);
-
-        Value location;
-        location.SetString(status.user.location.c_str(), allocator);
-        user_obj.AddMember("location", location, allocator);
-
-        Value description;
-        description.SetString(status.user.description.c_str(), allocator);
-        user_obj.AddMember("description", description, allocator);
-
-        user_obj.AddMember("verified", status.user.verified, allocator);
-        user_obj.AddMember("followers_count", status.user.followers_count, allocator);
-        user_obj.AddMember("friends_count", status.user.friends_count, allocator);
-        user_obj.AddMember("statuses_count", status.user.statuses_count, allocator);
-
-        status_obj.AddMember("user", user_obj, allocator);
-
-        status_obj.AddMember("retweet_count", status.retweet_count, allocator);
-        status_obj.AddMember("favorite_count", status.favorite_count, allocator);
-
-        statuses_array.PushBack(status_obj, allocator);
-    }
-
-    doc.AddMember("statuses", statuses_array, allocator);
-
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    doc.Accept(writer);
-
-    return buffer.GetString();
-}
-
-#endif // RAPIDJSON_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/twitter_data.h

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

benchmark/static_reflect/twitter_benchmark/yyjson_twitter_data.h

@@ -1,145 +0,0 @@
-#ifndef YYJSON_TWITTER_DATA_H
-#define YYJSON_TWITTER_DATA_H
-
-#include "twitter_data.h"
-#include <yyjson.h>
-#include <string>
-#include <stdexcept>
-
-// yyjson deserialization for simplified Twitter data
-TwitterData yyjson_deserialize(const std::string &json_str) {
-    TwitterData data;
-
-    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
-    if (!doc) {
-        throw std::runtime_error("yyjson parse error");
-    }
-
-    yyjson_val *root = yyjson_doc_get_root(doc);
-    if (!root) {
-        yyjson_doc_free(doc);
-        return data;
-    }
-
-    // Get statuses array
-    yyjson_val *statuses_val = yyjson_obj_get(root, "statuses");
-    if (!statuses_val || !yyjson_is_arr(statuses_val)) {
-        yyjson_doc_free(doc);
-        return data;
-    }
-
-    size_t idx, max;
-    yyjson_val *status_val;
-    yyjson_arr_foreach(statuses_val, idx, max, status_val) {
-        Status status;
-
-        // Parse status fields
-        yyjson_val *val;
-
-        val = yyjson_obj_get(status_val, "created_at");
-        if (val && yyjson_is_str(val)) status.created_at = yyjson_get_str(val);
-
-        val = yyjson_obj_get(status_val, "id");
-        if (val && yyjson_is_uint(val)) status.id = yyjson_get_uint(val);
-
-        val = yyjson_obj_get(status_val, "text");
-        if (val && yyjson_is_str(val)) status.text = yyjson_get_str(val);
-
-        val = yyjson_obj_get(status_val, "retweet_count");
-        if (val && yyjson_is_uint(val)) status.retweet_count = yyjson_get_uint(val);
-
-        val = yyjson_obj_get(status_val, "favorite_count");
-        if (val && yyjson_is_uint(val)) status.favorite_count = yyjson_get_uint(val);
-
-        // Parse user
-        yyjson_val *user_val = yyjson_obj_get(status_val, "user");
-        if (user_val && yyjson_is_obj(user_val)) {
-            User user;
-
-            val = yyjson_obj_get(user_val, "id");
-            if (val && yyjson_is_uint(val)) user.id = yyjson_get_uint(val);
-
-            val = yyjson_obj_get(user_val, "name");
-            if (val && yyjson_is_str(val)) user.name = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "screen_name");
-            if (val && yyjson_is_str(val)) user.screen_name = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "location");
-            if (val && yyjson_is_str(val)) user.location = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "description");
-            if (val && yyjson_is_str(val)) user.description = yyjson_get_str(val);
-
-            val = yyjson_obj_get(user_val, "verified");
-            if (val && yyjson_is_bool(val)) user.verified = yyjson_get_bool(val);
-
-            val = yyjson_obj_get(user_val, "followers_count");
-            if (val && yyjson_is_uint(val)) user.followers_count = yyjson_get_uint(val);
-
-            val = yyjson_obj_get(user_val, "friends_count");
-            if (val && yyjson_is_uint(val)) user.friends_count = yyjson_get_uint(val);
-
-            val = yyjson_obj_get(user_val, "statuses_count");
-            if (val && yyjson_is_uint(val)) user.statuses_count = yyjson_get_uint(val);
-
-            status.user = user;
-        }
-
-        data.statuses.push_back(status);
-    }
-
-    yyjson_doc_free(doc);
-    return data;
-}
-
-// yyjson serialization for simplified Twitter data
-std::string yyjson_serialize(const TwitterData &data) {
-    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
-    yyjson_mut_val *root = yyjson_mut_obj(doc);
-    yyjson_mut_doc_set_root(doc, root);
-
-    // Create statuses array
-    yyjson_mut_val *statuses_array = yyjson_mut_arr(doc);
-
-    for (const auto& status : data.statuses) {
-        yyjson_mut_val *status_obj = yyjson_mut_obj(doc);
-
-        // Add status fields
-        yyjson_mut_obj_add_str(doc, status_obj, "created_at", status.created_at.c_str());
-        yyjson_mut_obj_add_uint(doc, status_obj, "id", status.id);
-        yyjson_mut_obj_add_str(doc, status_obj, "text", status.text.c_str());
-
-        // User object
-        yyjson_mut_val *user_obj = yyjson_mut_obj(doc);
-        yyjson_mut_obj_add_uint(doc, user_obj, "id", status.user.id);
-        yyjson_mut_obj_add_str(doc, user_obj, "name", status.user.name.c_str());
-        yyjson_mut_obj_add_str(doc, user_obj, "screen_name", status.user.screen_name.c_str());
-        yyjson_mut_obj_add_str(doc, user_obj, "location", status.user.location.c_str());
-        yyjson_mut_obj_add_str(doc, user_obj, "description", status.user.description.c_str());
-        yyjson_mut_obj_add_bool(doc, user_obj, "verified", status.user.verified);
-        yyjson_mut_obj_add_uint(doc, user_obj, "followers_count", status.user.followers_count);
-        yyjson_mut_obj_add_uint(doc, user_obj, "friends_count", status.user.friends_count);
-        yyjson_mut_obj_add_uint(doc, user_obj, "statuses_count", status.user.statuses_count);
-        yyjson_mut_obj_add_val(doc, status_obj, "user", user_obj);
-
-        // Other fields
-        yyjson_mut_obj_add_uint(doc, status_obj, "retweet_count", status.retweet_count);
-        yyjson_mut_obj_add_uint(doc, status_obj, "favorite_count", status.favorite_count);
-
-        yyjson_mut_arr_append(statuses_array, status_obj);
-    }
-
-    // Add statuses array to root
-    yyjson_mut_obj_add_val(doc, root, "statuses", statuses_array);
-
-    // Write to string
-    char *json_output = yyjson_mut_write(doc, 0, NULL);
-    std::string result(json_output);
-    free(json_output);
-    yyjson_mut_doc_free(doc);
-
-    return result;
-}
-
-#endif // YYJSON_TWITTER_DATA_H

dependencies/CMakeLists.txt

@@ -12,7 +12,7 @@ cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark
 if(SIMDJSON_GOOGLE_BENCHMARKS)
   CPMAddPackage(
         NAME google_benchmarks
-        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.5.zip
+        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.4.zip
         OPTIONS
         "BENCHMARK_ENABLE_TESTING OFF"
         "BENCHMARK_ENABLE_INSTALL OFF"

doc/basics.md

@@ -271,21 +271,6 @@ Further, they may use the AreFileApisANSI function to determine whether
 the filename is interpreted using the ANSI or the system default OEM
 codepage, and they may call SetFileApisToOEM accordingly.
 
-
-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
-
-```cpp
-// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
-// under Windows at this time.
-simdjson::padded_memory_map map(myfilename);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-ondemand::document doc = parser.iterate(view); // parse the JSON
-```
-
-
 Documents are iterators
 -----------------------
 
@@ -389,10 +374,6 @@ builds to disable additional runtime testing and get the best performance. We
 disable these checks on a best-effort basis but the C++ standard does not provide
 a direct way to check for a release build.
 
-
-Warnign: Mixing debug and release simdjson code is unsafe: you either build all your code
-using simdjson in release mode or all of it in debug mode.
-
 Using the parsed JSON
 ---------------------
 
@@ -488,7 +469,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   out of the array, you may use an array access (e.g., `array[1]`). You should never reset an array as you are iterating through it. The following is an anti-pattern: `for(auto value: myarray) {myarray.reset()}`.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`. This will
   scan through the object looking for the field with the matching string, doing a character-by-character
-  comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). The returned value is only valid so long as you do not access another field: normally, you should therefore grab the value right after accessing a key (i.e., convert it to number, string, object, array...). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
+  comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
   not do `object["foo"]` followed by `object["foo"]` with the same `object` instance. Generally, you should not mix and match iterating through an object (`for(auto field : object) {...}`) and key accesses (`object["foo"]`): if you need to iterate through an object after a key access, you need to call `reset()` on the object. Whenever you call `reset()`, you need to keep in mind that though you can iterate over the array repeatedly, values should be consumedonly once (e.g., repeatedly calling `unescaped_key()` on the same  key is forbidden). Keep in mind that On-Demand does not buffer or save the result of the parsing: if you repeatedly access `object["foo"]`, then it must repeatedly seek the key and parse the content. The library does not provide a distinct function to check if a key is present, instead we recommend you attempt to access the key: e.g., by doing `ondemand::value val{}; if (!object["foo"].get(val)) {...}`, you have that `val` contains the requested value inside the if clause.  It is your responsibility as a user to temporarily keep a reference to the value (`auto v = object["foo"]`), or to consume the content and store it in your own data structures. If you consume an
   object twice: `std::string_view(object["foo"]` followed by `std::string_view(object["foo"]` then your code
   is in error. Furthermore, you can only consume one field at a time, on the same object. The

doc/dom.md

@@ -125,22 +125,6 @@ Further, they may use the AreFileApisANSI function to determine whether
 the filename is interpreted using the ANSI or the system default OEM
 codepage, and they may call SetFileApisToOEM accordingly.
 
-
-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
-
-```cpp
-// if the macro _WIN32 is defined, this will not work since we do not support Windows
-simdjson::padded_memory_map map(TWITTER_JSON);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-ondemand::document doc = parser.iterate(view); // parse the JSON
-```
-
-Using memory-file mapping requires some care. The file should not be modified while you are
-accessing it.
-
 Using the Parsed JSON
 ---------------------
 
@@ -168,23 +152,6 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
   as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
-* **Big Integer Support (opt-in):** By default, integers that exceed the 64-bit range cause parsing to fail with `BIGINT_ERROR`. You can opt in to big integer support so that these numbers are stored as raw digit strings on the tape instead:
-  ```cpp
-  simdjson::dom::parser parser;
-  parser.number_as_string(true); // opt-in, default false
-  simdjson::dom::element doc;
-  auto error = parser.parse("[1, 123456789012345678901]"_padded).get(doc);
-  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
-  for (simdjson::dom::element elem : doc) {
-    if (elem.is_bigint()) {
-      std::string_view digits;
-      error = elem.get_bigint().get(digits);
-      if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
-      std::cout << "big integer: " << digits << std::endl;
-    }
-  }
-  ```
-  When enabled, big integers have type `element_type::BIGINT`. Calling `get_int64()`, `get_uint64()`, or `get_double()` on a big integer returns `INCORRECT_TYPE`. Normal numbers (int64, uint64, double) are unaffected.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`.
 * **Array Iteration:** To iterate through an array, use `for (auto value : array) { ... }`. If you
   know the type of the value, you can cast it right there, too! `for (double value : array) { ... }`
@@ -197,7 +164,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array and Object size** Given an array or an object, you can get its size (number of elements or keys)
   with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
-  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL`, `simdjson::dom::element_type::NULL_VALUE` or, `simdjson::dom::element_type::BIGINT` (when big integer support is enabled).
+  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
 * **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`) or a prettified string version (`simdjson::prettify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).
 
 ### Examples

doc/implementation-selection.md

@@ -33,9 +33,6 @@ compiles *all* the implementations into the executable. On Intel, it will includ
 (icelake, haswell, westmere and fallback), on 64-bit ARM it will include just one since running dispatching is  unnecessary, and on PPC
 it will include 2 (ppc64 and fallback).
 
-On Loongson processors, LASX runtime dispatching is only enabled on GCC 15+, not on LLVM or older versions of GCC.
-Thus unless you compile specifically for LASX or use GCC 15+, you will not benefit from LASX support.
-
 If you know more about where you're going to run and want to save the space, you can disable any of
 these implementations at compile time with `-DSIMDJSON_IMPLEMENTATION_X=0` (where X is ICELAKE, HASWELL,
 WESTMERE, ARM64, PPC64, LSX, LASX and FALLBACK).

doc/iterate_many.md

@@ -154,20 +154,6 @@ for (auto doc : docs) {
 
 See [basics.md](basics.md#newline-delimited-json-ndjson-and-json-lines) for an overview of the API.
 
-
-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
-
-```cpp
-// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
-// under Windows at this time.
-simdjson::padded_memory_map map(myfilename);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-ondemand::document doc = parser.iterate(view); // parse the JSON
-```
-
 ## Use cases
 
 From [jsonlines.org](http://jsonlines.org/examples/):

doc/parse_many.md

@@ -217,20 +217,6 @@ got full document at 29
 ```
 
 
-
-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
-
-```cpp
-// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
-// under Windows at this time.
-simdjson::padded_memory_map map(myfilename);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-ondemand::document doc = parser.iterate(view); // parse the JSON
-```
-
 Incomplete streams
 -----------
 

doc/tape.md

@@ -93,14 +93,6 @@ Float values are represented as two 64-bit tape elements:
 
 Performance consideration: We store numbers of the main tape because we believe that locality of reference is helpful for performance.
 
-## Big Integers
-
-When a JSON integer exceeds the 64-bit range (both signed and unsigned), it is classified as a big integer. By default, parsing returns `BIGINT_ERROR`. When `parser.number_as_string(true)` is set, the raw digits are stored on the string tape using the same format as strings (4-byte little-endian length prefix, followed by the UTF-8 digit bytes, followed by a null terminator).
-
-A big integer is represented on the main tape as the 64-bit tape element `('Z' << 56) + x` where the payload `x` is the location on the string tape of the null-terminated digit string.
-
-For example, the JSON value `99999999999999999999` would be stored as the string `"99999999999999999999"` on the string tape, with a `'Z'` tag on the main tape. Negative big integers include the leading minus sign.
-
 ## Root node
 
 Each JSON document will have two special 64-bit tape elements representing a root node, one at the beginning and one at the end.

fuzz/fuzz_dump.cpp

@@ -54,9 +54,6 @@ static void print_json(std::ostream& os, simdjson::dom::element element) noexcep
   case simdjson::dom::element_type::NULL_VALUE:
     os << "null" << endl;
     break;
-  case simdjson::dom::element_type::BIGINT:
-    os << element.get_bigint().value_unsafe() << endl;
-    break;
   }
 }
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {

include/simdjson/arm64/simd.h

@@ -428,7 +428,6 @@ namespace {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 4, "ARM kernel should use four registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
-    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/arm64/stringparsing_defs.h

@@ -17,6 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -34,8 +35,10 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v0(src);
   simd8<uint8_t> v1(src + sizeof(v0));
+  if(dst != nullptr) {
     v0.store(dst);
     v1.store(dst + sizeof(v0));
+  }
 
   // Getting a 64-bit bitmask is much cheaper than multiple 16-bit bitmasks on ARM; therefore, we
   // smash them together into a 64-byte mask and get the bitmask from there.

include/simdjson/builtin.h

@@ -24,8 +24,6 @@
 #include "simdjson/lasx.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lsx)
 #include "simdjson/lsx.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
-#include "simdjson/rvv-vls.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/builtin/base.h

@@ -21,8 +21,6 @@ namespace simdjson {
   namespace lsx {}
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
   namespace lasx {}
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
-  namespace rvv_vls {}
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/builtin/builder.h

@@ -24,8 +24,6 @@
 #include "simdjson/lsx/builder.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/builder.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
-#include "simdjson/rvv-vls/builder.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/builtin/implementation.h

@@ -23,8 +23,6 @@
 #include "simdjson/lsx/implementation.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/implementation.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
-#include "simdjson/rvv-vls/implementation.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/builtin/ondemand.h

@@ -24,8 +24,6 @@
 #include "simdjson/lsx/ondemand.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/ondemand.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
-#include "simdjson/rvv-vls/ondemand.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/compiler_check.h

@@ -119,4 +119,5 @@
 #define SIMDJSON_CONSTEVAL 0
 #endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L && defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
 #endif // !defined(SIMDJSON_CONSTEVAL)
+
 #endif // SIMDJSON_COMPILER_CHECK_H

include/simdjson/dom/document-inl.h

@@ -141,15 +141,6 @@ inline bool document::dump_raw_tape(std::ostream &os) const noexcept {
     case 'r': // we start and end with the root node
       // should we be hitting the root node?
       return false;
-    case 'Z': // we have a big integer
-      os << "bigint ";
-      std::memcpy(&string_length, string_buf.get() + payload, sizeof(uint32_t));
-      os << std::string_view(
-        reinterpret_cast<const char *>(string_buf.get() + payload + sizeof(uint32_t)),
-        string_length
-      );
-      os << '\n';
-      break;
     default:
       return false;
     }

include/simdjson/dom/element-inl.h

@@ -81,10 +81,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<dom::element>::get_bool()
   if (error()) { return error(); }
   return first.get_bool();
 }
-simdjson_inline simdjson_result<std::string_view> simdjson_result<dom::element>::get_bigint() const noexcept {
-  if (error()) { return error(); }
-  return first.get_bigint();
-}
 
 simdjson_inline bool simdjson_result<dom::element>::is_array() const noexcept {
   return !error() && first.is_array();
@@ -114,9 +110,6 @@ simdjson_inline bool simdjson_result<dom::element>::is_bool() const noexcept {
 simdjson_inline bool simdjson_result<dom::element>::is_null() const noexcept {
   return !error() && first.is_null();
 }
-simdjson_inline bool simdjson_result<dom::element>::is_bigint() const noexcept {
-  return !error() && first.is_bigint();
-}
 
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::operator[](std::string_view key) const noexcept {
   if (error()) { return error(); }
@@ -225,15 +218,6 @@ inline simdjson_result<bool> element::get_bool() const noexcept {
   }
   return INCORRECT_TYPE;
 }
-inline simdjson_result<std::string_view> element::get_bigint() const noexcept {
-  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable());
-  switch (tape.tape_ref_type()) {
-    case internal::tape_type::BIGINT:
-      return tape.get_string_view();
-    default:
-      return INCORRECT_TYPE;
-  }
-}
 inline simdjson_result<const char *> element::get_c_str() const noexcept {
   SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
   switch (tape.tape_ref_type()) {
@@ -376,10 +360,6 @@ inline bool element::is_null() const noexcept {
   return tape.is_null_on_tape();
 }
 
-inline bool element::is_bigint() const noexcept {
-  return tape.tape_ref_type() == internal::tape_type::BIGINT;
-}
-
 #if SIMDJSON_EXCEPTIONS
 
 inline element::operator bool() const noexcept(false) { return get<bool>(); }
@@ -512,8 +492,6 @@ inline std::ostream& operator<<(std::ostream& out, element_type type) {
       return out << "bool";
     case element_type::NULL_VALUE:
       return out << "null";
-    case element_type::BIGINT:
-      return out << "bigint";
     default:
       return out << "unexpected content!!!"; // abort() usage is forbidden in the library
   }

include/simdjson/dom/element.h

@@ -21,8 +21,7 @@ enum class element_type {
   DOUBLE = 'd',    ///< double: Any number with a "." or "e" that fits in double.
   STRING = '"',    ///< std::string_view
   BOOL = 't',      ///< bool
-  NULL_VALUE = 'n', ///< null
+  NULL_VALUE = 'n' ///< null
-  BIGINT = 'Z'     ///< std::string_view: big integer stored as raw digit string
 };
 
 /**
@@ -121,14 +120,6 @@ public:
    */
   inline simdjson_result<bool> get_bool() const noexcept;
 
-  /**
-   * Read this element as a big integer (raw digit string).
-   *
-   * @returns A string_view of the raw digits, or:
-   *          INCORRECT_TYPE if the JSON element is not a big integer.
-   */
-  inline simdjson_result<std::string_view> get_bigint() const noexcept;
-
   /**
    * Whether this element is a json array.
    *
@@ -184,11 +175,6 @@ public:
    */
   inline bool is_null() const noexcept;
 
-  /**
-   * Whether this element is a big integer (number exceeding 64-bit range).
-   */
-  inline bool is_bigint() const noexcept;
-
   /**
    * Tell whether the value can be cast to provided type (T).
    *
@@ -547,7 +533,6 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64() const noexcept;
   simdjson_inline simdjson_result<double> get_double() const noexcept;
   simdjson_inline simdjson_result<bool> get_bool() const noexcept;
-  simdjson_inline simdjson_result<std::string_view> get_bigint() const noexcept;
 
   simdjson_inline bool is_array() const noexcept;
   simdjson_inline bool is_object() const noexcept;
@@ -558,7 +543,6 @@ public:
   simdjson_inline bool is_number() const noexcept;
   simdjson_inline bool is_bool() const noexcept;
   simdjson_inline bool is_null() const noexcept;
-  simdjson_inline bool is_bigint() const noexcept;
 
   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;

include/simdjson/dom/parser-inl.h

@@ -132,7 +132,6 @@ inline simdjson_result<element> parser::parse_into_document(document& provided_d
     buf += 3;
     len -= 3;
   }
-  implementation->_number_as_string = _number_as_string;
   _error = implementation->parse(buf, len, provided_doc);
 
   if (_error) { return _error; }

include/simdjson/dom/parser.h

@@ -610,13 +610,6 @@ public:
   inline bool dump_raw_tape(std::ostream &os) const noexcept;
 
 
-  /**
-   * When enabled, big integers (exceeding uint64 range) are stored as strings
-   * in the tape instead of returning BIGINT_ERROR. Default: false.
-   */
-  inline void number_as_string(bool enabled) noexcept { _number_as_string = enabled; }
-  inline bool number_as_string() const noexcept { return _number_as_string; }
-
 private:
   /**
    * The maximum document length this parser will automatically support.
@@ -625,9 +618,6 @@ private:
    */
   size_t _max_capacity;
 
-  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
-  bool _number_as_string{false};
-
   /**
    * The loaded buffer (reused each time load() is called)
    */

include/simdjson/dom/serialization-inl.h

@@ -460,12 +460,6 @@ inline void string_builder<serializer>::append(simdjson::dom::element value) {
     case tape_type::STRING:
       format.string(iter.get_string_view());
       break;
-    case tape_type::BIGINT: {
-      // Big integer stored as string — output raw digits (no quotes)
-      auto sv = iter.get_string_view();
-      format.chars(sv.data(), sv.data() + sv.size());
-      break;
-    }
     case tape_type::INT64:
       format.number(iter.next_tape_value<int64_t>());
       iter.json_index++; // numbers take up 2 spots, so we need to increment

include/simdjson/fallback/bitmanipulation.h

@@ -41,19 +41,6 @@ simdjson_inline int leading_zeroes(uint64_t input_num) {
 #endif// _MSC_VER
 }
 
-simdjson_inline int trailing_zeroes(uint64_t input_num) {
-#ifdef _MSC_VER
-  unsigned long trailing_zero = 0;
-  // Search the mask data from least significant bit (LSB)
-  // to most significant bit (MSB) for a set bit (1).
-  if (_BitScanForward64(&trailing_zero, input_num))
-    return (int)trailing_zero;
-  else    return 64;
-#else
-  return __builtin_ctzll(input_num);
-#endif// _MSC_VER
-}
-
 } // unnamed namespace
 } // namespace fallback
 } // namespace simdjson

include/simdjson/fallback/stringparsing_defs.h

@@ -13,6 +13,7 @@ namespace {
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 1;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return c == '"'; }
@@ -25,7 +26,9 @@ public:
 
 simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
   // store to dest unconditionally - we can overwrite the bits we don't like later
+  if(dst != nullptr) {
     dst[0] = src[0];
+  }
   return { src[0] };
 }
 

include/simdjson/generic/base.h

@@ -21,8 +21,6 @@
 #include "simdjson/lasx/begin.h"
 #elif SIMDJSON_IMPLEMENTATION_LSX
 #include "simdjson/lsx/begin.h"
-#elif SIMDJSON_IMPLEMENTATION_RVV_VLS
-#include "simdjson/rvv-vls/begin.h"
 #elif SIMDJSON_IMPLEMENTATION_FALLBACK
 #include "simdjson/fallback/begin.h"
 #else

include/simdjson/generic/builder/json_builder.h

@@ -275,7 +275,7 @@ simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, siz
 }
 
 template <class Z>
-simdjson_warn_unused error_code to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
@@ -352,7 +352,7 @@ simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t ini
   return std::string(s);
 }
 template <class Z>
-simdjson_warn_unused error_code to_json(const Z &z, std::string &s, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
   SIMDJSON_IMPLEMENTATION::builder::append(b, z);
   std::string_view view;

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

@@ -27,50 +27,12 @@
 #define SIMDJSON_EXPERIMENTAL_HAS_NEON 1
 #endif
 #endif
-#if defined(__loongarch_sx)
-#ifndef SIMDJSON_EXPERIMENTAL_HAS_LSX
-#define SIMDJSON_EXPERIMENTAL_HAS_LSX 1
-#endif
-#endif
-#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 11000 &&            \
-    defined(__riscv_vector)
-#ifndef SIMDJSON_EXPERIMENTAL_HAS_RVV
-#define SIMDJSON_EXPERIMENTAL_HAS_RVV 1
-#endif
-#endif
-#if (defined(__PPC64__) || defined(_M_PPC64)) && defined(__ALTIVEC__)
-#ifndef SIMDJSON_EXPERIMENTAL_HAS_PPC64
-#define SIMDJSON_EXPERIMENTAL_HAS_PPC64 1
-#endif
-#endif
 #if SIMDJSON_EXPERIMENTAL_HAS_NEON
 #include <arm_neon.h>
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
 #endif
 #if SIMDJSON_EXPERIMENTAL_HAS_SSE2
 #include <emmintrin.h>
-#ifdef _MSC_VER
-#include <intrin.h>
 #endif
-#endif
-#if SIMDJSON_EXPERIMENTAL_HAS_LSX
-#include <lsxintrin.h>
-#endif
-#if SIMDJSON_EXPERIMENTAL_HAS_RVV
-#include <riscv_vector.h>
-#endif
-#if SIMDJSON_EXPERIMENTAL_HAS_PPC64
-#include <altivec.h>
-#ifdef bool
-#undef bool
-#endif
-#ifdef vector
-#undef vector
-#endif
-#endif
-
 
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
@@ -171,45 +133,16 @@ simdjson_inline bool fast_needs_escaping(std::string_view view) {
   }
   return _mm_movemask_epi8(running) != 0;
 }
-#elif SIMDJSON_EXPERIMENTAL_HAS_PPC64
-simdjson_inline bool fast_needs_escaping(std::string_view view) {
-  if (view.size() < 16) {
-    return simple_needs_escaping(view);
-  }
-  size_t i = 0;
-  __vector unsigned char running = vec_splats((unsigned char)0);
-  __vector unsigned char v34 = vec_splats((unsigned char)34);
-  __vector unsigned char v92 = vec_splats((unsigned char)92);
-  __vector unsigned char v32 = vec_splats((unsigned char)32);
-
-  for (; i + 15 < view.size(); i += 16) {
-    __vector unsigned char word =
-        vec_vsx_ld(0, reinterpret_cast<const unsigned char *>(view.data() + i));
-    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v34));
-    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v92));
-    running = vec_or(running,
-        (__vector unsigned char)vec_cmplt(word, v32));
-  }
-  if (i < view.size()) {
-    __vector unsigned char word = vec_vsx_ld(
-        0, reinterpret_cast<const unsigned char *>(view.data() + view.length() - 16));
-    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v34));
-    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v92));
-    running = vec_or(running,
-        (__vector unsigned char)vec_cmplt(word, v32));
-  }
-  return !vec_all_eq(running, vec_splats((unsigned char)0));
-}
 #else
 simdjson_inline bool fast_needs_escaping(std::string_view view) {
   return simple_needs_escaping(view);
 }
 #endif
 
-// Scalar fallback for finding next quotable character
+SIMDJSON_CONSTEXPR_LAMBDA inline size_t
-SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
-find_next_json_quotable_character_scalar(const std::string_view view,
                                   size_t location) noexcept {
+
   for (auto pos = view.begin() + location; pos != view.end(); ++pos) {
     if (json_quotable_character[static_cast<uint8_t>(*pos)]) {
       return pos - view.begin();
@@ -218,213 +151,6 @@ find_next_json_quotable_character_scalar(const std::string_view view,
   return size_t(view.size());
 }
 
-// SIMD-accelerated position finding that directly locates the first quotable
-// character, combining detection and position extraction in a single pass to
-// minimize redundant work.
-#if SIMDJSON_EXPERIMENTAL_HAS_NEON
-simdjson_inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-  const size_t len = view.size();
-  const uint8_t *ptr =
-      reinterpret_cast<const uint8_t *>(view.data()) + location;
-  size_t remaining = len - location;
-
-  // SIMD constants for characters requiring escape
-  uint8x16_t v34 = vdupq_n_u8(34);  // '"'
-  uint8x16_t v92 = vdupq_n_u8(92);  // '\\'
-  uint8x16_t v32 = vdupq_n_u8(32);  // control char threshold
-
-  while (remaining >= 16) {
-    uint8x16_t word = vld1q_u8(ptr);
-
-    // Check for quotable characters: '"', '\\', or control chars (< 32)
-    uint8x16_t needs_escape = vceqq_u8(word, v34);
-    needs_escape = vorrq_u8(needs_escape, vceqq_u8(word, v92));
-    needs_escape = vorrq_u8(needs_escape, vcltq_u8(word, v32));
-
-    const uint8x8_t res = vshrn_n_u16(vreinterpretq_u16_u8(needs_escape), 4);
-    const uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
-    if(mask != 0) {
-      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
-      auto trailing_zero = trailing_zeroes(mask);
-      return offset + (trailing_zero >> 2);
-    }
-    ptr += 16;
-    remaining -= 16;
-  }
-
-  // Scalar fallback for remaining bytes
-  size_t current = len - remaining;
-  return find_next_json_quotable_character_scalar(view, current);
-}
-#elif SIMDJSON_EXPERIMENTAL_HAS_SSE2
-simdjson_inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-  const size_t len = view.size();
-  const uint8_t *ptr =
-      reinterpret_cast<const uint8_t *>(view.data()) + location;
-  size_t remaining = len - location;
-
-  // SIMD constants
-  __m128i v34 = _mm_set1_epi8(34);  // '"'
-  __m128i v92 = _mm_set1_epi8(92);  // '\\'
-  __m128i v31 = _mm_set1_epi8(31);  // for control char detection
-
-  while (remaining >= 16) {
-    __m128i word = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr));
-
-    // Check for quotable characters
-    __m128i needs_escape = _mm_cmpeq_epi8(word, v34);
-    needs_escape = _mm_or_si128(needs_escape, _mm_cmpeq_epi8(word, v92));
-    needs_escape = _mm_or_si128(
-        needs_escape,
-        _mm_cmpeq_epi8(_mm_subs_epu8(word, v31), _mm_setzero_si128()));
-
-    int mask = _mm_movemask_epi8(needs_escape);
-    if (mask != 0) {
-      // Found quotable character - use trailing zero count to find position
-      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
-      return offset + trailing_zeroes(mask);
-    }
-    ptr += 16;
-    remaining -= 16;
-  }
-
-  // Scalar fallback for remaining bytes
-  size_t current = len - remaining;
-  return find_next_json_quotable_character_scalar(view, current);
-}
-#elif SIMDJSON_EXPERIMENTAL_HAS_LSX
-simdjson_inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-  const size_t len = view.size();
-  const uint8_t *ptr =
-      reinterpret_cast<const uint8_t *>(view.data()) + location;
-  size_t remaining = len - location;
-
-  //SIMD constants for characters requiring escape
-  __m128i v34 = __lsx_vreplgr2vr_b(34);  // '"'
-  __m128i v92 = __lsx_vreplgr2vr_b(92);  // '\\'
-  __m128i v32 = __lsx_vreplgr2vr_b(32);  // control char threshold
-
-  while (remaining >= 16){
-    __m128i word = __lsx_vld(ptr, 0);
-
-    //Check for the quotable characters: '"', '\\', or control char (<32)
-    __m128i needs_escape = __lsx_vseq_b(word, v34);
-    needs_escape = __lsx_vor_v(needs_escape, __lsx_vseq_b(word, v92));
-    needs_escape = __lsx_vor_v(needs_escape, __lsx_vslt_bu(word, v32));
-
-    if (!__lsx_bz_v(needs_escape)){
-
-      //Found quotable character - extract exact byte position
-      uint64_t lo = __lsx_vpickve2gr_du(needs_escape,0);
-      uint64_t hi = __lsx_vpickve2gr_du(needs_escape,1);
-      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
-      if ( lo != 0) {
-        return offset + trailing_zeroes(lo) / 8;
-      } else {
-        return offset + 8 + trailing_zeroes(hi) / 8;
-      }
-    }
-    ptr += 16;
-    remaining -= 16;
-  }
-  size_t current = len - remaining;
-  return find_next_json_quotable_character_scalar(view, current);
-}
-#elif SIMDJSON_EXPERIMENTAL_HAS_RVV
-simdjson_inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-  const size_t len = view.size();
-  const uint8_t *ptr =
-      reinterpret_cast<const uint8_t *>(view.data()) + location;
-  size_t remaining = len - location;
-
-  while (remaining > 0) {
-    size_t vl = __riscv_vsetvl_e8m1(remaining);
-    vuint8m1_t word = __riscv_vle8_v_u8m1(ptr, vl);
-
-    // Check for quotable characters: '"', '\\', or control chars (< 32)
-    vbool8_t needs_escape = __riscv_vmseq(word, (uint8_t)34, vl);
-    needs_escape = __riscv_vmor(needs_escape,
-        __riscv_vmseq(word, (uint8_t)92, vl), vl);
-    needs_escape = __riscv_vmor(needs_escape,
-        __riscv_vmsltu(word, (uint8_t)32, vl), vl);
-
-    long first = __riscv_vfirst(needs_escape, vl);
-    if (first >= 0) {
-      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
-      return offset + first;
-    }
-    ptr += vl;
-    remaining -= vl;
-  }
-
-  return len;
-}
-#elif SIMDJSON_EXPERIMENTAL_HAS_PPC64
-simdjson_inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-  const size_t len = view.size();
-  const uint8_t *ptr =
-      reinterpret_cast<const uint8_t *>(view.data()) + location;
-  size_t remaining = len - location;
-
-  // SIMD constants for characters requiring escape
-  __vector unsigned char v34 = vec_splats((unsigned char)34);  // '"'
-  __vector unsigned char v92 = vec_splats((unsigned char)92);  // '\\'
-  __vector unsigned char v32 = vec_splats((unsigned char)32);  // control char threshold
-
-  // Bitmask for vec_vbpermq to extract one bit per byte
-  const __vector unsigned char perm_mask = {0x78, 0x70, 0x68, 0x60, 0x58, 0x50,
-                                            0x48, 0x40, 0x38, 0x30, 0x28, 0x20,
-                                            0x18, 0x10, 0x08, 0x00};
-
-  while (remaining >= 16) {
-    __vector unsigned char word =
-        vec_vsx_ld(0, reinterpret_cast<const unsigned char *>(ptr));
-
-    // Check for quotable characters: '"', '\\', or control chars (< 32)
-    __vector unsigned char needs_escape =
-        (__vector unsigned char)vec_cmpeq(word, v34);
-    needs_escape = vec_or(needs_escape,
-        (__vector unsigned char)vec_cmpeq(word, v92));
-    needs_escape = vec_or(needs_escape,
-        (__vector unsigned char)vec_cmplt(word, v32));
-
-    __vector unsigned long long result =
-        (__vector unsigned long long)vec_vbpermq(needs_escape, perm_mask);
-#ifdef __LITTLE_ENDIAN__
-    unsigned int mask = static_cast<unsigned int>(result[1]);
-#else
-    unsigned int mask = static_cast<unsigned int>(result[0]);
-#endif
-    if (mask != 0) {
-      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
-      return offset + __builtin_ctz(mask);
-    }
-    ptr += 16;
-    remaining -= 16;
-  }
-
-  // Scalar fallback for remaining bytes
-  size_t current = len - remaining;
-  return find_next_json_quotable_character_scalar(view, current);
-}
-#else
-SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-  return find_next_json_quotable_character_scalar(view, location);
-}
-#endif
-
 SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
     "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006",
     "\\u0007", "\\b",     "\\t",     "\\n",     "\\u000b", "\\f",     "\\r",
@@ -437,7 +163,7 @@ SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
 // control characters (U+0000 through U+001F). There are two-character sequence
 // escape representations of some popular characters:
 // \", \\, \b, \f, \n, \r, \t.
-SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline void escape_json_char(char c, char *&out) {
+SIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {
   if (c == '"') {
     memcpy(out, "\\\"", 2);
     out += 2;
@@ -451,20 +177,14 @@ SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline void escape_json_char(char c, char *&o
   }
 }
 
-// Writes the escaped version of input to out, returning the number of bytes
-// written. Uses SIMD position finding to locate quotable characters efficiently.
 inline size_t write_string_escaped(const std::string_view input, char *out) {
   size_t mysize = input.size();
-
+  if (!fast_needs_escaping(input)) { // fast path!
-  // Use SIMD position finder directly - it returns mysize if no escape needed
-  size_t location = find_next_json_quotable_character(input, 0);
-  if (location == mysize) {
-    // Fast path: no escaping needed
     memcpy(out, input.data(), input.size());
     return input.size();
   }
-
   const char *const initout = out;
+  size_t location = find_next_json_quotable_character(input, 0);
   memcpy(out, input.data(), location);
   out += location;
   escape_json_char(input[location], out);
@@ -496,7 +216,7 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
     return true;
   }
   // check for overflow, most of the time there is no overflow
-  if (simdjson_unlikely(position + upcoming_bytes < position)) {
+  if (simdjson_likely(position + upcoming_bytes < position)) {
     return false;
   }
   // We will rarely get here.
@@ -663,29 +383,12 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
     }
   }
   else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {
-    // Process 4 digits at a time instead of 2, reducing store operations
-    // and divisions by approximately half for large numbers.
     constexpr size_t max_number_size = 20;
     if (capacity_check(max_number_size)) {
       using unsigned_type = typename std::make_unsigned<number_type>::type;
       unsigned_type pv = static_cast<unsigned_type>(v);
       size_t dc = internal::digit_count(pv);
       char *write_pointer = buffer.get() + position + dc - 1;
-
-      // Process 4 digits per iteration for large numbers
-      while (pv >= 10000) {
-        unsigned_type q = pv / 10000;
-        unsigned_type r = pv % 10000;
-        unsigned_type r_hi = r / 100;  // High 2 digits of remainder
-        unsigned_type r_lo = r % 100;  // Low 2 digits of remainder
-        // Write low 2 digits first (rightmost), then high 2 digits
-        memcpy(write_pointer - 1, &internal::decimal_table[r_lo * 2], 2);
-        memcpy(write_pointer - 3, &internal::decimal_table[r_hi * 2], 2);
-        write_pointer -= 4;
-        pv = q;
-      }
-
-      // Handle remaining 1-4 digits with original 2-digit loop
       while (pv >= 100) {
         memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);
         write_pointer -= 2;
@@ -700,7 +403,6 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
     }
   }
   else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {
-    // Same 4-digit batching as unsigned path for signed integers
     constexpr size_t max_number_size = 20;
     if (capacity_check(max_number_size)) {
       using unsigned_type = typename std::make_unsigned<number_type>::type;
@@ -714,20 +416,6 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
       buffer.get()[position] = '-';
       position += negative ? 1 : 0;
       char *write_pointer = buffer.get() + position + dc - 1;
-
-      // Process 4 digits per iteration for large numbers
-      while (pv >= 10000) {
-        unsigned_type q = pv / 10000;
-        unsigned_type r = pv % 10000;
-        unsigned_type r_hi = r / 100;
-        unsigned_type r_lo = r % 100;
-        memcpy(write_pointer - 1, &internal::decimal_table[r_lo * 2], 2);
-        memcpy(write_pointer - 3, &internal::decimal_table[r_hi * 2], 2);
-        write_pointer -= 4;
-        pv = q;
-      }
-
-      // Handle remaining 1-4 digits
       while (pv >= 100) {
         memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);
         write_pointer -= 2;

include/simdjson/generic/builder/json_string_builder.h

@@ -280,7 +280,7 @@ simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t ini
   return std::string(s);
 }
 template <class Z>
-simdjson_warn_unused error_code to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view sv;

include/simdjson/generic/dom_parser_implementation.h

@@ -40,6 +40,7 @@ public:
   simdjson_warn_unused error_code stage1(const uint8_t *buf, size_t len, stage1_mode partial) noexcept final;
   simdjson_warn_unused error_code stage2(dom::document &doc) noexcept final;
   simdjson_warn_unused error_code stage2_next(dom::document &doc) noexcept final;
+  simdjson_warn_unused std::pair<const uint8_t *,bool> parse_string_if_needed(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept final;
   simdjson_warn_unused uint8_t *parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept final;
   simdjson_warn_unused uint8_t *parse_wobbly_string(const uint8_t *src, uint8_t *dst) const noexcept final;
   inline simdjson_warn_unused error_code set_capacity(size_t capacity) noexcept final;

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

@@ -364,7 +364,7 @@ simdjson_inline simdjson_result<std::string_view> json_iterator::unescape(raw_js
 #endif // !defined(SIMDJSON_VISUAL_STUDIO) && !defined(SIMDJSON_CLANG_VISUAL_STUDIO)
   return result;
 #else
-  return parser->unescape(in, _string_buf_loc, allow_replacement);
+  return parser->unescape_maybe(in, _string_buf_loc, allow_replacement);
 #endif
 }
 

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

@@ -179,6 +179,20 @@ simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
   }
 }
 
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_maybe(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  std::pair<const uint8_t *, bool> result = implementation->parse_string_if_needed(in.buf, dst, allow_replacement);
+  const uint8_t *end = result.first;
+  bool copied = result.second;
+  if (!end) { return STRING_ERROR; }
+  if(copied) {
+    std::string_view strresult(reinterpret_cast<const char *>(dst), end-dst);
+    dst = const_cast<uint8_t *>(end);
+    return strresult;
+  }
+  // fast path, no copy was made!!!
+  return std::string_view(reinterpret_cast<const char *>(in.buf), end-in.buf);
+}
+
 simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
   uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
   if (!end) { return STRING_ERROR; }

include/simdjson/generic/ondemand/parser.h

@@ -334,6 +334,32 @@ public:
    */
   simdjson_inline simdjson_result<std::string_view> unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement = false) const noexcept;
 
+  /**
+   * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer if
+   * needed. If no escaping is done, the string is returned as is and dst is not not changed.
+   * The result must be valid UTF-8.
+   * The provided pointer is advanced to the end of the string by reference if a copy is needed,
+    * and a string_view instance
+   * is returned. You can ensure that your buffer is large enough by allocating a block of memory at least
+   * as large as the input JSON plus SIMDJSON_PADDING and then unescape all strings to this one buffer.
+   *
+   * This unescape_maybe function is a low-level function. If you want a more user-friendly approach, you should
+   * avoid raw_json_string instances (e.g., by calling unescaped_key() instead of key() or get_string()
+   * instead of get_raw_json_string()).
+   *
+   * ## IMPORTANT: string_view lifetime
+   *
+   * The string_view is only valid as long as the bytes in dst.
+   *
+   * @param raw_json_string input
+   * @param dst A pointer to a buffer at least large enough to write this string as well as
+   *            an additional SIMDJSON_PADDING bytes.
+   * @param allow_replacement Whether we allow a replacement if the input string contains unmatched surrogate pairs.
+   * @return A string_view pointing at the unescaped string in dst
+   * @error STRING_ERROR if escapes are incorrect.
+   */
+  simdjson_inline simdjson_result<std::string_view> unescape_maybe(raw_json_string in, uint8_t *&dst, bool allow_replacement = false) const noexcept;
+
   /**
    * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer.
    * The result may not be valid UTF-8. See https://simonsapin.github.io/wtf-8/

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

@@ -515,13 +515,9 @@ simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_ite
 template <typename string_type>
 simdjson_warn_unused simdjson_inline error_code value_iterator::get_string(string_type& receiver, bool allow_replacement) noexcept {
   std::string_view content;
-  // Save the string buffer location so that we can restore it after get_string
-  auto saved_string_buf_loc = _json_iter->string_buf_loc();
   auto err = get_string(allow_replacement).get(content);
   if (err) { return err; }
   receiver = content;
-  // Restore the string buffer location, effectively discarding any temporary string storage
-  _json_iter->string_buf_loc() = saved_string_buf_loc;
   return SUCCESS;
 }
 simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_wobbly_string() noexcept {
@@ -661,13 +657,9 @@ simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_ite
 template <typename string_type>
 simdjson_warn_unused simdjson_inline error_code value_iterator::get_root_string(string_type& receiver, bool check_trailing, bool allow_replacement) noexcept {
   std::string_view content;
-  // Save the string buffer location so that we can restore it after get_string
-  auto saved_string_buf_loc = _json_iter->string_buf_loc();
   auto err = get_root_string(check_trailing, allow_replacement).get(content);
   if (err) { return err; }
   receiver = content;
-  // Restore the string buffer location, effectively discarding any temporary string storage
-  _json_iter->string_buf_loc() = saved_string_buf_loc;
   return SUCCESS;
 }
 simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_root_wobbly_string(bool check_trailing) noexcept {

include/simdjson/haswell/simd.h

@@ -300,7 +300,6 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 2, "Haswell kernel should use two registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
-    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/haswell/stringparsing_defs.h

@@ -17,6 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -34,7 +35,9 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v(src);
   // store to dest unconditionally - we can overwrite the bits we don't like later
+  if(dst != nullptr) {
     v.store(dst);
+  }
   return {
       static_cast<uint32_t>((v == '\\').to_bitmask()),     // bs_bits
       static_cast<uint32_t>((v == '"').to_bitmask()), // quote_bits

include/simdjson/icelake/simd.h

@@ -322,7 +322,6 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 1, "Icelake kernel should use one register per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
-    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/icelake/stringparsing_defs.h

@@ -17,6 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 64;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -34,7 +35,9 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v(src);
   // store to dest unconditionally - we can overwrite the bits we don't like later
+  if(dst != nullptr) {
     v.store(dst);
+  }
   return {
       static_cast<uint64_t>(v == '\\'), // bs_bits
       static_cast<uint64_t>(v == '"'), // quote_bits

include/simdjson/implementation_detection.h

@@ -12,8 +12,6 @@
 #define SIMDJSON_IMPLEMENTATION_ID_westmere 6
 #define SIMDJSON_IMPLEMENTATION_ID_lsx 7
 #define SIMDJSON_IMPLEMENTATION_ID_lasx 8
-//#define SIMDJSON_IMPLEMENTATION_ID_rvv 9
-#define SIMDJSON_IMPLEMENTATION_ID_rvv_vls 10
 
 #define SIMDJSON_IMPLEMENTATION_ID_FOR(IMPL) SIMDJSON_CAT(SIMDJSON_IMPLEMENTATION_ID_, IMPL)
 #define SIMDJSON_IMPLEMENTATION_ID SIMDJSON_IMPLEMENTATION_ID_FOR(SIMDJSON_IMPLEMENTATION)
@@ -128,14 +126,9 @@
 #endif
 #define SIMDJSON_CAN_ALWAYS_RUN_LSX (SIMDJSON_IMPLEMENTATION_LSX)
 
-#define SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS SIMDJSON_IS_RVV_VLS
-#ifndef SIMDJSON_IMPLEMENTATION_RVV_VLS
-#define SIMDJSON_IMPLEMENTATION_RVV_VLS SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS
-#endif
-
 // Default Fallback to on unless a builtin implementation has already been selected.
 #ifndef SIMDJSON_IMPLEMENTATION_FALLBACK
-#if SIMDJSON_CAN_ALWAYS_RUN_ARM64 || SIMDJSON_CAN_ALWAYS_RUN_ICELAKE || SIMDJSON_CAN_ALWAYS_RUN_HASWELL || SIMDJSON_CAN_ALWAYS_RUN_WESTMERE || SIMDJSON_CAN_ALWAYS_RUN_PPC64 || SIMDJSON_CAN_ALWAYS_RUN_LSX || SIMDJSON_CAN_ALWAYS_RUN_LASX || SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS
+#if SIMDJSON_CAN_ALWAYS_RUN_ARM64 || SIMDJSON_CAN_ALWAYS_RUN_ICELAKE || SIMDJSON_CAN_ALWAYS_RUN_HASWELL || SIMDJSON_CAN_ALWAYS_RUN_WESTMERE || SIMDJSON_CAN_ALWAYS_RUN_PPC64 || SIMDJSON_CAN_ALWAYS_RUN_LSX || SIMDJSON_CAN_ALWAYS_RUN_LASX
 // if anything at all except fallback can always run, then disable fallback.
 #define SIMDJSON_IMPLEMENTATION_FALLBACK 0
 #else
@@ -161,8 +154,6 @@
 #define SIMDJSON_BUILTIN_IMPLEMENTATION lsx
 #elif SIMDJSON_CAN_ALWAYS_RUN_LASX
 #define SIMDJSON_BUILTIN_IMPLEMENTATION lasx
-#elif SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS
-#define SIMDJSON_BUILTIN_IMPLEMENTATION rvv_vls
 #elif SIMDJSON_CAN_ALWAYS_RUN_FALLBACK
 #define SIMDJSON_BUILTIN_IMPLEMENTATION fallback
 #else

include/simdjson/internal/dom_parser_implementation.h

@@ -4,6 +4,7 @@
 #include "simdjson/base.h"
 #include "simdjson/error.h"
 #include <memory>
+#include <utility>
 
 namespace simdjson {
 
@@ -102,6 +103,24 @@ public:
    */
   simdjson_warn_unused virtual error_code stage2_next(dom::document &doc) noexcept = 0;
 
+  /**
+   * Unescape a valid UTF-8 string from src to dst, stopping at a final unescaped quote. There
+   * must be an unescaped quote terminating the string. It returns the final output
+   * position as pointer. In case of error (e.g., the string has bad escaped codes),
+   * then null_ptr is returned. If no escaping was required, then no copy is made.
+   * It is assumed that the output buffer is large
+   * enough to store the unescapedstring + SIMDJSON_PADDING bytes.
+   *
+   * Overridden by each implementation.
+   *
+   * @param str pointer to the beginning of a valid UTF-8 JSON string, must end with an unescaped quote.
+   * @param dst pointer to a destination buffer, it must point a region in memory of sufficient size.
+   * @param allow_replacement whether we allow a replacement character when the UTF-8 contains unmatched surrogate pairs.
+   * @return end of the of the written region (exclusive) or nullptr in case of error coupled with a Boolean telling you if a copy was made
+   */
+  simdjson_warn_unused virtual std::pair<const uint8_t *,bool> parse_string_if_needed(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept = 0;
+
+
   /**
    * Unescape a valid UTF-8 string from src to dst, stopping at a final unescaped quote. There
    * must be an unescaped quote terminating the string. It returns the final output
@@ -212,12 +231,6 @@ protected:
    */
   size_t _max_depth{0};
 
-public:
-  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
-  bool _number_as_string{false};
-
-protected:
-
   // Declaring these so that subclasses can use them to implement their constructors.
   simdjson_inline dom_parser_implementation() noexcept;
   simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;

include/simdjson/internal/instruction_set.h

@@ -69,8 +69,6 @@ enum instruction_set {
   AVX512VBMI2 = 0x10000,
   LSX = 0x20000,
   LASX = 0x40000,
-  //RVV = 0x80000,
-  RVV_VLS = 0x100000,
 };
 
 } // namespace internal

include/simdjson/internal/tape_type.h

@@ -19,8 +19,7 @@ enum class tape_type {
   DOUBLE = 'd',
   TRUE_VALUE = 't',
   FALSE_VALUE = 'f',
-  NULL_VALUE = 'n',
+  NULL_VALUE = 'n'
-  BIGINT = 'Z'  // Big integer stored as string in string buffer
 }; // enum class tape_type
 
 } // namespace internal

include/simdjson/lasx/simd.h

@@ -303,7 +303,6 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 2, "LASX kernel should use two registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
-    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/lasx/stringparsing_defs.h

@@ -17,6 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -33,7 +34,9 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   // SIMDJSON_PADDING of padding
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v(src);
+  if(dst != nullptr) {
     v.store(dst);
+  }
   return {
       static_cast<uint32_t>((v == '\\').to_bitmask()),     // bs_bits
       static_cast<uint32_t>((v == '"').to_bitmask()), // quote_bits

include/simdjson/lsx/simd.h

@@ -260,7 +260,6 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 4, "LSX kernel should use four registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
-    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/lsx/stringparsing_defs.h

@@ -17,6 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -34,8 +35,10 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v0(src);
   simd8<uint8_t> v1(src + sizeof(v0));
+  if(dst != nullptr) {
     v0.store(dst);
     v1.store(dst + sizeof(v0));
+  }
 
   // Getting a 64-bit bitmask is much cheaper than multiple 16-bit bitmasks on LSX; therefore, we
   // smash them together into a 64-byte mask and get the bitmask from there.

include/simdjson/padded_string-inl.h

@@ -10,14 +10,6 @@
 #include <climits>
 #include <cwchar>
 
-#ifndef _WIN32
-#include <fcntl.h>
-#include <stdio.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#endif
-
 namespace simdjson {
 namespace internal {
 
@@ -374,57 +366,6 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
   return true;
 }
 
-
-#ifndef _WIN32
-simdjson_inline padded_memory_map::padded_memory_map(const char *filename) noexcept {
-
-    int fd = open(filename, O_RDONLY);
-    if (fd == -1) {
-      return; // file not found or cannot be opened, data will be nullptr
-    }
-    struct stat st;
-    if (fstat(fd, &st) == -1) {
-      close(fd);
-      return; // failed to get file size, data will be nullptr
-    }
-    size = static_cast<size_t>(st.st_size);
-    size_t total_size = size + simdjson::SIMDJSON_PADDING;
-    void *anon_map =
-        mmap(NULL, total_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    if (anon_map == MAP_FAILED) {
-      close(fd);
-      return; // failed to create anonymous mapping, data will be nullptr
-    }
-    void *file_map =
-        mmap(anon_map, size, PROT_READ, MAP_SHARED | MAP_FIXED, fd, 0);
-    if (file_map == MAP_FAILED) {
-      munmap(anon_map, total_size);
-      close(fd);
-      return; // failed to mmap file, data will be nullptr
-    }
-    data = static_cast<const char *>(file_map);
-    close(fd); // no longer needed after mapping
-}
-
-simdjson_inline padded_memory_map::~padded_memory_map() noexcept {
-  if (data != nullptr) {
-    munmap(const_cast<char *>(data), size + simdjson::SIMDJSON_PADDING);
-  }
-}
-
-
-simdjson_inline simdjson::padded_string_view padded_memory_map::view() const noexcept simdjson_lifetime_bound {
-  if(!is_valid()) {
-    return simdjson::padded_string_view(); // return an empty view if mapping failed
-  }
-  return simdjson::padded_string_view(data, size, size + simdjson::SIMDJSON_PADDING);
-}
-
-simdjson_inline bool padded_memory_map::is_valid() const noexcept {
-  return data != nullptr;
-}
-#endif // _WIN32
-
 } // namespace simdjson
 
 inline simdjson::padded_string operator ""_padded(const char *str, size_t len) {
@@ -435,5 +376,4 @@ inline simdjson::padded_string operator ""_padded(const char8_t *str, size_t len
   return simdjson::padded_string(reinterpret_cast<const char *>(str), len);
 }
 #endif
-
 #endif // SIMDJSON_PADDED_STRING_INL_H

include/simdjson/padded_string.h

@@ -277,62 +277,6 @@ inline std::ostream& operator<<(std::ostream& out, const padded_string& s) { ret
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string> &s) noexcept(false) { return out << s.value(); }
 #endif
 
-
-#ifndef _WIN32
-/**
- * A class representing a memory-mapped file with padding.
- * It is only available on non-Windows platforms, as Windows has different APIs for memory mapping.
- */
-class padded_memory_map {
-public:
-  /**
-   * Create a new padded memory map for the given file.
-   * After creating the memory map, you can call view() to get a padded_string_view of the file content.
-   * The memory map will be automatically released when the padded_memory_map instance is destroyed.
-   * Note that the file content is not copied, so this is efficient for large files. However,
-   * the file must remain unchanged while the memory map is in use. In case of error (e.g., file not found,
-   * permission denied, etc.), the memory map will be invalid and view() will return an empty view.
-   * You can check if the memory map is valid by calling is_valid() before using view().
-   *
-   * @param filename the path to the file to memory-map.
-   */
-  simdjson_inline padded_memory_map(const char *filename) noexcept;
-  /**
-   * Destroy the padded memory map and release any resources.
-   */
-  simdjson_inline ~padded_memory_map() noexcept;
-
-  // lifetime of the view is tied to the memory map, so we can return a view
-  // directly
-  /**
-   * Get a view of the memory-mapped file. It always succeeds, but the view may be empty
-   * if the memory map is invalid (e.g., due to file not found, permission denied, etc.).
-   * You can check if the memory map is valid by calling is_valid() before using the view.
-   *
-   * Lifetime of the view is tied to the memory map, so the view should not be used after the
-   * padded_memory_map instance is destroyed.
-   *
-   * @return a padded_string_view representing the memory-mapped file, or an empty view if the memory map is invalid.
-   */
-  simdjson_inline simdjson::padded_string_view view() const noexcept simdjson_lifetime_bound;
-  /**
-   * Check if the memory map is valid.
-   *
-   * @return true if the memory map is valid, false otherwise.
-   */
-  simdjson_inline bool is_valid() const noexcept;
-
-private:
-  padded_memory_map() = delete;
-  padded_memory_map(const padded_memory_map &) = delete;
-  padded_memory_map &operator=(const padded_memory_map &) = delete;
-  const char *data{nullptr};
-  size_t size{0};
-};
-#endif // _WIN32
-
-
-
 } // namespace simdjson
 
 // This is deliberately outside of simdjson so that people get it without having to use the namespace

include/simdjson/padded_string_view.h

@@ -17,7 +17,7 @@ namespace simdjson {
  */
 class padded_string_view : public std::string_view {
 private:
-  size_t _capacity{0};
+  size_t _capacity;
 
 public:
   /** Create an empty padded_string_view. */

include/simdjson/portability.h

@@ -45,20 +45,22 @@ using std::size_t;
 #define SIMDJSON_IS_ARM64 1
 #elif defined(__riscv) && __riscv_xlen == 64
 #define SIMDJSON_IS_RISCV64 1
-
   #if __riscv_v_intrinsic >= 11000
     #define SIMDJSON_HAS_RVV_INTRINSICS 1
   #endif
 
-  #if SIMDJSON_HAS_RVV_INTRINSICS && __riscv_vector && __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64
+  #define SIMDJSON_HAS_ZVBB_INTRINSICS                                          \
-    #define SIMDJSON_IS_RVV 1 // RISC-V V extension
+    0 // there is currently no way to detect this
-  #endif
 
-  // current toolchains don't support fixed-size SIMD types that don't match VLEN directly
+  #if SIMDJSON_HAS_RVV_INTRINSICS && __riscv_vector &&                          \
-  #if __riscv_v_fixed_vlen >= 128 && __riscv_v_fixed_vlen <= 512
+      __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64
-    #define SIMDJSON_IS_RVV_VLS 1
+    // RISC-V V extension
+    #define SIMDJSON_IS_RVV 1
+    #if SIMDJSON_HAS_ZVBB_INTRINSICS && __riscv_zvbb >= 1000000
+      // RISC-V Vector Basic Bit-manipulation
+      #define SIMDJSON_IS_ZVBB 1
+    #endif
   #endif
-
 #elif defined(__loongarch_lp64)
 #define SIMDJSON_IS_LOONGARCH64 1
 #if defined(__loongarch_sx) && defined(__loongarch_asx)
@@ -66,25 +68,6 @@ using std::size_t;
   #define SIMDJSON_IS_LASX 1 // We can always run both
 #elif defined(__loongarch_sx)
   #define SIMDJSON_IS_LSX 1
-
-// Adjust for runtime dispatching support.
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__NVCOMPILER)
-#if __GNUC__ > 15 || (__GNUC__ == 15 && __GNUC_MINOR__ >= 0)
-  // We are ok, we will support runtime dispatch for LASX.
-#else
-  // We disable runtime dispatch for LASX, which means that we will not be able to use LASX
-  // even if it is supported by the hardware.
-  // Loongson users should update to GCC 15 or better.
-  #define SIMDJSON_IMPLEMENTATION_LASX 0
-#endif
-#else
-  // We are not using GCC, so we assume that we can support runtime dispatch for LASX.
-  // https://godbolt.org/z/jcMnrjYhs
-  #define SIMDJSON_IMPLEMENTATION_LASX 0
-#endif
-
-
-
 #endif
 #elif defined(__PPC64__) || defined(_M_PPC64)
 #define SIMDJSON_IS_PPC64 1

include/simdjson/ppc64/simd.h

@@ -397,7 +397,6 @@ template <typename T> struct simd8x64 {
   static_assert(NUM_CHUNKS == 4,
                 "PPC64 kernel should use four registers per 64-byte block.");
   const simd8<T> chunks[NUM_CHUNKS];
-  template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
   simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
   simd8x64<T> &

include/simdjson/ppc64/stringparsing_defs.h

@@ -17,6 +17,7 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
+  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote
   copy_and_find(const uint8_t *src, uint8_t *dst);
 
@@ -44,8 +45,10 @@ backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
                 "SIMDJSON_PADDING bytes");
   simd8<uint8_t> v0(src);
   simd8<uint8_t> v1(src + sizeof(v0));
+  if(dst != nullptr) {
     v0.store(dst);
     v1.store(dst + sizeof(v0));
+  }
 
   // Getting a 64-bit bitmask is much cheaper than multiple 16-bit bitmasks on
   // PPC; therefore, we smash them together into a 64-byte mask and get the

include/simdjson/rvv-vls.h

@@ -1,9 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_H
-#define SIMDJSON_RVV_VLS_H
-
-
-#include "simdjson/rvv-vls/begin.h"
-#include "simdjson/generic/amalgamated.h"
-#include "simdjson/rvv-vls/end.h"
-
-#endif // SIMDJSON_RVV_VLS_H

include/simdjson/rvv-vls/base.h

@@ -1,19 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_BASE_H
-#define SIMDJSON_RVV_VLS_BASE_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-/**
- * RVV-VLS implementation.
- */
-namespace rvv_vls {
-
-class implementation;
-
-} // namespace rvv_vls
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_VLS_BASE_H

include/simdjson/rvv-vls/begin.h

@@ -1,10 +0,0 @@
-#define SIMDJSON_IMPLEMENTATION rvv_vls
-#include "simdjson/rvv-vls/base.h"
-#include "simdjson/rvv-vls/intrinsics.h"
-#include "simdjson/rvv-vls/bitmanipulation.h"
-#include "simdjson/rvv-vls/bitmask.h"
-#include "simdjson/rvv-vls/simd.h"
-#include "simdjson/rvv-vls/stringparsing_defs.h"
-#include "simdjson/rvv-vls/numberparsing_defs.h"
-
-#define SIMDJSON_SKIP_BACKSLASH_SHORT_CIRCUIT 1

include/simdjson/rvv-vls/bitmanipulation.h

@@ -1,48 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_BITMANIPULATION_H
-#define SIMDJSON_RVV_VLS_BITMANIPULATION_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv_vls {
-namespace {
-
-// We sometimes call trailing_zero 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.
-SIMDJSON_NO_SANITIZE_UNDEFINED
-// This function can be used safely even if not all bytes have been
-// initialized.
-// See issue https://github.com/simdjson/simdjson/issues/1965
-SIMDJSON_NO_SANITIZE_MEMORY
-simdjson_inline int trailing_zeroes(uint64_t input_num) {
-  return __builtin_ctzll(input_num);
-}
-
-/* result might be undefined when input_num is zero */
-simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
-  return input_num & (input_num-1);
-}
-
-/* result might be undefined when input_num is zero */
-simdjson_inline int leading_zeroes(uint64_t input_num) {
-  return __builtin_clzll(input_num);
-}
-
-simdjson_inline long long int count_ones(uint64_t input_num) {
-  return __builtin_popcountll(input_num);
-}
-
-simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2,
-                                uint64_t *result) {
-  return __builtin_uaddll_overflow(value1, value2,
-                                   reinterpret_cast<unsigned long long *>(result));
-}
-
-} // unnamed namespace
-} // namespace rvv_vls
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_VLS_BITMANIPULATION_H

include/simdjson/rvv-vls/bitmask.h

@@ -1,39 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_BITMASK_H
-#define SIMDJSON_RVV_VLS_BITMASK_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#include "simdjson/rvv-vls/intrinsics.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv_vls {
-namespace {
-
-//
-// Perform a "cumulative bitwise xor," flipping bits each time a 1 is encountered.
-//
-// For example, prefix_xor(00100100) == 00011100
-//
-simdjson_inline uint64_t prefix_xor(uint64_t bitmask) {
-#if __riscv_zbc
-  return __riscv_clmul_64(bitmask, ~(uint64_t)0);
-#elif __riscv_zvbc
-  return __riscv_vmv_x(__riscv_vclmul(__riscv_vmv_s_x_u64m1(bitmask, 1), ~(uint64_t)0, 1));
-#else
-  bitmask ^= bitmask << 1;
-  bitmask ^= bitmask << 2;
-  bitmask ^= bitmask << 4;
-  bitmask ^= bitmask << 8;
-  bitmask ^= bitmask << 16;
-  bitmask ^= bitmask << 32;
-#endif
-  return bitmask;
-}
-
-} // unnamed namespace
-} // namespace rvv_vls
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_VLS_BITMASK_H
-

include/simdjson/rvv-vls/builder.h

@@ -1,8 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_BUILDER_H
-#define SIMDJSON_RVV_VLS_BUILDER_H
-
-#include "simdjson/rvv-vls/begin.h"
-#include "simdjson/generic/builder/amalgamated.h"
-#include "simdjson/rvv-vls/end.h"
-
-#endif // SIMDJSON_RVV_VLS_BUILDER_H

include/simdjson/rvv-vls/end.h

@@ -1,5 +0,0 @@
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#undef SIMDJSON_IMPLEMENTATION

include/simdjson/rvv-vls/implementation.h

@@ -1,34 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_IMPLEMENTATION_H
-#define SIMDJSON_RVV_VLS_IMPLEMENTATION_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#include "simdjson/implementation.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv_vls {
-
-/**
- * @private
- */
-class implementation final : public simdjson::implementation {
-public:
-  simdjson_inline implementation() : simdjson::implementation(
-      "rvv_vls",
-      "RISC-V V extension",
-      0
-  ) {}
-  simdjson_warn_unused error_code create_dom_parser_implementation(
-    size_t capacity,
-    size_t max_length,
-    std::unique_ptr<simdjson::internal::dom_parser_implementation>& dst
-  ) const noexcept final;
-  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
-  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
-};
-
-} // namespace rvv_vls
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_VLS_IMPLEMENTATION_H

include/simdjson/rvv-vls/intrinsics.h

@@ -1,32 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_INTRINSICS_H
-#define SIMDJSON_RVV_VLS_INTRINSICS_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#include <riscv_vector.h>
-
-#define simdutf_vrgather_u8m1x2(tbl, idx)                                      \
-  __riscv_vcreate_v_u8m1_u8m2(                                                 \
-      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m2_u8m1(idx, 0),          \
-                               __riscv_vsetvlmax_e8m1()),                      \
-      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m2_u8m1(idx, 1),          \
-                               __riscv_vsetvlmax_e8m1()))
-
-#define simdutf_vrgather_u8m1x4(tbl, idx)                                      \
-  __riscv_vcreate_v_u8m1_u8m4(                                                 \
-      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 0),          \
-                               __riscv_vsetvlmax_e8m1()),                      \
-      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 1),          \
-                               __riscv_vsetvlmax_e8m1()),                      \
-      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 2),          \
-                               __riscv_vsetvlmax_e8m1()),                      \
-      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 3),          \
-                               __riscv_vsetvlmax_e8m1()))
-
-#if __riscv_zbc
-#include <riscv_bitmanip.h>
-#endif
-
-#endif // SIMDJSON_RVV_VLS_INTRINSICS_H

include/simdjson/rvv-vls/numberparsing_defs.h

@@ -1,56 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_NUMBERPARSING_DEFS_H
-#define SIMDJSON_RVV_VLS_NUMBERPARSING_DEFS_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#include "simdjson/internal/numberparsing_tables.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#include <cstring>
-
-#ifdef JSON_TEST_NUMBERS // for unit testing
-void found_invalid_number(const uint8_t *buf);
-void found_integer(int64_t result, const uint8_t *buf);
-void found_unsigned_integer(uint64_t result, const uint8_t *buf);
-void found_float(double result, const uint8_t *buf);
-#endif
-
-namespace simdjson {
-namespace rvv_vls {
-namespace numberparsing {
-
-// credit: https://johnnylee-sde.github.io/Fast-numeric-string-to-int/
-/** @private */
-static simdjson_inline uint32_t parse_eight_digits_unrolled(const char *chars) {
-  uint64_t val;
-#if __riscv_misaligned_fast
-  memcpy(&val, chars, sizeof(uint64_t));
-#else
-  val = __riscv_vmv_x(__riscv_vreinterpret_u64m1(__riscv_vlmul_ext_u8m1(__riscv_vle8_v_u8mf2((uint8_t*)chars, 8))));
-#endif
-  val = (val & 0x0F0F0F0F0F0F0F0F) * 2561 >> 8;
-  val = (val & 0x00FF00FF00FF00FF) * 6553601 >> 16;
-  return uint32_t((val & 0x0000FFFF0000FFFF) * 42949672960001 >> 32);
-}
-
-/** @private */
-static simdjson_inline uint32_t parse_eight_digits_unrolled(const uint8_t *chars) {
-  return parse_eight_digits_unrolled(reinterpret_cast<const char *>(chars));
-}
-
-/** @private */
-simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t value2) {
-  internal::value128 answer;
-  __uint128_t r = (static_cast<__uint128_t>(value1)) * value2;
-  answer.low = uint64_t(r);
-  answer.high = uint64_t(r >> 64);
-  return answer;
-}
-
-} // namespace numberparsing
-} // namespace rvv_vls
-} // namespace simdjson
-
-#define SIMDJSON_SWAR_NUMBER_PARSING 1
-
-#endif // SIMDJSON_RVV_VLS_NUMBERPARSING_DEFS_H

include/simdjson/rvv-vls/ondemand.h

@@ -1,8 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_ONDEMAND_H
-#define SIMDJSON_RVV_VLS_ONDEMAND_H
-
-#include "simdjson/rvv-vls/begin.h"
-#include "simdjson/generic/ondemand/amalgamated.h"
-#include "simdjson/rvv-vls/end.h"
-
-#endif // SIMDJSON_RVV_VLS_ONDEMAND_H

include/simdjson/rvv-vls/simd.h

@@ -1,370 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_SIMD_H
-#define SIMDJSON_RVV_VLS_SIMD_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#include "simdjson/rvv-vls/bitmanipulation.h"
-#include "simdjson/internal/simdprune_tables.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv_vls {
-namespace {
-namespace simd {
-
-#if __riscv_v_fixed_vlen >= 512
-  static constexpr size_t VL8 = 512/8;
-  using vint8_t   = vint8m1_t   __attribute__((riscv_rvv_vector_bits(512)));
-  using vuint8_t  = vuint8m1_t  __attribute__((riscv_rvv_vector_bits(512)));
-  using vbool_t    = vbool8_t  __attribute__((riscv_rvv_vector_bits(512/8)));
-  using vbitmask_t = uint64_t;
-#else
-  static constexpr size_t VL8 = __riscv_v_fixed_vlen/8;
-  using vint8_t   = vint8m1_t   __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
-  using vuint8_t  = vuint8m1_t  __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
-  using vbool_t    = vbool8_t  __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen/8)));
-  #if __riscv_v_fixed_vlen == 128
-    using vbitmask_t = uint16_t;
-  #elif __riscv_v_fixed_vlen == 256
-    using vbitmask_t = uint32_t;
-  #endif
-#endif
-
-#if __riscv_v_fixed_vlen == 128
-  using vuint8x64_t = vuint8m4_t __attribute__((riscv_rvv_vector_bits(512)));
-  using vboolx64_t    = vbool2_t  __attribute__((riscv_rvv_vector_bits(512/8)));
-#elif __riscv_v_fixed_vlen == 256
-  using vuint8x64_t = vuint8m2_t __attribute__((riscv_rvv_vector_bits(512)));
-  using vboolx64_t    = vbool4_t  __attribute__((riscv_rvv_vector_bits(512/8)));
-#else
-  using vuint8x64_t = vuint8m1_t __attribute__((riscv_rvv_vector_bits(512)));
-  using vboolx64_t    = vbool8_t  __attribute__((riscv_rvv_vector_bits(512/8)));
-#endif
-
-  template<typename T>
-  struct simd8;
-
-  // SIMD byte mask type (returned by things like eq and gt)
-  template<>
-  struct simd8<bool> {
-    vbool_t value;
-    using bitmask_t = vbitmask_t;
-    static constexpr int SIZE = sizeof(value);
-
-    simdjson_inline simd8(const vbool_t _value) : value(_value) {}
-    simdjson_inline simd8() : simd8(__riscv_vmclr_m_b8(VL8)) {}
-    simdjson_inline simd8(bool _value) : simd8(splat(_value)) {}
-
-    simdjson_inline operator const vbool_t&() const { return value; }
-    simdjson_inline operator vbool_t&() { return value; }
-
-    static simdjson_inline simd8<bool> splat(bool _value) {
-      return __riscv_vreinterpret_b8(__riscv_vmv_v_x_u64m1(((uint64_t)!_value)-1, 1));
-    }
-
-    simdjson_inline vbitmask_t to_bitmask() const {
-#if __riscv_v_fixed_vlen == 128
-      return __riscv_vmv_x(__riscv_vreinterpret_u16m1(value));
-#elif __riscv_v_fixed_vlen == 256
-      return __riscv_vmv_x(__riscv_vreinterpret_u32m1(value));
-#else
-      return __riscv_vmv_x(__riscv_vreinterpret_u64m1(value));
-#endif
-    }
-
-    // Bit operations
-    simdjson_inline simd8<bool> operator|(const simd8<bool> other) const {  return __riscv_vmor(*this, other, VL8); }
-    simdjson_inline simd8<bool> operator&(const simd8<bool> other) const {  return __riscv_vmand(*this, other, VL8); }
-    simdjson_inline simd8<bool> operator^(const simd8<bool> other) const {  return __riscv_vmxor(*this, other, VL8); }
-    simdjson_inline simd8<bool> bit_andnot(const simd8<bool> other) const { return __riscv_vmandn(other, *this, VL8); }
-    simdjson_inline simd8<bool> operator~() const { return __riscv_vmnot(*this, VL8); }
-    simdjson_inline simd8<bool>& operator|=(const simd8<bool> other) { auto this_cast = static_cast<simd8<bool>*>(this); *this_cast = *this_cast | other; return *this_cast; }
-    simdjson_inline simd8<bool>& operator&=(const simd8<bool> other) { auto this_cast = static_cast<simd8<bool>*>(this); *this_cast = *this_cast & other; return *this_cast; }
-    simdjson_inline simd8<bool>& operator^=(const simd8<bool> other) { auto this_cast = static_cast<simd8<bool>*>(this); *this_cast = *this_cast ^ other; return *this_cast; }
-  };
-
-  // Unsigned bytes
-  template<>
-  struct simd8<uint8_t> {
-
-    vuint8_t value;
-    static constexpr int SIZE = sizeof(value);
-
-    simdjson_inline simd8(const vuint8_t _value) : value(_value) {}
-    simdjson_inline simd8() : simd8(zero()) {}
-    simdjson_inline simd8(const uint8_t values[VL8]) : simd8(load(values)) {}
-    simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
-    simdjson_inline simd8(simd8<bool> mask) : value(__riscv_vmerge_vxm_u8m1(zero(), -1, (vbool_t)mask, VL8)) {}
-
-    simdjson_inline operator const vuint8_t&() const { return this->value; }
-    simdjson_inline operator vuint8_t&() { return this->value; }
-
-    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
-    ) : simd8(vuint8_t{
-      v0, v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10,v11,v12,v13,v14,v15
-    }) {}
-
-    // Repeat 16 values as many times as necessary (usually for lookup tables)
-    simdjson_inline static simd8<uint8_t> repeat_16(
-      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
-    ) {
-      return simd8<uint8_t>(
-        v0, v1, v2, v3, v4, v5, v6, v7,
-        v8, v9, v10,v11,v12,v13,v14,v15
-      );
-    }
-
-    static simdjson_inline vuint8_t splat(uint8_t _value) { return __riscv_vmv_v_x_u8m1(_value, VL8); }
-    static simdjson_inline vuint8_t zero() { return splat(0); }
-    static simdjson_inline vuint8_t load(const uint8_t values[VL8]) { return __riscv_vle8_v_u8m1(values, VL8); }
-
-    // Bit operations
-    simdjson_inline simd8<uint8_t> operator|(const simd8<uint8_t> other) const { return  __riscv_vor_vv_u8m1(  value, other, VL8); }
-    simdjson_inline simd8<uint8_t> operator&(const simd8<uint8_t> other) const { return  __riscv_vand_vv_u8m1( value, other, VL8); }
-    simdjson_inline simd8<uint8_t> operator^(const simd8<uint8_t> other) const { return  __riscv_vxor_vv_u8m1( value, other, VL8); }
-    simdjson_inline simd8<uint8_t> operator~() const { return __riscv_vnot_v_u8m1(value, VL8); }
-#if __riscv_zvbb
-    simdjson_inline simd8<uint8_t> bit_andnot(const simd8<uint8_t> other) const { return __riscv_vandn_vv_u8m1(other, value, VL8); }
-#else
-    simdjson_inline simd8<uint8_t> bit_andnot(const simd8<uint8_t> other) const { return other & ~*this; }
-#endif
-    simdjson_inline simd8<uint8_t>& operator|=(const simd8<uint8_t> other) { value = *this | other; return *this; }
-    simdjson_inline simd8<uint8_t>& operator&=(const simd8<uint8_t> other) { value = *this & other; return *this; }
-    simdjson_inline simd8<uint8_t>& operator^=(const simd8<uint8_t> other) { value = *this ^ other; return *this; }
-
-    simdjson_inline simd8<bool> operator==(const simd8<uint8_t> other) const { return __riscv_vmseq(value, other, VL8); }
-    simdjson_inline simd8<bool> operator==(uint8_t other) const { return __riscv_vmseq(value, other, VL8); }
-
-    template<int N=1>
-    simdjson_inline simd8<uint8_t> prev(const simd8<uint8_t> prev_chunk) const {
-      return __riscv_vslideup(__riscv_vslidedown(prev_chunk, VL8-N, VL8), value, N, VL8);
-    }
-
-    // Store to array
-    simdjson_inline void store(uint8_t dst[VL8]) const { return __riscv_vse8(dst, value, VL8); }
-
-    // Saturated math
-    simdjson_inline simd8<uint8_t> saturating_add(const simd8<uint8_t> other) const { return __riscv_vsaddu(value, other, VL8); }
-    simdjson_inline simd8<uint8_t> saturating_sub(const simd8<uint8_t> other) const { return __riscv_vssubu(value, other, VL8); }
-
-    // Addition/subtraction are the same for signed and unsigned
-    simdjson_inline simd8<uint8_t> operator+(const simd8<uint8_t> other) const { return __riscv_vadd(value, other, VL8); }
-    simdjson_inline simd8<uint8_t> operator-(const simd8<uint8_t> other) const { return __riscv_vsub(value, other, VL8); }
-    simdjson_inline simd8<uint8_t>& operator+=(const simd8<uint8_t> other) { value = *this + other; return *this; }
-    simdjson_inline simd8<uint8_t>& operator-=(const simd8<uint8_t> other) { value = *this - other; return *this; }
-
-    // Order-specific operations
-    simdjson_inline simd8<bool> operator<=(const simd8<uint8_t> other) const { return __riscv_vmsleu(value, other, VL8); }
-    simdjson_inline simd8<bool> operator>=(const simd8<uint8_t> other) const { return __riscv_vmsgeu(value, other, VL8); }
-    simdjson_inline simd8<bool> operator<(const simd8<uint8_t> other) const  { return __riscv_vmsltu(value, other, VL8); }
-    simdjson_inline simd8<bool> operator>(const simd8<uint8_t> other) const  { return __riscv_vmsgtu(value, other, VL8); }
-
-    // Same as >, but instead of guaranteeing all 1's == true, false = 0 and true = nonzero.
-    simdjson_inline simd8<uint8_t> gt_bits(const simd8<uint8_t> other) const { return simd8<uint8_t>(*this > other); }
-    // Same as <, but instead of guaranteeing all 1's == true, false = 0 and true = nonzero.
-    simdjson_inline simd8<uint8_t> lt_bits(const simd8<uint8_t> other) const { return simd8<uint8_t>(*this < other); }
-
-    // Bit-specific operations
-    simdjson_inline bool any_bits_set_anywhere() const {
-      return __riscv_vfirst(__riscv_vmsne(value, 0, VL8), VL8) >= 0;
-    }
-    simdjson_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const { return (*this & bits).any_bits_set_anywhere(); }
-    template<int N>
-    simdjson_inline simd8<uint8_t> shr() const { return __riscv_vsrl(value, N, VL8); }
-    template<int N>
-    simdjson_inline simd8<uint8_t> shl() const { return __riscv_vsll(value, N, VL8); }
-
-
-    // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
-    template<typename L>
-    simdjson_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
-      return __riscv_vrgather(lookup_table, value, VL8);
-    }
-
-    // compress inactive elements, to match AVX-512 behavior
-    template<typename L>
-    simdjson_inline void compress(vbitmask_t mask, L * output) const {
-      mask = (vbitmask_t)~mask;
-#if __riscv_v_fixed_vlen == 128
-      vbool8_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u16m1(mask, 1));
-#elif __riscv_v_fixed_vlen == 256
-      vbool8_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u32m1(mask, 1));
-#else
-      vbool8_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u64m1(mask, 1));
-#endif
-      __riscv_vse8_v_u8m1(output, __riscv_vcompress(value, m, VL8), count_ones(mask));
-    }
-
-    template<typename L>
-    simdjson_inline simd8<L> lookup_16(
-        L replace0,  L replace1,  L replace2,  L replace3,
-        L replace4,  L replace5,  L replace6,  L replace7,
-        L replace8,  L replace9,  L replace10, L replace11,
-        L replace12, L replace13, L replace14, L replace15) const {
-      return lookup_16(simd8<L>::repeat_16(
-        replace0,  replace1,  replace2,  replace3,
-        replace4,  replace5,  replace6,  replace7,
-        replace8,  replace9,  replace10, replace11,
-        replace12, replace13, replace14, replace15
-      ));
-    }
-  };
-
-  // Signed bytes
-  template<>
-  struct simd8<int8_t> {
-    vint8_t value;
-    static constexpr int SIZE = sizeof(value);
-
-    simdjson_inline simd8(const vint8_t _value) : value(_value) {}
-    simdjson_inline simd8() : simd8(zero()) {}
-    simdjson_inline simd8(const int8_t values[VL8]) : simd8(load(values)) {}
-    simdjson_inline simd8(int8_t _value) : simd8(splat(_value)) {}
-
-    simdjson_inline operator const vint8_t&() const { return this->value; }
-    simdjson_inline operator vint8_t&() { return this->value; }
-
-    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
-    ) : simd8(vint8_t{
-      v0, v1, v2, v3, v4, v5, v6, v7,
-      v8, v9, v10,v11,v12,v13,v14,v15
-    }) {}
-
-    // Repeat 16 values as many times as necessary (usually for lookup tables)
-    simdjson_inline static simd8<int8_t> repeat_16(
-      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
-    ) {
-      return simd8<int8_t>(
-        v0, v1, v2, v3, v4, v5, v6, v7,
-        v8, v9, v10,v11,v12,v13,v14,v15
-      );
-    }
-
-    static simdjson_inline vint8_t splat(int8_t _value) { return __riscv_vmv_v_x_i8m1(_value, VL8); }
-    static simdjson_inline vint8_t zero() { return splat(0); }
-    static simdjson_inline vint8_t load(const int8_t values[VL8]) { return __riscv_vle8_v_i8m1(values, VL8); }
-
-
-    simdjson_inline void store(int8_t dst[VL8]) const { return __riscv_vse8(dst, value, VL8); }
-
-    // Explicit conversion to/from unsigned
-    simdjson_inline explicit simd8(const vuint8_t other): simd8(__riscv_vreinterpret_i8m1(other)) {}
-    simdjson_inline explicit operator simd8<uint8_t>() const { return __riscv_vreinterpret_u8m1(value); }
-
-    // Math
-    simdjson_inline simd8<int8_t> operator+(const simd8<int8_t> other) const { return __riscv_vadd(value, other, VL8); }
-    simdjson_inline simd8<int8_t> operator-(const simd8<int8_t> other) const { return __riscv_vsub(value, other, VL8); }
-    simdjson_inline simd8<int8_t>& operator+=(const simd8<int8_t> other) { value = *this + other; return *this; }
-    simdjson_inline simd8<int8_t>& operator-=(const simd8<int8_t> other) { value = *this - other; return *this; }
-
-    // Order-sensitive comparisons
-    simdjson_inline simd8<int8_t> max_val( const simd8<int8_t> other) const { return __riscv_vmax( value, other, VL8); }
-    simdjson_inline simd8<int8_t> min_val( const simd8<int8_t> other) const { return __riscv_vmin( value, other, VL8); }
-    simdjson_inline simd8<bool> operator>( const simd8<int8_t> other) const { return __riscv_vmsgt(value, other, VL8); }
-    simdjson_inline simd8<bool> operator<( const simd8<int8_t> other) const { return __riscv_vmslt(value, other, VL8); }
-    simdjson_inline simd8<bool> operator==(const simd8<int8_t> other) const { return __riscv_vmseq(value, other, VL8); }
-
-    template<int N=1>
-    simdjson_inline simd8<int8_t> prev(const simd8<int8_t> prev_chunk) const {
-      return __riscv_vslideup(__riscv_vslidedown(prev_chunk, VL8-N, VL8), value, N, VL8);
-    }
-
-    // Perform a lookup assuming no value is larger than 16
-    template<typename L>
-    simdjson_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
-      return __riscv_vrgather(lookup_table, value, VL8);
-    }
-    template<typename L>
-    simdjson_inline simd8<L> lookup_16(
-        L replace0,  L replace1,  L replace2,  L replace3,
-        L replace4,  L replace5,  L replace6,  L replace7,
-        L replace8,  L replace9,  L replace10, L replace11,
-        L replace12, L replace13, L replace14, L replace15) const {
-      return lookup_16(simd8<L>::repeat_16(
-        replace0,  replace1,  replace2,  replace3,
-        replace4,  replace5,  replace6,  replace7,
-        replace8,  replace9,  replace10, replace11,
-        replace12, replace13, replace14, replace15
-      ));
-    }
-  };
-
-  template<typename T>
-  struct simd8x64;
-  template<>
-  struct simd8x64<uint8_t> {
-    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<uint8_t>);
-    vuint8x64_t value;
-
-#if __riscv_v_fixed_vlen >= 512
-    template<int idx> simd8<uint8_t> get() const { return value; }
-#else
-    template<int idx> simd8<uint8_t> get() const { return __riscv_vget_u8m1(value, idx); }
-#endif
-
-    simdjson_inline operator const vuint8x64_t&() const { return this->value; }
-    simdjson_inline operator vuint8x64_t&() { return this->value; }
-
-    simd8x64(const simd8x64<uint8_t>& o) = delete; // no copy allowed
-    simd8x64<uint8_t>& operator=(const simd8<uint8_t>& other) = delete; // no assignment allowed
-    simd8x64() = delete; // no default constructor allowed
-
-#if __riscv_v_fixed_vlen == 128
-    simdjson_inline simd8x64(const uint8_t *ptr, size_t n = 64) : value(__riscv_vle8_v_u8m4(ptr, n)) {}
-#elif __riscv_v_fixed_vlen == 256
-    simdjson_inline simd8x64(const uint8_t *ptr, size_t n = 64) : value(__riscv_vle8_v_u8m2(ptr, n)) {}
-#else
-    simdjson_inline simd8x64(const uint8_t *ptr, size_t n = 64) : value(__riscv_vle8_v_u8m1(ptr, n)) {}
-#endif
-
-    simdjson_inline void store(uint8_t ptr[64]) const {
-      __riscv_vse8(ptr, value, 64);
-    }
-
-    simdjson_inline bool is_ascii() const {
-#if __riscv_v_fixed_vlen == 128
-      return __riscv_vfirst(__riscv_vmslt(__riscv_vreinterpret_i8m4(value), 0, 64), 64) < 0;
-#elif __riscv_v_fixed_vlen == 256
-      return __riscv_vfirst(__riscv_vmslt(__riscv_vreinterpret_i8m2(value), 0, 64), 64) < 0;
-#else
-      return __riscv_vfirst(__riscv_vmslt(__riscv_vreinterpret_i8m1(value), 0, 64), 64) < 0;
-#endif
-    }
-
-    // compress inactive elements, to match AVX-512 behavior
-    simdjson_inline uint64_t compress(uint64_t mask, uint8_t * output) const {
-      mask = ~mask;
-#if __riscv_v_fixed_vlen == 128
-      vboolx64_t m = __riscv_vreinterpret_b2(__riscv_vmv_s_x_u64m1(mask, 1));
-#elif __riscv_v_fixed_vlen == 256
-      vboolx64_t m = __riscv_vreinterpret_b4(__riscv_vmv_s_x_u64m1(mask, 1));
-#else
-      vboolx64_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u64m1(mask, 1));
-#endif
-      size_t cnt = count_ones(mask);
-      __riscv_vse8(output, __riscv_vcompress(value, m, 64), cnt);
-      return cnt;
-    }
-
-    simdjson_inline uint64_t eq(const uint8_t m) const {
-      return __riscv_vmv_x(__riscv_vreinterpret_u64m1(__riscv_vmseq(value, m, 64)));
-    }
-
-    simdjson_inline uint64_t lteq(const uint8_t m) const {
-      return __riscv_vmv_x(__riscv_vreinterpret_u64m1(__riscv_vmsleu(value, m, 64)));
-    }
-  }; // struct simd8x64<uint8_t>
-
-} // namespace simd
-} // unnamed namespace
-} // namespace rvv_vls
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_VLS_SIMD_H

include/simdjson/rvv-vls/stringparsing_defs.h

@@ -1,58 +0,0 @@
-#ifndef SIMDJSON_RVV_VLS_STRINGPARSING_DEFS_H
-#define SIMDJSON_RVV_VLS_STRINGPARSING_DEFS_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv-vls/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv_vls {
-namespace {
-
-using namespace simd;
-
-// Holds backslashes and quotes locations.
-struct backslash_and_quote {
-public:
-  static constexpr uint64_t BYTES_PROCESSED = sizeof(simd8<uint8_t>);
-  simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
-
-  simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
-  simdjson_inline bool has_backslash() { return ((quote_bits - 1) & bs_bits) != 0; }
-  simdjson_inline int quote_index() { return trailing_zeroes(quote_bits); }
-  simdjson_inline int backslash_index() { return trailing_zeroes(bs_bits); }
-
-  uint64_t bs_bits;
-  uint64_t quote_bits;
-}; // struct backslash_and_quote
-
-simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
-  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
-  simd8<uint8_t> v(src);
-  v.store(dst);
-  return { (v == '\\').to_bitmask(), (v == '"').to_bitmask() };
-}
-
-struct escaping {
-  static constexpr uint64_t BYTES_PROCESSED = sizeof(simd8<uint8_t>);
-  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
-
-  simdjson_inline bool has_escape() { return escape_bits != 0; }
-  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits) / 4; }
-
-  uint64_t escape_bits;
-}; // struct escaping
-
-simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
-  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
-  simd8<uint8_t> v(src);
-  v.store(dst);
-  return { ((v == '"') | (v == '\\') | (v == 32)).to_bitmask() };
-}
-
-
-} // unnamed namespace
-} // namespace rvv_vls
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_VLS_STRINGPARSING_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 "4.5.0"
+#define SIMDJSON_VERSION "4.2.4"
 
 namespace simdjson {
 enum {
@@ -15,11 +15,11 @@ enum {
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 5,
+  SIMDJSON_VERSION_MINOR = 2,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 0
+  SIMDJSON_VERSION_REVISION = 4
 };
 } // namespace simdjson