fix: remove .mise.toml that conflicts with CI mise-action (#689)

* Hook API Refactor2: Amendment Guards (#621)

* Hook API Refactor3: Consolidate the Hook API definitions from Enum.h and ApplyHook.h into a single file. (#622)

* Hook API Refactoring / Unit Testing (#581)

* fix `Xahau Ledger` to `Xahau Network` (#651)

* Add GitHub Actions workflow for Guard Checker Build (#658)

* fix `Xahau Ledger` to `Xahau Network` (#651)

* Add GitHub Actions workflow for Guard Checker Build (#658)

* fix: update guard checker build path for directory restructure

* fix: update stale ripple include paths in hook headers

* fix(test): avoid deleted PublicKey default ctor in HookAPI test

* chore(levelization): update ordering after hook/protocol dependency change

---------

Co-authored-by: tequ <git@tequ.dev>

.clang-format

@@ -44,7 +44,6 @@ DerivePointerAlignment: false
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 ForEachMacros:   [ Q_FOREACH,  BOOST_FOREACH ]
-IncludeBlocks:   Regroup
 IncludeCategories:
   - Regex:           '^<(test)/'
     Priority:        0
@@ -54,12 +53,8 @@ IncludeCategories:
     Priority:        2
   - Regex:           '^<(boost)/'
     Priority:        3
-  - Regex:           '^.*/'
-    Priority:        4
-  - Regex:           '^.*\.h'
-    Priority:        5
   - Regex:           '.*'
-    Priority:        6
+    Priority:        4
 IncludeIsMainRegex: '$'
 IndentCaseLabels: true
 IndentFunctionDeclarationAfterType: false
@@ -94,4 +89,3 @@ SpacesInSquareBrackets: false
 Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
-QualifierAlignment: Right

.githooks/pre-commit

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Pre-commit hook that runs the suspicious patterns check on staged files
-
-# Get the repository's root directory
-repo_root=$(git rev-parse --show-toplevel)
-
-# Run the suspicious patterns script in pre-commit mode
-"$repo_root/suspicious_patterns.sh" --pre-commit
-
-# Exit with the same code as the script
-exit $?

.githooks/setup.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-echo "Configuring git to use .githooks directory..."
-git config core.hooksPath .githooks

.github/workflows/clang-format.yml

@@ -8,15 +8,6 @@ jobs:
     env:
       CLANG_VERSION: 18
     steps:
-      # For jobs running in containers, $GITHUB_WORKSPACE and ${{ github.workspace }} might not be the
-      # same directory. The actions/checkout step is *supposed* to checkout into $GITHUB_WORKSPACE and
-      # then add it to safe.directory (see instructions at https://github.com/actions/checkout)
-      # but that's apparently not happening for some container images. We can't be sure what is actually
-      # happening, so let's pre-emptively add both directories to safe.directory. There's a
-      # Github issue opened in 2022 and not resolved in 2025 https://github.com/actions/runner/issues/2058 ¯\_(ツ)_/¯
-    - run: |
-        git config --global --add safe.directory $GITHUB_WORKSPACE
-        git config --global --add safe.directory ${{ github.workspace }}
     - uses: actions/checkout@v4
     - name: Install clang-format
       run: |
@@ -29,7 +20,7 @@ jobs:
         sudo apt-get update
         sudo apt-get install clang-format-${CLANG_VERSION}
     - name: Format first-party sources
-      run: find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/magic/magic_enum.h" -exec clang-format-${CLANG_VERSION} -i {} +
+      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/magic/magic_enum.h" -exec clang-format-${CLANG_VERSION} -i {} +
     - name: Check for differences
       id: assert
       run: |

.github/workflows/xahau-ga-macos.yml

@@ -122,6 +122,4 @@ jobs:
 
       - name: Test
         run: |
-          cd ${{ env.build_dir }}
-          ./rippled --unittest --unittest-jobs $(nproc)
-          ctest -j $(nproc) --output-on-failure
+          ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)

.github/workflows/xahau-ga-nix.yml

@@ -370,9 +370,7 @@ jobs:
         run: |
           # Ensure the binary exists before trying to run
           if [ -f "${{ env.build_dir }}/rippled" ]; then
-            cd ${{ env.build_dir }}
-            ./rippled --unittest --unittest-jobs $(nproc)
-            ctest -j $(nproc) --output-on-failure
+            ${{ env.build_dir }}/rippled --unittest --unittest-jobs $(nproc)
           else
              echo "Error: rippled executable not found in ${{ env.build_dir }}"
              exit 1

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 # .pre-commit-config.yaml
 repos:
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v18.1.8
+  rev: v18.1.3
   hooks:
   - id: clang-format

API-CHANGELOG.md

@@ -83,17 +83,9 @@ The [commandline](https://xrpl.org/docs/references/http-websocket-apis/api-conve
 
 The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode). However, use of reporting mode is now discouraged, in favor of using [Clio](https://github.com/XRPLF/clio) instead.
 
-## XRP Ledger server version 2.5.0
-
-As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
-
-### Additions and bugfixes in 2.5.0
-
-- `channel_authorize`: If `signing_support` is not enabled in the config, the RPC is disabled.
-
 ## XRP Ledger server version 2.4.0
 
-[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
+As of 2025-01-28, version 2.4.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
 
 ### Additions and bugfixes in 2.4.0
 

BUILD.md

@@ -1,7 +1,7 @@
-| :warning: **WARNING** :warning:
-|---|
-| These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md). |
-
+> These instructions assume you have a C++ development environment ready
+> with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up
+> on Linux, macOS, or Windows, see [our guide](./docs/build/environment.md).
+>
 > These instructions also assume a basic familiarity with Conan and CMake.
 > If you are unfamiliar with Conan,
 > you can read our [crash course](./docs/build/conan.md)
@@ -29,12 +29,9 @@ branch.
 git checkout develop
 ```
 
+
 ## Minimum Requirements
 
-See [System Requirements](https://xrpl.org/system-requirements.html).
-
-Building rippled generally requires git, Python, Conan, CMake, and a C++ compiler. Some guidance on setting up such a [C++ development environment can be found here](./docs/build/environment.md).
-
 - [Python 3.7](https://www.python.org/downloads/)
 - [Conan 2.x](https://conan.io/downloads)
 - [CMake 3.16](https://cmake.org/download/)
@@ -44,26 +41,11 @@ The [minimum compiler versions][2] required are:
 
 | Compiler    | Version |
 |-------------|---------|
-| GCC         | 11      |
+| GCC         | 10      |
 | Clang       | 13      |
 | Apple Clang | 13.1.6  |
 | MSVC        | 19.23   |
 
-### Linux
-
-The Ubuntu operating system has received the highest level of
-quality assurance, testing, and support.
-
-Here are [sample instructions for setting up a C++ development environment on Linux](./docs/build/environment.md#linux).
-
-### Mac
-
-Many xahaud engineers use macOS for development.
-
-Here are [sample instructions for setting up a C++ development environment on macOS](./docs/build/environment.md#macos).
-
-### Windows
-
 We don't recommend Windows for `xahaud` production at this time. As of
 November 2025, Ubuntu has the highest level of quality assurance, testing,
 and support.
@@ -72,23 +54,21 @@ Windows developers should use Visual Studio 2019. `xahaud` isn't
 compatible with [Boost](https://www.boost.org/) 1.78 or 1.79, and Conan
 can't build earlier Boost versions.
 
+**Note:** 32-bit Windows development isn't supported.
+
+
 ## Steps
 
+
 ### Set Up Conan
 
-After you have a [C++ development environment](./docs/build/environment.md) ready with Git, Python, Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
-
-These instructions assume a basic familiarity with Conan and CMake.
-
-If you are unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official [Getting Started][3] walkthrough.
-
-You'll need at least one Conan profile:
+1. (Optional) If you've never used Conan, use autodetect to set up a default profile.
 
    ```
    conan profile detect --force
    ```
 
-Update the compiler settings:
+2. Update the compiler settings.
 
    For Conan 2, you can edit the profile directly at `~/.conan2/profiles/default`,
    or use the Conan CLI. Ensure C++20 is set:
@@ -105,16 +85,10 @@ Update the compiler settings:
    compiler.cppstd=20
    ```
 
-Configure Conan (1.x only) to use recipe revisions:
-
-   ```
-   conan config set general.revisions_enabled=1
-   ```
-
-**Linux** developers will commonly have a default Conan [profile][] that compiles
-with GCC and links with libstdc++.
-If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
-then you will need to choose the `libstdc++11` ABI:
+   Linux developers will commonly have a default Conan [profile][] that compiles
+   with GCC and links with libstdc++.
+   If you are linking with libstdc++ (see profile setting `compiler.libcxx`),
+   then you will need to choose the `libstdc++11` ABI.
 
    ```
    # In ~/.conan2/profiles/default, ensure:
@@ -122,23 +96,9 @@ then you will need to choose the `libstdc++11` ABI:
    compiler.libcxx=libstdc++11
    ```
 
-
-Ensure inter-operability between `boost::string_view` and `std::string_view` types:
-
-```
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_BEAST_USE_STD_STRING_VIEW"]' default
-conan profile update 'env.CXXFLAGS="-DBOOST_BEAST_USE_STD_STRING_VIEW"' default
-```
-
-If you have other flags in the `conf.tools.build` or `env.CXXFLAGS` sections, make sure to retain the existing flags and append the new ones. You can check them with:
-```
-conan profile show default
-```
-
-
-**Windows** developers may need to use the x64 native build tools.
-An easy way to do that is to run the shortcut "x64 Native Tools Command
-Prompt" for the version of Visual Studio that you have installed.
+   On Windows, you should use the x64 native build tools.
+   An easy way to do that is to run the shortcut "x64 Native Tools Command
+   Prompt" for the version of Visual Studio that you have installed.
 
    Windows developers must also build `xahaud` and its dependencies for the x64
    architecture.
@@ -149,7 +109,10 @@ Prompt" for the version of Visual Studio that you have installed.
    arch=x86_64
    ```
 
-### Multiple compilers
+3. (Optional) If you have multiple compilers installed on your platform,
+   make sure that Conan and CMake select the one you want to use.
+   This setting will set the correct variables (`CMAKE_<LANG>_COMPILER`)
+   in the generated CMake toolchain file.
 
    ```
    # In ~/.conan2/profiles/default, add under [conf] section:
@@ -166,24 +129,16 @@ Prompt" for the version of Visual Studio that you have installed.
    CXX=<path>
    ```
 
-It should choose the compiler for dependencies as well,
-but not all of them have a Conan recipe that respects this setting (yet).
-For the rest, you can set these environment variables.
-Replace `<path>` with paths to the desired compilers:
-
-- `conan profile update env.CC=<path> default`
-- `conan profile update env.CXX=<path> default`
-
-Export our [Conan recipe for Snappy](./external/snappy).
-It does not explicitly link the C++ standard library,
-which allows you to statically link it with GCC, if you want.
+4. Export our [Conan recipe for Snappy](./external/snappy).
+   It doesn't explicitly link the C++ standard library,
+   which allows you to statically link it with GCC, if you want.
 
    ```
    conan export external/snappy --version 1.1.10 --user xahaud --channel stable
    ```
 
-Export our [Conan recipe for SOCI](./external/soci).
-It patches their CMake to correctly import its dependencies.
+5. Export our [Conan recipe for SOCI](./external/soci).
+   It patches their CMake to correctly import its dependencies.
 
    ```
    conan export external/soci --version 4.0.3 --user xahaud --channel stable
@@ -213,15 +168,13 @@ It patches their CMake to correctly import its dependencies.
    the `install-folder` or `-if` option to every `conan install` command
    in the next step.
 
-2. Use conan to generate CMake files for every configuration you want to build:
+2. Generate CMake files for every configuration you want to build. 
 
     ```
     conan install .. --output-folder . --build missing --settings build_type=Release
     conan install .. --output-folder . --build missing --settings build_type=Debug
     ```
 
-    To build Debug, in the next step, be sure to set `-DCMAKE_BUILD_TYPE=Debug`
-
     For a single-configuration generator, e.g. `Unix Makefiles` or `Ninja`,
     you only need to run this command once.
     For a multi-configuration generator, e.g. `Visual Studio`, you may want to
@@ -232,13 +185,13 @@ It patches their CMake to correctly import its dependencies.
     generated by the first. You can pass the build type on the command line with
     `--settings build_type=$BUILD_TYPE` or in the profile itself,
     under the section `[settings]` with the key `build_type`.
-
+    
     If you are using a Microsoft Visual C++ compiler,
     then you will need to ensure consistency between the `build_type` setting
     and the `compiler.runtime` setting.
-
+    
     When `build_type` is `Release`, `compiler.runtime` should be `MT`.
-
+    
     When `build_type` is `Debug`, `compiler.runtime` should be `MTd`.
 
     ```
@@ -250,22 +203,19 @@ It patches their CMake to correctly import its dependencies.
    `$OUTPUT_FOLDER/build/generators/conan_toolchain.cmake`.
 
     Single-config generators:
+    
+    ```
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release ..
+    ```
 
     Pass the CMake variable [`CMAKE_BUILD_TYPE`][build_type]
-    and make sure it matches the one of the `build_type` settings
-    you chose in the previous step.
+    and make sure it matches the `build_type` setting you chose in the previous
+    step.
 
-    For example, to build Debug, in the next command, replace "Release" with "Debug"
+    Multi-config gnerators:
 
     ```
-    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -Dxrpld=ON -Dtests=ON ..
-    ```
-
-
-    Multi-config generators:
-
-    ```
-    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake -Dxrpld=ON -Dtests=ON  ..
+    cmake -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
     ```
 
     **Note:** You can pass build options for `xahaud` in this step.
@@ -280,11 +230,11 @@ It patches their CMake to correctly import its dependencies.
    Single-config generators:
 
    ```
-   cmake --build . -j $(nproc)
+   cmake --build .
    ```
 
    Multi-config generators:
-
+    
    ```
    cmake --build . --config Release
    cmake --build . --config Debug
@@ -309,75 +259,15 @@ It patches their CMake to correctly import its dependencies.
    generator. Pass `--help` to see the rest of the command line options.
 
 
-## Coverage report
-
-The coverage report is intended for developers using compilers GCC
-or Clang (including Apple Clang). It is generated by the build target `coverage`,
-which is only enabled when the `coverage` option is set, e.g. with
-`--options coverage=True` in `conan` or `-Dcoverage=ON` variable in `cmake`
-
-Prerequisites for the coverage report:
-
-- [gcovr tool][gcovr] (can be installed e.g. with [pip][python-pip])
-- `gcov` for GCC (installed with the compiler by default) or
-- `llvm-cov` for Clang (installed with the compiler by default)
-- `Debug` build type
-
-A coverage report is created when the following steps are completed, in order:
-
-1. `rippled` binary built with instrumentation data, enabled by the `coverage`
-   option mentioned above
-2. completed run of unit tests, which populates coverage capture data
-3. completed run of the `gcovr` tool (which internally invokes either `gcov` or `llvm-cov`)
-   to assemble both instrumentation data and the coverage capture data into a coverage report
-
-The above steps are automated into a single target `coverage`. The instrumented
-`rippled` binary can also be used for regular development or testing work, at
-the cost of extra disk space utilization and a small performance hit
-(to store coverage capture). In case of a spurious failure of unit tests, it is
-possible to re-run the `coverage` target without rebuilding the `rippled` binary
-(since it is simply a dependency of the coverage report target). It is also possible
-to select only specific tests for the purpose of the coverage report, by setting
-the `coverage_test` variable in `cmake`
-
-The default coverage report format is `html-details`, but the user
-can override it to any of the formats listed in `cmake/CodeCoverage.cmake`
-by setting the `coverage_format` variable in `cmake`. It is also possible
-to generate more than one format at a time by setting the `coverage_extra_args`
-variable in `cmake`. The specific command line used to run the `gcovr` tool will be
-displayed if the `CODE_COVERAGE_VERBOSE` variable is set.
-
-By default, the code coverage tool runs parallel unit tests with `--unittest-jobs`
- set to the number of available CPU cores. This may cause spurious test
-errors on Apple. Developers can override the number of unit test jobs with
-the `coverage_test_parallelism` variable in `cmake`.
-
-Example use with some cmake variables set:
-
-```
-cd .build
-conan install .. --output-folder . --build missing --settings build_type=Debug
-cmake -DCMAKE_BUILD_TYPE=Debug -Dcoverage=ON -Dxrpld=ON -Dtests=ON -Dcoverage_test_parallelism=2 -Dcoverage_format=html-details -Dcoverage_extra_args="--json coverage.json" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
-cmake --build . --target coverage
-```
-
-After the `coverage` target is completed, the generated coverage report will be
-stored inside the build directory, as either of:
-
-- file named `coverage.`_extension_ , with a suitable extension for the report format, or
-- directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
-
-
 ## Options
 
 | Option | Default Value | Description |
 | --- | ---| ---|
 | `assert` | OFF | Enable assertions.
-| `coverage` | OFF | Prepare the coverage report. |
-| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
-| `tests` | OFF | Build tests. |
+| `reporting` | OFF | Build the reporting mode feature. |
+| `tests` | ON | Build tests. |
 | `unity` | ON | Configure a unity build. |
-| `xrpld` | OFF | Build the xrpld (`rippled`) application, and not just the libxrpl library. |
+| `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
 
 [Unity builds][5] may be faster for the first build
 (at the cost of much more memory) since they concatenate sources into fewer
@@ -416,18 +306,6 @@ tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
 ```
 
 
-### call to 'async_teardown' is ambiguous
-
-If you are compiling with an early version of Clang 16, then you might hit
-a [regression][6] when compiling C++20 that manifests as an [error in a Boost
-header][7]. You can workaround it by adding this preprocessor definition:
-
-```
-conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
-conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
-```
-
-
 ### recompile with -fPIC
 
 If you get a linker error suggesting that you recompile Boost with
@@ -579,10 +457,6 @@ but it is more convenient to put them in a [profile][profile].
 
 [1]: https://github.com/conan-io/conan-center-index/issues/13168
 [5]: https://en.wikipedia.org/wiki/Unity_build
-[6]: https://github.com/boostorg/beast/issues/2648
-[7]: https://github.com/boostorg/beast/issues/2661
-[gcovr]: https://gcovr.com/en/stable/getting-started.html
-[python-pip]: https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/
 [build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
 [runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
 [toolchain]: https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html

Builds/levelization/results/loops.txt

@@ -10,6 +10,9 @@ Loop: test.jtx test.toplevel
 Loop: test.jtx test.unit_test
   test.unit_test == test.jtx
 
+Loop: xrpl.hook xrpld.app
+  xrpld.app > xrpl.hook
+
 Loop: xrpl.protocol xrpld.app
   xrpld.app > xrpl.protocol
 
@@ -26,10 +29,10 @@ Loop: xrpld.app xrpld.nodestore
   xrpld.app > xrpld.nodestore
 
 Loop: xrpld.app xrpld.overlay
-  xrpld.overlay > xrpld.app
+  xrpld.overlay ~= xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
-  xrpld.peerfinder ~= xrpld.app
+  xrpld.app > xrpld.peerfinder
 
 Loop: xrpld.app xrpld.rpc
   xrpld.rpc > xrpld.app
@@ -44,7 +47,7 @@ Loop: xrpld.core xrpld.perflog
   xrpld.perflog == xrpld.core
 
 Loop: xrpld.net xrpld.rpc
-  xrpld.rpc ~= xrpld.net
+  xrpld.rpc > xrpld.net
 
 Loop: xrpld.overlay xrpld.rpc
   xrpld.rpc ~= xrpld.overlay

Builds/levelization/results/ordering.txt

@@ -7,7 +7,6 @@ libxrpl.protocol > xrpl.hook
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
 libxrpl.resource > xrpl.basics
-libxrpl.resource > xrpl.json
 libxrpl.resource > xrpl.resource
 libxrpl.server > xrpl.basics
 libxrpl.server > xrpl.json
@@ -44,7 +43,6 @@ test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpld.core
 test.consensus > xrpld.ledger
-test.consensus > xrpl.json
 test.consensus > xrpl.protocol
 test.core > test.jtx
 test.core > test.toplevel
@@ -62,6 +60,7 @@ test.json > test.jtx
 test.json > xrpl.json
 test.jtx > xrpl.basics
 test.jtx > xrpld.app
+test.jtx > xrpld.consensus
 test.jtx > xrpld.core
 test.jtx > xrpld.ledger
 test.jtx > xrpld.net
@@ -140,7 +139,6 @@ test.shamap > xrpl.protocol
 test.toplevel > test.csf
 test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
-tests.libxrpl > xrpl.basics
 xrpl.hook > xrpl.basics
 xrpl.hook > xrpl.protocol
 xrpl.json > xrpl.basics
@@ -157,7 +155,6 @@ xrpld.app > xrpl.basics
 xrpld.app > xrpld.conditions
 xrpld.app > xrpld.consensus
 xrpld.app > xrpld.perflog
-xrpld.app > xrpl.hook
 xrpld.app > xrpl.json
 xrpld.app > xrpl.resource
 xrpld.conditions > xrpl.basics
@@ -169,6 +166,7 @@ xrpld.core > xrpl.basics
 xrpld.core > xrpl.json
 xrpld.core > xrpl.protocol
 xrpld.ledger > xrpl.basics
+xrpld.ledger > xrpld.core
 xrpld.ledger > xrpl.json
 xrpld.ledger > xrpl.protocol
 xrpld.net > xrpl.basics
@@ -193,6 +191,7 @@ xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
 xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.json
+xrpld.perflog > xrpl.protocol
 xrpld.rpc > xrpl.basics
 xrpld.rpc > xrpld.core
 xrpld.rpc > xrpld.ledger

CMakeLists.txt

@@ -21,18 +21,6 @@ endif()
 project (xrpl)
 set(Boost_NO_BOOST_CMAKE ON)
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    # GCC-specific fixes
-    add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
-    # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    # Clang-specific fixes
-    add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif(MSVC)
-    # MSVC-specific fixes
-    add_compile_options(/wd4068) # Ignore unknown pragmas
-endif()
-
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
 if(Git_FOUND)
@@ -109,11 +97,6 @@ set_target_properties(OpenSSL::SSL PROPERTIES
   INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
 )
 set(SECP256K1_INSTALL TRUE)
-set(SECP256K1_BUILD_BENCHMARK FALSE)
-set(SECP256K1_BUILD_TESTS FALSE)
-set(SECP256K1_BUILD_EXHAUSTIVE_TESTS FALSE)
-set(SECP256K1_BUILD_CTIME_TESTS FALSE)
-set(SECP256K1_BUILD_EXAMPLES FALSE)
 add_subdirectory(external/secp256k1)
 add_library(secp256k1::secp256k1 ALIAS secp256k1)
 add_subdirectory(external/ed25519-donna)
@@ -126,7 +109,7 @@ find_package(lz4 REQUIRED)
 find_package(LibArchive REQUIRED)
 find_package(SOCI REQUIRED)
 find_package(SQLite3 REQUIRED)
-
+include(deps/WasmEdge)
 option(rocksdb "Enable RocksDB" ON)
 if(rocksdb)
   find_package(RocksDB REQUIRED)
@@ -135,12 +118,9 @@ if(rocksdb)
   )
   target_link_libraries(ripple_libs INTERFACE RocksDB::rocksdb)
 endif()
-
 find_package(nudb REQUIRED)
 find_package(date REQUIRED)
 find_package(xxHash REQUIRED)
-
-include(deps/WasmEdge) 
   if(TARGET nudb::core)
   set(nudb nudb::core)
 elseif(TARGET NuDB::nudb)
@@ -152,10 +132,11 @@ target_link_libraries(ripple_libs INTERFACE ${nudb})
 
 target_link_libraries(ripple_libs INTERFACE
   ed25519::ed25519
-  LibArchive::LibArchive
   lz4::lz4
   OpenSSL::Crypto
   OpenSSL::SSL
+  # Ripple::grpc_pbufs
+  # Ripple::pbufs
   secp256k1::secp256k1
   soci::soci
   SQLite::SQLite3
@@ -170,8 +151,3 @@ include(RippledCore)
 include(RippledInstall)
 include(RippledDocs)
 include(RippledValidatorKeys)
-
-if(tests)
-  include(CTest)
-  add_subdirectory(src/tests/libxrpl)
-endif()

CONTRIBUTING.md

@@ -57,12 +57,12 @@ Ensure that your code compiles according to the build instructions in the
 [`documentation`](https://docs.xahau.network/infrastructure/building-xahau).
 If you create new source files, they must go under `src/ripple`.
 You will need to add them to one of the
-[source lists](./Builds/CMake/RippledCore.cmake) in CMake.
+[source lists](./cmake/RippledCore.cmake) in CMake.
 
 Please write tests for your code.
 If you create new test source files, they must go under `src/test`.
 You will need to add them to one of the
-[source lists](./Builds/CMake/RippledCore.cmake) in CMake.
+[source lists](./cmake/RippledCore.cmake) in CMake.
 If your test can be run offline, in under 60 seconds, then it can be an
 automatic test run by `rippled --unittest`.
 Otherwise, it must be a manual test.

bin/physical.sh

@@ -2,7 +2,7 @@
 
 set -o errexit
 
-marker_base=f62f74da10c5936c64bd16cd509a8b68f1464e41
+marker_base=34be0ce4fef20c978df2923c29321ad6cc17facc
 marker_commit=${1:-${marker_base}}
 
 if [ $(git merge-base ${marker_commit} ${marker_base}) != ${marker_base} ]; then

build-core.sh

@@ -51,9 +51,10 @@ export CMAKE_STATIC_LINKER_FLAGS="-static-libstdc++"
 
 git config --global --add safe.directory /io &&
 git checkout src/libxrpl/protocol/BuildInfo.cpp &&
-sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)$(if [ -n "$4" ]; then echo "+$4"; fi)\"/g src/libxrpl/protocol/BuildInfo.cpp  &&
+sed -i s/\"0.0.0\"/\"$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)$(if [ -n "$4" ]; then echo "+$4"; fi)\"/g src/libxrpl/protocol/BuildInfo.cpp &&
 conan export external/snappy --version 1.1.10 --user xahaud --channel stable &&
 conan export external/soci --version 4.0.3 --user xahaud --channel stable &&
+conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable &&
 cd release-build &&
 # Install dependencies - tool_requires in conanfile.py handles glibc 2.28 compatibility
 # for build tools (protoc, grpc plugins, b2) in HBB environment

cfg/xahaud-example.cfg

@@ -13,7 +13,7 @@
 #
 #   4. HTTPS Client
 #
-#   5. <vacated>
+#   5. Reporting Mode
 #
 #   6. Database
 #
@@ -282,14 +282,12 @@
 #       ssl_cert
 #
 #           Specifies the path to the SSL certificate file in PEM format.
-#           This is not needed if the chain includes it. Use ssl_chain if
-#           your certificate includes one or more intermediates.
+#           This is not needed if the chain includes it.
 #
 #       ssl_chain
 #
 #           If you need a certificate chain, specify the path to the
 #           certificate chain here. The chain may include the end certificate.
-#           This must be used if the certificate includes intermediates.
 #
 #   ssl_ciphers = <cipherlist>
 #
@@ -387,32 +385,15 @@
 #
 #
 #
-# [compression]
-#
-#   true or false
-#
-#   true - enables compression
-#   false - disables compression [default].
-#
-#   The rippled server can save bandwidth by compressing its peer-to-peer communications, 
-#   at a cost of greater CPU usage. If you enable link compression, 
-#   the server automatically compresses communications with peer servers
-#   that also have link compression enabled.
-#   https://xrpl.org/enable-link-compression.html
-#
-#
-#
 # [ips]
 #
 #   List of hostnames or ips where the XRPL protocol is served.  A default
 #   starter list is included in the code and used if no other hostnames are
 #   available.
 #
-#   One address or domain name per line is allowed. A port may be specified
-#   after adding a space to the address. If a port is not specified, the default
-#   port of 2459 will be used. Many servers still use the legacy port of 51235.
-#   To connect to such servers, you must specify the port number. The ordering
-#   of entries does not generally matter.
+#   One address or domain name per line is allowed. A port may must be
+#   specified after adding a space to the address.  The ordering of entries
+#   does not generally matter.
 #
 #   The default list of entries is:
 #     - hubs.xahau.as16089.net 21337
@@ -894,6 +875,119 @@
 #
 #-------------------------------------------------------------------------------
 #
+# 5. Reporting Mode
+#
+#------------
+#
+#   xahaud has an optional operating mode called Reporting Mode. In Reporting
+#   Mode, xahaud does not connect to the peer to peer network. Instead, xahaud 
+#   will continuously extract data from one or more xahaud servers that are
+#   connected to the peer to peer network (referred to as an ETL source).
+#   Reporting mode servers will forward RPC requests that require access to the
+#   peer to peer network (submit, fee, etc) to an ETL source.
+#
+#   [reporting]  Settings for Reporting Mode. If and only if this section is
+#                present, xahaud will start in reporting mode. This section
+#                contains a list of ETL source names, and key-value pairs. The
+#                ETL source names each correspond to a configuration file
+#                section; the names must match exactly. The key-value pairs are
+#                optional.
+#
+#
+#   [<name>]
+#
+#   A series of key/value pairs that specify an ETL source.
+#
+#   source_ip = <IP-address>
+#
+#       Required. IP address of the ETL source. Can also be a DNS record.
+#
+#   source_ws_port = <number>
+#
+#       Required. Port on which ETL source is accepting unencrypted websocket
+#       connections.
+#
+#   source_grpc_port = <number>
+#
+#       Required for ETL. Port on which ETL source is accepting gRPC requests.
+#       If this option is ommitted, this ETL source cannot actually be used for
+#       ETL; the Reporting Mode server can still forward RPCs to this ETL
+#       source, but cannot extract data from this ETL source.
+#
+#
+#   Key-value pairs (all optional):
+#
+#       read_only    Valid values: 0, 1. Default is 0. If set to 1, the server
+#                    will start in strict read-only mode, and will not perform
+#                    ETL. The server will still handle RPC requests, and will
+#                    still forward RPC requests that require access to the p2p
+#                    network.
+#
+#      start_sequence
+#                   Sequence of first ledger to extract if the database is empty.
+#                   ETL extracts ledgers in order. If this setting is absent and
+#                   the database is empty, ETL will start with the next ledger
+#                   validated by the network. If this setting is present and the
+#                   database is not empty, an exception is thrown.
+#
+#     num_markers   Degree of parallelism used during the initial ledger
+#                   download. Only used if the database is empty. Valid values
+#                   are 1-256. A higher degree of parallelism results in a
+#                   faster download, but puts more load on the ETL source.
+#                   Default is 2.
+#
+#   Example:
+#
+#     [reporting]
+#     etl_source1
+#     etl_source2
+#     read_only=0
+#     start_sequence=32570
+#     num_markers=8
+#
+#     [etl_source1]
+#     source_ip=1.2.3.4
+#     source_ws_port=6005
+#     source_grpc_port=50051
+#
+#     [etl_source2]
+#     source_ip=5.6.7.8
+#     source_ws_port=6005
+#     source_grpc_port=50051
+#
+#   Minimal Example:
+#
+#     [reporting]
+#     etl_source1
+#
+#     [etl_source1]
+#     source_ip=1.2.3.4
+#     source_ws_port=6005
+#     source_grpc_port=50051
+#
+#
+#   Notes:
+#
+#   Reporting Mode requires Postgres (instead of SQLite). The Postgres
+#   connection info is specified under the [ledger_tx_tables] config section;
+#   see the Database section for further documentation.
+#
+#   Each ETL source specified must have gRPC enabled (by adding a [port_grpc]
+#   section to the config). It is recommended to add a secure_gateway entry to
+#   the gRPC section, in order to bypass the server's rate limiting.
+#   This section needs to be added to the config of the ETL source, not
+#   the config of the reporting node. In the example below, the
+#   reporting server is running at 127.0.0.1. Multiple IPs can be
+#   specified in secure_gateway via a comma separated list.
+#
+#   [port_grpc]
+#   ip = 0.0.0.0
+#   port = 50051
+#   secure_gateway = 127.0.0.1
+#
+#
+#-------------------------------------------------------------------------------
+#
 # 6. Database
 #
 #------------
@@ -901,7 +995,13 @@
 #   xahaud creates 4 SQLite database to hold bookkeeping information
 #   about transactions, local credentials, and various other things.
 #   It also creates the NodeDB, which holds all the objects that
-#   make up the current and historical ledgers.
+#   make up the current and historical ledgers. In Reporting Mode, xahauad 
+#   uses a Postgres database instead of SQLite.
+#
+#   The simplest way to work with Postgres is to install it locally.
+#   When it is running, execute the initdb.sh script in the current
+#   directory as: sudo -u postgres ./initdb.sh
+#   This will create the xahaud user and an empty database of the same name.
 #
 #   The size of the NodeDB grows in proportion to the amount of new data and the
 #   amount of historical data (a configurable setting) so the performance of the
@@ -943,6 +1043,14 @@
 #       keeping full history is not advised, and using online delete is
 #       recommended.
 #
+#   type = Cassandra
+#
+#       Apache Cassandra is an open-source, distributed key-value store - see
+#       https://cassandra.apache.org/ for more details.
+#
+#       Cassandra is an alternative backend to be used only with Reporting Mode.
+#       See the Reporting Mode section for more details about Reporting Mode.
+#
 #   type = RWDB
 #
 #       RWDB is a high-performance memory store written by XRPL-Labs and optimized
@@ -960,6 +1068,21 @@
 #                           grow unbounded without online_delete. See the
 #                           online_delete section below.
 #
+#   Required keys for Cassandra:
+#
+#      contact_points       IP of a node in the Cassandra cluster
+#
+#      port                 CQL Native Transport Port
+#
+#      secure_connect_bundle
+#                           Absolute path to a secure connect bundle. When using
+#                           a secure connect bundle, contact_points and port are
+#                           not required.
+#
+#      keyspace             Name of Cassandra keyspace to use
+#
+#      table_name           Name of table in above keyspace to use
+#
 #   Optional keys
 #
 #       cache_size          Size of cache for database records. Default is 16384.
@@ -976,7 +1099,7 @@
 #                           default value for the unspecified parameter.
 #
 #                           Note: the cache will not be created if online_delete
-#                           is specified.
+#                           is specified, or if shards are used.
 #
 #       fast_load           Boolean. If set, load the last persisted ledger
 #                           from disk upon process start before syncing to
@@ -999,6 +1122,10 @@
 #       earliest_seq        The default is 32570 to match the XRP Ledger's
 #                           network's earliest allowed sequence. Alternate
 #                           networks may set this value. Minimum value of 1.
+#                           If a [shard_db] section is defined, and this
+#                           value is present either [node_db] or [shard_db],
+#                           it must be defined with the same value in both
+#                           sections.
 #
 #   Optional keys for NuDB only:
 #
@@ -1074,6 +1201,25 @@
 #                           checking until healthy.
 #                           Default is 5.
 #
+#   Optional keys for Cassandra:
+#
+#       username            Username to use if Cassandra cluster requires
+#                           authentication
+#
+#       password            Password to use if Cassandra cluster requires
+#                           authentication
+#
+#       max_requests_outstanding
+#                           Limits the maximum number of concurrent database
+#                           writes. Default is 10 million. For slower clusters,
+#                           large numbers of concurrent writes can overload the
+#                           cluster. Setting this option can help eliminate
+#                           write timeouts and other write errors due to the
+#                           cluster being overloaded.
+#       io_threads
+#                           Set the number of IO threads used by the
+#                           Cassandra driver. Defaults to 4.
+#
 #   Notes:
 #       The 'node_db' entry configures the primary, persistent storage.
 #
@@ -1090,6 +1236,32 @@
 #   your xahaud.cfg file.
 #   Partial pathnames are relative to the location of the xahaud executable.
 #
+#   [shard_db]      Settings for the Shard Database (optional)
+#
+#   Format (without spaces):
+#       One or more lines of case-insensitive key / value pairs:
+#       <key> '=' <value>
+#       ...
+#
+#   Example:
+#       path=db/shards/nudb
+#
+#   Required keys:
+#       path                Location to store the database
+#
+#   Optional keys:
+#       max_historical_shards
+#                           The maximum number of historical shards
+#                           to store.
+#
+#   [historical_shard_paths]      Additional storage paths for the Shard Database (optional)
+#
+#   Format (without spaces):
+#       One or more lines, each expressing a full path for storing historical shards:
+#       /mnt/disk1
+#       /mnt/disk2
+#       ...
+#
 #   [sqlite]       Tuning settings for the SQLite databases (optional)
 #
 #   Format (without spaces):
@@ -1169,18 +1341,40 @@
 #                           This setting may not be combined with the
 #                           "safety_level" setting.
 #
-#       page_size           Valid values: integer (MUST be power of 2 between 512 and 65536)
-#                           The default is 4096 bytes. This setting determines
-#                           the size of a page in the transaction.db file.
-#                           See https://www.sqlite.org/pragma.html#pragma_page_size 
-#                           for more details about the available options.
+#  [ledger_tx_tables] (optional)
 #
-#       journal_size_limit  Valid values: integer
-#                           The default is 1582080. This setting limits
-#                           the size of the journal for transaction.db file. When the limit is
-#                           reached, older entries will be deleted.
-#                           See https://www.sqlite.org/pragma.html#pragma_journal_size_limit
-#                           for more details about the available options.
+#      conninfo             Info for connecting to Postgres. Format is
+#                           postgres://[username]:[password]@[ip]/[database].
+#                           The database and user must already exist. If this
+#                           section is missing and xahaud is running in
+#                           Reporting Mode, xahaud will connect as the
+#                           user running xahaud to a database with the
+#                           same name. On Linux and Mac OS X, the connection
+#                           will take place using the server's UNIX domain
+#                           socket. On Windows, through the localhost IP
+#                           address. Default is empty.
+#
+#      use_tx_tables        Valid values: 1, 0
+#                           The default is 1 (true). Determines whether to use
+#                           the SQLite transaction database. If set to 0,
+#                           xahaud will not write to the transaction database,
+#                           and will reject tx, account_tx and tx_history RPCs.
+#                           In Reporting Mode, this setting is ignored.
+#
+#      max_connections      Valid values: any positive integer up to 64 bit
+#                           storage length. This configures the maximum
+#                           number of concurrent connections to postgres.
+#                           Default is the maximum possible value to
+#                           fit in a 64 bit integer.
+#
+#      timeout              Number of seconds after which idle postgres
+#                           connections are discconnected. If set to 0,
+#                           connections never timeout. Default is 600.
+#
+#
+#      remember_ip          Value values: 1, 0
+#                           Default is 1 (true). Whether to cache host and
+#                           port connection settings.
 #
 #
 #-------------------------------------------------------------------------------
@@ -1446,12 +1640,6 @@
 #       Admin level API commands over Secure Websockets, when originating
 #       from the same machine (via the loopback adapter at 127.0.0.1).
 #
-#   "grpc"
-#
-#       ETL commands for Clio. We recommend setting secure_gateway
-#       in this section to a comma-separated list of the addresses
-#       of your Clio servers, in order to bypass rippled's rate limiting.
-#
 #   This port is commented out but can be enabled by removing
 #   the '#' from each corresponding line including the entry under [server]
 #
@@ -1496,7 +1684,6 @@ port = 6009
 ip = 127.0.0.1
 admin = 127.0.0.1
 protocol = ws
-send_queue_limit = 500
 
 [port_grpc]
 port = 50051
@@ -1507,7 +1694,6 @@ secure_gateway = 127.0.0.1
 #port = 6008
 #ip = 127.0.0.1
 #protocol = wss
-#send_queue_limit = 500
 
 #-------------------------------------------------------------------------------
 
@@ -1537,6 +1723,15 @@ advisory_delete=0
 /opt/xahaud/db
 
 
+# To use Postgres, uncomment this section and fill in the appropriate connection
+# info. Postgres can only be used in Reporting Mode.
+# To disable writing to the transaction database, uncomment this section, and
+# set use_tx_tables=0
+# [ledger_tx_tables]
+# conninfo = postgres://[username]:[password]@[ip]/[database]
+# use_tx_tables=1
+
+
 # This needs to be an absolute directory reference, not a relative one.
 # Modify this value as required.
 [debug_logfile]
@@ -1586,3 +1781,15 @@ validators-xahau.txt
 [network_id]
 21337
 # 21338
+
+
+# To run in Reporting Mode, uncomment this section and fill in the appropriate
+# connection info for one or more ETL sources.
+# [reporting]
+# etl_source
+#
+#
+# [etl_source]
+# source_grpc_port=50051
+# source_ws_port=6005
+# source_ip=127.0.0.1

cmake/RippledCore.cmake

@@ -78,6 +78,12 @@ target_link_libraries(xrpl.libxrpl.beast PUBLIC
   xrpl.libpb
 )
 
+# Conditionally add enhanced logging source when BEAST_ENHANCED_LOGGING is enabled
+if(DEFINED BEAST_ENHANCED_LOGGING AND BEAST_ENHANCED_LOGGING)
+  target_sources(xrpl.libxrpl.beast PRIVATE
+    src/libxrpl/beast/utility/src/beast_EnhancedLogging.cpp)
+endif()
+
 # Level 02
 add_module(xrpl basics)
 target_link_libraries(xrpl.libxrpl.basics PUBLIC xrpl.libxrpl.beast)
@@ -152,9 +158,6 @@ if(xrpld)
   add_executable(rippled)
   if(tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
-    target_compile_definitions(rippled PRIVATE
-                                       UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
-    )
   endif()
   target_include_directories(rippled
     PRIVATE

cmake/RippledSanity.cmake

@@ -2,7 +2,22 @@
    convenience variables and sanity checks
 #]===================================================================]
 
-get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+include(ProcessorCount)
+
+if (NOT ep_procs)
+  ProcessorCount(ep_procs)
+  if (ep_procs GREATER 1)
+    # never use more than half of cores for EP builds
+    math (EXPR ep_procs "${ep_procs} / 2")
+    message (STATUS "Using ${ep_procs} cores for ExternalProject builds.")
+  endif ()
+endif ()
+get_property (is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if (is_multiconfig STREQUAL "NOTFOUND")
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode" OR ${CMAKE_GENERATOR} MATCHES "^Visual Studio")
+    set (is_multiconfig TRUE)
+  endif ()
+endif ()
 
 set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
 if (NOT is_multiconfig)

cmake/RippledSettings.cmake

@@ -11,14 +11,8 @@ option(assert "Enables asserts, even in release builds" OFF)
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if(tests)
-  # This setting allows making a separate workflow to test fees other than default 10
-  if(NOT UNIT_TEST_REFERENCE_FEE)
-    set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-  endif()
-endif()
 
-option(unity "Creates a build using UNITY support in cmake." OFF)
+option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)
   if(NOT is_ci)
     set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")

cmake/deps/Boost.cmake

@@ -1,12 +1,12 @@
-find_package(Boost 1.86 REQUIRED
+find_package(Boost 1.83 REQUIRED
   COMPONENTS
     chrono
     container
+    context
     coroutine
     date_time
     filesystem
     json
-    json
     program_options
     regex
     system
@@ -24,13 +24,14 @@ endif()
 
 target_link_libraries(ripple_boost
   INTERFACE
-    Boost::headers
+    Boost::boost
     Boost::chrono
     Boost::container
     Boost::coroutine
     Boost::date_time
     Boost::filesystem
     Boost::json
+    Boost::iostreams
     Boost::program_options
     Boost::regex
     Boost::system

cmake/soci_patch.cmake

@@ -8,7 +8,7 @@
 # those warnings.
 if (RIPPLED_SOURCE)
   execute_process( COMMAND ${CMAKE_COMMAND} -E copy_if_different
-      ${RIPPLED_SOURCE}/Builds/CMake/SociConfig.cmake.patched
+      ${RIPPLED_SOURCE}/cmake/SociConfig.cmake.patched
       cmake/SociConfig.cmake )
 endif ()
 

cmake/xrpl_add_test.cmake

@@ -1,41 +0,0 @@
-include(isolate_headers)
-
-function(xrpl_add_test name)
-  set(target ${PROJECT_NAME}.test.${name})
-
-  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
-  "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
-  )
-  add_executable(${target} EXCLUDE_FROM_ALL ${ARGN} ${sources})
-
-  isolate_headers(
-    ${target}
-    "${CMAKE_SOURCE_DIR}"
-    "${CMAKE_SOURCE_DIR}/tests/${name}"
-    PRIVATE
-  )
-
-  # Make sure the test isn't optimized away in unity builds
-  set_target_properties(${target} PROPERTIES
-    UNITY_BUILD_MODE GROUP
-    UNITY_BUILD_BATCH_SIZE 0)  # Adjust as needed
-
-  add_test(NAME ${target} COMMAND ${target})
-  set_tests_properties(
-    ${target} PROPERTIES
-    FIXTURES_REQUIRED ${target}_fixture
-  )
-
-  add_test(
-    NAME ${target}.build
-    COMMAND
-      ${CMAKE_COMMAND}
-      --build ${CMAKE_BINARY_DIR}
-      --config $<CONFIG>
-      --target ${target}
-  )
-  set_tests_properties(${target}.build PROPERTIES
-    FIXTURES_SETUP ${target}_fixture
-  )
-endfunction()

conan/profiles/default

@@ -1,37 +0,0 @@
-{% set os = detect_api.detect_os() %}
-{% set arch = detect_api.detect_arch() %}
-{% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
-{% set compiler_version = version %}
-{% if os == "Linux" %}
-{% set compiler_version = detect_api.default_compiler_version(compiler, version) %}
-{% endif %}
-
-[settings]
-os={{ os }}
-arch={{ arch }}
-build_type=Debug
-compiler={{compiler}}
-compiler.version={{ compiler_version }}
-compiler.cppstd=20
-{% if os == "Windows" %}
-compiler.runtime=static
-{% else %}
-compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
-{% endif %}
-
-[conf]
-{% if compiler == "clang" and compiler_version >= 19 %}
-tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
-{% endif %}
-{% if compiler == "apple-clang" and compiler_version >= 17 %}
-tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
-{% endif %}
-{% if compiler == "clang" and compiler_version == 16 %}
-tools.build:cxxflags=['-DBOOST_ASIO_DISABLE_CONCEPTS']
-{% endif %}
-{% if compiler == "gcc" and compiler_version < 13 %}
-tools.build:cxxflags=['-Wno-restrict']
-{% endif %}
-
-[tool_requires]
-!cmake/*: cmake/[>=3 <4]

conanfile.py

@@ -1,4 +1,4 @@
-from conan import ConanFile, __version__ as conan_version
+from conan import ConanFile
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
@@ -26,18 +26,16 @@ class Xrpl(ConanFile):
     }
 
     requires = [
+        'date/3.0.3',
         'grpc/1.50.1',
-        'libarchive/3.8.1',
-        'nudb/2.0.9',
+        'libarchive/3.7.6',
+        'nudb/2.0.8',
         'openssl/3.6.0',
         'soci/4.0.3@xahaud/stable',
+        'xxhash/0.8.2',
         'zlib/1.3.1',
     ]
 
-    test_requires = [
-        'doctest/2.4.11',
-    ]
-
     tool_requires = [
         'protobuf/3.21.12',
     ]
@@ -52,9 +50,9 @@ class Xrpl(ConanFile):
         'static': True,
         'tests': False,
         'unity': False,
-        'xrpld': False,
         'with_wasmedge': True,
         'tool_requires_b2': False,
+        'xrpld': False,
 
         'date/*:header_only': False,
         'grpc/*:shared': False,
@@ -93,16 +91,14 @@ class Xrpl(ConanFile):
     }
 
     def set_version(self):
-        if self.version is None:
-            path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
-            regex = r'versionString\s?=\s?\"(.*)\"'
-            with open(path, encoding='utf-8') as file:
-                matches = (re.search(regex, line) for line in file)
-                match = next(m for m in matches if m)
-                self.version = match.group(1)
+        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
+        regex = r'versionString\s?=\s?\"(.*)\"'
+        with open(path, 'r') as file:
+            matches = (re.search(regex, line) for line in file)
+            match = next(m for m in matches if m)
+            self.version = match.group(1)
 
     def build_requirements(self):
-        # These provide build tools (protoc, grpc plugins) that run during build
         self.tool_requires('grpc/1.50.1')
         # Explicitly require b2 (e.g. for building from source for glibc compatibility)
         if self.options.tool_requires_b2:
@@ -113,24 +109,21 @@ class Xrpl(ConanFile):
             self.options['boost/*'].visibility = 'global'
 
     def requirements(self):
-        # Conan 2 requires transitive headers to be specified
-        transitive_headers_opt = {'transitive_headers': True} if conan_version.split('.')[0] == '2' else {}
-        # Force sqlite3 version to avoid conflicts with soci
-        self.requires('sqlite3/3.49.1', override=True)
-        # Force our custom snappy build to avoid Conan CMakeDeps stdc++ heuristic bug
-        self.requires('snappy/1.1.10@xahaud/stable', override=True)
         # Force boost version for all dependencies to avoid conflicts
-        self.requires('boost/1.86.0', force=True, **transitive_headers_opt)
-        self.requires('date/3.0.4', **transitive_headers_opt)
+        self.requires('boost/1.86.0', override=True)
         self.requires('lz4/1.10.0', force=True)
+        self.requires('protobuf/3.21.9', force=True)
+        # Force sqlite3 version to avoid conflicts with soci
+        self.requires('sqlite3/3.47.0', override=True)
+        # Force our custom snappy build for all dependencies
+        self.requires('snappy/1.1.10@xahaud/stable', override=True)
 
         if self.options.with_wasmedge:
-            self.requires('wasmedge/0.11.2@xahaud/stable', **transitive_headers_opt)
+            self.requires('wasmedge/0.11.2@xahaud/stable')
         if self.options.jemalloc:
-            self.requires('jemalloc/5.3.0', **transitive_headers_opt)
+            self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires('rocksdb/10.0.1')
-        self.requires('xxhash/0.8.3', **transitive_headers_opt)
+            self.requires('rocksdb/6.29.5')
 
     exports_sources = (
         'CMakeLists.txt',
@@ -185,17 +178,7 @@ class Xrpl(ConanFile):
         # `include/`, not `include/ripple/proto/`.
         libxrpl.includedirs = ['include', 'include/ripple/proto']
         libxrpl.requires = [
-            'boost::headers',
-            'boost::chrono',
-            'boost::container',
-            'boost::coroutine',
-            'boost::date_time',
-            'boost::filesystem',
-            'boost::json',
-            'boost::program_options',
-            'boost::regex',
-            'boost::system',
-            'boost::thread',
+            'boost::boost',
             'date::date',
             'grpc::grpc++',
             'libarchive::libarchive',

docs/build/environment.md

@@ -23,7 +23,7 @@ direction.
 
 ```
 apt update
-apt install --yes curl git libssl-dev pipx python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
+apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
 
 curl --location --remote-name \
   "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
@@ -35,8 +35,7 @@ make --jobs $(nproc)
 make install
 cd ..
 
-pipx install 'conan<2'
-pipx ensurepath
+pip3 install 'conan<2'
 ```
 
 [1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh

examples/example/CMakeLists.txt

@@ -9,7 +9,7 @@ project(
   LANGUAGES CXX
 )
 
-find_package(xrpl CONFIG REQUIRED)
+find_package(xrpl REQUIRED)
 
 add_executable(example)
 target_sources(example PRIVATE src/example.cpp)

examples/example/conanfile.py

@@ -0,0 +1,59 @@
+from conan import ConanFile, conan_version
+from conan.tools.cmake import CMake, cmake_layout
+
+class Example(ConanFile):
+
+    def set_name(self):
+        if self.name is None:
+            self.name = 'example'
+
+    def set_version(self):
+        if self.version is None:
+            self.version = '0.1.0'
+
+    license = 'ISC'
+    author = 'John Freeman <jfreeman08@gmail.com>'
+
+    settings = 'os', 'compiler', 'build_type', 'arch'
+    options = {'shared': [True, False], 'fPIC': [True, False]}
+    default_options = {
+        'shared': False,
+        'fPIC': True,
+        'xrpl:xrpld': False,
+    }
+
+    requires = ['xrpl/2.2.0-rc1@jfreeman/nodestore']
+    generators = ['CMakeDeps', 'CMakeToolchain']
+
+    exports_sources = [
+        'CMakeLists.txt',
+        'cmake/*',
+        'external/*',
+        'include/*',
+        'src/*',
+    ]
+
+    # For out-of-source build.
+    # https://docs.conan.io/en/latest/reference/build_helpers/cmake.html#configure
+    no_copy_source = True
+
+    def layout(self):
+        cmake_layout(self)
+
+    def config_options(self):
+        if self.settings.os == 'Windows':
+            del self.options.fPIC
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure(variables={'BUILD_TESTING': 'NO'})
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+
+    def package_info(self):
+        path = f'{self.package_folder}/share/{self.name}/cpp_info.py'
+        with open(path, 'r') as file:
+            exec(file.read(), {}, {'self': self.cpp_info})

examples/example/src/example.cpp

@@ -1,10 +1,8 @@
-#include <xrpl/protocol/BuildInfo.h>
-
 #include <cstdio>
 
-int
-main(int argc, char const** argv)
-{
+#include <xrpl/protocol/BuildInfo.h>
+
+int main(int argc, char const** argv) {
     std::printf("%s\n", ripple::BuildInfo::getVersionString().c_str());
     return 0;
 }

external/antithesis-sdk/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.25)
 
 # Note, version set explicitly by rippled project
 project(antithesis-sdk-cpp VERSION 0.4.4 LANGUAGES CXX)

external/nudb/conandata.yml

@@ -0,0 +1,10 @@
+sources:
+  "2.0.8":
+    url: "https://github.com/CPPAlliance/NuDB/archive/2.0.8.tar.gz"
+    sha256: "9b71903d8ba111cd893ab064b9a8b6ac4124ed8bd6b4f67250205bc43c7f13a8"
+patches:
+  "2.0.8":
+    - patch_file: "patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch"
+      patch_description: "Fix build for MSVC by including stdexcept"
+      patch_type: "portability"
+      patch_source: "https://github.com/cppalliance/NuDB/pull/100/files"

external/nudb/conanfile.py

@@ -0,0 +1,72 @@
+import os
+
+from conan import ConanFile
+from conan.tools.build import check_min_cppstd
+from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get
+from conan.tools.layout import basic_layout
+
+required_conan_version = ">=1.52.0"
+
+
+class NudbConan(ConanFile):
+    name = "nudb"
+    description = "A fast key/value insert-only database for SSD drives in C++11"
+    license = "BSL-1.0"
+    url = "https://github.com/conan-io/conan-center-index"
+    homepage = "https://github.com/CPPAlliance/NuDB"
+    topics = ("header-only", "KVS", "insert-only")
+
+    package_type = "header-library"
+    settings = "os", "arch", "compiler", "build_type"
+    no_copy_source = True
+
+    @property
+    def _min_cppstd(self):
+        return 11
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def layout(self):
+        basic_layout(self, src_folder="src")
+
+    def requirements(self):
+        self.requires("boost/1.83.0")
+
+    def package_id(self):
+        self.info.clear()
+
+    def validate(self):
+        if self.settings.compiler.cppstd:
+            check_min_cppstd(self, self._min_cppstd)
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def build(self):
+        apply_conandata_patches(self)
+
+    def package(self):
+        copy(self, "LICENSE*",
+             dst=os.path.join(self.package_folder, "licenses"),
+             src=self.source_folder)
+        copy(self, "*",
+             dst=os.path.join(self.package_folder, "include"),
+             src=os.path.join(self.source_folder, "include"))
+
+    def package_info(self):
+        self.cpp_info.bindirs = []
+        self.cpp_info.libdirs = []
+
+        self.cpp_info.set_property("cmake_target_name", "NuDB")
+        self.cpp_info.set_property("cmake_target_aliases", ["NuDB::nudb"])
+        self.cpp_info.set_property("cmake_find_mode", "both")
+
+        self.cpp_info.components["core"].set_property("cmake_target_name", "nudb")
+        self.cpp_info.components["core"].names["cmake_find_package"] = "nudb"
+        self.cpp_info.components["core"].names["cmake_find_package_multi"] = "nudb"
+        self.cpp_info.components["core"].requires = ["boost::thread", "boost::system"]
+
+        # TODO: to remove in conan v2 once cmake_find_package_* generators removed
+        self.cpp_info.names["cmake_find_package"] = "NuDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "NuDB"

external/nudb/patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch

@@ -0,0 +1,24 @@
+diff --git a/include/nudb/detail/stream.hpp b/include/nudb/detail/stream.hpp
+index 6c07bf1..e0ce8ed 100644
+--- a/include/nudb/detail/stream.hpp
++++ b/include/nudb/detail/stream.hpp
+@@ -14,6 +14,7 @@
+ #include <cstdint>
+ #include <cstring>
+ #include <memory>
++#include <stdexcept>
+ 
+ namespace nudb {
+ namespace detail {
+diff --git a/include/nudb/impl/context.ipp b/include/nudb/impl/context.ipp
+index beb7058..ffde0b3 100644
+--- a/include/nudb/impl/context.ipp
++++ b/include/nudb/impl/context.ipp
+@@ -9,6 +9,7 @@
+ #define NUDB_IMPL_CONTEXT_IPP
+ 
+ #include <nudb/detail/store_base.hpp>
++#include <stdexcept>
+ 
+ namespace nudb {
+ 

external/rocksdb/conandata.yml

@@ -0,0 +1,27 @@
+sources:
+  "6.29.5":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.29.5.tar.gz"
+    sha256: "ddbf84791f0980c0bbce3902feb93a2c7006f6f53bfd798926143e31d4d756f0"
+  "6.27.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.27.3.tar.gz"
+    sha256: "ee29901749b9132692b26f0a6c1d693f47d1a9ed8e3771e60556afe80282bf58"
+  "6.20.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.20.3.tar.gz"
+    sha256: "c6502c7aae641b7e20fafa6c2b92273d935d2b7b2707135ebd9a67b092169dca"
+  "8.8.1":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v8.8.1.tar.gz"
+    sha256: "056c7e21ad8ae36b026ac3b94b9d6e0fcc60e1d937fc80330921e4181be5c36e"
+patches:
+  "6.29.5":
+    - patch_file: "patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix build with gcc 13 by including cstdint"
+      patch_type: "portability"
+      patch_source: "https://github.com/facebook/rocksdb/pull/11118"
+    - patch_file: "patches/6.29.5-0002-exclude-thirdparty.patch"
+      patch_description: "Do not include thirdparty.inc"
+      patch_type: "portability"
+  "6.27.3":
+    - patch_file: "patches/6.27.3-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix build with gcc 13 by including cstdint"
+      patch_type: "portability"
+      patch_source: "https://github.com/facebook/rocksdb/pull/11118"

external/rocksdb/conanfile.py

@@ -0,0 +1,233 @@
+import os
+import glob
+import shutil
+
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import apply_conandata_patches, collect_libs, copy, export_conandata_patches, get, rm, rmdir
+from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
+from conan.tools.scm import Version
+
+required_conan_version = ">=1.53.0"
+
+
+class RocksDBConan(ConanFile):
+    name = "rocksdb"
+    homepage = "https://github.com/facebook/rocksdb"
+    license = ("GPL-2.0-only", "Apache-2.0")
+    url = "https://github.com/conan-io/conan-center-index"
+    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    topics = ("database", "leveldb", "facebook", "key-value")
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "lite": [True, False],
+        "with_gflags": [True, False],
+        "with_snappy": [True, False],
+        "with_lz4": [True, False],
+        "with_zlib": [True, False],
+        "with_zstd": [True, False],
+        "with_tbb": [True, False],
+        "with_jemalloc": [True, False],
+        "enable_sse": [False, "sse42", "avx2"],
+        "use_rtti": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "lite": False,
+        "with_snappy": False,
+        "with_lz4": False,
+        "with_zlib": False,
+        "with_zstd": False,
+        "with_gflags": False,
+        "with_tbb": False,
+        "with_jemalloc": False,
+        "enable_sse": False,
+        "use_rtti": False,
+    }
+
+    @property
+    def _min_cppstd(self):
+        return "11" if Version(self.version) < "8.8.1" else "17"
+
+    @property
+    def _compilers_minimum_version(self):
+        return {} if self._min_cppstd == "11" else {
+                "apple-clang": "10",
+                "clang": "7",
+                "gcc": "7",
+                "msvc": "191",
+                "Visual Studio": "15",
+            }
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+        if self.settings.arch != "x86_64":
+            del self.options.with_tbb
+        if self.settings.build_type == "Debug":
+            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def requirements(self):
+        if self.options.with_gflags:
+            self.requires("gflags/2.2.2")
+        if self.options.with_snappy:
+            self.requires("snappy/1.1.10")
+        if self.options.with_lz4:
+            self.requires("lz4/1.10.0")
+        if self.options.with_zlib:
+            self.requires("zlib/[>=1.2.11 <2]")
+        if self.options.with_zstd:
+            self.requires("zstd/1.5.6")
+        if self.options.get_safe("with_tbb"):
+            self.requires("onetbb/2021.12.0")
+        if self.options.with_jemalloc:
+            self.requires("jemalloc/5.3.0")
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, self._min_cppstd)
+
+        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
+        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
+            raise ConanInvalidConfiguration(
+                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
+            )
+
+        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
+            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
+
+        check_min_vs(self, "191")
+
+        if self.version == "6.20.3" and \
+           self.settings.os == "Linux" and \
+           self.settings.compiler == "gcc" and \
+           Version(self.settings.compiler.version) < "5":
+            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["FAIL_ON_WARNINGS"] = False
+        tc.variables["WITH_TESTS"] = False
+        tc.variables["WITH_TOOLS"] = False
+        tc.variables["WITH_CORE_TOOLS"] = False
+        tc.variables["WITH_BENCHMARK_TOOLS"] = False
+        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
+        if is_msvc(self):
+            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
+        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
+        tc.variables["ROCKSDB_LITE"] = self.options.lite
+        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
+        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
+        tc.variables["WITH_LZ4"] = self.options.with_lz4
+        tc.variables["WITH_ZLIB"] = self.options.with_zlib
+        tc.variables["WITH_ZSTD"] = self.options.with_zstd
+        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
+        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
+        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
+        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["USE_RTTI"] = self.options.use_rtti
+        if not bool(self.options.enable_sse):
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = False
+        elif self.options.enable_sse == "sse42":
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = True
+        elif self.options.enable_sse == "avx2":
+            tc.variables["PORTABLE"] = False
+            tc.variables["FORCE_SSE42"] = False
+        # not available yet in CCI
+        tc.variables["WITH_NUMA"] = False
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        if self.options.with_jemalloc:
+            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
+            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
+        deps.generate()
+
+    def build(self):
+        apply_conandata_patches(self)
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def _remove_static_libraries(self):
+        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
+        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
+            if not lib.endswith(".dll.a"):
+                os.remove(lib)
+
+    def _remove_cpp_headers(self):
+        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
+            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
+                if os.path.isfile(path):
+                    os.remove(path)
+                else:
+                    shutil.rmtree(path)
+
+    def package(self):
+        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        cmake = CMake(self)
+        cmake.install()
+        if self.options.shared:
+            self._remove_static_libraries()
+            self._remove_cpp_headers() # Force stable ABI for shared libraries
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+
+    def package_info(self):
+        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
+        self.cpp_info.set_property("cmake_file_name", "RocksDB")
+        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
+        if self.settings.os == "Windows":
+            self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
+            if self.options.shared:
+                self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
+        elif self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+        if self.options.lite:
+            self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "RocksDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
+        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
+        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
+        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        if self.options.with_gflags:
+            self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_lz4:
+            self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_zlib:
+            self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
+        if self.options.with_zstd:
+            self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
+        if self.options.get_safe("with_tbb"):
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")

external/rocksdb/patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch

@@ -0,0 +1,30 @@
+--- a/include/rocksdb/utilities/checkpoint.h
++++ b/include/rocksdb/utilities/checkpoint.h
+@@ -8,6 +8,7 @@
+ #pragma once
+ #ifndef ROCKSDB_LITE
+ 
++#include <cstdint>
+ #include <string>
+ #include <vector>
+ #include "rocksdb/status.h"
+--- a/table/block_based/data_block_hash_index.h
++++ b/table/block_based/data_block_hash_index.h
+@@ -5,6 +5,7 @@
+ 
+ #pragma once
+ 
++#include <cstdint>
+ #include <string>
+ #include <vector>
+ 
+--- a/util/string_util.h
++++ b/util/string_util.h
+@@ -6,6 +6,7 @@
+ 
+ #pragma once
+ 
++#include <cstdint>
+ #include <sstream>
+ #include <string>
+ #include <unordered_map>

external/rocksdb/patches/6.29.5-0002-exclude-thirdparty.patch

@@ -0,0 +1,16 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index ec59d4491..35577c998 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -101 +100,0 @@ if(MSVC)
+-  option(WITH_GFLAGS "build with GFlags" OFF)
+@@ -103,2 +102,2 @@ if(MSVC)
+-  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
+-else()
++endif()
++
+@@ -117 +116 @@ else()
+-  if(MINGW)
++  if(MINGW OR MSVC)
+@@ -183 +181,0 @@ else()
+-endif()

hook/hookapi.h

@@ -45,8 +45,8 @@
 
 #include "error.h"
 #include "extern.h"
-#include "macro.h"
 #include "sfcodes.h"
+#include "macro.h"
 #include "tts.h"
 
 #endif

hook/sfcodes.h

@@ -9,7 +9,6 @@
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
 #define sfWasLockingChainSend ((16U << 16U) + 19U)
-#define sfWithdrawalPolicy ((16U << 16U) + 20U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
@@ -73,7 +72,6 @@
 #define sfLockCount ((2U << 16U) + 49U)
 #define sfFirstNFTokenSequence ((2U << 16U) + 50U)
 #define sfOracleDocumentID ((2U << 16U) + 51U)
-#define sfPermissionValue ((2U << 16U) + 52U)
 #define sfStartTime ((2U << 16U) + 93U)
 #define sfRepeatCount ((2U << 16U) + 94U)
 #define sfDelaySeconds ((2U << 16U) + 95U)
@@ -117,7 +115,6 @@
 #define sfTakerGetsCurrency ((17U << 16U) + 3U)
 #define sfTakerGetsIssuer ((17U << 16U) + 4U)
 #define sfMPTokenIssuanceID ((21U << 16U) + 1U)
-#define sfShareMPTID ((21U << 16U) + 2U)
 #define sfLedgerHash ((5U << 16U) + 1U)
 #define sfParentHash ((5U << 16U) + 2U)
 #define sfTransactionHash ((5U << 16U) + 3U)
@@ -155,20 +152,14 @@
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
 #define sfDomainID ((5U << 16U) + 37U)
-#define sfVaultID ((5U << 16U) + 38U)
-#define sfParentBatchID ((5U << 16U) + 39U)
-#define sfHookOnOutgoing ((5U << 16U) + 93U)
-#define sfHookOnIncoming ((5U << 16U) + 94U)
-#define sfCron ((5U << 16U) + 95U)
-#define sfHookCanEmit ((5U << 16U) + 96U)
-#define sfEmittedTxnID ((5U << 16U) + 97U)
-#define sfGovernanceMarks ((5U << 16U) + 98U)
 #define sfGovernanceFlags ((5U << 16U) + 99U)
+#define sfGovernanceMarks ((5U << 16U) + 98U)
+#define sfEmittedTxnID ((5U << 16U) + 97U)
+#define sfHookCanEmit ((5U << 16U) + 96U)
+#define sfCron ((5U << 16U) + 95U)
+#define sfHookOnIncoming ((5U << 16U) + 94U)
+#define sfHookOnOutgoing ((5U << 16U) + 93U)
 #define sfNumber ((9U << 16U) + 1U)
-#define sfAssetsAvailable ((9U << 16U) + 2U)
-#define sfAssetsMaximum ((9U << 16U) + 3U)
-#define sfAssetsTotal ((9U << 16U) + 4U)
-#define sfLossUnrealized ((9U << 16U) + 5U)
 #define sfAmount ((6U << 16U) + 1U)
 #define sfBalance ((6U << 16U) + 2U)
 #define sfLimitAmount ((6U << 16U) + 3U)
@@ -241,7 +232,6 @@
 #define sfNFTokenMinter ((8U << 16U) + 9U)
 #define sfEmitCallback ((8U << 16U) + 10U)
 #define sfHolder ((8U << 16U) + 11U)
-#define sfDelegate ((8U << 16U) + 12U)
 #define sfHookAccount ((8U << 16U) + 16U)
 #define sfOtherChainSource ((8U << 16U) + 18U)
 #define sfOtherChainDestination ((8U << 16U) + 19U)
@@ -279,7 +269,6 @@
 #define sfNFToken ((14U << 16U) + 12U)
 #define sfEmitDetails ((14U << 16U) + 13U)
 #define sfHook ((14U << 16U) + 14U)
-#define sfPermission ((14U << 16U) + 15U)
 #define sfSigner ((14U << 16U) + 16U)
 #define sfMajority ((14U << 16U) + 18U)
 #define sfDisabledValidator ((14U << 16U) + 19U)
@@ -297,9 +286,6 @@
 #define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
 #define sfPriceData ((14U << 16U) + 32U)
 #define sfCredential ((14U << 16U) + 33U)
-#define sfRawTransaction ((14U << 16U) + 34U)
-#define sfBatchSigner ((14U << 16U) + 35U)
-#define sfBook ((14U << 16U) + 36U)
 #define sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -317,7 +303,6 @@
 #define sfNFTokens ((15U << 16U) + 10U)
 #define sfHooks ((15U << 16U) + 11U)
 #define sfVoteSlots ((15U << 16U) + 12U)
-#define sfAdditionalBooks ((15U << 16U) + 13U)
 #define sfMajorities ((15U << 16U) + 16U)
 #define sfDisabledValidators ((15U << 16U) + 17U)
 #define sfHookExecutions ((15U << 16U) + 18U)
@@ -330,12 +315,9 @@
 #define sfAuthorizeCredentials ((15U << 16U) + 26U)
 #define sfUnauthorizeCredentials ((15U << 16U) + 27U)
 #define sfAcceptedCredentials ((15U << 16U) + 28U)
-#define sfPermissions ((15U << 16U) + 29U)
-#define sfRawTransactions ((15U << 16U) + 30U)
-#define sfBatchSigners ((15U << 16U) + 31U)
-#define sfAmounts ((15U << 16U) + 92U)
-#define sfHookEmissions ((15U << 16U) + 93U)
-#define sfImportVLKeys ((15U << 16U) + 94U)
-#define sfActiveValidators ((15U << 16U) + 95U)
-#define sfGenesisMints ((15U << 16U) + 96U)
 #define sfRemarks ((15U << 16U) + 97U)
+#define sfGenesisMints ((15U << 16U) + 96U)
+#define sfActiveValidators ((15U << 16U) + 95U)
+#define sfImportVLKeys ((15U << 16U) + 94U)
+#define sfHookEmissions ((15U << 16U) + 93U)
+#define sfAmounts ((15U << 16U) + 92U)

hook/tts.h

@@ -61,14 +61,6 @@
 #define ttNFTOKEN_MODIFY 70
 #define ttPERMISSIONED_DOMAIN_SET 71
 #define ttPERMISSIONED_DOMAIN_DELETE 72
-#define ttDELEGATE_SET 73
-#define ttVAULT_CREATE 74
-#define ttVAULT_SET 75
-#define ttVAULT_DELETE 76
-#define ttVAULT_DEPOSIT 77
-#define ttVAULT_WITHDRAW 78
-#define ttVAULT_CLAWBACK 79
-#define ttBATCH 80
 #define ttCRON 92
 #define ttCRON_SET 93
 #define ttREMARKS_SET 94

include/xrpl/basics/BasicConfig.h

@@ -27,6 +27,7 @@
 
 #include <algorithm>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -367,7 +368,7 @@ get(Section const& section,
 }
 
 inline std::string
-get(Section const& section, std::string const& name, char const* defaultValue)
+get(Section const& section, std::string const& name, const char* defaultValue)
 {
     try
     {

include/xrpl/basics/Buffer.h

@@ -22,10 +22,10 @@
 
 #include <xrpl/basics/Slice.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <utility>
 
 namespace ripple {
 

include/xrpl/basics/CompressionAlgorithms.h

@@ -21,11 +21,9 @@
 #define RIPPLED_COMPRESSIONALGORITHMS_H_INCLUDED
 
 #include <xrpl/basics/contract.h>
-
-#include <lz4.h>
-
 #include <algorithm>
 #include <cstdint>
+#include <lz4.h>
 #include <stdexcept>
 #include <vector>
 
@@ -55,7 +53,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in),
+        reinterpret_cast<const char*>(in),
         reinterpret_cast<char*>(compressed),
         inSize,
         outCapacity);
@@ -89,7 +87,7 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in),
+            reinterpret_cast<const char*>(in),
             reinterpret_cast<char*>(decompressed),
             inSize,
             decompressedSize) != decompressedSize)

include/xrpl/basics/CountedObject.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_COUNTEDOBJECT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
-
 #include <atomic>
 #include <string>
 #include <utility>

include/xrpl/basics/Expected.h

@@ -22,19 +22,11 @@
 
 #include <xrpl/basics/contract.h>
 
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 #include <boost/outcome.hpp>
 
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
+#include <concepts>
 #include <stdexcept>
+#include <type_traits>
 
 namespace ripple {
 
@@ -103,7 +95,7 @@ public:
     {
     }
 
-    constexpr E const&
+    constexpr const E&
     value() const&
     {
         return val_;
@@ -121,7 +113,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr E const&&
+    constexpr const E&&
     value() const&&
     {
         return std::move(val_);
@@ -146,14 +138,14 @@ public:
     template <typename U>
         requires std::convertible_to<U, T>
     constexpr Expected(U&& r)
-        : Base(boost::outcome_v2::in_place_type_t<T>{}, std::forward<U>(r))
+        : Base(boost::outcome_v2::success(T(std::forward<U>(r))))
     {
     }
 
     template <typename U>
         requires std::convertible_to<U, E> && (!std::is_reference_v<U>)
     constexpr Expected(Unexpected<U> e)
-        : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
+        : Base(boost::outcome_v2::failure(E(std::move(e.value()))))
     {
     }
 

include/xrpl/basics/IntrusivePointer.h

@@ -1,515 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEPOINTER_H_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEPOINTER_H_INCLUDED
-
-#include <concepts>
-#include <cstdint>
-#include <type_traits>
-#include <utility>
-
-namespace ripple {
-
-//------------------------------------------------------------------------------
-
-/** Tag to create an intrusive pointer from another intrusive pointer by using a
-    static cast. This is useful to create an intrusive pointer to a derived
-    class from an intrusive pointer to a base class.
-*/
-struct StaticCastTagSharedIntrusive
-{
-};
-
-/** Tag to create an intrusive pointer from another intrusive pointer by using a
-    dynamic cast. This is useful to create an intrusive pointer to a derived
-    class from an intrusive pointer to a base class. If the cast fails an empty
-    (null) intrusive pointer is created.
-*/
-struct DynamicCastTagSharedIntrusive
-{
-};
-
-/** When creating or adopting a raw pointer, controls whether the strong count
-    is incremented or not. Use this tag to increment the strong count.
-*/
-struct SharedIntrusiveAdoptIncrementStrongTag
-{
-};
-
-/** When creating or adopting a raw pointer, controls whether the strong count
-    is incremented or not. Use this tag to leave the strong count unchanged.
-*/
-struct SharedIntrusiveAdoptNoIncrementTag
-{
-};
-
-//------------------------------------------------------------------------------
-//
-
-template <class T>
-concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
-    std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
-
-//------------------------------------------------------------------------------
-
-/** A shared intrusive pointer class that supports weak pointers.
-
-    This is meant to be used for SHAMapInnerNodes, but may be useful for other
-    cases. Since the reference counts are stored on the pointee, the pointee is
-    not destroyed until both the strong _and_ weak pointer counts go to zero.
-    When the strong pointer count goes to zero, the "partialDestructor" is
-    called. This can be used to destroy as much of the object as possible while
-    still retaining the reference counts. For example, for SHAMapInnerNodes the
-    children may be reset in that function. Note that std::shared_poiner WILL
-    run the destructor when the strong count reaches zero, but may not free the
-    memory used by the object until the weak count reaches zero. In rippled, we
-    typically allocate shared pointers with the `make_shared` function. When
-    that is used, the memory is not reclaimed until the weak count reaches zero.
-*/
-template <class T>
-class SharedIntrusive
-{
-public:
-    SharedIntrusive() = default;
-
-    template <CAdoptTag TAdoptTag>
-    SharedIntrusive(T* p, TAdoptTag) noexcept;
-
-    SharedIntrusive(SharedIntrusive const& rhs);
-
-    template <class TT>
-    // TODO: convertible_to isn't quite right. That include a static castable.
-    // Find the right concept.
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT> const& rhs);
-
-    SharedIntrusive(SharedIntrusive&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT>&& rhs);
-
-    SharedIntrusive&
-    operator=(SharedIntrusive const& rhs);
-
-    bool
-    operator!=(std::nullptr_t) const;
-
-    bool
-    operator==(std::nullptr_t) const;
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    SharedIntrusive&
-    operator=(SharedIntrusive&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive&
-    operator=(SharedIntrusive<TT>&& rhs);
-
-    /** Adopt the raw pointer. The strong reference may or may not be
-        incremented, depending on the TAdoptTag
-     */
-    template <CAdoptTag TAdoptTag = SharedIntrusiveAdoptIncrementStrongTag>
-    void
-    adopt(T* p);
-
-    ~SharedIntrusive();
-
-    /** Create a new SharedIntrusive by statically casting the pointer
-        controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(
-        StaticCastTagSharedIntrusive,
-        SharedIntrusive<TT> const& rhs);
-
-    /** Create a new SharedIntrusive by statically casting the pointer
-       controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
-
-    /** Create a new SharedIntrusive by dynamically casting the pointer
-       controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(
-        DynamicCastTagSharedIntrusive,
-        SharedIntrusive<TT> const& rhs);
-
-    /** Create a new SharedIntrusive by dynamically casting the pointer
-       controlled by the rhs param.
-    */
-    template <class TT>
-    SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
-
-    T&
-    operator*() const noexcept;
-
-    T*
-    operator->() const noexcept;
-
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the strong count, and run the
-        appropriate release action.
-      */
-    void
-    reset();
-
-    /** Get the raw pointer */
-    T*
-    get() const;
-
-    /** Return the strong count */
-    std::size_t
-    use_count() const;
-
-    template <class TT, class... Args>
-    friend SharedIntrusive<TT>
-    make_SharedIntrusive(Args&&... args);
-
-    template <class TT>
-    friend class SharedIntrusive;
-
-    template <class TT>
-    friend class SharedWeakUnion;
-
-    template <class TT>
-    friend class WeakIntrusive;
-
-private:
-    /** Return the raw pointer held by this object. */
-    T*
-    unsafeGetRawPtr() const;
-
-    /** Exchange the current raw pointer held by this object with the given
-        pointer. Decrement the strong count of the raw pointer previously held
-        by this object and run the appropriate release action.
-     */
-    void
-    unsafeReleaseAndStore(T* next);
-
-    /** Set the raw pointer directly. This is wrapped in a function so the class
-        can support both atomic and non-atomic pointers in a future patch.
-     */
-    void
-    unsafeSetRawPtr(T* p);
-
-    /** Exchange the raw pointer directly.
-        This sets the raw pointer to the given value and returns the previous
-        value. This is wrapped in a function so the class can support both
-        atomic and non-atomic pointers in a future patch.
-     */
-    T*
-    unsafeExchange(T* p);
-
-    /** pointer to the type with an intrusive count */
-    T* ptr_{nullptr};
-};
-
-//------------------------------------------------------------------------------
-
-/** A weak intrusive pointer class for the SharedIntrusive pointer class.
-
-Note that this weak pointer class asks differently from normal weak pointer
-classes. When the strong pointer count goes to zero, the "partialDestructor"
-is called. See the comment on SharedIntrusive for a fuller explanation.
-*/
-template <class T>
-class WeakIntrusive
-{
-public:
-    WeakIntrusive() = default;
-
-    WeakIntrusive(WeakIntrusive const& rhs);
-
-    WeakIntrusive(WeakIntrusive&& rhs);
-
-    WeakIntrusive(SharedIntrusive<T> const& rhs);
-
-    // There is no move constructor from a strong intrusive ptr because
-    // moving would be move expensive than copying in this case (the strong
-    // ref would need to be decremented)
-    WeakIntrusive(SharedIntrusive<T> const&& rhs) = delete;
-
-    // Since there are no current use cases for copy assignment in
-    // WeakIntrusive, we delete this operator to simplify the implementation. If
-    // a need arises in the future, we can reintroduce it with proper
-    // consideration."
-    WeakIntrusive&
-    operator=(WeakIntrusive const&) = delete;
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    WeakIntrusive&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    /** Adopt the raw pointer and increment the weak count. */
-    void
-    adopt(T* ptr);
-
-    ~WeakIntrusive();
-
-    /** Get a strong pointer from the weak pointer, if possible. This will
-       only return a seated pointer if the strong count on the raw pointer
-       is non-zero before locking.
-     */
-    SharedIntrusive<T>
-    lock() const;
-
-    /** Return true if the strong count is zero. */
-    bool
-    expired() const;
-
-    /** Set the pointer to null and decrement the weak count.
-
-    Note: This may run the destructor if the strong count is zero.
-    */
-    void
-    reset();
-
-private:
-    T* ptr_ = nullptr;
-
-    /** Decrement the weak count. This does _not_ set the raw pointer to
-    null.
-
-    Note: This may run the destructor if the strong count is zero.
-    */
-    void
-    unsafeReleaseNoStore();
-};
-
-//------------------------------------------------------------------------------
-
-/** A combination of a strong and a weak intrusive pointer stored in the
-    space of a single pointer.
-
-    This class is similar to a `std::variant<SharedIntrusive,WeakIntrusive>`
-    with some optimizations. In particular, it uses a low-order bit to
-    determine if the raw pointer represents a strong pointer or a weak
-    pointer. It can also be quickly switched between its strong pointer and
-    weak pointer representations. This class is useful for storing intrusive
-    pointers in tagged caches.
-  */
-
-template <class T>
-class SharedWeakUnion
-{
-    // Tagged pointer. Low bit determines if this is a strong or a weak
-    // pointer. The low bit must be masked to zero when converting back to a
-    // pointer. If the low bit is '1', this is a weak pointer.
-    static_assert(
-        alignof(T) >= 2,
-        "Bad alignment: Combo pointer requires low bit to be zero");
-
-public:
-    SharedWeakUnion() = default;
-
-    SharedWeakUnion(SharedWeakUnion const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT> const& rhs);
-
-    SharedWeakUnion(SharedWeakUnion&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT>&& rhs);
-
-    SharedWeakUnion&
-    operator=(SharedWeakUnion const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion&
-    operator=(SharedIntrusive<TT>&& rhs);
-
-    ~SharedWeakUnion();
-
-    /** Return a strong pointer if this is already a strong pointer (i.e.
-       don't lock the weak pointer. Use the `lock` method if that's what's
-       needed)
-     */
-    SharedIntrusive<T>
-    getStrong() const;
-
-    /** Return true if this is a strong pointer and the strong pointer is
-        seated.
-     */
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the appropriate ref count, and
-       run the appropriate release action.
-     */
-    void
-    reset();
-
-    /** If this is a strong pointer, return the raw pointer. Otherwise
-       return null.
-     */
-    T*
-    get() const;
-
-    /** If this is a strong pointer, return the strong count. Otherwise
-     * return 0
-     */
-    std::size_t
-    use_count() const;
-
-    /** Return true if there is a non-zero strong count. */
-    bool
-    expired() const;
-
-    /** If this is a strong pointer, return the strong pointer. Otherwise
-        attempt to lock the weak pointer.
-     */
-    SharedIntrusive<T>
-    lock() const;
-
-    /** Return true is this represents a strong pointer. */
-    bool
-    isStrong() const;
-
-    /** Return true is this represents a weak pointer. */
-    bool
-    isWeak() const;
-
-    /** If this is a weak pointer, attempt to convert it to a strong
-       pointer.
-
-        @return true if successfully converted to a strong pointer (or was
-                already a strong pointer). Otherwise false.
-      */
-    bool
-    convertToStrong();
-
-    /** If this is a strong pointer, attempt to convert it to a weak
-       pointer.
-
-        @return false if the pointer is null. Otherwise return true.
-      */
-    bool
-    convertToWeak();
-
-private:
-    // Tagged pointer. Low bit determines if this is a strong or a weak
-    // pointer. The low bit must be masked to zero when converting back to a
-    // pointer. If the low bit is '1', this is a weak pointer.
-    std::uintptr_t tp_{0};
-    static constexpr std::uintptr_t tagMask = 1;
-    static constexpr std::uintptr_t ptrMask = ~tagMask;
-
-private:
-    /** Return the raw pointer held by this object.
-     */
-    T*
-    unsafeGetRawPtr() const;
-
-    enum class RefStrength { strong, weak };
-    /** Set the raw pointer and tag bit directly.
-     */
-    void
-    unsafeSetRawPtr(T* p, RefStrength rs);
-
-    /** Set the raw pointer and tag bit to all zeros (strong null pointer).
-     */
-    void unsafeSetRawPtr(std::nullptr_t);
-
-    /** Decrement the appropriate ref count, and run the appropriate release
-        action. Note: this does _not_ set the raw pointer to null.
-     */
-    void
-    unsafeReleaseNoStore();
-};
-
-//------------------------------------------------------------------------------
-
-/** Create a shared intrusive pointer.
-
-    Note: unlike std::shared_ptr, where there is an advantage of allocating
-    the pointer and control block together, there is no benefit for intrusive
-    pointers.
-*/
-template <class TT, class... Args>
-SharedIntrusive<TT>
-make_SharedIntrusive(Args&&... args)
-{
-    auto p = new TT(std::forward<Args>(args)...);
-
-    static_assert(
-        noexcept(SharedIntrusive<TT>(
-            std::declval<TT*>(),
-            std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
-        "SharedIntrusive constructor should not throw or this can leak "
-        "memory");
-
-    return SharedIntrusive<TT>(p, SharedIntrusiveAdoptNoIncrementTag{});
-}
-
-//------------------------------------------------------------------------------
-
-namespace intr_ptr {
-template <class T>
-using SharedPtr = SharedIntrusive<T>;
-
-template <class T>
-using WeakPtr = WeakIntrusive<T>;
-
-template <class T>
-using SharedWeakUnionPtr = SharedWeakUnion<T>;
-
-template <class T, class... A>
-SharedPtr<T>
-make_shared(A&&... args)
-{
-    return make_SharedIntrusive<T>(std::forward<A>(args)...);
-}
-
-template <class T, class TT>
-SharedPtr<T>
-static_pointer_cast(TT const& v)
-{
-    return SharedPtr<T>(StaticCastTagSharedIntrusive{}, v);
-}
-
-template <class T, class TT>
-SharedPtr<T>
-dynamic_pointer_cast(TT const& v)
-{
-    return SharedPtr<T>(DynamicCastTagSharedIntrusive{}, v);
-}
-}  // namespace intr_ptr
-}  // namespace ripple
-#endif

include/xrpl/basics/IntrusivePointer.ipp

@@ -1,740 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEPOINTER_IPP_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEPOINTER_IPP_INCLUDED
-
-#include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/basics/IntrusiveRefCounts.h>
-
-#include <utility>
-
-namespace ripple {
-
-template <class T>
-template <CAdoptTag TAdoptTag>
-SharedIntrusive<T>::SharedIntrusive(T* p, TAdoptTag) noexcept : ptr_{p}
-{
-    if constexpr (std::is_same_v<
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
-    {
-        if (p)
-            p->addStrongRef();
-    }
-}
-
-template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive const& rhs)
-    : ptr_{[&] {
-        auto p = rhs.unsafeGetRawPtr();
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = rhs.unsafeGetRawPtr();
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs)
-    : ptr_{rhs.unsafeExchange(nullptr)}
-{
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs)
-    : ptr_{rhs.unsafeExchange(nullptr)}
-{
-}
-template <class T>
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive const& rhs)
-{
-    if (this == &rhs)
-        return *this;
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeReleaseAndStore(p);
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    if constexpr (std::is_same_v<T, TT>)
-    {
-        // This case should never be hit. The operator above will run instead.
-        // (The normal operator= is needed or it will be marked `deleted`)
-        if (this == &rhs)
-            return *this;
-    }
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeReleaseAndStore(p);
-    return *this;
-}
-
-template <class T>
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive&& rhs)
-{
-    if (this == &rhs)
-        return *this;
-
-    unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
-{
-    static_assert(
-        !std::is_same_v<T, TT>,
-        "This overload should not be instantiated for T == TT");
-
-    unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
-    return *this;
-}
-
-template <class T>
-bool
-SharedIntrusive<T>::operator!=(std::nullptr_t) const
-{
-    return this->get() != nullptr;
-}
-
-template <class T>
-bool
-SharedIntrusive<T>::operator==(std::nullptr_t) const
-{
-    return this->get() == nullptr;
-}
-
-template <class T>
-template <CAdoptTag TAdoptTag>
-void
-SharedIntrusive<T>::adopt(T* p)
-{
-    if constexpr (std::is_same_v<
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
-    {
-        if (p)
-            p->addStrongRef();
-    }
-    unsafeReleaseAndStore(p);
-}
-
-template <class T>
-SharedIntrusive<T>::~SharedIntrusive()
-{
-    unsafeReleaseAndStore(nullptr);
-};
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = static_cast<T*>(rhs.unsafeGetRawPtr());
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
-    : ptr_{static_cast<T*>(rhs.unsafeExchange(nullptr))}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = dynamic_cast<T*>(rhs.unsafeGetRawPtr());
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
-{
-    // This can be simplified without the `exchange`, but the `exchange` is kept
-    // in anticipation of supporting atomic operations.
-    auto toSet = rhs.unsafeExchange(nullptr);
-    if (toSet)
-    {
-        ptr_ = dynamic_cast<T*>(toSet);
-        if (!ptr_)
-            // need to set the pointer back or will leak
-            rhs.unsafeExchange(toSet);
-    }
-}
-
-template <class T>
-T&
-SharedIntrusive<T>::operator*() const noexcept
-{
-    return *unsafeGetRawPtr();
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::operator->() const noexcept
-{
-    return unsafeGetRawPtr();
-}
-
-template <class T>
-SharedIntrusive<T>::operator bool() const noexcept
-{
-    return bool(unsafeGetRawPtr());
-}
-
-template <class T>
-void
-SharedIntrusive<T>::reset()
-{
-    unsafeReleaseAndStore(nullptr);
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::get() const
-{
-    return unsafeGetRawPtr();
-}
-
-template <class T>
-std::size_t
-SharedIntrusive<T>::use_count() const
-{
-    if (auto p = unsafeGetRawPtr())
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::unsafeGetRawPtr() const
-{
-    return ptr_;
-}
-
-template <class T>
-void
-SharedIntrusive<T>::unsafeSetRawPtr(T* p)
-{
-    ptr_ = p;
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::unsafeExchange(T* p)
-{
-    return std::exchange(ptr_, p);
-}
-
-template <class T>
-void
-SharedIntrusive<T>::unsafeReleaseAndStore(T* next)
-{
-    auto prev = unsafeExchange(next);
-    if (!prev)
-        return;
-
-    using enum ReleaseStrongRefAction;
-    auto action = prev->releaseStrongRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            delete prev;
-            break;
-        case partialDestroy:
-            prev->partialDestructor();
-            partialDestructorFinished(&prev);
-            // prev is null and may no longer be used
-            break;
-    }
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(WeakIntrusive const& rhs) : ptr_{rhs.ptr_}
-{
-    if (ptr_)
-        ptr_->addWeakRef();
-}
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(WeakIntrusive&& rhs) : ptr_{rhs.ptr_}
-{
-    rhs.ptr_ = nullptr;
-}
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs)
-    : ptr_{rhs.unsafeGetRawPtr()}
-{
-    if (ptr_)
-        ptr_->addWeakRef();
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-WeakIntrusive<T>&
-WeakIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    unsafeReleaseNoStore();
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addWeakRef();
-    return *this;
-}
-
-template <class T>
-void
-WeakIntrusive<T>::adopt(T* ptr)
-{
-    unsafeReleaseNoStore();
-    if (ptr)
-        ptr->addWeakRef();
-    ptr_ = ptr;
-}
-
-template <class T>
-WeakIntrusive<T>::~WeakIntrusive()
-{
-    unsafeReleaseNoStore();
-}
-
-template <class T>
-SharedIntrusive<T>
-WeakIntrusive<T>::lock() const
-{
-    if (ptr_ && ptr_->checkoutStrongRefFromWeak())
-    {
-        return SharedIntrusive<T>{ptr_, SharedIntrusiveAdoptNoIncrementTag{}};
-    }
-    return {};
-}
-
-template <class T>
-bool
-WeakIntrusive<T>::expired() const
-{
-    return (!ptr_ || ptr_->expired());
-}
-
-template <class T>
-void
-WeakIntrusive<T>::reset()
-{
-    unsafeReleaseNoStore();
-    ptr_ = nullptr;
-}
-
-template <class T>
-void
-WeakIntrusive<T>::unsafeReleaseNoStore()
-{
-    if (!ptr_)
-        return;
-
-    using enum ReleaseWeakRefAction;
-    auto action = ptr_->releaseWeakRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            delete ptr_;
-            break;
-    }
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion const& rhs) : tp_{rhs.tp_}
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (!p)
-        return;
-
-    if (rhs.isStrong())
-        p->addStrongRef();
-    else
-        p->addWeakRef();
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT> const& rhs)
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeSetRawPtr(p, RefStrength::strong);
-}
-
-template <class T>
-SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion&& rhs) : tp_{rhs.tp_}
-{
-    rhs.unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT>&& rhs)
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        unsafeSetRawPtr(p, RefStrength::strong);
-    rhs.unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedWeakUnion const& rhs)
-{
-    if (this == &rhs)
-        return *this;
-    unsafeReleaseNoStore();
-
-    if (auto p = rhs.unsafeGetRawPtr())
-    {
-        if (rhs.isStrong())
-        {
-            p->addStrongRef();
-            unsafeSetRawPtr(p, RefStrength::strong);
-        }
-        else
-        {
-            p->addWeakRef();
-            unsafeSetRawPtr(p, RefStrength::weak);
-        }
-    }
-    else
-    {
-        unsafeSetRawPtr(nullptr);
-    }
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    unsafeReleaseNoStore();
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeSetRawPtr(p, RefStrength::strong);
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedIntrusive<TT>&& rhs)
-{
-    unsafeReleaseNoStore();
-    unsafeSetRawPtr(rhs.unsafeGetRawPtr(), RefStrength::strong);
-    rhs.unsafeSetRawPtr(nullptr);
-    return *this;
-}
-
-template <class T>
-SharedWeakUnion<T>::~SharedWeakUnion()
-{
-    unsafeReleaseNoStore();
-};
-
-// Return a strong pointer if this is already a strong pointer (i.e. don't
-// lock the weak pointer. Use the `lock` method if that's what's needed)
-template <class T>
-SharedIntrusive<T>
-SharedWeakUnion<T>::getStrong() const
-{
-    SharedIntrusive<T> result;
-    auto p = unsafeGetRawPtr();
-    if (p && isStrong())
-    {
-        result.template adopt<SharedIntrusiveAdoptIncrementStrongTag>(p);
-    }
-    return result;
-}
-
-template <class T>
-SharedWeakUnion<T>::operator bool() const noexcept
-{
-    return bool(get());
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::reset()
-{
-    unsafeReleaseNoStore();
-    unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-T*
-SharedWeakUnion<T>::get() const
-{
-    return isStrong() ? unsafeGetRawPtr() : nullptr;
-}
-
-template <class T>
-std::size_t
-SharedWeakUnion<T>::use_count() const
-{
-    if (auto p = get())
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::expired() const
-{
-    auto p = unsafeGetRawPtr();
-    return (!p || p->expired());
-}
-
-template <class T>
-SharedIntrusive<T>
-SharedWeakUnion<T>::lock() const
-{
-    SharedIntrusive<T> result;
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return result;
-
-    if (isStrong())
-    {
-        result.template adopt<SharedIntrusiveAdoptIncrementStrongTag>(p);
-        return result;
-    }
-
-    if (p->checkoutStrongRefFromWeak())
-    {
-        result.template adopt<SharedIntrusiveAdoptNoIncrementTag>(p);
-        return result;
-    }
-    return result;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::isStrong() const
-{
-    return !(tp_ & tagMask);
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::isWeak() const
-{
-    return tp_ & tagMask;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::convertToStrong()
-{
-    if (isStrong())
-        return true;
-
-    auto p = unsafeGetRawPtr();
-    if (p && p->checkoutStrongRefFromWeak())
-    {
-        [[maybe_unused]] auto action = p->releaseWeakRef();
-        XRPL_ASSERT(
-            (action == ReleaseWeakRefAction::noop),
-            "ripple::SharedWeakUnion::convertToStrong : "
-            "action is noop");
-        unsafeSetRawPtr(p, RefStrength::strong);
-        return true;
-    }
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::convertToWeak()
-{
-    if (isWeak())
-        return true;
-
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return false;
-
-    using enum ReleaseStrongRefAction;
-    auto action = p->addWeakReleaseStrongRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            // We just added a weak ref. How could we destroy?
-            UNREACHABLE(
-                "ripple::SharedWeakUnion::convertToWeak : destroying freshly "
-                "added ref");
-            delete p;
-            unsafeSetRawPtr(nullptr);
-            return true;  // Should never happen
-        case partialDestroy:
-            // This is a weird case. We just converted the last strong
-            // pointer to a weak pointer.
-            p->partialDestructor();
-            partialDestructorFinished(&p);
-            // p is null and may no longer be used
-            break;
-    }
-    unsafeSetRawPtr(p, RefStrength::weak);
-    return true;
-}
-
-template <class T>
-T*
-SharedWeakUnion<T>::unsafeGetRawPtr() const
-{
-    return reinterpret_cast<T*>(tp_ & ptrMask);
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeSetRawPtr(T* p, RefStrength rs)
-{
-    tp_ = reinterpret_cast<std::uintptr_t>(p);
-    if (tp_ && rs == RefStrength::weak)
-        tp_ |= tagMask;
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeSetRawPtr(std::nullptr_t)
-{
-    tp_ = 0;
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeReleaseNoStore()
-{
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return;
-
-    if (isStrong())
-    {
-        using enum ReleaseStrongRefAction;
-        auto strongAction = p->releaseStrongRef();
-        switch (strongAction)
-        {
-            case noop:
-                break;
-            case destroy:
-                delete p;
-                break;
-            case partialDestroy:
-                p->partialDestructor();
-                partialDestructorFinished(&p);
-                // p is null and may no longer be used
-                break;
-        }
-    }
-    else
-    {
-        using enum ReleaseWeakRefAction;
-        auto weakAction = p->releaseWeakRef();
-        switch (weakAction)
-        {
-            case noop:
-                break;
-            case destroy:
-                delete p;
-                break;
-        }
-    }
-}
-
-}  // namespace ripple
-#endif

include/xrpl/basics/IntrusiveRefCounts.h

@@ -1,502 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEREFCOUNTS_H_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEREFCOUNTS_H_INCLUDED
-
-#include <xrpl/beast/utility/instrumentation.h>
-
-#include <atomic>
-#include <cstdint>
-
-namespace ripple {
-
-/** Action to perform when releasing a strong pointer.
-
-    noop: Do nothing. For example, a `noop` action will occur when a count is
-    decremented to a non-zero value.
-
-    partialDestroy: Run the `partialDestructor`. This action will happen when a
-    strong count is decremented to zero and the weak count is non-zero.
-
-    destroy: Run the destructor. This action will occur when either the strong
-    count or weak count is decremented and the other count is also zero.
- */
-enum class ReleaseStrongRefAction { noop, partialDestroy, destroy };
-
-/** Action to perform when releasing a weak pointer.
-
-    noop: Do nothing. For example, a `noop` action will occur when a count is
-    decremented to a non-zero value.
-
-    destroy: Run the destructor. This action will occur when either the strong
-    count or weak count is decremented and the other count is also zero.
- */
-enum class ReleaseWeakRefAction { noop, destroy };
-
-/** Implement the strong count, weak count, and bit flags for an intrusive
-    pointer.
-
-    A class can satisfy the requirements of a ripple::IntrusivePointer by
-    inheriting from this class.
-  */
-struct IntrusiveRefCounts
-{
-    virtual ~IntrusiveRefCounts() noexcept;
-
-    // This must be `noexcept` or the make_SharedIntrusive function could leak
-    // memory.
-    void
-    addStrongRef() const noexcept;
-
-    void
-    addWeakRef() const noexcept;
-
-    ReleaseStrongRefAction
-    releaseStrongRef() const;
-
-    // Same as:
-    // {
-    //   addWeakRef();
-    //   return releaseStrongRef;
-    // }
-    // done as one atomic operation
-    ReleaseStrongRefAction
-    addWeakReleaseStrongRef() const;
-
-    ReleaseWeakRefAction
-    releaseWeakRef() const;
-
-    // Returns true is able to checkout a strong ref. False otherwise
-    bool
-    checkoutStrongRefFromWeak() const noexcept;
-
-    bool
-    expired() const noexcept;
-
-    std::size_t
-    use_count() const noexcept;
-
-    // This function MUST be called after a partial destructor finishes running.
-    // Calling this function may cause other threads to delete the object
-    // pointed to by `o`, so `o` should never be used after calling this
-    // function. The parameter will be set to a `nullptr` after calling this
-    // function to emphasize that it should not be used.
-    // Note: This is intentionally NOT called at the end of `partialDestructor`.
-    // The reason for this is if new classes are written to support this smart
-    // pointer class, they need to write their own `partialDestructor` function
-    // and ensure `partialDestructorFinished` is called at the end. Putting this
-    // call inside the smart pointer class itself is expected to be less error
-    // prone.
-    // Note: The "two-star" programming is intentional. It emphasizes that `o`
-    // may be deleted and the unergonomic API is meant to signal the special
-    // nature of this function call to callers.
-    // Note: This is a template to support incompletely defined classes.
-    template <class T>
-    friend void
-    partialDestructorFinished(T** o);
-
-private:
-    // TODO: We may need to use a uint64_t for both counts. This will reduce the
-    // memory savings. We need to audit the code to make sure 16 bit counts are
-    // enough for strong pointers and 14 bit counts are enough for weak
-    // pointers. Use type aliases to make it easy to switch types.
-    using CountType = std::uint16_t;
-    static constexpr size_t StrongCountNumBits = sizeof(CountType) * 8;
-    static constexpr size_t WeakCountNumBits = StrongCountNumBits - 2;
-    using FieldType = std::uint32_t;
-    static constexpr size_t FieldTypeBits = sizeof(FieldType) * 8;
-    static constexpr FieldType one = 1;
-
-    /** `refCounts` consists of four fields that are treated atomically:
-
-         1. Strong count. This is a count of the number of shared pointers that
-         hold a reference to this object. When the strong counts goes to zero,
-         if the weak count is zero, the destructor is run. If the weak count is
-         non-zero when the strong count goes to zero then the partialDestructor
-         is run.
-
-         2. Weak count. This is a count of the number of weak pointer that hold
-         a reference to this object. When the weak count goes to zero and the
-         strong count is also zero, then the destructor is run.
-
-         3. Partial destroy started bit. This bit is set if the
-         `partialDestructor` function has been started (or is about to be
-         started). This is used to prevent the destructor from running
-         concurrently with the partial destructor. This can easily happen when
-         the last strong pointer release its reference in one thread and starts
-         the partialDestructor, while in another thread the last weak pointer
-         goes out of scope and starts the destructor while the partialDestructor
-         is still running. Both a start and finished bit is needed to handle a
-         corner-case where the last strong pointer goes out of scope, then then
-         last `weakPointer` goes out of scope, but this happens before the
-         `partialDestructor` bit is set. It would be possible to use a single
-         bit if it could also be set atomically when the strong count goes to
-         zero and the weak count is non-zero, but that would add complexity (and
-         likely slow down common cases as well).
-
-         4. Partial destroy finished bit. This bit is set when the
-         `partialDestructor` has finished running. See (3) above for more
-         information.
-
-         */
-
-    mutable std::atomic<FieldType> refCounts{strongDelta};
-
-    /**  Amount to change the strong count when adding or releasing a reference
-
-         Note: The strong count is stored in the low `StrongCountNumBits` bits
-       of refCounts
-      */
-    static constexpr FieldType strongDelta = 1;
-
-    /**  Amount to change the weak count when adding or releasing a reference
-
-         Note: The weak count is stored in the high `WeakCountNumBits` bits of
-         refCounts
-      */
-    static constexpr FieldType weakDelta = (one << StrongCountNumBits);
-
-    /**  Flag that is set when the partialDestroy function has started running
-         (or is about to start running).
-
-         See description of the `refCounts` field for a fuller description of
-         this field.
-      */
-    static constexpr FieldType partialDestroyStartedMask =
-        (one << (FieldTypeBits - 1));
-
-    /**  Flag that is set when the partialDestroy function has finished running
-
-         See description of the `refCounts` field for a fuller description of
-         this field.
-      */
-    static constexpr FieldType partialDestroyFinishedMask =
-        (one << (FieldTypeBits - 2));
-
-    /** Mask that will zero out all the `count` bits and leave the tag bits
-        unchanged.
-      */
-    static constexpr FieldType tagMask =
-        partialDestroyStartedMask | partialDestroyFinishedMask;
-
-    /** Mask that will zero out the `tag` bits and leave the count bits
-        unchanged.
-      */
-    static constexpr FieldType valueMask = ~tagMask;
-
-    /** Mask that will zero out everything except the strong count.
-     */
-    static constexpr FieldType strongMask =
-        ((one << StrongCountNumBits) - 1) & valueMask;
-
-    /** Mask that will zero out everything except the weak count.
-     */
-    static constexpr FieldType weakMask =
-        (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
-
-    /** Unpack the count and tag fields from the packed atomic integer form. */
-    struct RefCountPair
-    {
-        CountType strong;
-        CountType weak;
-        /**  The `partialDestroyStartedBit` is set to on when the partial
-             destroy function is started. It is not a boolean; it is a uint32
-             with all bits zero with the possible exception of the
-             `partialDestroyStartedMask` bit. This is done so it can be directly
-             masked into the `combinedValue`.
-         */
-        FieldType partialDestroyStartedBit{0};
-        /**  The `partialDestroyFinishedBit` is set to on when the partial
-             destroy function has finished.
-         */
-        FieldType partialDestroyFinishedBit{0};
-        RefCountPair(FieldType v) noexcept;
-        RefCountPair(CountType s, CountType w) noexcept;
-
-        /** Convert back to the packed integer form. */
-        FieldType
-        combinedValue() const noexcept;
-
-        static constexpr CountType maxStrongValue =
-            static_cast<CountType>((one << StrongCountNumBits) - 1);
-        static constexpr CountType maxWeakValue =
-            static_cast<CountType>((one << WeakCountNumBits) - 1);
-        /**  Put an extra margin to detect when running up against limits.
-             This is only used in debug code, and is useful if we reduce the
-             number of bits in the strong and weak counts (to 16 and 14 bits).
-         */
-        static constexpr CountType checkStrongMaxValue = maxStrongValue - 32;
-        static constexpr CountType checkWeakMaxValue = maxWeakValue - 32;
-    };
-};
-
-inline void
-IntrusiveRefCounts::addStrongRef() const noexcept
-{
-    refCounts.fetch_add(strongDelta, std::memory_order_acq_rel);
-}
-
-inline void
-IntrusiveRefCounts::addWeakRef() const noexcept
-{
-    refCounts.fetch_add(weakDelta, std::memory_order_acq_rel);
-}
-
-inline ReleaseStrongRefAction
-IntrusiveRefCounts::releaseStrongRef() const
-{
-    // Subtract `strongDelta` from refCounts. If this releases the last strong
-    // ref, set the `partialDestroyStarted` bit. It is important that the ref
-    // count and the `partialDestroyStartedBit` are changed atomically (hence
-    // the loop and `compare_exchange` op). If this didn't need to be done
-    // atomically, the loop could be replaced with a `fetch_sub` and a
-    // conditional `fetch_or`. This loop will almost always run once.
-
-    using enum ReleaseStrongRefAction;
-    auto prevIntVal = refCounts.load(std::memory_order_acquire);
-    while (1)
-    {
-        RefCountPair const prevVal{prevIntVal};
-        XRPL_ASSERT(
-            (prevVal.strong >= strongDelta),
-            "ripple::IntrusiveRefCounts::releaseStrongRef : previous ref "
-            "higher than new");
-        auto nextIntVal = prevIntVal - strongDelta;
-        ReleaseStrongRefAction action = noop;
-        if (prevVal.strong == 1)
-        {
-            if (prevVal.weak == 0)
-            {
-                action = destroy;
-            }
-            else
-            {
-                nextIntVal |= partialDestroyStartedMask;
-                action = partialDestroy;
-            }
-        }
-
-        if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
-        {
-            // Can't be in partial destroy because only decrementing the strong
-            // count to zero can start a partial destroy, and that can't happen
-            // twice.
-            XRPL_ASSERT(
-                (action == noop) || !(prevIntVal & partialDestroyStartedMask),
-                "ripple::IntrusiveRefCounts::releaseStrongRef : not in partial "
-                "destroy");
-            return action;
-        }
-    }
-}
-
-inline ReleaseStrongRefAction
-IntrusiveRefCounts::addWeakReleaseStrongRef() const
-{
-    using enum ReleaseStrongRefAction;
-
-    static_assert(weakDelta > strongDelta);
-    auto constexpr delta = weakDelta - strongDelta;
-    auto prevIntVal = refCounts.load(std::memory_order_acquire);
-    // This loop will almost always run once. The loop is needed to atomically
-    // change the counts and flags (the count could be atomically changed, but
-    // the flags depend on the current value of the counts).
-    //
-    // Note: If this becomes a perf bottleneck, the `partialDestoryStartedMask`
-    // may be able to be set non-atomically. But it is easier to reason about
-    // the code if the flag is set atomically.
-    while (1)
-    {
-        RefCountPair const prevVal{prevIntVal};
-        // Converted the last strong pointer to a weak pointer.
-        //
-        // Can't be in partial destroy because only decrementing the
-        // strong count to zero can start a partial destroy, and that
-        // can't happen twice.
-        XRPL_ASSERT(
-            (!prevVal.partialDestroyStartedBit),
-            "ripple::IntrusiveRefCounts::addWeakReleaseStrongRef : not in "
-            "partial destroy");
-
-        auto nextIntVal = prevIntVal + delta;
-        ReleaseStrongRefAction action = noop;
-        if (prevVal.strong == 1)
-        {
-            if (prevVal.weak == 0)
-            {
-                action = noop;
-            }
-            else
-            {
-                nextIntVal |= partialDestroyStartedMask;
-                action = partialDestroy;
-            }
-        }
-        if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
-        {
-            XRPL_ASSERT(
-                (!(prevIntVal & partialDestroyStartedMask)),
-                "ripple::IntrusiveRefCounts::addWeakReleaseStrongRef : not "
-                "started partial destroy");
-            return action;
-        }
-    }
-}
-
-inline ReleaseWeakRefAction
-IntrusiveRefCounts::releaseWeakRef() const
-{
-    auto prevIntVal = refCounts.fetch_sub(weakDelta, std::memory_order_acq_rel);
-    RefCountPair prev = prevIntVal;
-    if (prev.weak == 1 && prev.strong == 0)
-    {
-        if (!prev.partialDestroyStartedBit)
-        {
-            // This case should only be hit if the partialDestroyStartedBit is
-            // set non-atomically (and even then very rarely). The code is kept
-            // in case we need to set the flag non-atomically for perf reasons.
-            refCounts.wait(prevIntVal, std::memory_order_acquire);
-            prevIntVal = refCounts.load(std::memory_order_acquire);
-            prev = RefCountPair{prevIntVal};
-        }
-        if (!prev.partialDestroyFinishedBit)
-        {
-            // partial destroy MUST finish before running a full destroy (when
-            // using weak pointers)
-            refCounts.wait(prevIntVal - weakDelta, std::memory_order_acquire);
-        }
-        return ReleaseWeakRefAction::destroy;
-    }
-    return ReleaseWeakRefAction::noop;
-}
-
-inline bool
-IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
-{
-    auto curValue = RefCountPair{1, 1}.combinedValue();
-    auto desiredValue = RefCountPair{2, 1}.combinedValue();
-
-    while (!refCounts.compare_exchange_weak(
-        curValue, desiredValue, std::memory_order_acq_rel))
-    {
-        RefCountPair const prev{curValue};
-        if (!prev.strong)
-            return false;
-
-        desiredValue = curValue + strongDelta;
-    }
-    return true;
-}
-
-inline bool
-IntrusiveRefCounts::expired() const noexcept
-{
-    RefCountPair const val = refCounts.load(std::memory_order_acquire);
-    return val.strong == 0;
-}
-
-inline std::size_t
-IntrusiveRefCounts::use_count() const noexcept
-{
-    RefCountPair const val = refCounts.load(std::memory_order_acquire);
-    return val.strong;
-}
-
-inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
-{
-#ifndef NDEBUG
-    auto v = refCounts.load(std::memory_order_acquire);
-    XRPL_ASSERT(
-        (!(v & valueMask)),
-        "ripple::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
-    auto t = v & tagMask;
-    XRPL_ASSERT(
-        (!t || t == tagMask),
-        "ripple::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
-    IntrusiveRefCounts::FieldType v) noexcept
-    : strong{static_cast<CountType>(v & strongMask)}
-    , weak{static_cast<CountType>((v & weakMask) >> StrongCountNumBits)}
-    , partialDestroyStartedBit{v & partialDestroyStartedMask}
-    , partialDestroyFinishedBit{v & partialDestroyFinishedMask}
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside "
-        "range");
-}
-
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
-    IntrusiveRefCounts::CountType s,
-    IntrusiveRefCounts::CountType w) noexcept
-    : strong{s}, weak{w}
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair(CountType, CountType) : "
-        "inputs inside range");
-}
-
-inline IntrusiveRefCounts::FieldType
-IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
-        "inside range");
-    return (static_cast<IntrusiveRefCounts::FieldType>(weak)
-            << IntrusiveRefCounts::StrongCountNumBits) |
-        static_cast<IntrusiveRefCounts::FieldType>(strong) |
-        partialDestroyStartedBit | partialDestroyFinishedBit;
-}
-
-template <class T>
-inline void
-partialDestructorFinished(T** o)
-{
-    T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
-        self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
-    XRPL_ASSERT(
-        (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit &&
-         !p.strong),
-        "ripple::partialDestructorFinished : not a weak ref");
-    if (!p.weak)
-    {
-        // There was a weak count before the partial destructor ran (or we would
-        // have run the full destructor) and now there isn't a weak count. Some
-        // thread is waiting to run the destructor.
-        self.refCounts.notify_one();
-    }
-    // Set the pointer to null to emphasize that the object shouldn't be used
-    // after calling this function as it may be destroyed in another thread.
-    *o = nullptr;
-}
-//------------------------------------------------------------------------------
-
-}  // namespace ripple
-#endif

include/xrpl/basics/LocalValue.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_LOCALVALUE_H_INCLUDED
 
 #include <boost/thread/tss.hpp>
-
 #include <memory>
 #include <unordered_map>
 

include/xrpl/basics/Log.h

@@ -22,10 +22,8 @@
 
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/beast/utility/Journal.h>
-
 #include <boost/beast/core/string.hpp>
 #include <boost/filesystem.hpp>
-
 #include <fstream>
 #include <map>
 #include <memory>

include/xrpl/basics/Resolver.h

@@ -20,11 +20,11 @@
 #ifndef RIPPLE_BASICS_RESOLVER_H_INCLUDED
 #define RIPPLE_BASICS_RESOLVER_H_INCLUDED
 
-#include <xrpl/beast/net/IPEndpoint.h>
-
 #include <functional>
 #include <vector>
 
+#include <xrpl/beast/net/IPEndpoint.h>
+
 namespace ripple {
 
 class Resolver

include/xrpl/basics/ResolverAsio.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/basics/Resolver.h>
 #include <xrpl/beast/utility/Journal.h>
-
 #include <boost/asio/io_service.hpp>
 
 namespace ripple {

include/xrpl/basics/SharedWeakCachePointer.h

@@ -1,135 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
-#define RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
-
-#include <memory>
-#include <variant>
-
-namespace ripple {
-
-/** A combination of a std::shared_ptr and a std::weak_pointer.
-
-
-This class is a wrapper to a `std::variant<std::shared_ptr,std::weak_ptr>`
-This class is useful for storing intrusive pointers in tagged caches using less
-memory than storing both pointers directly.
-*/
-
-template <class T>
-class SharedWeakCachePointer
-{
-public:
-    SharedWeakCachePointer() = default;
-
-    SharedWeakCachePointer(SharedWeakCachePointer const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer(std::shared_ptr<TT> const& rhs);
-
-    SharedWeakCachePointer(SharedWeakCachePointer&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer(std::shared_ptr<TT>&& rhs);
-
-    SharedWeakCachePointer&
-    operator=(SharedWeakCachePointer const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer&
-    operator=(std::shared_ptr<TT> const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer&
-    operator=(std::shared_ptr<TT>&& rhs);
-
-    ~SharedWeakCachePointer();
-
-    /** Return a strong pointer if this is already a strong pointer (i.e. don't
-        lock the weak pointer. Use the `lock` method if that's what's needed)
-     */
-    std::shared_ptr<T> const&
-    getStrong() const;
-
-    /** Return true if this is a strong pointer and the strong pointer is
-        seated.
-     */
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the appropriate ref count, and run
-        the appropriate release action.
-     */
-    void
-    reset();
-
-    /** If this is a strong pointer, return the raw pointer. Otherwise return
-        null.
-     */
-    T*
-    get() const;
-
-    /** If this is a strong pointer, return the strong count. Otherwise return 0
-     */
-    std::size_t
-    use_count() const;
-
-    /** Return true if there is a non-zero strong count. */
-    bool
-    expired() const;
-
-    /** If this is a strong pointer, return the strong pointer. Otherwise
-        attempt to lock the weak pointer.
-     */
-    std::shared_ptr<T>
-    lock() const;
-
-    /** Return true is this represents a strong pointer. */
-    bool
-    isStrong() const;
-
-    /** Return true is this represents a weak pointer. */
-    bool
-    isWeak() const;
-
-    /** If this is a weak pointer, attempt to convert it to a strong pointer.
-
-        @return true if successfully converted to a strong pointer (or was
-                already a strong pointer). Otherwise false.
-      */
-    bool
-    convertToStrong();
-
-    /** If this is a strong pointer, attempt to convert it to a weak pointer.
-
-        @return false if the pointer is null. Otherwise return true.
-      */
-    bool
-    convertToWeak();
-
-private:
-    std::variant<std::shared_ptr<T>, std::weak_ptr<T>> combo_;
-};
-}  // namespace ripple
-#endif

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -1,192 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_IPP_INCLUDED
-#define RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_IPP_INCLUDED
-
-#include <xrpl/basics/SharedWeakCachePointer.h>
-
-namespace ripple {
-template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    SharedWeakCachePointer const& rhs) = default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    std::shared_ptr<TT> const& rhs)
-    : combo_{rhs}
-{
-}
-
-template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    SharedWeakCachePointer&& rhs) = default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs)
-    : combo_{std::move(rhs)}
-{
-}
-
-template <class T>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(SharedWeakCachePointer const& rhs) =
-    default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(std::shared_ptr<TT> const& rhs)
-{
-    combo_ = rhs;
-    return *this;
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(std::shared_ptr<TT>&& rhs)
-{
-    combo_ = std::move(rhs);
-    return *this;
-}
-
-template <class T>
-SharedWeakCachePointer<T>::~SharedWeakCachePointer() = default;
-
-// Return a strong pointer if this is already a strong pointer (i.e. don't
-// lock the weak pointer. Use the `lock` method if that's what's needed)
-template <class T>
-std::shared_ptr<T> const&
-SharedWeakCachePointer<T>::getStrong() const
-{
-    static std::shared_ptr<T> const empty;
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return *p;
-    return empty;
-}
-
-template <class T>
-SharedWeakCachePointer<T>::operator bool() const noexcept
-{
-    return !!std::get_if<std::shared_ptr<T>>(&combo_);
-}
-
-template <class T>
-void
-SharedWeakCachePointer<T>::reset()
-{
-    combo_ = std::shared_ptr<T>{};
-}
-
-template <class T>
-T*
-SharedWeakCachePointer<T>::get() const
-{
-    return std::get_if<std::shared_ptr<T>>(&combo_).get();
-}
-
-template <class T>
-std::size_t
-SharedWeakCachePointer<T>::use_count() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::expired() const
-{
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-        return p->expired();
-    return !std::get_if<std::shared_ptr<T>>(&combo_);
-}
-
-template <class T>
-std::shared_ptr<T>
-SharedWeakCachePointer<T>::lock() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return *p;
-
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-        return p->lock();
-
-    return {};
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::isStrong() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return !!p->get();
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::isWeak() const
-{
-    return !isStrong();
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::convertToStrong()
-{
-    if (isStrong())
-        return true;
-
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-    {
-        if (auto s = p->lock())
-        {
-            combo_ = std::move(s);
-            return true;
-        }
-    }
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::convertToWeak()
-{
-    if (isWeak())
-        return true;
-
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-    {
-        combo_ = std::weak_ptr<T>(*p);
-        return true;
-    }
-
-    return false;
-}
-}  // namespace ripple
-#endif

include/xrpl/basics/Slice.h

@@ -23,7 +23,6 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <algorithm>
 #include <array>
 #include <cstdint>

include/xrpl/basics/StringUtilities.h

@@ -29,6 +29,7 @@
 #include <array>
 #include <cstdint>
 #include <optional>
+#include <sstream>
 #include <string>
 
 namespace ripple {

include/xrpl/basics/TaggedCache.h

@@ -20,14 +20,11 @@
 #ifndef RIPPLE_BASICS_TAGGEDCACHE_H_INCLUDED
 #define RIPPLE_BASICS_TAGGEDCACHE_H_INCLUDED
 
-#include <xrpl/basics/IntrusivePointer.h>
 #include <xrpl/basics/Log.h>
-#include <xrpl/basics/SharedWeakCachePointer.ipp>
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/basics/hardened_hash.h>
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/insight/Insight.h>
-
 #include <atomic>
 #include <functional>
 #include <mutex>
@@ -53,8 +50,6 @@ template <
     class Key,
     class T,
     bool IsKeyCache = false,
-    class SharedWeakUnionPointerType = SharedWeakCachePointer<T>,
-    class SharedPointerType = std::shared_ptr<T>,
     class Hash = hardened_hash<>,
     class KeyEqual = std::equal_to<Key>,
     class Mutex = std::recursive_mutex>
@@ -65,8 +60,6 @@ public:
     using key_type = Key;
     using mapped_type = T;
     using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
-    using shared_weak_combo_pointer_type = SharedWeakUnionPointerType;
-    using shared_pointer_type = SharedPointerType;
 
 public:
     TaggedCache(
@@ -76,48 +69,231 @@ public:
         clock_type& clock,
         beast::Journal journal,
         beast::insight::Collector::ptr const& collector =
-            beast::insight::NullCollector::New());
+            beast::insight::NullCollector::New())
+        : m_journal(journal)
+        , m_clock(clock)
+        , m_stats(
+              name,
+              std::bind(&TaggedCache::collect_metrics, this),
+              collector)
+        , m_name(name)
+        , m_target_size(size)
+        , m_target_age(expiration)
+        , m_cache_count(0)
+        , m_hits(0)
+        , m_misses(0)
+    {
+    }
 
 public:
     /** Return the clock associated with the cache. */
     clock_type&
-    clock();
+    clock()
+    {
+        return m_clock;
+    }
 
     /** Returns the number of items in the container. */
     std::size_t
-    size() const;
+    size() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache.size();
+    }
+
+    void
+    setTargetSize(int s)
+    {
+        std::lock_guard lock(m_mutex);
+        m_target_size = s;
+
+        if (s > 0)
+        {
+            for (auto& partition : m_cache.map())
+            {
+                partition.rehash(static_cast<std::size_t>(
+                    (s + (s >> 2)) /
+                        (partition.max_load_factor() * m_cache.partitions()) +
+                    1));
+            }
+        }
+
+        JLOG(m_journal.debug()) << m_name << " target size set to " << s;
+    }
+
+    clock_type::duration
+    getTargetAge() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_target_age;
+    }
+
+    void
+    setTargetAge(clock_type::duration s)
+    {
+        std::lock_guard lock(m_mutex);
+        m_target_age = s;
+        JLOG(m_journal.debug())
+            << m_name << " target age set to " << m_target_age.count();
+    }
 
     int
-    getCacheSize() const;
+    getCacheSize() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache_count;
+    }
 
     int
-    getTrackSize() const;
+    getTrackSize() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache.size();
+    }
 
     float
-    getHitRate();
+    getHitRate()
+    {
+        std::lock_guard lock(m_mutex);
+        auto const total = static_cast<float>(m_hits + m_misses);
+        return m_hits * (100.0f / std::max(1.0f, total));
+    }
 
     void
-    clear();
+    clear()
+    {
+        std::lock_guard lock(m_mutex);
+        m_cache.clear();
+        m_cache_count = 0;
+    }
 
     void
-    reset();
+    reset()
+    {
+        std::lock_guard lock(m_mutex);
+        m_cache.clear();
+        m_cache_count = 0;
+        m_hits = 0;
+        m_misses = 0;
+    }
 
     /** Refresh the last access time on a key if present.
         @return `true` If the key was found.
     */
     template <class KeyComparable>
     bool
-    touch_if_exists(KeyComparable const& key);
+    touch_if_exists(KeyComparable const& key)
+    {
+        std::lock_guard lock(m_mutex);
+        auto const iter(m_cache.find(key));
+        if (iter == m_cache.end())
+        {
+            ++m_stats.misses;
+            return false;
+        }
+        iter->second.touch(m_clock.now());
+        ++m_stats.hits;
+        return true;
+    }
 
-    using SweptPointersVector = std::vector<SharedWeakUnionPointerType>;
+    using SweptPointersVector = std::pair<
+        std::vector<std::shared_ptr<mapped_type>>,
+        std::vector<std::weak_ptr<mapped_type>>>;
 
     void
-    sweep();
+    sweep()
+    {
+        // Keep references to all the stuff we sweep
+        // For performance, each worker thread should exit before the swept data
+        // is destroyed but still within the main cache lock.
+        std::vector<SweptPointersVector> allStuffToSweep(m_cache.partitions());
+
+        clock_type::time_point const now(m_clock.now());
+        clock_type::time_point when_expire;
+
+        auto const start = std::chrono::steady_clock::now();
+        {
+            std::lock_guard lock(m_mutex);
+
+            if (m_target_size == 0 ||
+                (static_cast<int>(m_cache.size()) <= m_target_size))
+            {
+                when_expire = now - m_target_age;
+            }
+            else
+            {
+                when_expire =
+                    now - m_target_age * m_target_size / m_cache.size();
+
+                clock_type::duration const minimumAge(std::chrono::seconds(1));
+                if (when_expire > (now - minimumAge))
+                    when_expire = now - minimumAge;
+
+                JLOG(m_journal.trace())
+                    << m_name << " is growing fast " << m_cache.size() << " of "
+                    << m_target_size << " aging at "
+                    << (now - when_expire).count() << " of "
+                    << m_target_age.count();
+            }
+
+            std::vector<std::thread> workers;
+            workers.reserve(m_cache.partitions());
+            std::atomic<int> allRemovals = 0;
+
+            for (std::size_t p = 0; p < m_cache.partitions(); ++p)
+            {
+                workers.push_back(sweepHelper(
+                    when_expire,
+                    now,
+                    m_cache.map()[p],
+                    allStuffToSweep[p],
+                    allRemovals,
+                    lock));
+            }
+            for (std::thread& worker : workers)
+                worker.join();
+
+            m_cache_count -= allRemovals;
+        }
+        // At this point allStuffToSweep will go out of scope outside the lock
+        // and decrement the reference count on each strong pointer.
+        JLOG(m_journal.debug())
+            << m_name << " TaggedCache sweep lock duration "
+            << std::chrono::duration_cast<std::chrono::milliseconds>(
+                   std::chrono::steady_clock::now() - start)
+                   .count()
+            << "ms";
+    }
 
     bool
-    del(key_type const& key, bool valid);
+    del(const key_type& key, bool valid)
+    {
+        // Remove from cache, if !valid, remove from map too. Returns true if
+        // removed from cache
+        std::lock_guard lock(m_mutex);
+
+        auto cit = m_cache.find(key);
+
+        if (cit == m_cache.end())
+            return false;
+
+        Entry& entry = cit->second;
+
+        bool ret = false;
+
+        if (entry.isCached())
+        {
+            --m_cache_count;
+            entry.ptr.reset();
+            ret = true;
+        }
+
+        if (!valid || entry.isExpired())
+            m_cache.erase(cit);
+
+        return ret;
+    }
 
-public:
     /** Replace aliased objects with originals.
 
         Due to concurrency it is possible for two separate objects with
@@ -131,23 +307,100 @@ public:
 
         @return `true` If the key already existed.
     */
-    template <class R>
+public:
     bool
     canonicalize(
-        key_type const& key,
-        SharedPointerType& data,
-        R&& replaceCallback);
+        const key_type& key,
+        std::shared_ptr<T>& data,
+        std::function<bool(std::shared_ptr<T> const&)>&& replace)
+    {
+        // Return canonical value, store if needed, refresh in cache
+        // Return values: true=we had the data already
+        std::lock_guard lock(m_mutex);
+
+        auto cit = m_cache.find(key);
+
+        if (cit == m_cache.end())
+        {
+            m_cache.emplace(
+                std::piecewise_construct,
+                std::forward_as_tuple(key),
+                std::forward_as_tuple(m_clock.now(), data));
+            ++m_cache_count;
+            return false;
+        }
+
+        Entry& entry = cit->second;
+        entry.touch(m_clock.now());
+
+        if (entry.isCached())
+        {
+            if (replace(entry.ptr))
+            {
+                entry.ptr = data;
+                entry.weak_ptr = data;
+            }
+            else
+            {
+                data = entry.ptr;
+            }
+
+            return true;
+        }
+
+        auto cachedData = entry.lock();
+
+        if (cachedData)
+        {
+            if (replace(entry.ptr))
+            {
+                entry.ptr = data;
+                entry.weak_ptr = data;
+            }
+            else
+            {
+                entry.ptr = cachedData;
+                data = cachedData;
+            }
+
+            ++m_cache_count;
+            return true;
+        }
+
+        entry.ptr = data;
+        entry.weak_ptr = data;
+        ++m_cache_count;
+
+        return false;
+    }
 
     bool
     canonicalize_replace_cache(
-        key_type const& key,
-        SharedPointerType const& data);
+        const key_type& key,
+        std::shared_ptr<T> const& data)
+    {
+        return canonicalize(
+            key,
+            const_cast<std::shared_ptr<T>&>(data),
+            [](std::shared_ptr<T> const&) { return true; });
+    }
 
     bool
-    canonicalize_replace_client(key_type const& key, SharedPointerType& data);
+    canonicalize_replace_client(const key_type& key, std::shared_ptr<T>& data)
+    {
+        return canonicalize(
+            key, data, [](std::shared_ptr<T> const&) { return false; });
+    }
 
-    SharedPointerType
-    fetch(key_type const& key);
+    std::shared_ptr<T>
+    fetch(const key_type& key)
+    {
+        std::lock_guard<mutex_type> l(m_mutex);
+        auto ret = initialFetch(key, l);
+        if (!ret)
+            ++m_misses;
+        return ret;
+    }
 
     /** Insert the element into the container.
         If the key already exists, nothing happens.
@@ -156,11 +409,26 @@ public:
     template <class ReturnType = bool>
     auto
     insert(key_type const& key, T const& value)
-        -> std::enable_if_t<!IsKeyCache, ReturnType>;
+        -> std::enable_if_t<!IsKeyCache, ReturnType>
+    {
+        auto p = std::make_shared<T>(std::cref(value));
+        return canonicalize_replace_client(key, p);
+    }
 
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
+    {
+        std::lock_guard lock(m_mutex);
+        clock_type::time_point const now(m_clock.now());
+        auto [it, inserted] = m_cache.emplace(
+            std::piecewise_construct,
+            std::forward_as_tuple(key),
+            std::forward_as_tuple(now));
+        if (!inserted)
+            it->second.last_access = now;
+        return inserted;
+    }
 
     // VFALCO NOTE It looks like this returns a copy of the data in
     //             the output parameter 'data'. This could be expensive.
@@ -168,18 +436,50 @@ public:
     //             simply return an iterator.
     //
     bool
-    retrieve(key_type const& key, T& data);
+    retrieve(const key_type& key, T& data)
+    {
+        // retrieve the value of the stored data
+        auto entry = fetch(key);
+
+        if (!entry)
+            return false;
+
+        data = *entry;
+        return true;
+    }
 
     mutex_type&
-    peekMutex();
+    peekMutex()
+    {
+        return m_mutex;
+    }
 
     std::vector<key_type>
-    getKeys() const;
+    getKeys() const
+    {
+        std::vector<key_type> v;
+
+        {
+            std::lock_guard lock(m_mutex);
+            v.reserve(m_cache.size());
+            for (auto const& _ : m_cache)
+                v.push_back(_.first);
+        }
+
+        return v;
+    }
 
     // CachedSLEs functions.
     /** Returns the fraction of cache hits. */
     double
-    rate() const;
+    rate() const
+    {
+        std::lock_guard lock(m_mutex);
+        auto const tot = m_hits + m_misses;
+        if (tot == 0)
+            return 0;
+        return double(m_hits) / tot;
+    }
 
     /** Fetch an item from the cache.
         If the digest was not found, Handler
@@ -187,16 +487,73 @@ public:
             std::shared_ptr<SLE const>(void)
     */
     template <class Handler>
-    SharedPointerType
-    fetch(key_type const& digest, Handler const& h);
+    std::shared_ptr<T>
+    fetch(key_type const& digest, Handler const& h)
+    {
+        {
+            std::lock_guard l(m_mutex);
+            if (auto ret = initialFetch(digest, l))
+                return ret;
+        }
+
+        auto sle = h();
+        if (!sle)
+            return {};
+
+        std::lock_guard l(m_mutex);
+        ++m_misses;
+        auto const [it, inserted] =
+            m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
+        if (!inserted)
+            it->second.touch(m_clock.now());
+        return it->second.ptr;
+    }
     // End CachedSLEs functions.
 
 private:
-    SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
+    std::shared_ptr<T>
+    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    {
+        auto cit = m_cache.find(key);
+        if (cit == m_cache.end())
+            return {};
+
+        Entry& entry = cit->second;
+        if (entry.isCached())
+        {
+            ++m_hits;
+            entry.touch(m_clock.now());
+            return entry.ptr;
+        }
+        entry.ptr = entry.lock();
+        if (entry.isCached())
+        {
+            // independent of cache size, so not counted as a hit
+            ++m_cache_count;
+            entry.touch(m_clock.now());
+            return entry.ptr;
+        }
+
+        m_cache.erase(cit);
+        return {};
+    }
 
     void
-    collect_metrics();
+    collect_metrics()
+    {
+        m_stats.size.set(getCacheSize());
+
+        {
+            beast::insight::Gauge::value_type hit_rate(0);
+            {
+                std::lock_guard lock(m_mutex);
+                auto const total(m_hits + m_misses);
+                if (total != 0)
+                    hit_rate = (m_hits * 100) / total;
+            }
+            m_stats.hit_rate.set(hit_rate);
+        }
+    }
 
 private:
     struct Stats
@@ -242,37 +599,36 @@ private:
     class ValueEntry
     {
     public:
-        shared_weak_combo_pointer_type ptr;
+        std::shared_ptr<mapped_type> ptr;
+        std::weak_ptr<mapped_type> weak_ptr;
         clock_type::time_point last_access;
 
         ValueEntry(
             clock_type::time_point const& last_access_,
-            shared_pointer_type const& ptr_)
-            : ptr(ptr_), last_access(last_access_)
+            std::shared_ptr<mapped_type> const& ptr_)
+            : ptr(ptr_), weak_ptr(ptr_), last_access(last_access_)
         {
         }
 
         bool
         isWeak() const
         {
-            if (!ptr)
-                return true;
-            return ptr.isWeak();
+            return ptr == nullptr;
         }
         bool
         isCached() const
         {
-            return ptr && ptr.isStrong();
+            return ptr != nullptr;
         }
         bool
         isExpired() const
         {
-            return ptr.expired();
+            return weak_ptr.expired();
         }
-        SharedPointerType
+        std::shared_ptr<mapped_type>
         lock()
         {
-            return ptr.lock();
+            return weak_ptr.lock();
         }
         void
         touch(clock_type::time_point const& now)
@@ -301,7 +657,72 @@ private:
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&)
+    {
+        return std::thread([&, this]() {
+            int cacheRemovals = 0;
+            int mapRemovals = 0;
+
+            // Keep references to all the stuff we sweep
+            // so that we can destroy them outside the lock.
+            stuffToSweep.first.reserve(partition.size());
+            stuffToSweep.second.reserve(partition.size());
+            {
+                auto cit = partition.begin();
+                while (cit != partition.end())
+                {
+                    if (cit->second.isWeak())
+                    {
+                        // weak
+                        if (cit->second.isExpired())
+                        {
+                            stuffToSweep.second.push_back(
+                                std::move(cit->second.weak_ptr));
+                            ++mapRemovals;
+                            cit = partition.erase(cit);
+                        }
+                        else
+                        {
+                            ++cit;
+                        }
+                    }
+                    else if (cit->second.last_access <= when_expire)
+                    {
+                        // strong, expired
+                        ++cacheRemovals;
+                        if (cit->second.ptr.use_count() == 1)
+                        {
+                            stuffToSweep.first.push_back(
+                                std::move(cit->second.ptr));
+                            ++mapRemovals;
+                            cit = partition.erase(cit);
+                        }
+                        else
+                        {
+                            // remains weakly cached
+                            cit->second.ptr.reset();
+                            ++cit;
+                        }
+                    }
+                    else
+                    {
+                        // strong, not expired
+                        ++cit;
+                    }
+                }
+            }
+
+            if (mapRemovals || cacheRemovals)
+            {
+                JLOG(m_journal.debug())
+                    << "TaggedCache partition sweep " << m_name
+                    << ": cache = " << partition.size() << "-" << cacheRemovals
+                    << ", map-=" << mapRemovals;
+            }
+
+            allRemovals += cacheRemovals;
+        });
+    }
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -310,7 +731,45 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&)
+    {
+        return std::thread([&, this]() {
+            int cacheRemovals = 0;
+            int mapRemovals = 0;
+
+            // Keep references to all the stuff we sweep
+            // so that we can destroy them outside the lock.
+            {
+                auto cit = partition.begin();
+                while (cit != partition.end())
+                {
+                    if (cit->second.last_access > now)
+                    {
+                        cit->second.last_access = now;
+                        ++cit;
+                    }
+                    else if (cit->second.last_access <= when_expire)
+                    {
+                        cit = partition.erase(cit);
+                    }
+                    else
+                    {
+                        ++cit;
+                    }
+                }
+            }
+
+            if (mapRemovals || cacheRemovals)
+            {
+                JLOG(m_journal.debug())
+                    << "TaggedCache partition sweep " << m_name
+                    << ": cache = " << partition.size() << "-" << cacheRemovals
+                    << ", map-=" << mapRemovals;
+            }
+
+            allRemovals += cacheRemovals;
+        });
+    };
 
     beast::Journal m_journal;
     clock_type& m_clock;
@@ -322,10 +781,10 @@ private:
     std::string m_name;
 
     // Desired number of cache entries (0 = ignore)
-    int const m_target_size;
+    int m_target_size;
 
     // Desired maximum cache age
-    clock_type::duration const m_target_age;
+    clock_type::duration m_target_age;
 
     // Number of items cached
     int m_cache_count;

include/xrpl/basics/UnorderedContainers.h

@@ -25,7 +25,6 @@
 #include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/hash/xxhasher.h>
-
 #include <unordered_map>
 #include <unordered_set>
 

include/xrpl/basics/algorithm.h

@@ -20,6 +20,7 @@
 #ifndef RIPPLE_ALGORITHM_H_INCLUDED
 #define RIPPLE_ALGORITHM_H_INCLUDED
 
+#include <iterator>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/base_uint.h

@@ -33,13 +33,12 @@
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/endian/conversion.hpp>
 #include <boost/functional/hash.hpp>
-
 #include <algorithm>
 #include <array>
 #include <cstring>
+#include <functional>
 #include <type_traits>
 
 namespace ripple {
@@ -386,7 +385,7 @@ public:
     }
 
     base_uint&
-    operator^=(base_uint const& b)
+    operator^=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] ^= b.data_[i];
@@ -395,7 +394,7 @@ public:
     }
 
     base_uint&
-    operator&=(base_uint const& b)
+    operator&=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] &= b.data_[i];
@@ -404,7 +403,7 @@ public:
     }
 
     base_uint&
-    operator|=(base_uint const& b)
+    operator|=(const base_uint& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] |= b.data_[i];
@@ -427,11 +426,11 @@ public:
         return *this;
     }
 
-    base_uint const
+    const base_uint
     operator++(int)
     {
         // postfix operator
-        base_uint const ret = *this;
+        const base_uint ret = *this;
         ++(*this);
 
         return ret;
@@ -453,11 +452,11 @@ public:
         return *this;
     }
 
-    base_uint const
+    const base_uint
     operator--(int)
     {
         // postfix operator
-        base_uint const ret = *this;
+        const base_uint ret = *this;
         --(*this);
 
         return ret;
@@ -478,7 +477,7 @@ public:
     }
 
     base_uint&
-    operator+=(base_uint const& b)
+    operator+=(const base_uint& b)
     {
         std::uint64_t carry = 0;
 
@@ -523,7 +522,7 @@ public:
     }
 
     [[nodiscard]] constexpr bool
-    parseHex(char const* str)
+    parseHex(const char* str)
     {
         return parseHex(std::string_view{str});
     }

include/xrpl/basics/chrono.h

@@ -20,16 +20,17 @@
 #ifndef RIPPLE_BASICS_CHRONO_H_INCLUDED
 #define RIPPLE_BASICS_CHRONO_H_INCLUDED
 
+#include <date/date.h>
+
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/clock/basic_seconds_clock.h>
 #include <xrpl/beast/clock/manual_clock.h>
 
-#include <date/date.h>
-
 #include <chrono>
 #include <cstdint>
 #include <ratio>
 #include <string>
+#include <type_traits>
 
 namespace ripple {
 

include/xrpl/basics/comparators.h

@@ -43,7 +43,7 @@ struct less
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::less<T>()(left, right);
     }
@@ -55,7 +55,7 @@ struct equal_to
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::equal_to<T>()(left, right);
     }

include/xrpl/basics/contract.h

@@ -21,9 +21,9 @@
 #define RIPPLE_BASICS_CONTRACT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
-
 #include <exception>
 #include <string>
+#include <typeinfo>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/hardened_hash.h

@@ -24,8 +24,12 @@
 #include <xrpl/beast/hash/xxhasher.h>
 
 #include <cstdint>
+#include <functional>
 #include <mutex>
 #include <random>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/make_SSLContext.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_MAKE_SSLCONTEXT_H_INCLUDED
 
 #include <boost/asio/ssl/context.hpp>
-
 #include <string>
 
 namespace ripple {

include/xrpl/basics/mulDiv.h

@@ -23,6 +23,7 @@
 #include <cstdint>
 #include <limits>
 #include <optional>
+#include <utility>
 
 namespace ripple {
 auto constexpr muldiv_max = std::numeric_limits<std::uint64_t>::max();

include/xrpl/basics/partitioned_unordered_map.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <functional>
 #include <optional>
 #include <string>
@@ -52,7 +51,7 @@ template <
     typename Value,
     typename Hash,
     typename Pred = std::equal_to<Key>,
-    typename Alloc = std::allocator<std::pair<Key const, Value>>>
+    typename Alloc = std::allocator<std::pair<const Key, Value>>>
 class partitioned_unordered_map
 {
     std::size_t partitions_;

include/xrpl/basics/random.h

@@ -22,9 +22,9 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/beast/xor_shift_engine.h>
-
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <limits>
 #include <mutex>
 #include <random>

include/xrpl/basics/spinlock.h

@@ -19,7 +19,6 @@
 #define RIPPLE_BASICS_SPINLOCK_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <atomic>
 #include <limits>
 #include <type_traits>

include/xrpl/basics/tagged_integer.h

@@ -21,11 +21,11 @@
 #define BEAST_UTILITY_TAGGED_INTEGER_H_INCLUDED
 
 #include <xrpl/beast/hash/hash_append.h>
-
 #include <boost/operators.hpp>
-
+#include <functional>
 #include <iostream>
 #include <type_traits>
+#include <utility>
 
 namespace ripple {
 
@@ -74,13 +74,13 @@ public:
     }
 
     bool
-    operator<(tagged_integer const& rhs) const noexcept
+    operator<(const tagged_integer& rhs) const noexcept
     {
         return m_value < rhs.m_value;
     }
 
     bool
-    operator==(tagged_integer const& rhs) const noexcept
+    operator==(const tagged_integer& rhs) const noexcept
     {
         return m_value == rhs.m_value;
     }
@@ -142,14 +142,14 @@ public:
     }
 
     tagged_integer&
-    operator<<=(tagged_integer const& rhs) noexcept
+    operator<<=(const tagged_integer& rhs) noexcept
     {
         m_value <<= rhs.m_value;
         return *this;
     }
 
     tagged_integer&
-    operator>>=(tagged_integer const& rhs) noexcept
+    operator>>=(const tagged_integer& rhs) noexcept
     {
         m_value >>= rhs.m_value;
         return *this;

include/xrpl/beast/asio/io_latency_probe.h

@@ -21,7 +21,6 @@
 #define BEAST_ASIO_IO_LATENCY_PROBE_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/basic_waitable_timer.hpp>
 #include <boost/asio/io_service.hpp>
 

include/xrpl/beast/clock/abstract_clock.h

@@ -20,6 +20,9 @@
 #ifndef BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 
+#include <chrono>
+#include <string>
+
 namespace beast {
 
 /** Abstract interface to a clock.

include/xrpl/beast/clock/manual_clock.h

@@ -23,8 +23,6 @@
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <chrono>
-
 namespace beast {
 
 /** Manual clock implementation.

include/xrpl/beast/container/aged_container_utility.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/beast/container/aged_container.h>
 
-#include <chrono>
 #include <type_traits>
 
 namespace beast {

include/xrpl/beast/container/detail/aged_associative_container.h

@@ -20,6 +20,8 @@
 #ifndef BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 #define BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 
+#include <type_traits>
+
 namespace beast {
 namespace detail {
 

include/xrpl/beast/container/detail/aged_ordered_container.h

@@ -25,14 +25,13 @@
 #include <xrpl/beast/container/detail/aged_associative_container.h>
 #include <xrpl/beast/container/detail/aged_container_iterator.h>
 #include <xrpl/beast/container/detail/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/set.hpp>
 #include <boost/version.hpp>
-
 #include <algorithm>
 #include <functional>
 #include <initializer_list>
+#include <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility>

include/xrpl/beast/container/detail/aged_unordered_container.h

@@ -25,10 +25,8 @@
 #include <xrpl/beast/container/detail/aged_associative_container.h>
 #include <xrpl/beast/container/detail/aged_container_iterator.h>
 #include <xrpl/beast/container/detail/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/unordered_set.hpp>
-
 #include <algorithm>
 #include <cmath>
 #include <functional>

include/xrpl/beast/container/detail/empty_base_optimization.h

@@ -11,7 +11,6 @@
 #define BEAST_CONTAINER_DETAIL_EMPTY_BASE_OPTIMIZATION_H_INCLUDED
 
 #include <boost/type_traits/is_final.hpp>
-
 #include <type_traits>
 #include <utility>
 

include/xrpl/beast/core/LexicalCast.h

@@ -23,15 +23,16 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <boost/core/detail/string_view.hpp>
-
 #include <algorithm>
 #include <cerrno>
 #include <charconv>
 #include <cstdlib>
 #include <iterator>
+#include <limits>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
+#include <utility>
 
 namespace beast {
 

include/xrpl/beast/core/List.h

@@ -21,6 +21,7 @@
 #define BEAST_INTRUSIVE_LIST_H_INCLUDED
 
 #include <iterator>
+#include <type_traits>
 
 namespace beast {
 

include/xrpl/beast/hash/hash_append.h

@@ -23,37 +23,14 @@
 
 #include <boost/container/flat_set.hpp>
 #include <boost/endian/conversion.hpp>
-
-/*
-
-Workaround for overzealous clang warning, which trips on libstdc++ headers
-
-  In file included from
-  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_algo.h:61:
-  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_tempbuf.h:263:8:
-  error: 'get_temporary_buffer<std::pair<ripple::Quality, const
-  std::vector<std::unique_ptr<ripple::Step>> *>>' is deprecated
-  [-Werror,-Wdeprecated-declarations] 263 |
-  std::get_temporary_buffer<value_type>(_M_original_len));
-       ^
-*/
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <functional>
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 #include <array>
 #include <chrono>
+#include <cstdint>
 #include <cstring>
+#include <functional>
+#include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <system_error>
 #include <tuple>

include/xrpl/beast/hash/uhash.h

@@ -30,7 +30,7 @@ namespace beast {
 template <class Hasher = xxhasher>
 struct uhash
 {
-    uhash() = default;
+    explicit uhash() = default;
 
     using result_type = typename Hasher::result_type;
 

include/xrpl/beast/hash/xxhasher.h

@@ -21,7 +21,6 @@
 #define BEAST_HASH_XXHASHER_H_INCLUDED
 
 #include <boost/endian/conversion.hpp>
-
 #include <xxhash.h>
 
 #include <cstddef>

include/xrpl/beast/insight/Meter.h

@@ -20,10 +20,10 @@
 #ifndef BEAST_INSIGHT_METER_H_INCLUDED
 #define BEAST_INSIGHT_METER_H_INCLUDED
 
-#include <xrpl/beast/insight/MeterImpl.h>
-
 #include <memory>
 
+#include <xrpl/beast/insight/MeterImpl.h>
+
 namespace beast {
 namespace insight {
 

include/xrpl/beast/insight/StatsDCollector.h

@@ -21,6 +21,7 @@
 #define BEAST_INSIGHT_STATSDCOLLECTOR_H_INCLUDED
 
 #include <xrpl/beast/insight/Collector.h>
+
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/Journal.h>
 

include/xrpl/beast/net/IPAddress.h

@@ -25,11 +25,13 @@
 #include <xrpl/beast/net/IPAddressV4.h>
 #include <xrpl/beast/net/IPAddressV6.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/ip/address.hpp>
 #include <boost/functional/hash.hpp>
-
+#include <cstdint>
+#include <ios>
+#include <sstream>
 #include <string>
+#include <typeinfo>
 
 //------------------------------------------------------------------------------
 

include/xrpl/beast/net/IPAddressConversion.h

@@ -22,6 +22,8 @@
 
 #include <xrpl/beast/net/IPEndpoint.h>
 
+#include <sstream>
+
 #include <boost/asio.hpp>
 
 namespace beast {

include/xrpl/beast/net/IPAddressV4.h

@@ -21,8 +21,12 @@
 #define BEAST_NET_IPADDRESSV4_H_INCLUDED
 
 #include <xrpl/beast/hash/hash_append.h>
-
 #include <boost/asio/ip/address_v4.hpp>
+#include <cstdint>
+#include <functional>
+#include <ios>
+#include <string>
+#include <utility>
 
 namespace beast {
 namespace IP {

include/xrpl/beast/net/IPAddressV6.h

@@ -21,8 +21,12 @@
 #define BEAST_NET_IPADDRESSV6_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/ip/address_v6.hpp>
+#include <cstdint>
+#include <functional>
+#include <ios>
+#include <string>
+#include <utility>
 
 namespace beast {
 namespace IP {

include/xrpl/beast/net/IPEndpoint.h

@@ -25,6 +25,7 @@
 #include <xrpl/beast/net/IPAddress.h>
 
 #include <cstdint>
+#include <ios>
 #include <optional>
 #include <string>
 
@@ -214,7 +215,7 @@ namespace std {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    hash() = default;
+    explicit hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const
@@ -229,7 +230,7 @@ namespace boost {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    hash() = default;
+    explicit hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const

include/xrpl/beast/rfc2616.h

@@ -20,6 +20,10 @@
 #ifndef BEAST_RFC2616_HPP
 #define BEAST_RFC2616_HPP
 
+// TODO: This include <cstdint> is a workaround for beast compilation bug.
+// Remove when fix https://github.com/boostorg/beast/pull/2682/ is available.
+#include <cstdint>
+
 #include <boost/beast/http/message.hpp>
 #include <boost/beast/http/rfc7230.hpp>
 #include <boost/range/algorithm/equal.hpp>
@@ -30,6 +34,7 @@
 #include <cctype>
 #include <iterator>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace beast {

include/xrpl/beast/test/yield_to.h

@@ -11,8 +11,8 @@
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/spawn.hpp>
 #include <boost/optional.hpp>
-
 #include <condition_variable>
+#include <functional>
 #include <mutex>
 #include <thread>
 #include <vector>

include/xrpl/beast/unit_test/match.h

@@ -9,7 +9,6 @@
 #define BEAST_UNIT_TEST_MATCH_HPP
 
 #include <xrpl/beast/unit_test/suite_info.h>
-
 #include <string>
 
 namespace beast {

include/xrpl/beast/unit_test/reporter.h

@@ -10,12 +10,11 @@
 
 #include <xrpl/beast/unit_test/amount.h>
 #include <xrpl/beast/unit_test/recorder.h>
-
 #include <boost/lexical_cast.hpp>
 #include <boost/optional.hpp>
-
 #include <algorithm>
 #include <chrono>
+#include <functional>
 #include <iomanip>
 #include <iostream>
 #include <sstream>

include/xrpl/beast/unit_test/runner.h

@@ -9,10 +9,9 @@
 #define BEAST_UNIT_TEST_RUNNER_H_INCLUDED
 
 #include <xrpl/beast/unit_test/suite_info.h>
-
 #include <boost/assert.hpp>
-
 #include <mutex>
+#include <ostream>
 #include <string>
 
 namespace beast {

include/xrpl/beast/unit_test/suite.h

@@ -9,11 +9,9 @@
 #define BEAST_UNIT_TEST_SUITE_HPP
 
 #include <xrpl/beast/unit_test/runner.h>
-
 #include <boost/filesystem.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/throw_exception.hpp>
-
 #include <ostream>
 #include <sstream>
 #include <string>

include/xrpl/beast/unit_test/suite_list.h

@@ -10,9 +10,7 @@
 
 #include <xrpl/beast/unit_test/detail/const_container.h>
 #include <xrpl/beast/unit_test/suite_info.h>
-
 #include <boost/assert.hpp>
-
 #include <set>
 #include <typeindex>
 #include <unordered_set>

include/xrpl/beast/unit_test/thread.h

@@ -9,7 +9,6 @@
 #define BEAST_UNIT_TEST_THREAD_HPP
 
 #include <xrpl/beast/unit_test/suite.h>
-
 #include <functional>
 #include <thread>
 #include <utility>

include/xrpl/beast/utility/EnhancedLogging.h

@@ -32,14 +32,14 @@ should_log_use_colors();
 
 // Get the log highlight color - can be overridden via
 // LOG_HIGHLIGHT_COLOR
-char const*
+const char*
 get_log_highlight_color();
 
 // Strip source root path from __FILE__ at compile time
 // IMPORTANT: This MUST stay in the header as constexpr for compile-time
 // evaluation!
-constexpr char const*
-strip_source_root(char const* file)
+constexpr const char*
+strip_source_root(const char* file)
 {
     // Handle relative paths from build/ directory (common with ccache)
     // e.g., "../src/ripple/..." -> "ripple/..."
@@ -50,15 +50,15 @@ strip_source_root(char const* file)
     }
 
 #ifdef SOURCE_ROOT_PATH
-    constexpr char const* sourceRoot = SOURCE_ROOT_PATH;
-    constexpr auto strlen_constexpr = [](char const* s) constexpr {
-        char const* p = s;
+    constexpr const char* sourceRoot = SOURCE_ROOT_PATH;
+    constexpr auto strlen_constexpr = [](const char* s) constexpr {
+        const char* p = s;
         while (*p)
             ++p;
         return p - s;
     };
     constexpr auto strncmp_constexpr =
-        [](char const* a, char const* b, size_t n) constexpr {
+        [](const char* a, const char* b, size_t n) constexpr {
             for (size_t i = 0; i < n; ++i)
             {
                 if (a[i] != b[i])
@@ -83,7 +83,7 @@ should_show_location();
 
 // Helper to write location string (no leading/trailing space)
 void
-log_write_location_string(std::ostream& os, char const* file, int line);
+log_write_location_string(std::ostream& os, const char* file, int line);
 
 }  // namespace detail
 }  // namespace beast