fix: Use renamed keylet::mptokenIssuance in Vault_test after merge

# Conflicts:
#	include/xrpl/protocol/detail/features.macro
#	src/libxrpl/tx/transactors/vault/VaultDelete.cpp
#	src/test/app/Vault_test.cpp

.clang-tidy

@@ -9,43 +9,90 @@ Checks: "-*,
 
   cppcoreguidelines-*,
   -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-capturing-lambda-coroutines,
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-goto,
   -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-avoid-reference-coroutine-parameters,
   -cppcoreguidelines-c-copy-assignment-signature,
+  -cppcoreguidelines-explicit-virtual-functions,
   -cppcoreguidelines-interfaces-global-init,
+  -cppcoreguidelines-macro-to-enum,
   -cppcoreguidelines-macro-usage,
   -cppcoreguidelines-missing-std-forward,
   -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-no-malloc,
+  -cppcoreguidelines-noexcept-destructor,
   -cppcoreguidelines-noexcept-move-operations,
+  -cppcoreguidelines-noexcept-swap,
   -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-prefer-member-initializer,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
   -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-pro-type-cstyle-cast,
   -cppcoreguidelines-pro-type-reinterpret-cast,
   -cppcoreguidelines-pro-type-union-access,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-slicing,
   -cppcoreguidelines-special-member-functions,
 
   llvm-namespace-comment,
 
   misc-*,
+  -misc-anonymous-namespace-in-header,
+  -misc-confusable-identifiers,
+  -misc-coroutine-hostile-raii,
+  -misc-misleading-bidirectional,
+  -misc-misleading-identifier,
   -misc-multiple-inheritance,
+  -misc-new-delete-overloads,
   -misc-no-recursion,
+  -misc-non-copyable-objects,
   -misc-non-private-member-variables-in-classes,
   -misc-override-with-different-visibility,
+  -misc-predictable-rand,
+  -misc-unconventional-assign-operator,
+  -misc-uniqueptr-reset-release,
   -misc-unused-parameters,
   -misc-use-anonymous-namespace,
   -misc-use-internal-linkage,
 
   modernize-*,
+  -modernize-avoid-bind,
   -modernize-avoid-c-arrays,
   -modernize-avoid-c-style-cast,
+  -modernize-avoid-setjmp-longjmp,
+  -modernize-avoid-variadic-functions,
+  -modernize-deprecated-ios-base-aliases,
+  -modernize-loop-convert,
+  -modernize-macro-to-enum,
+  -modernize-min-max-use-initializer-list,
+  -modernize-raw-string-literal,
+  -modernize-redundant-void-arg,
+  -modernize-replace-auto-ptr,
+  -modernize-replace-disallow-copy-and-assign-macro,
+  -modernize-replace-random-shuffle,
   -modernize-return-braced-init-list,
+  -modernize-shrink-to-fit,
+  -modernize-unary-static-assert,
+  -modernize-use-auto,
+  -modernize-use-bool-literals,
+  -modernize-use-constraints,
+  -modernize-use-default-member-init,
   -modernize-use-integer-sign-comparison,
+  -modernize-use-noexcept,
+  -modernize-use-nullptr,
+  -modernize-use-std-format,
+  -modernize-use-std-print,
   -modernize-use-trailing-return-type,
+  -modernize-use-transparent-functors,
+  -modernize-use-uncaught-exceptions,
 
   performance-*,
   -performance-avoid-endl,
@@ -100,7 +147,7 @@ CheckOptions:
   bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
   bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
 
-  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/.*;openssl/obj_mac\\.h"
+  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
 
   readability-braces-around-statements.ShortStatementLines: 2
   readability-identifier-naming.MacroDefinitionCase: UPPER_CASE

.gersemi/definitions.cmake

@@ -48,12 +48,6 @@ endfunction()
 function(add_module parent name)
 endfunction()
 
-function(verify_target_headers target headers_dir)
-endfunction()
-
-function(_verify_add_headers target dir)
-endfunction()
-
 function(setup_protocol_autogen)
 endfunction()
 

.github/scripts/levelization/results/loops.txt

@@ -1,3 +1,9 @@
+Loop: test.jtx test.toplevel
+  test.toplevel > test.jtx
+
+Loop: test.jtx test.unit_test
+  test.unit_test ~= test.jtx
+
 Loop: xrpld.app xrpld.overlay
   xrpld.app > xrpld.overlay
 

.github/scripts/levelization/results/ordering.txt

@@ -72,6 +72,7 @@ test.app > xrpl.server
 test.app > xrpl.shamap
 test.app > xrpl.tx
 test.basics > test.jtx
+test.basics > test.unit_test
 test.basics > xrpl.basics
 test.basics > xrpl.core
 test.basics > xrpld.rpc
@@ -104,9 +105,9 @@ test.csf > xrpl.basics
 test.csf > xrpld.consensus
 test.csf > xrpl.json
 test.csf > xrpl.ledger
+test.csf > xrpl.protocol
 test.json > test.jtx
 test.json > xrpl.json
-test.jtx > test.unit_test
 test.jtx > xrpl.basics
 test.jtx > xrpl.config
 test.jtx > xrpl.core
@@ -161,6 +162,9 @@ test.protocol > test.unit_test
 test.protocol > xrpl.basics
 test.protocol > xrpl.json
 test.protocol > xrpl.protocol
+test.resource > test.unit_test
+test.resource > xrpl.basics
+test.resource > xrpl.resource
 test.rpc > test.jtx
 test.rpc > xrpl.basics
 test.rpc > xrpl.config
@@ -184,6 +188,14 @@ test.server > xrpld.core
 test.server > xrpl.json
 test.server > xrpl.protocol
 test.server > xrpl.server
+test.shamap > test.unit_test
+test.shamap > xrpl.basics
+test.shamap > xrpl.config
+test.shamap > xrpl.nodestore
+test.shamap > xrpl.protocol
+test.shamap > xrpl.shamap
+test.toplevel > test.csf
+test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
@@ -195,7 +207,6 @@ tests.libxrpl > xrpl.net
 tests.libxrpl > xrpl.nodestore
 tests.libxrpl > xrpl.protocol
 tests.libxrpl > xrpl.protocol_autogen
-tests.libxrpl > xrpl.resource
 tests.libxrpl > xrpl.server
 tests.libxrpl > xrpl.shamap
 tests.libxrpl > xrpl.tx
@@ -207,14 +218,11 @@ xrpl.core > xrpl.json
 xrpl.core > xrpl.protocol
 xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics
-xrpl.ledger > xrpl.json
-xrpl.ledger > xrpl.nodestore
 xrpl.ledger > xrpl.protocol
 xrpl.ledger > xrpl.shamap
 xrpl.net > xrpl.basics
 xrpl.nodestore > xrpl.basics
 xrpl.nodestore > xrpl.config
-xrpl.nodestore > xrpl.json
 xrpl.nodestore > xrpl.protocol
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
@@ -232,6 +240,7 @@ xrpl.server > xrpl.json
 xrpl.server > xrpl.protocol
 xrpl.server > xrpl.rdb
 xrpl.server > xrpl.resource
+xrpl.server > xrpl.shamap
 xrpl.shamap > xrpl.basics
 xrpl.shamap > xrpl.nodestore
 xrpl.shamap > xrpl.protocol
@@ -286,10 +295,8 @@ xrpld.peerfinder > xrpl.rdb
 xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.config
 xrpld.perflog > xrpl.core
-xrpld.perflog > xrpld.app
 xrpld.perflog > xrpld.rpc
 xrpld.perflog > xrpl.json
-xrpld.perflog > xrpl.nodestore
 xrpld.perflog > xrpl.protocol
 xrpld.rpc > xrpl.basics
 xrpld.rpc > xrpl.config
@@ -307,6 +314,5 @@ xrpld.rpc > xrpl.shamap
 xrpld.rpc > xrpl.tx
 xrpld.shamap > xrpl.basics
 xrpld.shamap > xrpld.core
-xrpld.shamap > xrpl.nodestore
 xrpld.shamap > xrpl.protocol
 xrpld.shamap > xrpl.shamap

.github/workflows/pre-commit.yml

@@ -14,7 +14,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@1bde119a1ab71305ba5d3716e7a82cea1c7bdede
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@e06d4138c9ec8dceeb7c818645faa38087ea9e3d
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/publish-docs.yml

@@ -47,7 +47,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@9355d190fd7d4de80fadfd161e6edddc9702cd9f
         with:
           enable_ccache: false
 

.github/workflows/reusable-build-test-config.yml

@@ -113,7 +113,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@9355d190fd7d4de80fadfd161e6edddc9702cd9f
         with:
           enable_ccache: ${{ inputs.ccache_enabled }}
 

.github/workflows/reusable-clang-tidy.yml

@@ -43,7 +43,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@9355d190fd7d4de80fadfd161e6edddc9702cd9f
         with:
           enable_ccache: false
 
@@ -79,7 +79,6 @@ jobs:
               -Dtests=ON \
               -Dwerr=ON \
               -Dxrpld=ON \
-              -Dverify_headers=ON \
               ..
 
       # clang-tidy needs headers generated from proto files
@@ -92,7 +91,7 @@ jobs:
         id: run_clang_tidy
         continue-on-error: true
         env:
-          TARGETS: ${{ needs.determine-files.outputs.need_full_run != 'true' && needs.determine-files.outputs.cpp_changed_files || 'include src tests' }}
+          TARGETS: ${{ needs.determine-files.outputs.need_full_run != 'true' && needs.determine-files.outputs.cpp_changed_files || 'src tests' }}
         run: |
           set -o pipefail
           run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -fix -allow-no-checks ${TARGETS} 2>&1 | tee "${OUTPUT_FILE}"

.github/workflows/reusable-package.yml

@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: "3.13"
 

.github/workflows/reusable-strategy-matrix.yml

@@ -26,7 +26,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: "3.13"
 

.github/workflows/upload-conan-deps.yml

@@ -68,7 +68,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@9355d190fd7d4de80fadfd161e6edddc9702cd9f
         with:
           enable_ccache: false
 

.pre-commit-config.yaml

@@ -28,10 +28,8 @@ repos:
         entry: ./bin/pre-commit/clang_tidy_check.py
         language: python
         types_or: [c++, c]
-        # .ipp fragments are included by their owning header rather than compiled
-        # as standalone translation units, so they have no compile_commands.json
-        # entry to lint (verify_headers checks them transitively).
-        exclude: '^include/xrpl/protocol_autogen|\.ipp$'
+        exclude: ^include/xrpl/protocol_autogen
+        pass_filenames: false # script determines the staged files itself
       - id: fix-include-style
         name: fix include style
         entry: ./bin/pre-commit/fix_include_style.py
@@ -53,12 +51,12 @@ repos:
         exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
 
   - repo: https://github.com/BlankSpruce/gersemi-pre-commit
-    rev: e98930bdc210d3387007f9252d8c1694ea7e410f # frozen: 0.27.7
+    rev: faadd6a9d852369ca94f4d15b2404c967ba8cb01 # frozen: 0.27.6
     hooks:
       - id: gersemi
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 39e2973981e6d2f9b6c543b0086a2d2393abdc89 # frozen: v3.9.4
+    rev: 515f543f5718ebfd6ce22e16708bb32c68ff96e1 # frozen: v3.8.3
     hooks:
       - id: prettier
         args: [--end-of-line=auto]
@@ -88,21 +86,22 @@ repos:
         files: \.md$
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: ea11f9efc0bec520073405bc30552da887ba71bc # frozen: v10.0.1
+    rev: 4643f154907327ee0a2c7038f0296e0dd77d9776 # frozen: v10.0.0
     hooks:
