actions/upload-artifact@v7

.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

.github/workflows/clang-format.yml

@@ -20,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-nix.yml

@@ -375,3 +375,15 @@ jobs:
              echo "Error: rippled executable not found in ${{ env.build_dir }}"
              exit 1
           fi
+
+      - name: Export server definitions
+        run: |
+          ${{ env.build_dir }}/rippled --definitions | python3 -m json.tool > server_definitions.json
+
+      - name: Upload server definitions
+        if: matrix.compiler_id == 'gcc-13-libstdcxx'
+        uses: actions/upload-artifact@v7
+        with:
+          name: server-definitions
+          path: server_definitions.json
+          archive: false

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
 

Builds/levelization/results/loops.txt

@@ -29,7 +29,7 @@ Loop: xrpld.app xrpld.overlay
   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 +44,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
@@ -168,6 +167,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
@@ -192,6 +192,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)

cmake/RippledCore.cmake

@@ -152,9 +152,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/RippledSettings.cmake

@@ -11,12 +11,6 @@ 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. This is the default" ON)
 if(unity)

conanfile.py

@@ -123,7 +123,7 @@ class Xrpl(ConanFile):
         if self.options.jemalloc:
             self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires('rocksdb/9.7.3')
+            self.requires('rocksdb/6.29.5')
 
     exports_sources = (
         'CMakeLists.txt',

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/rocksdb/conandata.yml

@@ -1,12 +1,27 @@
 sources:
-  "9.7.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v9.7.3.tar.gz"
-    sha256: "acfabb989cbfb5b5c4d23214819b059638193ec33dad2d88373c46448d16d38b"
+  "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:
-  "9.7.3":
-    - patch_file: "patches/9.x.x-0001-exclude-thirdparty.patch"
+  "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"
-    - patch_file: "patches/9.7.3-0001-memory-leak.patch"
-      patch_description: "Fix a leak of obsolete blob files left open until DB::Close()"
+  "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

@@ -15,10 +15,10 @@ required_conan_version = ">=1.53.0"
 
 class RocksDBConan(ConanFile):
     name = "rocksdb"
-    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    homepage = "https://github.com/facebook/rocksdb"
     license = ("GPL-2.0-only", "Apache-2.0")
     url = "https://github.com/conan-io/conan-center-index"
-    homepage = "https://github.com/facebook/rocksdb"
+    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"
@@ -58,12 +58,12 @@ class RocksDBConan(ConanFile):
     @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",
-        }
+                "apple-clang": "10",
+                "clang": "7",
+                "gcc": "7",
+                "msvc": "191",
+                "Visual Studio": "15",
+            }
 
     def export_sources(self):
         export_conandata_patches(self)
@@ -115,9 +115,9 @@ class RocksDBConan(ConanFile):
         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":
+           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):
@@ -163,8 +163,6 @@ class RocksDBConan(ConanFile):
         if self.options.with_jemalloc:
             deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
             deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
-        if self.options.with_zstd:
-            deps.set_property("zstd", "cmake_target_name", "zstd::zstd")
         deps.generate()
 
     def build(self):

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()

external/rocksdb/patches/9.7.3-0001-memory-leak.patch