-      - id: cspell
-        name: check changed files spelling
+      - id: cspell # Spell check changed files
         exclude: |
           (?x)^(
-              \.cspell\.config\.yaml|
+              .config/cspell.config.yaml|
               include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
           )$
-      - id: cspell
+      - id: cspell # Spell check the commit message
         name: check commit message spelling
         args:
           - --no-must-find-files
           - --no-progress
           - --no-summary
+          - --files
+          - .git/COMMIT_EDITMSG
         stages: [commit-msg]
 
   - repo: local

BUILD.md

@@ -25,7 +25,7 @@ You can verify that the required tools are installed and runnable with:
 | ----------- | --------------- |
 | GCC         | 15.2            |
 | Clang       | 22              |
-| Apple Clang | 21              |
+| Apple Clang | 17              |
 | MSVC        | 19.44[^windows] |
 
 ## Operating Systems
@@ -317,41 +317,21 @@ See [Sanitizers docs](./docs/build/sanitizers.md) for more details.
 
 ## Options
 
-| Option           | Default Value | Description                                                                   |
-| ---------------- | ------------- | ----------------------------------------------------------------------------- |
-| `assert`         | OFF           | Force enabling assertions.                                                    |
-| `coverage`       | OFF           | Prepare the coverage report.                                                  |
-| `tests`          | OFF           | Build tests.                                                                  |
-| `unity`          | OFF           | Configure a unity build.                                                      |
-| `verify_headers` | ON            | Make the `verify-headers` target available to compile each header on its own. |
-| `xrpld`          | OFF           | Build the xrpld application, and not just the libxrpl library.                |
-| `werr`           | OFF           | Treat compilation warnings as errors                                          |
-| `wextra`         | OFF           | Enable additional compilation warnings                                        |
+| Option     | Default Value | Description                                                    |
+| ---------- | ------------- | -------------------------------------------------------------- |
+| `assert`   | OFF           | Force enabling assertions.                                     |
+| `coverage` | OFF           | Prepare the coverage report.                                   |
+| `tests`    | OFF           | Build tests.                                                   |
+| `unity`    | OFF           | Configure a unity build.                                       |
+| `xrpld`    | OFF           | Build the xrpld application, and not just the libxrpl library. |
+| `werr`     | OFF           | Treat compilation warnings as errors                           |
+| `wextra`   | OFF           | Enable additional compilation warnings                         |
 
 [Unity builds][unity-build] may be faster for the first build (at the cost of much more
 memory) since they concatenate sources into fewer translation units. Non-unity
 builds may be faster for incremental builds, and can be helpful for detecting
 `#include` omissions.
 
-### Verifying headers
-
-The regular build only compiles `.cpp` files, so a header is only ever checked
-through whatever translation unit happens to include it. A header that forgets
-an `#include` is not caught as long as every `.cpp` that uses it includes its
-missing dependency first. The `verify_headers` option (ON by default) adds a
-`verify-headers` target that compiles every header on its own, which fails if a
-header is not self-contained:
-
-```bash
-cmake --build . --target verify-headers
-```
-
-The per-header objects are excluded from the `all` target, so a normal build
-never compiles them; they are built only through `verify-headers`. The generated
-translation units do appear in `compile_commands.json`, so clang-tidy (and
-clangd and IDEs) can lint each header on its own. Pass `-Dverify_headers=OFF` to
-omit them entirely.
-
 ## Troubleshooting
 
 ### Conan

bin/pre-commit/clang_tidy_check.py

@@ -1,27 +1,24 @@
 #!/usr/bin/env python3
-"""Pre-commit hook that runs clang-tidy on changed files using run-clang-tidy.
-
-The set of files is chosen by pre-commit (see .pre-commit-config.yaml), which
-filters to C/C++ sources and excludes `.ipp` fragments. Headers are linted
-directly: the `verify_headers` build option (ON by default) compiles every
-`.h`/`.hpp` on its own, so each header is the main file of its own
-compile_commands.json entry and run-clang-tidy can analyse it just like a
-`.cpp`.
-"""
+"""Pre-commit hook that runs clang-tidy on changed files using run-clang-tidy."""
 
 from __future__ import annotations
 
+import json
 import os
+import re
 import shutil
 import subprocess
 import sys
+from collections import defaultdict
 from pathlib import Path
 
-CLANG_TIDY_VERSION = 22
+HEADER_EXTENSIONS = {".h", ".hpp", ".ipp"}
+SOURCE_EXTENSIONS = {".cpp"}
+INCLUDE_RE = re.compile(r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]")
 
 
 def find_run_clang_tidy() -> str | None:
-    for candidate in (f"run-clang-tidy-{CLANG_TIDY_VERSION}", "run-clang-tidy"):
+    for candidate in ("run-clang-tidy-21", "run-clang-tidy"):
         if path := shutil.which(candidate):
             return path
     return None
@@ -35,23 +32,142 @@ def find_build_dir(repo_root: Path) -> Path | None:
     return None
 
 
+def build_include_graph(build_dir: Path, repo_root: Path) -> tuple[dict, set]:
+    """
+    Scan all files reachable from compile_commands.json and build an inverted include graph.
+
+    Returns:
+        inverted: header_path -> set of files that include it
+        source_files: set of all TU paths from compile_commands.json
+    """
+    with open(build_dir / "compile_commands.json") as f:
+        db = json.load(f)
+
+    source_files = {Path(e["file"]).resolve() for e in db}
+    include_roots = [repo_root / "include", repo_root / "src"]
+    inverted: dict[Path, set[Path]] = defaultdict(set)
+
+    to_scan: set[Path] = set(source_files)
+    scanned: set[Path] = set()
+
+    while to_scan:
+        file = to_scan.pop()
+        if file in scanned or not file.exists():
+            continue
+        scanned.add(file)
+
+        content = file.read_text()
+
+        for line in content.splitlines():
+            m = INCLUDE_RE.match(line)
+            if not m:
+                continue
+            for root in include_roots:
+                candidate = (root / m.group(1)).resolve()
+                if candidate.exists():
+                    inverted[candidate].add(file)
+                    if candidate not in scanned:
+                        to_scan.add(candidate)
+                    break
+
+    return inverted, source_files
+
+
+def find_tus_for_headers(
+    headers: list[Path],
+    inverted: dict[Path, set[Path]],
+    source_files: set[Path],
+) -> set[Path]:
+    """
+    For each header, pick one TU that transitively includes it.
+    Prefers a TU whose stem matches the header's stem, otherwise picks the first found.
+    """
+    result: set[Path] = set()
+
+    for header in headers:
+        preferred: Path | None = None
+        visited: set[Path] = {header}
+        stack: list[Path] = [header]
+
+        while stack:
+            h = stack.pop()
+            for inc in inverted.get(h, ()):
+                if inc in source_files:
+                    if inc.stem == header.stem:
+                        preferred = inc
+                        break
+                    if preferred is None:
+                        preferred = inc
+                if inc not in visited:
+                    visited.add(inc)
+                    stack.append(inc)
+            if preferred is not None and preferred.stem == header.stem:
+                break
+
+        if preferred is not None:
+            result.add(preferred)
+
+    return result
+
+
+def resolve_files(
+    input_files: list[str], build_dir: Path, repo_root: Path
+) -> list[str]:
+    """
+    Split input into source files and headers. Source files are passed through;
+    headers are resolved to the TUs that transitively include them.
+    """
+    sources: list[Path] = []
+    headers: list[Path] = []
+
+    for f in input_files:
+        p = Path(f).resolve()
+        if p.suffix in SOURCE_EXTENSIONS:
+            sources.append(p)
+        elif p.suffix in HEADER_EXTENSIONS:
+            headers.append(p)
+
+    if not headers:
+        return [str(p) for p in sources]
+
+    print(
+        f"Resolving {len(headers)} header(s) to compilation units...", file=sys.stderr
+    )
+    inverted, source_files = build_include_graph(build_dir, repo_root)
+    tus = find_tus_for_headers(headers, inverted, source_files)
+
+    if not tus:
+        print(
+            "Warning: no compilation units found that include the modified headers; "
+            "skipping clang-tidy for headers.",
+            file=sys.stderr,
+        )
+
+    return sorted({str(p) for p in (*sources, *tus)})
+
+
+def staged_files(repo_root: Path) -> list[str]:
+    result = subprocess.run(
+        ["git", "diff", "--staged", "--name-only", "--diff-filter=d"],
+        capture_output=True,
+        text=True,
+        cwd=repo_root,
+    )
+    if result.returncode != 0:
+        print(
+            "clang-tidy check failed: 'git diff --staged' command failed.",
+            file=sys.stderr,
+        )
+        if result.stderr:
+            print(result.stderr, file=sys.stderr)
+        sys.exit(result.returncode or 1)
+    return [str(repo_root / p) for p in result.stdout.splitlines() if p]
+
+
 def main():
     if not os.environ.get("TIDY"):
         return 0
 
-    files = sys.argv[1:]
-    if not files:
-        return 0
-
-    run_clang_tidy = find_run_clang_tidy()
-    if not run_clang_tidy:
-        print(
-            f"clang-tidy check failed: TIDY is enabled but neither "
-            f"'run-clang-tidy-{CLANG_TIDY_VERSION}' nor 'run-clang-tidy' was found in PATH.",
-            file=sys.stderr,
-        )
-        return 1
-
     repo_root = Path(
         subprocess.check_output(
             ["git", "rev-parse", "--show-toplevel"],
@@ -59,6 +175,19 @@ def main():
             text=True,
         ).strip()
     )
+    files = staged_files(repo_root)
+    if not files:
+        return 0
+
+    run_clang_tidy = find_run_clang_tidy()
+    if not run_clang_tidy:
+        print(
+            "clang-tidy check failed: TIDY is enabled but neither "
+            "'run-clang-tidy-21' nor 'run-clang-tidy' was found in PATH.",
+            file=sys.stderr,
+        )
+        return 1
+
     build_dir = find_build_dir(repo_root)
     if not build_dir:
         print(
@@ -68,9 +197,13 @@ def main():
         )
         return 1
 
+    tidy_files = resolve_files(files, build_dir, repo_root)
+    if not tidy_files:
+        return 0
+
     result = subprocess.run(
         [run_clang_tidy, "-quiet", "-p", str(build_dir), "-fix", "-allow-no-checks"]
-        + files
+        + tidy_files
     )
     return result.returncode
 

cmake/XrplCore.cmake

@@ -293,13 +293,4 @@ if(xrpld)
             PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
         )
     endif()
-
-    # The xrpld headers are not built with add_module, so verify them against
-    # the executable's own compile environment.
-    if(verify_headers)
-        verify_target_headers(xrpld "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld")
-        if(tests)
-            verify_target_headers(xrpld "${CMAKE_CURRENT_SOURCE_DIR}/src/test")
-        endif()
-    endif()
 endif()

cmake/XrplSettings.cmake

@@ -30,23 +30,6 @@ if(tests)
     endif()
 endif()
 
-# Enabled by default so every header is compiled on its own as the main file of
-# its own compile_commands.json entry - this is what lets clang-tidy (and clangd
-# and IDEs) analyse a header's own includes directly. The per-header objects are
-# EXCLUDE_FROM_ALL (see cmake/verify_headers.cmake) and the aggregate target
-# below is not part of `all`, so a normal `cmake --build` never compiles them.
-option(
-    verify_headers
-    "Compile every header on its own to verify it is self-contained."
-    ON
-)
-if(verify_headers)
-    # Aggregate target that builds every per-module header-verification library
-    # created by add_module (see cmake/verify_headers.cmake). Build it with:
-    #   cmake --build . --target verify-headers
-    add_custom_target(verify-headers)
-endif()
-
 option(unity "Creates a build using UNITY support in cmake." OFF)
 if(unity)
     if(NOT is_ci)

cmake/add_module.cmake

@@ -1,5 +1,4 @@
 include(isolate_headers)
-include(verify_headers)
 
 # Create an OBJECT library target named
 #
@@ -38,20 +37,4 @@ function(add_module parent name)
         "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
         PRIVATE
     )
-    # protocol_autogen contains generated headers that are deliberately exempt
-    # from clang-tidy (see ExcludeHeaderFilterRegex in .clang-tidy), so we do not
-    # verify them either.
-    if(
-        verify_headers
-        AND NOT "${parent}/${name}" STREQUAL "xrpl/protocol_autogen"
-    )
-        verify_target_headers(
-            ${target}
-            "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
-        )
-        verify_target_headers(
-            ${target}
-            "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
-        )
-    endif()
 endfunction()

cmake/verify_headers.cmake

@@ -1,84 +0,0 @@
-# Our normal build only ever compiles `.cpp` files, so a header is only ever
-# checked through whatever translation unit happens to include it. A header that
-# is missing an `#include` is never caught as long as every `.cpp` that uses it
-# includes its missing dependency first. To check a header on its own we compile
-# it directly as a translation unit.
-#
-# Compiling the header itself - rather than a `.cpp` wrapper that includes it -
-# gives two checks at once:
-#   * the compiler fails if the header is not self-contained, i.e. it uses a
-#     declaration that is not available (directly or transitively); and
-#   * the header is the *main file* of its `compile_commands.json` entry, so
-#     clang-tidy's misc-include-cleaner analyses (and can --fix) the header's own
-#     includes - flagging a dependency that is only available transitively, which
-#     a plain compile cannot catch. A wrapper would be the main file instead, and
-#     include-cleaner never looks inside the headers a main file includes.
-#
-# The objects are never linked anywhere; we build them only for these checks.
-
-# Verify that the headers under headers_dir compile on their own, using the
-# compile environment of an existing target so each header is compiled exactly as
-# that target compiles it. This works for both add_module libraries and the xrpld
-# and test binaries: a library's isolated public and private include directories
-# and a binary's `-I src` both live in its INCLUDE_DIRECTORIES, and the modules or
-# libraries it links live in its LINK_LIBRARIES. We copy those usage requirements
-# through generator expressions (rather than linking ${target}, which is
-# impossible for an executable), evaluated at generation time so they capture
-# requirements the caller adds after this runs. The verify library is created
-# once; call this repeatedly to add more header directories.
-#
-# verify_target_headers(target headers_dir)
-function(verify_target_headers target headers_dir)
-    set(verify ${target}.verify)
-    if(NOT TARGET ${verify})
-        add_library(${verify} OBJECT EXCLUDE_FROM_ALL)
-        # A unity build would concatenate the headers into a single translation
-        # unit, where a header missing an include could be satisfied by one that
-        # precedes it in the blob - exactly the bug we want to catch.
-        set_target_properties(${verify} PROPERTIES UNITY_BUILD OFF)
-        target_include_directories(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},INCLUDE_DIRECTORIES>
-        )
-        target_compile_definitions(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},COMPILE_DEFINITIONS>
-        )
-        target_compile_options(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},COMPILE_OPTIONS>
-        )
-        target_link_libraries(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},LINK_LIBRARIES>
-        )
-        add_dependencies(verify-headers ${verify})
-    endif()
-    _verify_add_headers(${verify} "${headers_dir}")
-endfunction()
-
-# Add every .h/.hpp under dir to target as a directly-compiled C++ translation
-# unit. .ipp files are inline-implementation fragments included by their owning
-# header (often after a class declaration), so they are not self-contained on
-# their own and are verified transitively when that header is verified.
-function(_verify_add_headers target dir)
-    file(GLOB_RECURSE headers CONFIGURE_DEPENDS "${dir}/*.h" "${dir}/*.hpp")
-    if(NOT headers)
-        return()
-    endif()
-    # `-xc++` forces the header to be compiled as a C++ translation unit; a lone
-    # `.h` is otherwise treated as a header to precompile. `#pragma once` is
-    # harmless (and warns) when the header is the main file, so silence it.
-    # Compiled on its own, a header legitimately defines constants and static or
-    # template functions that nothing in this single translation unit uses (they
-    # exist for the files that include it), so the resulting unused-entity
-    # warnings are expected and must not fail the build under -Werror.
-    set_source_files_properties(
-        ${headers}
-        PROPERTIES
-            LANGUAGE CXX
-            COMPILE_OPTIONS
-                "-xc++;-Wno-pragma-once-outside-header;-Wno-unused-const-variable;-Wno-unused-function"
-    )
-    target_sources(${target} PRIVATE ${headers})
-endfunction()

conan/profiles/default

@@ -10,18 +10,16 @@
 os={{ os }}
 arch={{ arch }}
 build_type=Debug
-compiler={{ compiler }}
+compiler={{compiler}}
 compiler.version={{ compiler_version }}
 compiler.cppstd=23
 {% if os == "Windows" %}
 compiler.runtime=static
 {% else %}
-compiler.libcxx={{ detect_api.detect_libcxx(compiler, version, compiler_exe) }}
+compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
 {% endif %}
 
 [conf]