@@ -1,319 +0,0 @@
-diff --git a/HISTORY.md b/HISTORY.md
-index 36d472229..05ad1a202 100644
---- a/HISTORY.md
-+++ b/HISTORY.md
-@@ -1,6 +1,10 @@
- # Rocksdb Change Log
- > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`
- 
-+## 9.7.4 (10/31/2024)
-+### Bug Fixes
-+* Fix a leak of obsolete blob files left open until DB::Close(). This bug was introduced in version 9.4.0.
-+
- ## 9.7.3 (10/16/2024)
- ### Behavior Changes
- * OPTIONS file to be loaded by remote worker is now preserved so that it does not get purged by the primary host. A similar technique as how we are preserving new SST files from getting purged is used for this. min_options_file_numbers_ is tracked like pending_outputs_ is tracked.
-diff --git a/db/blob/blob_file_cache.cc b/db/blob/blob_file_cache.cc
-index 5f340aadf..1b9faa238 100644
---- a/db/blob/blob_file_cache.cc
-+++ b/db/blob/blob_file_cache.cc
-@@ -42,6 +42,7 @@ Status BlobFileCache::GetBlobFileReader(
-   assert(blob_file_reader);
-   assert(blob_file_reader->IsEmpty());
- 
-+  // NOTE: sharing same Cache with table_cache
-   const Slice key = GetSliceForKey(&blob_file_number);
- 
-   assert(cache_);
-@@ -98,4 +99,13 @@ Status BlobFileCache::GetBlobFileReader(
-   return Status::OK();
- }
- 
-+void BlobFileCache::Evict(uint64_t blob_file_number) {
-+  // NOTE: sharing same Cache with table_cache
-+  const Slice key = GetSliceForKey(&blob_file_number);
-+
-+  assert(cache_);
-+
-+  cache_.get()->Erase(key);
-+}
-+
- }  // namespace ROCKSDB_NAMESPACE
-diff --git a/db/blob/blob_file_cache.h b/db/blob/blob_file_cache.h
-index 740e67ada..6858d012b 100644
---- a/db/blob/blob_file_cache.h
-+++ b/db/blob/blob_file_cache.h
-@@ -36,6 +36,15 @@ class BlobFileCache {
-                            uint64_t blob_file_number,
-                            CacheHandleGuard<BlobFileReader>* blob_file_reader);
- 
-+  // Called when a blob file is obsolete to ensure it is removed from the cache
-+  // to avoid effectively leaking the open file and assicated memory
-+  void Evict(uint64_t blob_file_number);
-+
-+  // Used to identify cache entries for blob files (not normally useful)
-+  static const Cache::CacheItemHelper* GetHelper() {
-+    return CacheInterface::GetBasicHelper();
-+  }
-+
-  private:
-   using CacheInterface =
-       BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;
-diff --git a/db/column_family.h b/db/column_family.h
-index e4b7adde8..86637736a 100644
---- a/db/column_family.h
-+++ b/db/column_family.h
-@@ -401,6 +401,7 @@ class ColumnFamilyData {
-                          SequenceNumber earliest_seq);
- 
-   TableCache* table_cache() const { return table_cache_.get(); }
-+  BlobFileCache* blob_file_cache() const { return blob_file_cache_.get(); }
-   BlobSource* blob_source() const { return blob_source_.get(); }
- 
-   // See documentation in compaction_picker.h
-diff --git a/db/db_impl/db_impl.cc b/db/db_impl/db_impl.cc
-index 261593423..06573ac2e 100644
---- a/db/db_impl/db_impl.cc
-+++ b/db/db_impl/db_impl.cc
-@@ -659,8 +659,9 @@ Status DBImpl::CloseHelper() {
-   // We need to release them before the block cache is destroyed. The block
-   // cache may be destroyed inside versions_.reset(), when column family data
-   // list is destroyed, so leaving handles in table cache after
--  // versions_.reset() may cause issues.
--  // Here we clean all unreferenced handles in table cache.
-+  // versions_.reset() may cause issues. Here we clean all unreferenced handles
-+  // in table cache, and (for certain builds/conditions) assert that no obsolete
-+  // files are hanging around unreferenced (leak) in the table/blob file cache.
-   // Now we assume all user queries have finished, so only version set itself
-   // can possibly hold the blocks from block cache. After releasing unreferenced
-   // handles here, only handles held by version set left and inside
-@@ -668,6 +669,9 @@ Status DBImpl::CloseHelper() {
-   // time a handle is released, we erase it from the cache too. By doing that,
-   // we can guarantee that after versions_.reset(), table cache is empty
-   // so the cache can be safely destroyed.
-+#ifndef NDEBUG
-+  TEST_VerifyNoObsoleteFilesCached(/*db_mutex_already_held=*/true);
-+#endif  // !NDEBUG
-   table_cache_->EraseUnRefEntries();
- 
-   for (auto& txn_entry : recovered_transactions_) {
-@@ -3227,6 +3231,8 @@ Status DBImpl::MultiGetImpl(
-       s = Status::Aborted();
-       break;
-     }
-+    // This could be a long-running operation
-+    ROCKSDB_THREAD_YIELD_HOOK();
-   }
- 
-   // Post processing (decrement reference counts and record statistics)
-diff --git a/db/db_impl/db_impl.h b/db/db_impl/db_impl.h
-index 5e4fa310b..ccc0abfa7 100644
---- a/db/db_impl/db_impl.h
-+++ b/db/db_impl/db_impl.h
-@@ -1241,9 +1241,14 @@ class DBImpl : public DB {
-   static Status TEST_ValidateOptions(const DBOptions& db_options) {
-     return ValidateOptions(db_options);
-   }
--
- #endif  // NDEBUG
- 
-+  // In certain configurations, verify that the table/blob file cache only
-+  // contains entries for live files, to check for effective leaks of open
-+  // files. This can only be called when purging of obsolete files has
-+  // "settled," such as during parts of DB Close().
-+  void TEST_VerifyNoObsoleteFilesCached(bool db_mutex_already_held) const;
-+
-   // persist stats to column family "_persistent_stats"
-   void PersistStats();
- 
-diff --git a/db/db_impl/db_impl_debug.cc b/db/db_impl/db_impl_debug.cc
-index 790a50d7a..67f5b4aaf 100644
---- a/db/db_impl/db_impl_debug.cc
-+++ b/db/db_impl/db_impl_debug.cc
-@@ -9,6 +9,7 @@
- 
- #ifndef NDEBUG
- 
-+#include "db/blob/blob_file_cache.h"
- #include "db/column_family.h"
- #include "db/db_impl/db_impl.h"
- #include "db/error_handler.h"
-@@ -328,5 +329,49 @@ size_t DBImpl::TEST_EstimateInMemoryStatsHistorySize() const {
-   InstrumentedMutexLock l(&const_cast<DBImpl*>(this)->stats_history_mutex_);
-   return EstimateInMemoryStatsHistorySize();
- }
-+
-+void DBImpl::TEST_VerifyNoObsoleteFilesCached(
-+    bool db_mutex_already_held) const {
-+  // This check is somewhat expensive and obscure to make a part of every
-+  // unit test in every build variety. Thus, we only enable it for ASAN builds.
-+  if (!kMustFreeHeapAllocations) {
-+    return;
-+  }
-+
-+  std::optional<InstrumentedMutexLock> l;
-+  if (db_mutex_already_held) {
-+    mutex_.AssertHeld();
-+  } else {
-+    l.emplace(&mutex_);
-+  }
-+
-+  std::vector<uint64_t> live_files;
-+  for (auto cfd : *versions_->GetColumnFamilySet()) {
-+    if (cfd->IsDropped()) {
-+      continue;
-+    }
-+    // Sneakily add both SST and blob files to the same list
-+    cfd->current()->AddLiveFiles(&live_files, &live_files);
-+  }
-+  std::sort(live_files.begin(), live_files.end());
-+
-+  auto fn = [&live_files](const Slice& key, Cache::ObjectPtr, size_t,
-+                          const Cache::CacheItemHelper* helper) {
-+    if (helper != BlobFileCache::GetHelper()) {
-+      // Skip non-blob files for now
-+      // FIXME: diagnose and fix the leaks of obsolete SST files revealed in
-+      // unit tests.
-+      return;
-+    }
-+    // See TableCache and BlobFileCache
-+    assert(key.size() == sizeof(uint64_t));
-+    uint64_t file_number;
-+    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
-+    // Assert file is in sorted live_files
-+    assert(
-+        std::binary_search(live_files.begin(), live_files.end(), file_number));
-+  };
-+  table_cache_->ApplyToAllEntries(fn, {});
-+}
- }  // namespace ROCKSDB_NAMESPACE
- #endif  // NDEBUG
-diff --git a/db/db_iter.cc b/db/db_iter.cc
-index e02586377..bf4749eb9 100644
---- a/db/db_iter.cc
-+++ b/db/db_iter.cc
-@@ -540,6 +540,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
-     } else {
-       iter_.Next();
-     }
-+    // This could be a long-running operation due to tombstones, etc.
-+    ROCKSDB_THREAD_YIELD_HOOK();
-   } while (iter_.Valid());
- 
-   valid_ = false;
-diff --git a/db/table_cache.cc b/db/table_cache.cc
-index 71fc29c32..8a5be75e8 100644
---- a/db/table_cache.cc
-+++ b/db/table_cache.cc
-@@ -164,6 +164,7 @@ Status TableCache::GetTableReader(
- }
- 
- Cache::Handle* TableCache::Lookup(Cache* cache, uint64_t file_number) {
-+  // NOTE: sharing same Cache with BlobFileCache
-   Slice key = GetSliceForFileNumber(&file_number);
-   return cache->Lookup(key);
- }
-@@ -179,6 +180,7 @@ Status TableCache::FindTable(
-     size_t max_file_size_for_l0_meta_pin, Temperature file_temperature) {
-   PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos, ioptions_.clock);
-   uint64_t number = file_meta.fd.GetNumber();
-+  // NOTE: sharing same Cache with BlobFileCache
-   Slice key = GetSliceForFileNumber(&number);
-   *handle = cache_.Lookup(key);
-   TEST_SYNC_POINT_CALLBACK("TableCache::FindTable:0",
-diff --git a/db/version_builder.cc b/db/version_builder.cc
-index ed8ab8214..c98f53f42 100644
---- a/db/version_builder.cc
-+++ b/db/version_builder.cc
-@@ -24,6 +24,7 @@
- #include <vector>
- 
- #include "cache/cache_reservation_manager.h"
-+#include "db/blob/blob_file_cache.h"
- #include "db/blob/blob_file_meta.h"
- #include "db/dbformat.h"
- #include "db/internal_stats.h"
-@@ -744,12 +745,9 @@ class VersionBuilder::Rep {
-       return Status::Corruption("VersionBuilder", oss.str());
-     }
- 
--    // Note: we use C++11 for now but in C++14, this could be done in a more
--    // elegant way using generalized lambda capture.
--    VersionSet* const vs = version_set_;
--    const ImmutableCFOptions* const ioptions = ioptions_;
--
--    auto deleter = [vs, ioptions](SharedBlobFileMetaData* shared_meta) {
-+    auto deleter = [vs = version_set_, ioptions = ioptions_,
-+                    bc = cfd_ ? cfd_->blob_file_cache()
-+                              : nullptr](SharedBlobFileMetaData* shared_meta) {
-       if (vs) {
-         assert(ioptions);
-         assert(!ioptions->cf_paths.empty());
-@@ -758,6 +756,9 @@ class VersionBuilder::Rep {
-         vs->AddObsoleteBlobFile(shared_meta->GetBlobFileNumber(),
-                                 ioptions->cf_paths.front().path);
-       }
-+      if (bc) {
-+        bc->Evict(shared_meta->GetBlobFileNumber());
-+      }
- 
-       delete shared_meta;
-     };
-@@ -766,7 +767,7 @@ class VersionBuilder::Rep {
-         blob_file_number, blob_file_addition.GetTotalBlobCount(),
-         blob_file_addition.GetTotalBlobBytes(),
-         blob_file_addition.GetChecksumMethod(),
--        blob_file_addition.GetChecksumValue(), deleter);
-+        blob_file_addition.GetChecksumValue(), std::move(deleter));
- 
-     mutable_blob_file_metas_.emplace(
-         blob_file_number, MutableBlobFileMetaData(std::move(shared_meta)));
-diff --git a/db/version_set.h b/db/version_set.h
-index 9336782b1..024f869e7 100644
---- a/db/version_set.h
-+++ b/db/version_set.h
-@@ -1514,7 +1514,6 @@ class VersionSet {
-   void GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata);
- 
-   void AddObsoleteBlobFile(uint64_t blob_file_number, std::string path) {
--    // TODO: Erase file from BlobFileCache?
-     obsolete_blob_files_.emplace_back(blob_file_number, std::move(path));
-   }
- 
-diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h
-index 2a19796b8..0afa2cab1 100644
---- a/include/rocksdb/version.h
-+++ b/include/rocksdb/version.h
-@@ -13,7 +13,7 @@
- // minor or major version number planned for release.
- #define ROCKSDB_MAJOR 9
- #define ROCKSDB_MINOR 7
--#define ROCKSDB_PATCH 3
-+#define ROCKSDB_PATCH 4
- 
- // Do not use these. We made the mistake of declaring macros starting with
- // double underscore. Now we have to live with our choice. We'll deprecate these
-diff --git a/port/port.h b/port/port.h
-index 13aa56d47..141716e5b 100644
---- a/port/port.h
-+++ b/port/port.h
-@@ -19,3 +19,19 @@
- #elif defined(OS_WIN)
- #include "port/win/port_win.h"
- #endif
-+
-+#ifdef OS_LINUX
-+// A temporary hook into long-running RocksDB threads to support modifying their
-+// priority etc. This should become a public API hook once the requirements
-+// are better understood.
-+extern "C" void RocksDbThreadYield() __attribute__((__weak__));
-+#define ROCKSDB_THREAD_YIELD_HOOK() \
-+  {                                 \
-+    if (RocksDbThreadYield) {       \
-+      RocksDbThreadYield();         \
-+    }                               \
-+  }
-+#else
-+#define ROCKSDB_THREAD_YIELD_HOOK() \
-+  {}
-+#endif

external/rocksdb/patches/9.x.x-0001-exclude-thirdparty.patch

@@ -1,30 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 93b884d..b715cb6 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -106,14 +106,9 @@ endif()
- include(CMakeDependentOption)
-
- if(MSVC)
--  option(WITH_GFLAGS "build with GFlags" OFF)
-   option(WITH_XPRESS "build with windows built in compression" OFF)
--  option(ROCKSDB_SKIP_THIRDPARTY "skip thirdparty.inc" OFF)
--
--  if(NOT ROCKSDB_SKIP_THIRDPARTY)
--    include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
--  endif()
--else()
-+endif()
-+if(TRUE)
-   if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD" AND NOT CMAKE_SYSTEM_NAME MATCHES "kFreeBSD")
-     # FreeBSD has jemalloc as default malloc
-     # but it does not have all the jemalloc files in include/...
-@@ -126,7 +121,7 @@ else()
-     endif()
-   endif()
-
--  if(MINGW)
-+  if(MSVC OR MINGW)
-     option(WITH_GFLAGS "build with GFlags" OFF)
-   else()
-     option(WITH_GFLAGS "build with GFlags" ON)

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,8 +152,6 @@
 #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)
@@ -165,10 +160,6 @@
 #define sfGovernanceMarks ((5U << 16U) + 98U)
 #define sfGovernanceFlags ((5U << 16U) + 99U)
 #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,8 +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 sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -328,9 +315,6 @@
 #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)

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,9 +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

@@ -24,7 +24,9 @@
 
 #include <boost/outcome.hpp>
 
+#include <concepts>
 #include <stdexcept>
+#include <type_traits>
 
 namespace ripple {
 
@@ -93,7 +95,7 @@ public:
     {
     }
 
-    constexpr E const&
+    constexpr const E&
     value() const&
     {
         return val_;
@@ -111,7 +113,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr E const&&
+    constexpr const E&&
     value() const&&
     {
         return std::move(val_);

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/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/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/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/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,9 +21,7 @@
 #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>
@@ -76,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;
     }
@@ -144,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/container/detail/aged_ordered_container.h

@@ -25,11 +25,9 @@
 #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/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,7 +23,6 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <boost/core/detail/string_view.hpp>
-
 #include <algorithm>
 #include <cerrno>
 #include <charconv>

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,7 +23,6 @@
 
 #include <boost/container/flat_set.hpp>
 #include <boost/endian/conversion.hpp>
-
 #include <array>
 #include <chrono>
 #include <cstdint>

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,10 +25,8 @@
 #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/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,9 +21,7 @@
 #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/xrpl/beast/net/IPAddressV6.h

@@ -21,9 +21,7 @@
 #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/xrpl/beast/net/IPEndpoint.h

@@ -215,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
@@ -230,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>
@@ -28,7 +32,6 @@
 
 #include <algorithm>
 #include <cctype>
-#include <cstdint>
 #include <iterator>
 #include <string>
 #include <utility>

include/xrpl/beast/test/yield_to.h

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

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,10 +10,8 @@
 
 #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/xrpl/beast/unit_test/runner.h

@@ -9,9 +9,7 @@
 #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>

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

include/xrpl/beast/utility/Journal.h

@@ -21,7 +21,6 @@
 #define BEAST_UTILITY_JOURNAL_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <sstream>
 
 namespace beast {
@@ -157,7 +156,7 @@ public:
         ScopedStream(Sink& sink, Severity level);
 
 #ifdef BEAST_ENHANCED_LOGGING
-        ScopedStream(Sink& sink, Severity level, char const* file, int line);
+        ScopedStream(Sink& sink, Severity level, const char* file, int line);
 #endif
 
         template <typename T>
@@ -188,7 +187,7 @@ public:
         Severity const m_level;
         std::ostringstream mutable m_ostream;
 #ifdef BEAST_ENHANCED_LOGGING
-        char const* file_ = nullptr;
+        const char* file_ = nullptr;
         int line_ = 0;
 #endif
     };
@@ -216,7 +215,7 @@ public:
     class StreamWithLocation
     {
     public:
-        StreamWithLocation(Stream const& stream, char const* file, int line)
+        StreamWithLocation(Stream const& stream, const char* file, int line)
             : file_(file), line_(line), stream_(stream)
         {
         }
@@ -230,9 +229,9 @@ public:
         operator<<(std::ostream& manip(std::ostream&)) const;
 
     private:
-        char const* file_;
+        const char* file_;
         int line_;
-        Stream const& stream_;
+        const Stream& stream_;
     };
 #endif
 
@@ -306,7 +305,7 @@ public:
 #ifdef BEAST_ENHANCED_LOGGING
         /** Create a StreamWithLocation that prepends file:line info */
         StreamWithLocation
-        withLocation(char const* file, int line) const
+        withLocation(const char* file, int line) const
         {
             return StreamWithLocation(*this, file, line);
         }

include/xrpl/beast/utility/PropertyStream.h

@@ -22,9 +22,11 @@
 
 #include <xrpl/beast/core/List.h>
 
+#include <cstdint>
 #include <mutex>
 #include <sstream>
 #include <string>
+#include <utility>
 
 namespace beast {
 

include/xrpl/beast/utility/rngfill.h

@@ -21,7 +21,6 @@
 #define BEAST_RANDOM_RNGFILL_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <array>
 #include <cstdint>
 #include <cstring>

include/xrpl/beast/utility/temp_dir.h

@@ -21,7 +21,6 @@
 #define BEAST_UTILITY_TEMP_DIR_H_INCLUDED
 
 #include <boost/filesystem.hpp>
-
 #include <string>
 
 namespace beast {
@@ -37,9 +36,9 @@ class temp_dir
 
 public:
 #if !GENERATING_DOCS
-    temp_dir(temp_dir const&) = delete;
+    temp_dir(const temp_dir&) = delete;
     temp_dir&
-    operator=(temp_dir const&) = delete;
+    operator=(const temp_dir&) = delete;
 #endif
 
     /// Construct a temporary directory.

include/xrpl/crypto/csprng.h

@@ -21,6 +21,8 @@
 #define RIPPLE_CRYPTO_RANDOM_H_INCLUDED
 
 #include <mutex>
+#include <string>
+#include <type_traits>
 
 namespace ripple {
 

include/xrpl/hook/Enum.h

@@ -20,7 +20,7 @@ namespace hook_api {
 struct Rules
 {
     constexpr bool
-    enabled(uint256 const& feature) const
+    enabled(const uint256& feature) const
     {
         return true;
     }
@@ -393,12 +393,12 @@ enum ExitType : uint8_t {
     ACCEPT = 3,
 };
 
-uint16_t const max_state_modifications = 256;
-uint8_t const max_slots = 255;
-uint8_t const max_nonce = 255;
-uint8_t const max_emit = 255;
-uint8_t const max_params = 16;
-double const fee_base_multiplier = 1.1f;
+const uint16_t max_state_modifications = 256;
+const uint8_t max_slots = 255;
+const uint8_t max_nonce = 255;
+const uint8_t max_emit = 255;
+const uint8_t max_params = 16;
+const double fee_base_multiplier = 1.1f;
 
 using APIWhitelist = std::map<std::string, std::vector<uint8_t>>;
 

include/xrpl/hook/Guard.h

@@ -1,5 +1,4 @@
 #include "Enum.h"
-
 #include <functional>
 #include <iostream>
 #include <map>
@@ -205,7 +204,7 @@ struct WasmBlkInf
     }
 // compute worst case execution time
 inline uint64_t
-compute_wce(WasmBlkInf const* blk, int level, bool* recursion_limit_reached)
+compute_wce(const WasmBlkInf* blk, int level, bool* recursion_limit_reached)
 {
     if (level > 16)
     {
@@ -972,7 +971,7 @@ validateGuards(
                 }
 
                 if (std::string_view(
-                        (char const*)(wasm.data() + i), (size_t)mod_length) !=
+                        (const char*)(wasm.data() + i), (size_t)mod_length) !=
                     "env")
                 {
                     GUARDLOG(hook::log::IMPORT_MODULE_ENV)
@@ -1000,7 +999,7 @@ validateGuards(
                 }
 
                 std::string import_name{
-                    (char const*)(wasm.data() + i), (size_t)name_length};
+                    (const char*)(wasm.data() + i), (size_t)name_length};
 
                 i += name_length;
                 CHECK_SHORT_HOOK();

include/xrpl/hook/Misc.h

@@ -6,7 +6,7 @@ namespace ripple {
 // RH TODO: there's definitely a mucher nicer way to do this, but it involves
 // modifying the base_uint class and we don't want to do that yet.
 
-static std::array<ripple::uint256, 256> const UINT256_BIT = {
+static const std::array<ripple::uint256, 256> UINT256_BIT = {
     ripple::uint256(
         "0000000000000000000000000000000000000000000000000000000000000001"),
     ripple::uint256(

include/xrpl/hook/guard_checker.cpp

@@ -2,21 +2,22 @@
 #include "Enum.h"
 #include "Guard.h"
 #include <fcntl.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
 #include <iostream>
 #include <optional>
 #include <ostream>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
 #include <string_view>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include <vector>
 
 int
 main(int argc, char** argv)
 {
-    char const* fin = 0;
+    const char* fin = 0;
 
     if (argc > 2)
         return fprintf(

include/xrpl/hook/xahau.h

@@ -2,7 +2,7 @@
 #define XAHAU_GENESIS_HOOKS
 #include <vector>
 
-static std::vector<uint8_t> const GovernanceHook = {
+static const std::vector<uint8_t> GovernanceHook = {
     0x00U, 0x61U, 0x73U, 0x6DU, 0x01U, 0x00U, 0x00U, 0x00U, 0x01U, 0x42U, 0x09U,
     0x60U, 0x02U, 0x7FU, 0x7FU, 0x01U, 0x7FU, 0x60U, 0x01U, 0x7FU, 0x01U, 0x7EU,
     0x60U, 0x04U, 0x7FU, 0x7FU, 0x7FU, 0x7FU, 0x01U, 0x7EU, 0x60U, 0x03U, 0x7FU,
@@ -813,7 +813,7 @@ static std::vector<uint8_t> const GovernanceHook = {
     0xB5U, 0xF7U, 0x62U, 0x79U, 0x8AU, 0x53U, 0xD5U, 0x43U, 0xA0U, 0x14U, 0xCAU,
     0xF8U, 0xB2U, 0x97U, 0xCFU, 0xF8U, 0xF2U, 0xF9U, 0x37U, 0xE8U};
 
-static std::vector<uint8_t> const RewardHook = {
+static const std::vector<uint8_t> RewardHook = {
     0x00U, 0x61U, 0x73U, 0x6DU, 0x01U, 0x00U, 0x00U, 0x00U, 0x01U, 0x61U, 0x0EU,
     0x60U, 0x01U, 0x7FU, 0x01U, 0x7EU, 0x60U, 0x02U, 0x7FU, 0x7FU, 0x01U, 0x7FU,
     0x60U, 0x00U, 0x01U, 0x7EU, 0x60U, 0x03U, 0x7FU, 0x7FU, 0x7EU, 0x01U, 0x7EU,

include/xrpl/json/Object.h

@@ -21,7 +21,6 @@
 #define RIPPLE_JSON_OBJECT_H_INCLUDED
 
 #include <xrpl/json/Writer.h>
-
 #include <memory>
 
 namespace Json {

include/xrpl/json/Output.h

@@ -21,7 +21,6 @@
 #define RIPPLE_JSON_OUTPUT_H_INCLUDED
 
 #include <boost/beast/core/string.hpp>
-
 #include <functional>
 #include <string>
 

include/xrpl/json/Writer.h

@@ -24,7 +24,6 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/json/Output.h>
 #include <xrpl/json/json_value.h>
-
 #include <memory>
 
 namespace Json {

include/xrpl/json/detail/json_assert.h

@@ -20,7 +20,6 @@
 #ifndef RIPPLE_JSON_JSON_ASSERT_H_INCLUDED
 #define RIPPLE_JSON_JSON_ASSERT_H_INCLUDED
 
-#include <xrpl/basics/contract.h>
 #include <xrpl/json/json_errors.h>
 
 #define JSON_ASSERT_MESSAGE(condition, message) \

include/xrpl/json/json_reader.h

@@ -24,9 +24,7 @@
 
 #include <xrpl/json/json_forwards.h>
 #include <xrpl/json/json_value.h>
-
 #include <boost/asio/buffer.hpp>
-
 #include <stack>
 
 namespace Json {
@@ -39,7 +37,7 @@ class Reader
 {
 public:
     using Char = char;
-    using Location = Char const*;
+    using Location = const Char*;
 
     /** \brief Constructs a Reader allowing all features
      * for parsing.
@@ -64,7 +62,7 @@ public:
      * error occurred.
      */
     bool
-    parse(char const* beginDoc, char const* endDoc, Value& root);
+    parse(const char* beginDoc, const char* endDoc, Value& root);
 
     /// \brief Parse from input stream.
     /// \see Json::operator>>(std::istream&, Json::Value&).
@@ -133,7 +131,7 @@ private:
     using Errors = std::deque<ErrorInfo>;
 
     bool
-    expectToken(TokenType type, Token& token, char const* message);
+    expectToken(TokenType type, Token& token, const char* message);
     bool
     readToken(Token& token);
     void

include/xrpl/json/json_value.h

@@ -20,13 +20,10 @@
 #ifndef RIPPLE_JSON_JSON_VALUE_H_INCLUDED
 #define RIPPLE_JSON_JSON_VALUE_H_INCLUDED
 
-#include <xrpl/basics/Number.h>
 #include <xrpl/json/json_forwards.h>
-
 #include <cstring>
 #include <map>
 #include <string>
-#include <utility>
 #include <vector>
 
 /** \brief JSON (JavaScript Object Notation).
@@ -63,24 +60,24 @@ enum ValueType {
 class StaticString
 {
 public:
-    constexpr explicit StaticString(char const* czstring) : str_(czstring)
+    constexpr explicit StaticString(const char* czstring) : str_(czstring)
     {
     }
 
     constexpr
-    operator char const*() const
+    operator const char*() const
     {
         return str_;
     }
 
-    constexpr char const*
+    constexpr const char*
     c_str() const
     {
         return str_;
     }
 
 private:
-    char const* str_;
+    const char* str_;
 };
 
 inline bool
@@ -158,10 +155,10 @@ public:
     using Int = Json::Int;
     using ArrayIndex = UInt;
 
-    static Value const null;
-    static Int const minInt;
-    static Int const maxInt;
-    static UInt const maxUInt;
+    static const Value null;
+    static const Int minInt;
+    static const Int maxInt;
+    static const UInt maxUInt;
 
 private:
     class CZString
@@ -173,24 +170,24 @@ private:
             duplicateOnCopy
         };
         CZString(int index);
-        CZString(char const* cstr, DuplicationPolicy allocate);
-        CZString(CZString const& other);
+        CZString(const char* cstr, DuplicationPolicy allocate);
+        CZString(const CZString& other);
         ~CZString();
         CZString&
-        operator=(CZString const& other) = delete;
+        operator=(const CZString& other) = delete;
         bool
-        operator<(CZString const& other) const;
+        operator<(const CZString& other) const;
         bool
-        operator==(CZString const& other) const;
+        operator==(const CZString& other) const;
         int
         index() const;
-        char const*
+        const char*
         c_str() const;
         bool
         isStaticString() const;
 
     private:
-        char const* cstr_;
+        const char* cstr_;
         int index_;
     };
 
@@ -217,8 +214,7 @@ public:
     Value(Int value);
     Value(UInt value);
     Value(double value);
-    Value(char const* value);
-    Value(ripple::Number const& value);
+    Value(const char* value);
     /** \brief Constructs a value from a static string.
 
      * Like other value string constructor but do not duplicate the string for
@@ -230,10 +226,10 @@ public:
      * Json::Value aValue( StaticString("some text") );
      * \endcode
      */
-    Value(StaticString const& value);
+    Value(const StaticString& value);
     Value(std::string const& value);
     Value(bool value);
-    Value(Value const& other);
+    Value(const Value& other);
     ~Value();
 
     Value&
@@ -250,7 +246,7 @@ public:
     ValueType
     type() const;
 
-    char const*
+    const char*
     asCString() const;
     /** Returns the unquoted string value. */
     std::string
@@ -320,12 +316,12 @@ public:
     /// Access an array element (zero based index )
     /// (You may need to say 'value[0u]' to get your compiler to distinguish
     ///  this from the operator[] which takes a string.)
-    Value const&
+    const Value&
     operator[](UInt index) const;
     /// If the array contains at least index+1 elements, returns the element
     /// value, otherwise returns defaultValue.
     Value
-    get(UInt index, Value const& defaultValue) const;
+    get(UInt index, const Value& defaultValue) const;
     /// Return true if index < size().
     bool
     isValidIndex(UInt index) const;
@@ -333,25 +329,25 @@ public:
     ///
     /// Equivalent to jsonvalue[jsonvalue.size()] = value;
     Value&
-    append(Value const& value);
+    append(const Value& value);
     Value&
     append(Value&& value);
 
     /// Access an object value by name, create a null member if it does not
     /// exist.
     Value&
-    operator[](char const* key);
+    operator[](const char* key);
     /// Access an object value by name, returns null if there is no member with
     /// that name.
-    Value const&
-    operator[](char const* key) const;
+    const Value&
+    operator[](const char* key) const;
     /// Access an object value by name, create a null member if it does not
     /// exist.
     Value&
     operator[](std::string const& key);
     /// Access an object value by name, returns null if there is no member with
     /// that name.
-    Value const&
+    const Value&
     operator[](std::string const& key) const;
     /** \brief Access an object value by name, create a null member if it does
      not exist.
@@ -367,16 +363,14 @@ public:
      * \endcode
      */
     Value&
-    operator[](StaticString const& key);
-    Value const&
-    operator[](StaticString const& key) const;
+    operator[](const StaticString& key);
 
     /// Return the member named key if it exist, defaultValue otherwise.
     Value
-    get(char const* key, Value const& defaultValue) const;
+    get(const char* key, const Value& defaultValue) const;
     /// Return the member named key if it exist, defaultValue otherwise.
     Value
-    get(std::string const& key, Value const& defaultValue) const;
+    get(std::string const& key, const Value& defaultValue) const;
 
     /// \brief Remove and return the named member.
     ///
@@ -385,14 +379,14 @@ public:
     /// \pre type() is objectValue or nullValue
     /// \post type() is unchanged
     Value
-    removeMember(char const* key);
+    removeMember(const char* key);
     /// Same as removeMember(const char*)
     Value
     removeMember(std::string const& key);
 
     /// Return true if the object has a member named key.
     bool
-    isMember(char const* key) const;
+    isMember(const char* key) const;
     /// Return true if the object has a member named key.
     bool
     isMember(std::string const& key) const;
@@ -419,13 +413,13 @@ public:
     end();
 
     friend bool
-    operator==(Value const&, Value const&);
+    operator==(const Value&, const Value&);
     friend bool
-    operator<(Value const&, Value const&);
+    operator<(const Value&, const Value&);
 
 private:
     Value&
-    resolveReference(char const* key, bool isStatic);
+    resolveReference(const char* key, bool isStatic);
 
 private:
     union ValueHolder
@@ -441,38 +435,32 @@ private:
     int allocated_ : 1;  // Notes: if declared as bool, bitfield is useless.
 };
 
-inline Value
-to_json(ripple::Number const& number)
-{
-    return to_string(number);
-}
-
 bool
-operator==(Value const&, Value const&);
+operator==(const Value&, const Value&);
 
 inline bool
-operator!=(Value const& x, Value const& y)
+operator!=(const Value& x, const Value& y)
 {
     return !(x == y);
 }
 
 bool
-operator<(Value const&, Value const&);
+operator<(const Value&, const Value&);
 
 inline bool
-operator<=(Value const& x, Value const& y)
+operator<=(const Value& x, const Value& y)
 {
     return !(y < x);
 }
 
 inline bool
-operator>(Value const& x, Value const& y)
+operator>(const Value& x, const Value& y)
 {
     return y < x;
 }
 
 inline bool
-operator>=(Value const& x, Value const& y)
+operator>=(const Value& x, const Value& y)
 {
     return !(x < y);
 }
@@ -493,11 +481,11 @@ public:
     virtual ~ValueAllocator() = default;
 
     virtual char*
-    makeMemberName(char const* memberName) = 0;
+    makeMemberName(const char* memberName) = 0;
     virtual void
     releaseMemberName(char* memberName) = 0;
     virtual char*
-    duplicateStringValue(char const* value, unsigned int length = unknown) = 0;
+    duplicateStringValue(const char* value, unsigned int length = unknown) = 0;
     virtual void
     releaseStringValue(char* value) = 0;
 };
@@ -514,16 +502,16 @@ public:
 
     ValueIteratorBase();
 
-    explicit ValueIteratorBase(Value::ObjectValues::iterator const& current);
+    explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);
 
     bool
-    operator==(SelfType const& other) const
+    operator==(const SelfType& other) const
     {
         return isEqual(other);
     }
 
     bool
-    operator!=(SelfType const& other) const
+    operator!=(const SelfType& other) const
     {
         return !isEqual(other);
     }
@@ -539,7 +527,7 @@ public:
 
     /// Return the member name of the referenced Value. "" if it is not an
     /// objectValue.
-    char const*
+    const char*
     memberName() const;
 
 protected:
@@ -553,13 +541,13 @@ protected:
     decrement();
 
     difference_type
-    computeDistance(SelfType const& other) const;
+    computeDistance(const SelfType& other) const;
 
     bool
-    isEqual(SelfType const& other) const;
+    isEqual(const SelfType& other) const;
 
     void
-    copy(SelfType const& other);
+    copy(const SelfType& other);
 
 private:
     Value::ObjectValues::iterator current_;
@@ -577,8 +565,8 @@ class ValueConstIterator : public ValueIteratorBase
 public:
     using size_t = unsigned int;
     using difference_type = int;
-    using reference = Value const&;
-    using pointer = Value const*;
+    using reference = const Value&;
+    using pointer = const Value*;
     using SelfType = ValueConstIterator;
 
     ValueConstIterator() = default;
@@ -586,11 +574,11 @@ public:
 private:
     /*! \internal Use by Value to create an iterator.
      */
-    explicit ValueConstIterator(Value::ObjectValues::iterator const& current);
+    explicit ValueConstIterator(const Value::ObjectValues::iterator& current);
 
 public:
     SelfType&
-    operator=(ValueIteratorBase const& other);
+    operator=(const ValueIteratorBase& other);
 
     SelfType
     operator++(int)
@@ -643,17 +631,17 @@ public:
     using SelfType = ValueIterator;
 
     ValueIterator() = default;
-    ValueIterator(ValueConstIterator const& other);
-    ValueIterator(ValueIterator const& other);
+    ValueIterator(const ValueConstIterator& other);
+    ValueIterator(const ValueIterator& other);
 
 private:
     /*! \internal Use by Value to create an iterator.
      */
-    explicit ValueIterator(Value::ObjectValues::iterator const& current);
+    explicit ValueIterator(const Value::ObjectValues::iterator& current);
 
 public:
     SelfType&
-    operator=(SelfType const& other);
+    operator=(const SelfType& other);
 
     SelfType
     operator++(int)

include/xrpl/json/json_writer.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/json/json_forwards.h>
 #include <xrpl/json/json_value.h>
-
 #include <ostream>
 #include <vector>
 
@@ -39,7 +38,7 @@ public:
     {
     }
     virtual std::string
-    write(Value const& root) = 0;
+    write(const Value& root) = 0;
 };
 
 /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format
@@ -60,11 +59,11 @@ public:
 
 public:  // overridden from Writer
     std::string
-    write(Value const& root) override;
+    write(const Value& root) override;
 
 private:
     void
-    writeValue(Value const& value);
+    writeValue(const Value& value);
 
     std::string document_;
 };
@@ -101,15 +100,15 @@ public:  // overridden from Writer
      * JSON document that represents the root value.
      */
     std::string
-    write(Value const& root) override;
+    write(const Value& root) override;
 
 private:
     void
-    writeValue(Value const& value);
+    writeValue(const Value& value);
     void
-    writeArrayValue(Value const& value);
+    writeArrayValue(const Value& value);
     bool
-    isMultineArray(Value const& value);
+    isMultineArray(const Value& value);
     void
     pushValue(std::string const& value);
     void
@@ -168,15 +167,15 @@ public:
      * return a value.
      */
     void
-    write(std::ostream& out, Value const& root);
+    write(std::ostream& out, const Value& root);
 
 private:
     void
-    writeValue(Value const& value);
+    writeValue(const Value& value);
     void
-    writeArrayValue(Value const& value);
+    writeArrayValue(const Value& value);
     bool
-    isMultineArray(Value const& value);
+    isMultineArray(const Value& value);
     void
     pushValue(std::string const& value);
     void
@@ -207,12 +206,12 @@ valueToString(double value);
 std::string
 valueToString(bool value);
 std::string
-valueToQuotedString(char const* value);
+valueToQuotedString(const char* value);
 
 /// \brief Output using the StyledStreamWriter.
 /// \see Json::operator>>()
 std::ostream&
-operator<<(std::ostream&, Value const& root);
+operator<<(std::ostream&, const Value& root);
 
 //------------------------------------------------------------------------------
 

include/xrpl/json/to_string.h

@@ -37,7 +37,7 @@ pretty(Value const&);
 
 /** Output using the StyledStreamWriter. @see Json::operator>>(). */
 std::ostream&
-operator<<(std::ostream&, Value const& root);
+operator<<(std::ostream&, const Value& root);
 
 }  // namespace Json
 

include/xrpl/protocol/AMMCore.h

@@ -48,6 +48,14 @@ class STObject;
 class STAmount;
 class Rules;
 
+/** Calculate AMM account ID.
+ */
+AccountID
+ammAccountID(
+    std::uint16_t prefix,
+    uint256 const& parentHash,
+    uint256 const& ammID);
+
 /** Calculate Liquidity Provider Token (LPT) Currency.
  */
 Currency

include/xrpl/protocol/AccountID.h

@@ -149,7 +149,7 @@ namespace std {
 template <>
 struct hash<ripple::AccountID> : ripple::AccountID::hasher
 {
-    hash() = default;
+    explicit hash() = default;
 };
 
 }  // namespace std

include/xrpl/protocol/Asset.h

@@ -20,7 +20,6 @@
 #ifndef RIPPLE_PROTOCOL_ASSET_H_INCLUDED
 #define RIPPLE_PROTOCOL_ASSET_H_INCLUDED
 
-#include <xrpl/basics/Number.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/MPTIssue.h>
@@ -28,7 +27,6 @@
 namespace ripple {
 
 class Asset;
-class STAmount;
 
 template <typename TIss>
 concept ValidIssueType =
@@ -94,9 +92,6 @@ public:
     void
     setJson(Json::Value& jv) const;
 
-    STAmount
-    operator()(Number const&) const;
-
     bool
     native() const
     {
@@ -119,14 +114,6 @@ public:
     equalTokens(Asset const& lhs, Asset const& rhs);
 };
 
-inline Json::Value
-to_json(Asset const& asset)
-{
-    Json::Value jv;
-    asset.setJson(jv);
-    return jv;
-}
-
 template <ValidIssueType TIss>
 constexpr bool
 Asset::holds() const
@@ -232,6 +219,9 @@ validJSONAsset(Json::Value const& jv);
 Asset
 assetFromJson(Json::Value const& jv);
 
+Json::Value
+to_json(Asset const& asset);
+
 }  // namespace ripple
 
 #endif  // RIPPLE_PROTOCOL_ASSET_H_INCLUDED

include/xrpl/protocol/Batch.h

@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2024 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.
-*/
-//==============================================================================
-
-#include <xrpl/protocol/HashPrefix.h>
-#include <xrpl/protocol/STVector256.h>
-#include <xrpl/protocol/Serializer.h>
-
-namespace ripple {
-
-inline void
-serializeBatch(
-    Serializer& msg,
-    std::uint32_t const& flags,
-    std::vector<uint256> const& txids)
-{
-    msg.add32(HashPrefix::batch);
-    msg.add32(flags);
-    msg.add32(std::uint32_t(txids.size()));
-    for (auto const& txid : txids)
-        msg.addBitString(txid);
-}
-
-}  // namespace ripple

include/xrpl/protocol/Book.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/protocol/Issue.h>
-
 #include <boost/utility/base_from_member.hpp>
 
 namespace ripple {
@@ -104,7 +103,7 @@ private:
         boost::base_from_member<std::hash<ripple::AccountID>, 1>;
 
 public:
-    hash() = default;
+    explicit hash() = default;
 
     using value_type = std::size_t;
     using argument_type = ripple::Issue;
@@ -131,7 +130,7 @@ private:
     hasher m_hasher;
 
 public:
-    hash() = default;
+    explicit hash() = default;
 
     using value_type = std::size_t;
     using argument_type = ripple::Book;
@@ -154,7 +153,7 @@ namespace boost {
 template <>
 struct hash<ripple::Issue> : std::hash<ripple::Issue>
 {
-    hash() = default;
+    explicit hash() = default;
 
     using Base = std::hash<ripple::Issue>;
     // VFALCO NOTE broken in vs2012
@@ -164,7 +163,7 @@ struct hash<ripple::Issue> : std::hash<ripple::Issue>
 template <>
 struct hash<ripple::Book> : std::hash<ripple::Book>
 {
-    hash() = default;
+    explicit hash() = default;
 
     using Base = std::hash<ripple::Book>;
     // VFALCO NOTE broken in vs2012

include/xrpl/protocol/ErrorCodes.h

@@ -121,7 +121,7 @@ enum error_code_i {
     rpcSRC_ACT_MALFORMED = 65,
     rpcSRC_ACT_MISSING = 66,
     rpcSRC_ACT_NOT_FOUND = 67,
-    rpcDELEGATE_ACT_NOT_FOUND = 68,
+    // unused                  68,
     rpcSRC_CUR_MALFORMED = 69,
     rpcSRC_ISR_MALFORMED = 70,
     rpcSTREAM_MALFORMED = 71,

include/xrpl/protocol/Feature.h

@@ -21,9 +21,7 @@
 #define RIPPLE_PROTOCOL_FEATURE_H_INCLUDED
 
 #include <xrpl/basics/base_uint.h>
-
 #include <boost/container/flat_map.hpp>
-
 #include <array>
 #include <bitset>
 #include <map>
@@ -35,39 +33,35 @@
  *
  * Steps required to add new features to the code:
  *
- * 1) Add the appropriate XRPL_FEATURE or XRPL_FIX macro definition for the
- *    feature to features.macro with the feature's name, `Supported::no`, and
- *    `VoteBehavior::DefaultNo`.
- *
- * 2) Use the generated variable name as the parameter to `view.rules.enabled()`
- *    to control flow into new code that this feature limits. (featureName or
- *    fixName)
- *
- * 3) If the feature development is COMPLETE, and the feature is ready to be
- *    SUPPORTED, change the macro parameter in features.macro to Supported::yes.
- *
- * 4) In general, any newly supported amendments (`Supported::yes`) should have
- *    a `VoteBehavior::DefaultNo` indefinitely so that external governance can
- *    make the decision on when to activate it. High priority bug fixes can be
- *    an exception to this rule. In such cases, ensure the fix has been
- *    clearly communicated to the community using appropriate channels,
- *    then change the macro parameter in features.macro to
- *    `VoteBehavior::DefaultYes`. The communication process is beyond
- *    the scope of these instructions.
- *
+ * 1) In this file, increment `numFeatures` and add a uint256 declaration
+ *    for the feature at the bottom
+ * 2) Add a uint256 definition for the feature to the corresponding source
+ *    file (Feature.cpp). Use `registerFeature` to create the feature with
+ *    the feature's name, `Supported::no`, and `VoteBehavior::DefaultNo`. This
+ *    should be the only place the feature's name appears in code as a string.
+ * 3) Use the uint256 as the parameter to `view.rules.enabled()` to
+ *    control flow into new code that this feature limits.
+ * 4) If the feature development is COMPLETE, and the feature is ready to be
+ *    SUPPORTED, change the `registerFeature` parameter to Supported::yes.
+ * 5) When the feature is ready to be ENABLED, change the `registerFeature`
+ *    parameter to `VoteBehavior::DefaultYes`.
+ * In general, any newly supported amendments (`Supported::yes`) should have
+ * a `VoteBehavior::DefaultNo` for at least one full release cycle. High
+ * priority bug fixes can be an exception to this rule of thumb.
  *
  * When a feature has been enabled for several years, the conditional code
  * may be removed, and the feature "retired". To retire a feature:
- *
- * 1) MOVE the macro definition in features.macro to the "retired features"
- *    section at the end of the file, and change the macro to XRPL_RETIRE.
- *
+ * 1) Remove the uint256 declaration from this file.
+ * 2) MOVE the uint256 definition in Feature.cpp to the "retired features"
+ *    section at the end of the file.
+ * 3) CHANGE the name of the variable to start with "retired".
+ * 4) CHANGE the parameters of the `registerFeature` call to `Supported::yes`
+ *    and `VoteBehavior::DefaultNo`.
  * The feature must remain registered and supported indefinitely because it
- * may exist in the Amendments object on ledger. There is no need to vote
- * for it because there's nothing to vote for. If the feature definition is
- * removed completely from the code, any instances running that code will get
- * amendment blocked. Removing the feature from the ledger is beyond the scope
- * of these instructions.
+ * still exists in the ledger, but there is no need to vote for it because
+ * there's nothing to vote for. If it is removed completely from the code, any
+ * instances running that code will get amendment blocked. Removing the
+ * feature from the ledger is beyond the scope of these instructions.
  *
  */
 
@@ -82,32 +76,11 @@ allAmendments();
 
 namespace detail {
 
-#pragma push_macro("XRPL_FEATURE")
-#undef XRPL_FEATURE
-#pragma push_macro("XRPL_FIX")
-#undef XRPL_FIX
-#pragma push_macro("XRPL_RETIRE")
-#undef XRPL_RETIRE
-
-#define XRPL_FEATURE(name, supported, vote) +1
-#define XRPL_FIX(name, supported, vote) +1
-#define XRPL_RETIRE(name) +1
-
 // This value SHOULD be equal to the number of amendments registered in
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures =
-    (0 +
-#include <xrpl/protocol/detail/features.macro>
-    );
-
-#undef XRPL_RETIRE
-#pragma pop_macro("XRPL_RETIRE")
-#undef XRPL_FIX
-#pragma pop_macro("XRPL_FIX")
-#undef XRPL_FEATURE
-#pragma pop_macro("XRPL_FEATURE")
+static constexpr std::size_t numFeatures = 113;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated
@@ -347,17 +320,12 @@ foreachFeature(FeatureBitset bs, F&& f)
 #undef XRPL_FEATURE
 #pragma push_macro("XRPL_FIX")
 #undef XRPL_FIX
-#pragma push_macro("XRPL_RETIRE")
-#undef XRPL_RETIRE
 
 #define XRPL_FEATURE(name, supported, vote) extern uint256 const feature##name;
 #define XRPL_FIX(name, supported, vote) extern uint256 const fix##name;
-#define XRPL_RETIRE(name)
 
 #include <xrpl/protocol/detail/features.macro>
 
-#undef XRPL_RETIRE
-#pragma pop_macro("XRPL_RETIRE")
 #undef XRPL_FIX
 #pragma pop_macro("XRPL_FIX")
 #undef XRPL_FEATURE

include/xrpl/protocol/FeeUnits.h

@@ -23,7 +23,6 @@
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/json_value.h>
-
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/operators.hpp>
 
@@ -336,7 +335,7 @@ public:
 // Output Fees as just their numeric value.
 template <class Char, class Traits, class UnitTag, class T>
 std::basic_ostream<Char, Traits>&
-operator<<(std::basic_ostream<Char, Traits>& os, TaggedFee<UnitTag, T> const& q)
+operator<<(std::basic_ostream<Char, Traits>& os, const TaggedFee<UnitTag, T>& q)
 {
     return os << q.value();
 }