-{# By default, Conan tries to reuse binaries built with different cppstd versions. #}
-{# We want to avoid that to improve reproduceability, so we add the cppstd version to the package ID. #}
-{# More info: https://docs.conan.io/2/reference/extensions/binary_compatibility.html #}
-user.package:cppstd_version=23
-tools.info.package_id:confs+=["user.package:cppstd_version"]
+{% if compiler == "gcc" and compiler_version < 13 %}
+tools.build:cxxflags+=['-Wno-restrict']
+{% endif %}

conan/profiles/sanitizers

@@ -87,15 +87,15 @@ include(default)
 {% endif %}
 
 [conf]
-tools.build:defines+={{ defines }}
-tools.build:cxxflags+={{ sanitizer_compiler_flags }}
-tools.build:sharedlinkflags+={{ sanitizer_linker_flags }}
-tools.build:exelinkflags+={{ sanitizer_linker_flags }}
+tools.build:defines+={{defines}}
+tools.build:cxxflags+={{sanitizer_compiler_flags}}
+tools.build:sharedlinkflags+={{sanitizer_linker_flags}}
+tools.build:exelinkflags+={{sanitizer_linker_flags}}
 
 tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags", "tools.build:defines"]
 
 # &: means "apply only to the consumer/root package"
-&:tools.cmake.cmaketoolchain:extra_variables={"SANITIZERS": "{{ sanitizers }}", "SANITIZERS_COMPILER_FLAGS": "{{ sanitizer_compiler_flags | join(' ') }}", "SANITIZERS_LINKER_FLAGS": "{{ sanitizer_linker_flags | join(' ') }}"}
+&:tools.cmake.cmaketoolchain:extra_variables={"SANITIZERS": "{{sanitizers}}", "SANITIZERS_COMPILER_FLAGS": "{{sanitizer_compiler_flags | join(' ')}}", "SANITIZERS_LINKER_FLAGS": "{{sanitizer_linker_flags | join(' ')}}"}
 
 [options]
 {% if enable_asan %}

cspell.config.yaml

@@ -36,7 +36,9 @@ overrides:
       - /'[^']*'/g # single-quoted strings
       - /`[^`]*`/g # backtick strings
 suggestWords:
-  - unsynched->unsynced
+  - xprl->xrpl
+  - xprld->xrpld # cspell: disable-line not sure what this problem is....
+  - unsynched->unsynced # cspell: disable-line not sure what this problem is....
   - synched->synced
   - synch->sync
 words:

docs/0001-negative-unl/README.md

@@ -288,7 +288,7 @@ components with non-trivial changes are colored green.
     validated.
 
 ![Sequence diagram](./negativeUNL_highLevel_sequence.png?raw=true "Negative UNL
-Changes")
+ Changes")
 
 ## Roads Not Taken
 

include/xrpl/basics/Buffer.h

@@ -6,7 +6,6 @@
 #include <cstdint>
 #include <cstring>
 #include <memory>
-#include <utility>
 
 namespace xrpl {
 

include/xrpl/basics/CompressionAlgorithms.h

@@ -5,7 +5,6 @@
 #include <lz4.h>
 
 #include <algorithm>
-#include <cstddef>
 #include <cstdint>
 #include <stdexcept>
 #include <vector>

include/xrpl/basics/DecayingSample.h

@@ -2,7 +2,6 @@
 
 #include <chrono>
 #include <cmath>
-#include <cstddef>
 
 namespace xrpl {
 

include/xrpl/basics/FileUtilities.h

@@ -3,9 +3,7 @@
 #include <boost/filesystem.hpp>
 #include <boost/system/error_code.hpp>
 
-#include <cstddef>
 #include <optional>
-#include <string>
 
 namespace xrpl {
 

include/xrpl/basics/IntrusivePointer.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <concepts>
-#include <cstddef>
 #include <cstdint>
 #include <type_traits>
 #include <utility>

include/xrpl/basics/IntrusiveRefCounts.h

@@ -3,7 +3,6 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <atomic>
-#include <cstddef>
 #include <cstdint>
 
 namespace xrpl {

include/xrpl/basics/Log.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/beast/utility/Journal.h>
 
 #include <boost/beast/core/string.hpp>
@@ -10,9 +11,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <string>
 #include <utility>
-#include <vector>
 
 namespace xrpl {
 

include/xrpl/basics/Number.h

@@ -2,9 +2,7 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <algorithm>
 #include <array>
-#include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <limits>
@@ -13,9 +11,7 @@
 #include <set>
 #include <stdexcept>
 #include <string>
-#include <type_traits>
 #include <unordered_map>
-#include <utility>
 
 namespace xrpl {
 

include/xrpl/basics/RangeSet.h

@@ -6,7 +6,6 @@
 #include <boost/icl/closed_interval.hpp>
 #include <boost/icl/interval_set.hpp>
 
-#include <functional>
 #include <optional>
 #include <string>
 #include <vector>

include/xrpl/basics/Resolver.h

@@ -3,7 +3,6 @@
 #include <xrpl/beast/net/IPEndpoint.h>
 
 #include <functional>
-#include <string>
 #include <vector>
 
 namespace xrpl {

include/xrpl/basics/ResolverAsio.h

@@ -5,8 +5,6 @@
 
 #include <boost/asio/io_context.hpp>
 
-#include <memory>
-
 namespace xrpl {
 
 class ResolverAsio : public Resolver

include/xrpl/basics/SHAMapHash.h

@@ -3,9 +3,7 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/partitioned_unordered_map.h>
 
-#include <cstddef>
 #include <ostream>
-#include <string>
 
 namespace xrpl {
 

include/xrpl/basics/SharedWeakCachePointer.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <concepts>
-#include <cstddef>
 #include <memory>
 #include <variant>
 

include/xrpl/basics/SlabAllocator.h

@@ -15,7 +15,6 @@
 #include <cstdint>
 #include <cstring>
 #include <mutex>
-#include <stdexcept>
 #include <vector>
 
 #if BOOST_OS_LINUX

include/xrpl/basics/Slice.h

@@ -211,17 +211,15 @@ operator<<(Stream& s, Slice const& v)
 }
 
 template <class T, std::size_t N>
-Slice
+std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
 makeSlice(std::array<T, N> const& a)
-    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return Slice(a.data(), a.size());
 }
 
 template <class T, class Alloc>
-Slice
+std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
 makeSlice(std::vector<T, Alloc> const& v)
-    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return Slice(v.data(), v.size());
 }

include/xrpl/basics/StringUtilities.h

@@ -1,19 +1,18 @@
 #pragma once
 
 #include <xrpl/basics/Blob.h>
+#include <xrpl/basics/strHex.h>
 
 #include <boost/format.hpp>
 #include <boost/utility/string_view.hpp>
 
 #include <array>
 #include <concepts>
-#include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <utility>
 
 namespace xrpl {
 

include/xrpl/basics/TaggedCache.h

@@ -1,24 +1,17 @@
 #pragma once
 
-#include <xrpl/basics/SharedWeakCachePointer.h>
-#include <xrpl/basics/SharedWeakCachePointer.ipp>  // IWYU pragma: keep
+#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/Collector.h>
-#include <xrpl/beast/insight/Gauge.h>
-#include <xrpl/beast/insight/Hook.h>
-#include <xrpl/beast/insight/NullCollector.h>
-#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/insight/Insight.h>
 
 #include <atomic>
-#include <chrono>
 #include <cstddef>
-#include <cstdint>
 #include <functional>
-#include <memory>
 #include <mutex>
-#include <string>
 #include <thread>
 #include <type_traits>
 #include <vector>
@@ -212,13 +205,11 @@ public:
     */
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key, T const& value) -> ReturnType
-        requires(!IsKeyCache);
+    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>;
 
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key) -> ReturnType
-        requires IsKeyCache;
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
 
     // VFALCO NOTE It looks like this returns a copy of the data in
     //             the output parameter 'data'. This could be expensive.

include/xrpl/basics/TaggedCache.ipp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <xrpl/basics/IntrusivePointer.ipp>
-#include <xrpl/basics/Log.h>  // IWYU pragma: keep
 #include <xrpl/basics/TaggedCache.h>
 
 namespace xrpl {
@@ -57,10 +56,7 @@ inline TaggedCache<
         beast::insight::Collector::ptr const& collector)
     : journal_(journal)
     , clock_(clock)
-    , stats_(
-          name,
-          [this] { collectMetrics(); },
-          collector)
+    , stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
     , name_(name)
     , targetSize_(size)
     , targetAge_(expiration)
@@ -503,8 +499,7 @@ template <
 template <class ReturnType>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key, T const& value) -> ReturnType
-    requires(!IsKeyCache)
+    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
 {
     static_assert(
         std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -534,8 +529,7 @@ template <
 template <class ReturnType>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key) -> ReturnType
-    requires IsKeyCache
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
 {
     std::scoped_lock const lock(mutex_);
     clock_type::time_point const now(clock_.now());

include/xrpl/basics/ToString.h

@@ -12,9 +12,8 @@ namespace xrpl {
  */
 
 template <class T>
-std::string
+std::enable_if_t<std::is_arithmetic_v<T>, std::string>
 to_string(T t)  // NOLINT(readability-identifier-naming)
-    requires(std::is_arithmetic_v<T>)
 {
     return std::to_string(t);
 }

include/xrpl/basics/UnorderedContainers.h

@@ -2,14 +2,12 @@
 
 #include <xrpl/basics/hardened_hash.h>
 #include <xrpl/basics/partitioned_unordered_map.h>
+#include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/hash/xxhasher.h>
 
-#include <functional>
-#include <memory>
 #include <unordered_map>
 #include <unordered_set>
-#include <utility>
 
 /**
  * Use hash_* containers for keys that do not need a cryptographically secure

include/xrpl/basics/base64.h

@@ -34,7 +34,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 #include <string>
 #include <string_view>

include/xrpl/basics/base_uint.h

@@ -10,7 +10,6 @@
 #include <xrpl/basics/hardened_hash.h>
 #include <xrpl/basics/partitioned_unordered_map.h>
 #include <xrpl/basics/strHex.h>
-#include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
@@ -19,17 +18,8 @@
 
 #include <algorithm>
 #include <array>
-#include <compare>
-#include <cstddef>
-#include <cstdint>
 #include <cstring>
 #include <expected>
-#include <iterator>
-#include <optional>
-#include <ostream>
-#include <stdexcept>
-#include <string>
-#include <string_view>
 #include <type_traits>
 
 namespace xrpl {
@@ -97,7 +87,7 @@ public:
     //
 
     static constexpr std::size_t kBytes = Bits / 8;
-    static_assert(sizeof(data_) == kBytes);
+    static_assert(sizeof(data_) == kBytes, "");
 
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
@@ -280,11 +270,12 @@ public:
     {
     }
 
-    template <class Container>
-    explicit BaseUInt(Container const& c)
-        requires(
+    template <
+        class Container,
+        class = std::enable_if_t<
             detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>)
+            std::is_trivially_copyable_v<typename Container::value_type>>>
+    explicit BaseUInt(Container const& c)
     {
         // Use AlwaysFalseT so the static_assert condition is dependent
         // and only triggers when this constructor template is instantiated.
@@ -294,12 +285,13 @@ public:
             "Use base_uint::fromRaw instead.");
     }
 
-    template <class Container>
+    template <
+        class Container,
+        class = std::enable_if_t<
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>>>
     static BaseUInt
     fromRaw(Container const& c)
-        requires(
-            detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         BaseUInt result;
         XRPL_ASSERT(
@@ -310,11 +302,11 @@ public:
     }
 
     template <class Container>
-    BaseUInt&
+    std::enable_if_t<
+        detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>,
+        BaseUInt&>
     operator=(Container const& c)
-        requires(
-            detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),

include/xrpl/basics/chrono.h

@@ -10,7 +10,6 @@
 #include <cstdint>
 #include <ratio>
 #include <string>
-#include <type_traits>
 
 namespace xrpl {
 

include/xrpl/basics/comparators.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+
+namespace xrpl {
+
+#ifdef _MSC_VER
+
+/*
+ * MSVC 2019 version 16.9.0 added [[nodiscard]] to the std comparison
+ * operator() functions. boost::bimap checks that the comparator is a
+ * BinaryFunction, in part by calling the function and ignoring the value.
+ * These two things don't play well together. These wrapper classes simply
+ * strip [[nodiscard]] from operator() for use in boost::bimap.
+ *
+ * See also:
+ *  https://www.boost.org/doc/libs/1_75_0/libs/bimap/doc/html/boost_bimap/the_tutorial/controlling_collection_types.html
+ */
+
+template <class T = void>
+struct less
+{
+    using result_type = bool;
+
+    constexpr bool
+    operator()(T const& left, T const& right) const
+    {
+        return std::less<T>()(left, right);
+    }
+};
+
+template <class T = void>
+struct equal_to
+{
+    using result_type = bool;
+
+    constexpr bool
+    operator()(T const& left, T const& right) const
+    {
+        return std::equal_to<T>()(left, right);
+    }
+};
+
+#else
+
+template <class T = void>
+using less = std::less<T>;
+
+template <class T = void>
+using equal_to = std::equal_to<T>;
+
+#endif
+
+}  // namespace xrpl

include/xrpl/basics/hardened_hash.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/hash/xxhasher.h>
 
 #include <cstdint>

include/xrpl/basics/join.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include <cstddef>
 #include <string>
 #include <string_view>
-#include <utility>
 
 namespace xrpl {
 

include/xrpl/basics/make_SSLContext.h

@@ -2,7 +2,6 @@
 
 #include <boost/asio/ssl/context.hpp>
 
-#include <memory>
 #include <string>
 
 namespace xrpl {

include/xrpl/basics/partitioned_unordered_map.h

@@ -3,10 +3,7 @@
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <cstddef>
 #include <functional>
-#include <iterator>
-#include <memory>
 #include <optional>
 #include <string>
 #include <thread>
@@ -138,8 +135,11 @@ public:
         {
         }
 
-        ConstIterator(Iterator const& orig) : map(orig.map), ait(orig.ait), mit(orig.mit)
+        ConstIterator(Iterator const& orig)
         {
+            map = orig.map;
+            ait = orig.ait;
+            mit = orig.mit;
         }
 
         const_reference
@@ -228,11 +228,11 @@ private:
 
 public:
     PartitionedUnorderedMap(std::optional<std::size_t> partitions = std::nullopt)
+    {
         // Set partitions to the number of hardware threads if the parameter
         // is either empty or set to 0.
-        : partitions_(
-              partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency())
-    {
+        partitions_ =
+            partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency();
         map_.resize(partitions_);
         XRPL_ASSERT(
             partitions_,

include/xrpl/basics/random.h

@@ -3,6 +3,7 @@
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/beast/xor_shift_engine.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <limits>
 #include <mutex>
@@ -91,9 +92,8 @@ defaultPrng()
 */
 /** @{ */
 template <class Engine, class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral min, Integral max)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
 
@@ -104,41 +104,36 @@ randInt(Engine& engine, Integral min, Integral max)
 }
 
 template <class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 randInt(Integral min, Integral max)
-    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), min, max);
 }
 
 template <class Engine, class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral max)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     return randInt(engine, Integral(0), max);
 }
 
 template <class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 randInt(Integral max)
-    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), max);
 }
 
 template <class Integral, class Engine>
-Integral
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     return randInt(engine, std::numeric_limits<Integral>::max());
 }
 
 template <class Integral = int>
-Integral
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 randInt()
-    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), std::numeric_limits<Integral>::max());
 }
@@ -147,20 +142,19 @@ randInt()
 /** Return a random byte */
 /** @{ */
 template <class Byte, class Engine>
-Byte
+std::enable_if_t<
+    (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
+        detail::is_engine<Engine>::value,
+    Byte>
 randByte(Engine& engine)
-    requires(
-        (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
-        detail::is_engine<Engine>::value)
 {
     return static_cast<Byte>(randInt<Engine, std::uint32_t>(
         engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
 }
 
 template <class Byte = std::uint8_t>
-Byte
+std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
 randByte()
-    requires(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>)
 {
     return randByte<Byte>(defaultPrng());
 }

include/xrpl/basics/safe_cast.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <xrpl/beast/utility/instrumentation.h>  // IWYU pragma: keep
+#include <xrpl/beast/utility/instrumentation.h>
 
 #include <type_traits>
 
@@ -17,9 +17,8 @@ concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
                                                      : sizeof(Dest) >= sizeof(Src));
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
 safeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
     static_assert(
         std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
@@ -31,17 +30,15 @@ safeCast(Src s) noexcept
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
 safeCast(Src s) noexcept
-    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
     return static_cast<Dest>(safeCast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
 safeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
     return safeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
@@ -51,9 +48,8 @@ safeCast(Src s) noexcept
 // underlying types become safe, it can be converted to a safe_cast.
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
 unsafeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
     static_assert(
         !SafeToCast<Src, Dest>,
@@ -63,17 +59,15 @@ unsafeCast(Src s) noexcept
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
 unsafeCast(Src s) noexcept
-    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
     return static_cast<Dest>(unsafeCast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
 unsafeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
     return unsafeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }

include/xrpl/basics/scope.h

@@ -46,9 +46,11 @@ public:
     operator=(ScopeExit&&) = delete;
 
     template <class EFP>
-    explicit ScopeExit(EFP&& f) noexcept
-        requires(
-            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> && std::is_constructible_v<EF, EFP>)
+    explicit ScopeExit(
+        EFP&& f,
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> &&
+            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exitFunction_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -91,9 +93,11 @@ public:
     operator=(ScopeFail&&) = delete;
 
     template <class EFP>
-    explicit ScopeFail(EFP&& f) noexcept
-        requires(
-            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> && std::is_constructible_v<EF, EFP>)
+    explicit ScopeFail(
+        EFP&& f,
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> &&
+            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exitFunction_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -136,11 +140,12 @@ public:
     operator=(ScopeSuccess&&) = delete;
 
     template <class EFP>
-    explicit ScopeSuccess(EFP&& f) noexcept(
-        std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
-        requires(
+    explicit ScopeSuccess(
+        EFP&& f,
+        std::enable_if_t<
             !std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
-            std::is_constructible_v<EF, EFP>)
+            std::is_constructible_v<EF, EFP>>* =
+            0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
         : exitFunction_{std::forward<EFP>(f)}
     {
     }

include/xrpl/basics/strHex.h

@@ -3,9 +3,6 @@
 #include <boost/algorithm/hex.hpp>
 #include <boost/endian/conversion.hpp>
 
-#include <iterator>
-#include <string>
-
 namespace xrpl {
 
 template <class FwdIt>

include/xrpl/basics/tagged_integer.h

@@ -7,7 +7,6 @@
 #include <boost/operators.hpp>
 
 #include <iostream>
-#include <string>
 #include <type_traits>
 
 namespace xrpl {
@@ -43,10 +42,10 @@ public:
 
     TaggedInteger() = default;
 
-    template <class OtherInt>
-    explicit constexpr TaggedInteger(OtherInt value) noexcept
-        requires(std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int))
-        : value_(value)
+    template <
+        class OtherInt,
+        class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
+    explicit constexpr TaggedInteger(OtherInt value) noexcept : value_(value)
     {
         static_assert(sizeof(TaggedInteger) == sizeof(Int), "tagged_integer is adding padding");
     }

include/xrpl/beast/asio/io_latency_probe.h

@@ -8,7 +8,6 @@
 
 #include <chrono>
 #include <condition_variable>
-#include <cstddef>
 #include <mutex>
 #include <stdexcept>
 

include/xrpl/beast/container/aged_container_utility.h

@@ -3,15 +3,14 @@
 #include <xrpl/beast/container/aged_container.h>
 
 #include <chrono>
-#include <cstddef>
+#include <type_traits>
 
 namespace beast {
 
 /** Expire aged container items past the specified age. */
 template <class AgedContainer, class Rep, class Period>
-std::size_t
+std::enable_if_t<IsAgedContainer<AgedContainer>::value, std::size_t>
 expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
-    requires(IsAgedContainer<AgedContainer>::value)
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);

include/xrpl/beast/container/aged_map.h

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <utility>
 
 namespace beast {
 

include/xrpl/beast/container/aged_multimap.h

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <utility>
 
 namespace beast {
 

include/xrpl/beast/container/aged_unordered_map.h

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <utility>
 
 namespace beast {
 

include/xrpl/beast/container/aged_unordered_multimap.h

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <functional>
 #include <memory>
-#include <utility>
 
 namespace beast {
 

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

@@ -30,19 +30,20 @@ public:
 
     // Disable constructing a const_iterator from a non-const_iterator.
     // Converting between reverse and non-reverse iterators should be explicit.
-    template <bool OtherIsConst, class OtherIterator>
-    explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-        requires(
+    template <
+        bool OtherIsConst,
+        class OtherIterator,
+        class = std::enable_if_t<
             (!OtherIsConst || IsConst) &&
-            !static_cast<bool>(std::is_same_v<Iterator, OtherIterator>))
+            !static_cast<bool>(std::is_same_v<Iterator, OtherIterator>)>>
+    explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
         : iter_(other.iter_)
     {
     }
 
     // Disable constructing a const_iterator from a non-const_iterator.
-    template <bool OtherIsConst>
+    template <bool OtherIsConst, class = std::enable_if_t<!OtherIsConst || IsConst>>
     AgedContainerIterator(AgedContainerIterator<OtherIsConst, Iterator> const& other)
-        requires(!OtherIsConst || IsConst)
         : iter_(other.iter_)
     {
     }
@@ -51,8 +52,7 @@ public:
     template <bool OtherIsConst, class OtherIterator>
     auto
     operator=(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-        -> AgedContainerIterator&
-        requires(!OtherIsConst || IsConst)
+        -> std::enable_if_t<!OtherIsConst || IsConst, AgedContainerIterator&>
     {
         iter_ = other.iter_;
         return *this;

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

@@ -11,14 +11,9 @@
 #include <boost/version.hpp>
 
 #include <algorithm>
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
 #include <functional>
 #include <initializer_list>
 #include <memory>
-#include <stdexcept>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
@@ -111,9 +106,10 @@ private:
         {
         }
 
-        template <class... Args>
+        template <
+            class... Args,
+            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
         Element(time_point const& when, Args&&... args)
-            requires(std::is_constructible_v<value_type, Args...>)
             : value(std::forward<Args>(args)...), when(when)
         {
         }
@@ -359,7 +355,6 @@ private:
     deleteElement(Element const* p)
     {
         ElementAllocatorTraits::destroy(config_.alloc(), p);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         ElementAllocatorTraits::deallocate(config_.alloc(), const_cast<Element*>(p), 1);
     }
 
@@ -608,25 +603,35 @@ public:
     //
     //--------------------------------------------------------------------------
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    at(K const& k)
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k);
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional<IsMap, T, void*>::type const&
-    at(K const& k) const
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k) const;
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key const& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key const& key);
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key&& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key&& key);
 
     //--------------------------------------------------------------------------
     //
@@ -760,40 +765,35 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> iterator
-        requires MaybeMulti;
+    insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // set
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti && !MaybeMap);
+    insert(value_type&& value)
+        -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
 
     // multiset
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> iterator
-        requires(MaybeMulti && !MaybeMap);
+    insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
 
     //---
 
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(const_iterator hint, value_type const& value) -> iterator
-        requires(!MaybeMulti);
+    insert(const_iterator hint, value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
-        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return insert(value);
@@ -802,14 +802,12 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(const_iterator hint, value_type&& value) -> iterator
-        requires(!MaybeMulti);
+    insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
-        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return insert(std::move(value));
@@ -817,18 +815,20 @@ public:
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplace(std::forward<P>(value));
     }
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(const_iterator hint, P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -850,45 +850,46 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> iterator
-        requires MaybeMulti;
+    emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // map, set
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplaceHint(const_iterator hint, Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplaceHint(const_iterator hint, Args&&... args)
+        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     emplaceHint(const_iterator /*hint*/, Args&&... args)
-        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return emplace<MaybeMulti>(std::forward<Args>(args)...);
     }
 
-    // The constraint prevents erase (reverse_iterator pos) from compiling
-    template <bool IsConst, class Iterator>
+    // enable_if prevents erase (reverse_iterator pos) from compiling
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     beast::detail::AgedContainerIterator<false, Iterator>
-    erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
-        requires(!IsBoostReverseIterator<Iterator>::value);
+    erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos);
 
-    // The constraint prevents erase (reverse_iterator first, reverse_iterator last)
+    // enable_if prevents erase (reverse_iterator first, reverse_iterator last)
     // from compiling
-    template <bool IsConst, class Iterator>
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     beast::detail::AgedContainerIterator<false, Iterator>
     erase(
         beast::detail::AgedContainerIterator<IsConst, Iterator> first,
-        beast::detail::AgedContainerIterator<IsConst, Iterator> last)
-        requires(!IsBoostReverseIterator<Iterator>::value);
+        beast::detail::AgedContainerIterator<IsConst, Iterator> last);
 
     template <class K>
     auto
@@ -899,11 +900,13 @@ public:
 
     //--------------------------------------------------------------------------
 
-    // The constraint prevents touch (reverse_iterator pos) from compiling
-    template <bool IsConst, class Iterator>
+    // enable_if prevents touch (reverse_iterator pos) from compiling
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     void
     touch(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
-        requires(!IsBoostReverseIterator<Iterator>::value)
     {
         touch(pos, clock().now());
     }
@@ -1134,25 +1137,25 @@ public:
     }
 
 private:
-    // The constraint prevents erase (reverse_iterator pos, now) from compiling
-    template <bool IsConst, class Iterator>
+    // enable_if prevents erase (reverse_iterator pos, now) from compiling
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     void
     touch(
         beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
-        clock_type::time_point const& now)
-        requires(!IsBoostReverseIterator<Iterator>::value);
+        clock_type::time_point const& now);
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
-    swapData(AgedOrderedContainer& other) noexcept
-        requires MaybePropagate;
+    std::enable_if_t<MaybePropagate>
+    swapData(AgedOrderedContainer& other) noexcept;
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
-    swapData(AgedOrderedContainer& other) noexcept
-        requires(!MaybePropagate);
+    std::enable_if_t<!MaybePropagate>
+    swapData(AgedOrderedContainer& other) noexcept;
 
 private:
     ConfigT config_;
@@ -1244,7 +1247,12 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     AgedOrderedContainer const& other)
-    : config_(other.config_), cont_(other.cont_.get_comp())
+    : config_(other.config_)
+#if BOOST_VERSION >= 108000
+    , cont_(other.cont_.get_comp())
+#else
+    , cont_(other.cont_.comp())
+#endif
 {
     insert(other.cbegin(), other.cend());
 }
@@ -1253,7 +1261,12 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     AgedOrderedContainer const& other,
     Allocator const& alloc)
-    : config_(other.config_, alloc), cont_(other.cont_.get_comp())
+    : config_(other.config_, alloc)
+#if BOOST_VERSION >= 108000
+    , cont_(other.cont_.get_comp())
+#else
+    , cont_(other.cont_.comp())
+#endif
 {
     insert(other.cbegin(), other.cend());
 }
@@ -1270,7 +1283,13 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     AgedOrderedContainer&& other,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
     Allocator const& alloc)
-    : config_(std::move(other.config_), alloc), cont_(std::move(other.cont_.get_comp()))
+    : config_(std::move(other.config_), alloc)
+#if BOOST_VERSION >= 108000
+    , cont_(std::move(other.cont_.get_comp()))
+#else
+    , cont_(std::move(other.cont_.comp()))
+#endif
+
 {
     insert(other.cbegin(), other.cend());
     other.clear();
@@ -1361,10 +1380,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k)
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
     if (iter == cont_.end())
@@ -1373,10 +1391,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional<IsMap, T, void*>::type const&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k) const
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
     if (iter == cont_.end())
@@ -1385,10 +1402,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1404,10 +1420,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1441,8 +1456,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1461,8 +1475,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> iterator
-    requires MaybeMulti
+    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
 {
     auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
     Element* const p(newElement(value));
@@ -1476,8 +1489,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-    -> std::pair<iterator, bool>
-    requires(!MaybeMulti && !MaybeMap)
+    -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1496,8 +1508,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-    -> iterator
-    requires(MaybeMulti && !MaybeMap)
+    -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
 {
     auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
     Element* const p(newElement(std::move(value)));
@@ -1514,8 +1525,7 @@ template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type const& value) -> iterator
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1536,8 +1546,7 @@ template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type&& value) -> iterator
-    requires(!MaybeMulti)
+    value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1557,8 +1566,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1580,8 +1588,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> iterator
-    requires MaybeMulti
+    -> std::enable_if_t<MaybeMulti, iterator>
 {
     Element* const p(newElement(std::forward<Args>(args)...));
     auto const before(cont_.upper_bound(extract(p->value), std::cref(config_.keyCompare())));
@@ -1596,8 +1603,7 @@ template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplaceHint(
     const_iterator hint,
-    Args&&... args) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1616,23 +1622,21 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator>
+template <bool IsConst, class Iterator, class>
 beast::detail::AgedContainerIterator<false, Iterator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
-    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     unlinkAndDeleteElement(&*((pos++).iterator()));
     return beast::detail::AgedContainerIterator<false, Iterator>(pos.iterator());
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator>
+template <bool IsConst, class Iterator, class>
 beast::detail::AgedContainerIterator<false, Iterator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
     beast::detail::AgedContainerIterator<IsConst, Iterator> first,
     beast::detail::AgedContainerIterator<IsConst, Iterator> last)
-    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     for (; first != last;)
         unlinkAndDeleteElement(&*((first++).iterator()));
@@ -1735,12 +1739,11 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator>
+template <bool IsConst, class Iterator, class>
 void
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
     clock_type::time_point const& now)
-    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     auto& e(*pos.iterator());
     e.when = now;
@@ -1750,10 +1753,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool MaybePropagate>
-void
+std::enable_if_t<MaybePropagate>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
     AgedOrderedContainer& other) noexcept
-    requires MaybePropagate
 {
     std::swap(config_.keyCompare(), other.config_.keyCompare());
     std::swap(config_.alloc(), other.config_.alloc());
@@ -1762,10 +1764,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapDat
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool MaybePropagate>
-void
+std::enable_if_t<!MaybePropagate>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
     AgedOrderedContainer& other) noexcept
-    requires(!MaybePropagate)
 {
     std::swap(config_.keyCompare(), other.config_.keyCompare());
     std::swap(config_.clock, other.config_.clock);

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

@@ -10,19 +10,13 @@
 #include <boost/intrusive/unordered_set.hpp>
 
 #include <algorithm>
-#include <chrono>
 #include <cmath>
-#include <cstddef>
-#include <cstdint>
 #include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
-#include <stdexcept>
-#include <tuple>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 /*
 
@@ -117,9 +111,10 @@ private:
         {
         }
 
-        template <class... Args>
+        template <
+            class... Args,
+            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
         Element(time_point const& when, Args&&... args)
-            requires(std::is_constructible_v<value_type, Args...>)
             : value(std::forward<Args>(args)...), when(when)
         {
         }
@@ -528,7 +523,6 @@ private:
     deleteElement(Element const* p)
     {
         ElementAllocatorTraits::destroy(config_.alloc(), p);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         ElementAllocatorTraits::deallocate(config_.alloc(), const_cast<Element*>(p), 1);
     }
 
@@ -841,25 +835,35 @@ public:
     //
     //--------------------------------------------------------------------------
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    at(K const& k)
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k);
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional<IsMap, T, void*>::type const&
-    at(K const& k) const
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k) const;
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key const& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key const& key);
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key&& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key&& key);
 
     //--------------------------------------------------------------------------
     //
@@ -957,32 +961,28 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> iterator
-        requires MaybeMulti;
+    insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // map, set
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti && !MaybeMap);
+    insert(value_type&& value)
+        -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> iterator
-        requires(MaybeMulti && !MaybeMap);
+    insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
 
     // map, set
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<!MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
-        requires(!MaybeMulti)
     {
         // Hint is ignored but we provide the interface so
         // callers may use ordered and unordered interchangeably.
@@ -991,9 +991,8 @@ public:
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
-        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used to let
         //             the client order equal ranges
@@ -1002,9 +1001,8 @@ public:
 
     // map, set
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<!MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
-        requires(!MaybeMulti)
     {
         // Hint is ignored but we provide the interface so
         // callers may use ordered and unordered interchangeably.
@@ -1013,9 +1011,8 @@ public:
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
-        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used to let
         //             the client order equal ranges
@@ -1024,18 +1021,20 @@ public:
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplace(std::forward<P>(value));
     }
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(const_iterator hint, P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -1056,26 +1055,23 @@ public:
     // set, map
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> iterator
-        requires MaybeMulti;
+    emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // set, map
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplaceHint(const_iterator /*hint*/, Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplaceHint(const_iterator /*hint*/, Args&&... args)
+        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     emplaceHint(const_iterator /*hint*/, Args&&... args)
-        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used for multi, to let
         //             the client order equal ranges
@@ -1306,7 +1302,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool MaybeMulti = IsMulti>
-    bool
+    std::enable_if_t<!MaybeMulti, bool>
     operator==(AgedUnorderedContainer<
                false,
                OtherIsMap,
@@ -1315,8 +1311,7 @@ public:
                OtherDuration,
                OtherHash,
                KeyEqual,
-               OtherAllocator> const& other) const
-        requires(!MaybeMulti);
+               OtherAllocator> const& other) const;
 
     template <
         bool OtherIsMap,
@@ -1326,7 +1321,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool MaybeMulti = IsMulti>
-    bool
+    std::enable_if_t<MaybeMulti, bool>
     operator==(AgedUnorderedContainer<
                true,
                OtherIsMap,
@@ -1335,8 +1330,7 @@ public:
                OtherDuration,
                OtherHash,
                KeyEqual,
-               OtherAllocator> const& other) const
-        requires MaybeMulti;
+               OtherAllocator> const& other) const;
 
     template <
         bool OtherIsMulti,
@@ -1381,14 +1375,13 @@ private:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insertUnchecked(value_type const& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    insertUnchecked(value_type const& value)
+        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insertUnchecked(value_type const& value) -> iterator
-        requires MaybeMulti;
+    insertUnchecked(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
 
     template <class InputIt>
     void
@@ -1429,9 +1422,8 @@ private:
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
+    std::enable_if_t<MaybePropagate>
     swapData(AgedUnorderedContainer& other) noexcept
-        requires MaybePropagate
     {
         std::swap(config_.hashFunction(), other.config_.hashFunction());
         std::swap(config_.keyEq(), other.config_.keyEq());
@@ -1441,9 +1433,8 @@ private:
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
+    std::enable_if_t<!MaybePropagate>
     swapData(AgedUnorderedContainer& other) noexcept
-        requires(!MaybePropagate)
     {
         std::swap(config_.hashFunction(), other.config_.hashFunction());
         std::swap(config_.keyEq(), other.config_.keyEq());
@@ -2097,10 +2088,9 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(K const& k)
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(
         cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2118,11 +2108,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional<IsMap, T, void*>::type const&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(
     K const& k) const
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(
         cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2140,11 +2129,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key const& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2170,11 +2158,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key&& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2227,8 +2214,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2257,8 +2243,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> iterator
-    requires MaybeMulti
+    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
 {
     maybeRehash(1);
     Element* const p(newElement(value));
@@ -2280,8 +2265,7 @@ template <
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti && !MaybeMap)
+    value_type&& value) -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2310,8 +2294,7 @@ template <
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> iterator
-    requires(MaybeMulti && !MaybeMap)
+    value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
 {
     maybeRehash(1);
     Element* const p(newElement(std::move(value)));
@@ -2320,6 +2303,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     return iterator(iter);
 }
 
+#if 1  // Use insert() instead of insert_check() insert_commit()
 // set, map
 template <
     bool IsMulti,
@@ -2333,8 +2317,7 @@ template <
 template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2349,6 +2332,42 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     deleteElement(p);
     return std::make_pair(iterator(result.first), false);
 }
+#else   // As original, use insert_check() / insert_commit () pair.
+// set, map
+template <
+    bool IsMulti,
+    bool IsMap,
+    class Key,
+    class T,
+    class Clock,
+    class Hash,
+    class KeyEqual,
+    class Allocator>
+template <bool maybe_multi, class... Args>
+auto
+AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
+    Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+{
+    maybe_rehash(1);
+    // VFALCO NOTE Its unfortunate that we need to
+    //             construct element here
+    element* const p(new_element(std::forward<Args>(args)...));
+    typename cont_type::insert_commit_data d;
+    auto const result(m_cont.insert_check(
+        extract(p->value),
+        std::cref(m_config.hashFunction()),
+        std::cref(m_config.keyValueEqual()),
+        d));
+    if (result.second)
+    {
+        auto const iter(m_cont.insert_commit(*p, d));
+        chronological.list.push_back(*p);
+        return std::make_pair(iterator(iter), true);
+    }
+    delete_element(p);
+    return std::make_pair(iterator(result.first), false);
+}
+#endif  // 0
 
 // multiset, multimap
 template <
@@ -2363,8 +2382,7 @@ template <
 template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> iterator
-    requires MaybeMulti
+    Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>
 {
     maybeRehash(1);
     Element* const p(newElement(std::forward<Args>(args)...));
@@ -2387,8 +2405,7 @@ template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplaceHint(
     const_iterator /*hint*/,
-    Args&&... args) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2539,7 +2556,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool MaybeMulti>
-bool
+std::enable_if_t<!MaybeMulti, bool>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     AgedUnorderedContainer<
         false,
@@ -2550,7 +2567,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
         OtherHash,
         KeyEqual,
         OtherAllocator> const& other) const
-    requires(!MaybeMulti)
 {
     if (size() != other.size())
         return false;
@@ -2580,7 +2596,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool MaybeMulti>
-bool
+std::enable_if_t<MaybeMulti, bool>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     AgedUnorderedContainer<
         true,
@@ -2591,7 +2607,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
         OtherHash,
         KeyEqual,
         OtherAllocator> const& other) const
-    requires MaybeMulti
 {
     if (size() != other.size())
         return false;
@@ -2628,8 +2643,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
-    value_type const& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(
@@ -2657,8 +2671,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
-    value_type const& value) -> iterator
-    requires MaybeMulti
+    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
 {
     Element* const p(newElement(value));
     chronological.list_.push_back(*p);

include/xrpl/beast/core/CurrentThreadName.h

@@ -6,7 +6,6 @@
 
 #include <boost/predef.h>
 
-#include <cstddef>
 #include <string>
 #include <string_view>
 

include/xrpl/beast/core/LexicalCast.h

@@ -5,12 +5,11 @@
 #include <boost/core/detail/string_view.hpp>
 
 #include <algorithm>
-#include <cctype>
+#include <cerrno>
 #include <charconv>
+#include <cstdlib>
 #include <iterator>
 #include <string>
-#include <string_view>
-#include <system_error>
 #include <type_traits>
 #include <typeinfo>
 
@@ -29,18 +28,16 @@ struct LexicalCast<std::string, In>
     explicit LexicalCast() = default;
 
     template <class Arithmetic = In>
-    bool
+    std::enable_if_t<std::is_arithmetic_v<Arithmetic>, bool>
     operator()(std::string& out, Arithmetic in)
-        requires(std::is_arithmetic_v<Arithmetic>)
     {
         out = std::to_string(in);
         return true;
     }
 
     template <class Enumeration = In>
-    bool
+    std::enable_if_t<std::is_enum_v<Enumeration>, bool>
     operator()(std::string& out, Enumeration in)
-        requires(std::is_enum_v<Enumeration>)
     {
         out = std::to_string(static_cast<std::underlying_type_t<Enumeration>>(in));
         return true;
@@ -58,9 +55,8 @@ struct LexicalCast<Out, std::string_view>
         "beast::LexicalCast can only be used with integral types");
 
     template <class Integral = Out>
-    bool
+    std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, bool>
     operator()(Integral& out, std::string_view in) const
-        requires(std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>)
     {
         auto first = in.data();
         auto last = in.data() + in.size();

include/xrpl/beast/core/List.h

@@ -1,8 +1,6 @@
 #pragma once
 
-#include <cstddef>
 #include <iterator>
-#include <type_traits>
 
 namespace beast {
 

include/xrpl/beast/core/LockFreeStack.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <atomic>
-#include <cstddef>
 #include <iterator>
 #include <type_traits>
 
@@ -41,7 +40,7 @@ public:
     operator=(NodePtr node)
     {
         node_ = node;
-        return *this;
+        return static_cast<LockFreeStackIterator&>(*this);
     }
 
     LockFreeStackIterator&
@@ -59,7 +58,7 @@ public:
         return result;
     }
 
-    [[nodiscard]] NodePtr
+    NodePtr
     node() const
     {
         return node_;

include/xrpl/beast/hash/hash_append.h

@@ -5,8 +5,8 @@
 
 #include <array>
 #include <chrono>
-#include <cstddef>
 #include <cstring>
+#include <functional>
 #include <memory>
 #include <string>
 #include <system_error>
@@ -26,7 +26,7 @@ template <class T>
 inline void
 reverseBytes(T& t)
 {
-    auto* bytes =
+    unsigned char* bytes =
         static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
     for (unsigned i = 0; i < sizeof(T) / 2; ++i)
         std::swap(bytes[i], bytes[sizeof(T) - 1 - i]);
@@ -200,29 +200,26 @@ struct IsContiguouslyHashable<T[N], HashAlgorithm>
 // scalars
 
 template <class Hasher, class T>
-inline void
+inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, T const& t) noexcept
-    requires(IsContiguouslyHashable<T, Hasher>::value)
 {
     // NOLINTNEXTLINE(bugprone-sizeof-expression)
     h(static_cast<void const*>(std::addressof(t)), sizeof(t));
 }
 
 template <class Hasher, class T>
-inline void
+inline std::enable_if_t<
+    !IsContiguouslyHashable<T, Hasher>::value &&
+    (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
 hash_append(Hasher& h, T t) noexcept
-    requires(
-        !IsContiguouslyHashable<T, Hasher>::value &&
-        (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>))
 {
     detail::reverseBytes(t);
     h(std::addressof(t), sizeof(t));
 }
 
 template <class Hasher, class T>
-inline void
+inline std::enable_if_t<std::is_floating_point_v<T>>
 hash_append(Hasher& h, T t) noexcept
-    requires(std::is_floating_point_v<T>)
 {
     if (t == 0)
         t = 0;
@@ -242,44 +239,36 @@ hash_append(Hasher& h, std::nullptr_t) noexcept
 // Forward declarations for ADL purposes
 
 template <class Hasher, class T, std::size_t N>
-void
-hash_append(Hasher& h, T (&a)[N]) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
+hash_append(Hasher& h, T (&a)[N]) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-void
-hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(!IsContiguouslyHashable<CharT, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-void
-hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(IsContiguouslyHashable<CharT, Hasher>::value);
+std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class T, class U>
-void
-hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
-    requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
+hash_append(Hasher& h, std::pair<T, U> const& p) noexcept;
 
 template <class Hasher, class T, class Alloc>
-void
-hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
+hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
 
 template <class Hasher, class T, class Alloc>
-void
-hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<T, Hasher>::value);
+std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
+hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
 
 template <class Hasher, class T, std::size_t N>
-void
-hash_append(Hasher& h, std::array<T, N> const& a) noexcept
-    requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
+hash_append(Hasher& h, std::array<T, N> const& a) noexcept;
 
 template <class Hasher, class... T>
-void
-hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
-    requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
+hash_append(Hasher& h, std::tuple<T...> const& t) noexcept;
 
 template <class Hasher, class Key, class T, class Hash, class Pred, class Alloc>
 void
@@ -290,13 +279,11 @@ void
 hash_append(Hasher& h, std::unordered_set<Key, Hash, Pred, Alloc> const& s);
 
 template <class Hasher, class Key, class Compare, class Alloc>
-void
-hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<Key, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
 template <class Hasher, class Key, class Compare, class Alloc>
-void
-hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<Key, Hasher>::value);
+std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
 template <class Hasher, class T0, class T1, class... T>
 void
 hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
@@ -304,9 +291,8 @@ hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
 // c-array
 
 template <class Hasher, class T, std::size_t N>
-void
+std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, T (&a)[N]) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value)
 {
     for (auto const& t : a)
         hash_append(h, t);
@@ -315,9 +301,8 @@ hash_append(Hasher& h, T (&a)[N]) noexcept
 // basic_string
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-inline void
+inline std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(!IsContiguouslyHashable<CharT, Hasher>::value)
 {
     for (auto c : s)
         hash_append(h, c);
@@ -325,9 +310,8 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
 }
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-inline void
+inline std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(IsContiguouslyHashable<CharT, Hasher>::value)
 {
     h(s.data(), s.size() * sizeof(CharT));
     hash_append(h, s.size());
@@ -336,9 +320,8 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
 // pair
 
 template <class Hasher, class T, class U>
-inline void
+inline std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
 hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
-    requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value)
 {
     hash_append(h, p.first, p.second);
 }
@@ -346,9 +329,8 @@ hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
 // vector
 
 template <class Hasher, class T, class Alloc>
-inline void
+inline std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value)
 {
     for (auto const& t : v)
         hash_append(h, t);
@@ -356,9 +338,8 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
 }
 
 template <class Hasher, class T, class Alloc>
-inline void
+inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<T, Hasher>::value)
 {
     h(v.data(), v.size() * sizeof(T));
     hash_append(h, v.size());
@@ -367,37 +348,57 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
 // array
 
 template <class Hasher, class T, std::size_t N>
-void
+std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
 hash_append(Hasher& h, std::array<T, N> const& a) noexcept
-    requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value)
 {
     for (auto const& t : a)
         hash_append(h, t);
 }
 
 template <class Hasher, class Key, class Compare, class Alloc>
-void
+std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
 hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<Key, Hasher>::value)
 {
     for (auto const& t : v)
         hash_append(h, t);
 }
 template <class Hasher, class Key, class Compare, class Alloc>
-void
+std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
 hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<Key, Hasher>::value)
 {
     h(&(v.begin()), v.size() * sizeof(Key));
 }
 // tuple
 
-template <class Hasher, class... T>
+namespace detail {
+
 inline void
-hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
-    requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value)
+forEachItem(...) noexcept
 {
-    std::apply([&h](auto const&... item) { (hash_append(h, item), ...); }, t);
+}
+
+template <class Hasher, class T>
+inline int
+hashOne(Hasher& h, T const& t) noexcept
+{
+    hash_append(h, t);
+    return 0;
+}
+
+template <class Hasher, class... T, std::size_t... I>
+inline void
+tuple_hash(Hasher& h, std::tuple<T...> const& t, std::index_sequence<I...>) noexcept
+{
+    for_each_item(hash_one(h, std::get<I>(t))...);
+}
+
+}  // namespace detail
+
+template <class Hasher, class... T>
+inline std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
+hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
+{
+    detail::tuple_hash(h, t, std::index_sequence_for<T...>{});
 }
 
 // shared_ptr

include/xrpl/beast/hash/xxhasher.h

@@ -124,18 +124,14 @@ public:
         }
     }
 
-    template <class Seed>
-    explicit Xxhasher(Seed seed)
-        requires(std::is_unsigned_v<Seed>)
-        : seed_(seed)
+    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
+    explicit Xxhasher(Seed seed) : seed_(seed)
     {
         resetBuffers();
     }
 
-    template <class Seed>
-    Xxhasher(Seed seed, Seed)
-        requires(std::is_unsigned_v<Seed>)
-        : seed_(seed)
+    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
+    Xxhasher(Seed seed, Seed) : seed_(seed)
     {
         resetBuffers();
     }

include/xrpl/beast/insight/Collector.h

@@ -4,10 +4,8 @@
 #include <xrpl/beast/insight/Event.h>
 #include <xrpl/beast/insight/Gauge.h>
 #include <xrpl/beast/insight/Hook.h>
-#include <xrpl/beast/insight/HookImpl.h>
 #include <xrpl/beast/insight/Meter.h>
 
-#include <memory>
 #include <string>
 
 namespace beast::insight {

include/xrpl/beast/insight/Gauge.h

@@ -49,11 +49,6 @@ public:
             impl_->set(value);
     }
 
-    // This is a write-through handle: assignment sets the value of the
-    // referenced metric.  It is const-qualified and returns Gauge const&
-    // (a non-const Gauge& would require a const_cast), so it does not follow
-    // the conventional assignment-operator signature.
-    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     Gauge const&
     operator=(value_type value) const
     {

include/xrpl/beast/insight/Insight.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <xrpl/beast/insight/Collector.h>
+#include <xrpl/beast/insight/Counter.h>
+#include <xrpl/beast/insight/CounterImpl.h>
+#include <xrpl/beast/insight/Event.h>
+#include <xrpl/beast/insight/EventImpl.h>
+#include <xrpl/beast/insight/Gauge.h>
+#include <xrpl/beast/insight/GaugeImpl.h>
+#include <xrpl/beast/insight/Group.h>
+#include <xrpl/beast/insight/Groups.h>
+#include <xrpl/beast/insight/Hook.h>
+#include <xrpl/beast/insight/HookImpl.h>
+#include <xrpl/beast/insight/NullCollector.h>
+#include <xrpl/beast/insight/StatsDCollector.h>

include/xrpl/beast/insight/NullCollector.h

@@ -2,8 +2,6 @@
 
 #include <xrpl/beast/insight/Collector.h>
 
-#include <memory>
-
 namespace beast::insight {
 
 /** A Collector which does not collect metrics. */

include/xrpl/beast/insight/StatsDCollector.h

@@ -4,9 +4,6 @@
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/Journal.h>
 
-#include <memory>
-#include <string>
-
 namespace beast::insight {
 
 /** A Collector that reports metrics to a StatsD server.

include/xrpl/beast/net/IPAddress.h

@@ -9,7 +9,6 @@
 #include <boost/asio/ip/address.hpp>
 #include <boost/functional/hash.hpp>
 
-#include <cstddef>
 #include <string>
 
 //------------------------------------------------------------------------------

include/xrpl/beast/net/IPAddressV4.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <xrpl/beast/hash/hash_append.h>
+
 #include <boost/asio/ip/address_v4.hpp>
 
 namespace beast::IP {

include/xrpl/beast/net/IPAddressV6.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <xrpl/beast/utility/instrumentation.h>
+
 #include <boost/asio/ip/address_v6.hpp>
 
 namespace beast::IP {

include/xrpl/beast/net/IPEndpoint.h

@@ -3,13 +3,8 @@
 #include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/net/IPAddress.h>
-#include <xrpl/beast/net/IPAddressV4.h>
-#include <xrpl/beast/net/IPAddressV6.h>
 
-#include <cstddef>
 #include <cstdint>
-#include <functional>
-#include <istream>
 #include <optional>
 #include <string>
 

include/xrpl/beast/rfc2616.h

@@ -8,7 +8,6 @@
 
 #include <algorithm>
 #include <cctype>
-#include <cstddef>
 #include <iterator>
 #include <string>
 #include <vector>

include/xrpl/beast/test/yield_to.h

@@ -11,8 +11,6 @@
 #include <boost/thread/csbl/memory/allocator_arg.hpp>
 
 #include <condition_variable>
-#include <cstddef>
-#include <exception>
 #include <mutex>
 #include <thread>
 #include <vector>

include/xrpl/beast/type_name.h

@@ -23,7 +23,6 @@ typeName()
     if (auto s = abi::__cxa_demangle(name.c_str(), nullptr, nullptr, nullptr))
     {
         name = s;
-        // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
         std::free(s);
     }
 #endif

include/xrpl/beast/unit_test.h

@@ -1,6 +1,15 @@
 #pragma once
 
+#include <xrpl/beast/unit_test/amount.h>
+#include <xrpl/beast/unit_test/global_suites.h>
+#include <xrpl/beast/unit_test/match.h>
+#include <xrpl/beast/unit_test/recorder.h>
+#include <xrpl/beast/unit_test/reporter.h>
+#include <xrpl/beast/unit_test/results.h>
+#include <xrpl/beast/unit_test/runner.h>
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/unit_test/suite_info.h>
+#include <xrpl/beast/unit_test/suite_list.h>
 
 #ifndef BEAST_EXPECT
 #define BEAST_EXPECT_S1(x) #x

include/xrpl/beast/unit_test/match.h

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

include/xrpl/beast/unit_test/recorder.h

@@ -6,10 +6,6 @@
 
 #include <xrpl/beast/unit_test/results.h>
 #include <xrpl/beast/unit_test/runner.h>
-#include <xrpl/beast/unit_test/suite_info.h>
-
-#include <string>
-#include <utility>
 
 namespace beast::unit_test {
 

include/xrpl/beast/unit_test/reporter.h

@@ -5,21 +5,18 @@
 #pragma once
 
 #include <xrpl/beast/unit_test/amount.h>
-#include <xrpl/beast/unit_test/runner.h>
-#include <xrpl/beast/unit_test/suite_info.h>
+#include <xrpl/beast/unit_test/recorder.h>
 
 #include <boost/lexical_cast.hpp>
 #include <boost/optional.hpp>
 
 #include <algorithm>
 #include <chrono>
-#include <cstddef>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <utility>
-#include <vector>
 
 namespace beast::unit_test {
 

include/xrpl/beast/unit_test/results.h

@@ -6,7 +6,6 @@
 
 #include <xrpl/beast/unit_test/detail/const_container.h>
 
-#include <cstddef>
 #include <string>
 #include <utility>
 #include <vector>

include/xrpl/beast/unit_test/suite.h

@@ -10,8 +10,6 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/throw_exception.hpp>
 
-#include <exception>
-#include <memory>
 #include <ostream>
 #include <sstream>
 #include <string>
@@ -636,7 +634,7 @@ Suite::run(Runner& r)
 #define BEAST_DEFINE_TESTSUITE_MANUAL_PRIO(Class, Module, Library, Priority)
 
 #else
-#include <xrpl/beast/unit_test/global_suites.h>  // IWYU pragma: keep
+#include <xrpl/beast/unit_test/global_suites.h>
 #define BEAST_DEFINE_TESTSUITE(Class, Module, Library) \
     BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, false, 0)
 #define BEAST_DEFINE_TESTSUITE_MANUAL(Class, Module, Library) \

include/xrpl/beast/unit_test/suite_info.h

@@ -4,9 +4,9 @@
 
 #pragma once
 
+#include <cstring>
 #include <functional>
 #include <string>
-#include <tuple>
 #include <utility>
 
 namespace beast::unit_test {

include/xrpl/beast/unit_test/suite_list.h

@@ -10,9 +10,8 @@
 #include <boost/assert.hpp>
 
 #include <set>
-#include <string>         // IWYU pragma: keep
-#include <typeindex>      // IWYU pragma: keep
-#include <unordered_set>  // IWYU pragma: keep
+#include <typeindex>
+#include <unordered_set>
 
 namespace beast::unit_test {
 

include/xrpl/beast/unit_test/thread.h

@@ -6,9 +6,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 
-#include <exception>
 #include <functional>
-#include <string>
 #include <thread>
 #include <utility>
 
@@ -45,10 +43,7 @@ public:
     template <class F, class... Args>
     explicit Thread(Suite& s, F&& f, Args&&... args) : s_(&s)
     {
-        std::function<void(void)> b = [f = std::forward<F>(f),
-                                       ... args = std::forward<Args>(args)]() mutable {
-            std::invoke(f, args...);
-        };
+        std::function<void(void)> b = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
         t_ = std::thread(&Thread::run, this, std::move(b));
     }
 

include/xrpl/beast/utility/Journal.h

@@ -3,10 +3,7 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <cstdint>
-#include <ostream>
 #include <sstream>
-#include <string>
-#include <type_traits>
 
 namespace beast {
 
@@ -108,12 +105,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(!std::is_default_constructible_v<Sink>);
-    static_assert(!std::is_copy_constructible_v<Sink>);
-    static_assert(!std::is_move_constructible_v<Sink>);
-    static_assert(!std::is_copy_assignable_v<Sink>);
-    static_assert(!std::is_move_assignable_v<Sink>);
-    static_assert(std::is_nothrow_destructible_v<Sink>);
+    static_assert(!std::is_default_constructible_v<Sink>, "");
+    static_assert(!std::is_copy_constructible_v<Sink>, "");
+    static_assert(!std::is_move_constructible_v<Sink>, "");
+    static_assert(!std::is_copy_assignable_v<Sink>, "");
+    static_assert(!std::is_move_assignable_v<Sink>, "");
+    static_assert(std::is_nothrow_destructible_v<Sink>, "");
 #endif
 
     /** Returns a Sink which does nothing. */
@@ -164,12 +161,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(!std::is_default_constructible_v<ScopedStream>);
-    static_assert(std::is_copy_constructible_v<ScopedStream>);
-    static_assert(std::is_move_constructible_v<ScopedStream>);
-    static_assert(!std::is_copy_assignable_v<ScopedStream>);
-    static_assert(!std::is_move_assignable_v<ScopedStream>);
-    static_assert(std::is_nothrow_destructible_v<ScopedStream>);
+    static_assert(!std::is_default_constructible_v<ScopedStream>, "");
+    static_assert(std::is_copy_constructible_v<ScopedStream>, "");
+    static_assert(std::is_move_constructible_v<ScopedStream>, "");
+    static_assert(!std::is_copy_assignable_v<ScopedStream>, "");
+    static_assert(!std::is_move_assignable_v<ScopedStream>, "");
+    static_assert(std::is_nothrow_destructible_v<ScopedStream>, "");
 #endif
 
     //--------------------------------------------------------------------------
@@ -246,12 +243,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(std::is_default_constructible_v<Stream>);
-    static_assert(std::is_copy_constructible_v<Stream>);
-    static_assert(std::is_move_constructible_v<Stream>);
-    static_assert(!std::is_copy_assignable_v<Stream>);
-    static_assert(!std::is_move_assignable_v<Stream>);
-    static_assert(std::is_nothrow_destructible_v<Stream>);
+    static_assert(std::is_default_constructible_v<Stream>, "");
+    static_assert(std::is_copy_constructible_v<Stream>, "");
+    static_assert(std::is_move_constructible_v<Stream>, "");
+    static_assert(!std::is_copy_assignable_v<Stream>, "");
+    static_assert(!std::is_move_assignable_v<Stream>, "");
+    static_assert(std::is_nothrow_destructible_v<Stream>, "");
 #endif
 
     //--------------------------------------------------------------------------
@@ -329,12 +326,12 @@ public:
 };
 
 #ifndef __INTELLISENSE__
-static_assert(!std::is_default_constructible_v<Journal>);
-static_assert(std::is_copy_constructible_v<Journal>);
-static_assert(std::is_move_constructible_v<Journal>);
-static_assert(std::is_copy_assignable_v<Journal>);
-static_assert(std::is_move_assignable_v<Journal>);
-static_assert(std::is_nothrow_destructible_v<Journal>);
+static_assert(!std::is_default_constructible_v<Journal>, "");
+static_assert(std::is_copy_constructible_v<Journal>, "");
+static_assert(std::is_move_constructible_v<Journal>, "");
+static_assert(std::is_copy_assignable_v<Journal>, "");
+static_assert(std::is_move_assignable_v<Journal>, "");
+static_assert(std::is_nothrow_destructible_v<Journal>, "");
 #endif
 
 //------------------------------------------------------------------------------

include/xrpl/beast/utility/PropertyStream.h

@@ -3,10 +3,8 @@
 #include <xrpl/beast/core/List.h>
 
 #include <mutex>
-#include <ostream>
 #include <sstream>
 #include <string>
-#include <utility>
 
 namespace beast {
 

include/xrpl/beast/utility/WrappedSink.h

@@ -2,7 +2,6 @@
 
 #include <xrpl/beast/utility/Journal.h>
 
-#include <string>
 #include <utility>
 
 namespace beast {

include/xrpl/beast/utility/Zero.h

@@ -26,7 +26,9 @@ struct Zero
     explicit Zero() = default;
 };
 
-inline constexpr Zero kZero{};
+namespace {
+constexpr Zero kZero{};
+}  // namespace
 
 /** Default implementation of signum calls the method on the class. */
 template <typename T>

include/xrpl/beast/utility/rngfill.h

@@ -1,8 +1,11 @@
 #pragma once
 
+#include <xrpl/beast/utility/instrumentation.h>
+
 #include <array>
 #include <cstdint>
 #include <cstring>
+#include <type_traits>
 
 namespace beast {
 
@@ -13,7 +16,7 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     using result_type = Generator::result_type;
     constexpr std::size_t kResultSize = sizeof(result_type);
 
-    auto* const bufferStart = static_cast<std::uint8_t*>(buffer);
+    std::uint8_t* const bufferStart = static_cast<std::uint8_t*>(buffer);
     std::size_t const completeIterations = bytes / kResultSize;
     std::size_t const bytesRemaining = bytes % kResultSize;
 
@@ -32,14 +35,16 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     }
 }
 
-template <class Generator, std::size_t N>
+template <
+    class Generator,
+    std::size_t N,
+    class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
 void
 rngfill(std::array<std::uint8_t, N>& a, Generator& g)
-    requires(N % sizeof(typename Generator::result_type) == 0)
 {
     using result_type = Generator::result_type;
     auto i = N / sizeof(result_type);
-    auto* p = reinterpret_cast<result_type*>(a.data());
+    result_type* p = reinterpret_cast<result_type*>(a.data());
     while (i--)
         *p++ = g();
 }

include/xrpl/conditions/Condition.h

@@ -4,12 +4,8 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/conditions/detail/utils.h>
 
-#include <cstddef>
 #include <cstdint>
-#include <memory>
 #include <set>
-#include <system_error>
-#include <utility>
 
 namespace xrpl::cryptoconditions {
 

include/xrpl/conditions/Fulfillment.h

@@ -4,11 +4,6 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/conditions/Condition.h>
 
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <system_error>
-
 namespace xrpl::cryptoconditions {
 
 struct Fulfillment

include/xrpl/conditions/detail/PreimageSha256.h

@@ -7,11 +7,7 @@
 #include <xrpl/conditions/detail/error.h>
 #include <xrpl/protocol/digest.h>
 
-#include <cstddef>
-#include <cstdint>
 #include <memory>
-#include <system_error>
-#include <utility>
 
 namespace xrpl::cryptoconditions {
 

include/xrpl/conditions/detail/utils.h

@@ -6,10 +6,7 @@
 
 #include <boost/dynamic_bitset.hpp>
 
-#include <cstddef>
-#include <cstdint>
 #include <limits>
-#include <system_error>
 
 // A collection of functions to decode binary blobs
 // encoded with X.690 Distinguished Encoding Rules.