chore: Format all cmake files without comments (#6294)

This change adds `cmake-format` as. a pre-commit hook. The style file closely matches that in Clio, and they will be made to be equivalent over time. For now, some files have been excluded, as those need some manual adjustments, which will be done in future changes.

.clang-format

@@ -37,7 +37,7 @@ BinPackParameters: false
 BreakBeforeBinaryOperators: false
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: true
-ColumnLimit: 80
+ColumnLimit: 120
 CommentPragmas: "^ IWYU pragma:"
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4

.cmake-format.yaml

@@ -0,0 +1,247 @@
+_help_parse: Options affecting listfile parsing
+parse:
+  _help_additional_commands:
+    - Specify structure for custom cmake functions
+  additional_commands:
+    target_protobuf_sources:
+      pargs:
+        - target
+        - prefix
+      kwargs:
+        PROTOS: "*"
+        LANGUAGE: cpp
+        IMPORT_DIRS: "*"
+        GENERATE_EXTENSIONS: "*"
+        PLUGIN: "*"
+  _help_override_spec:
+    - Override configurations per-command where available
+  override_spec: {}
+  _help_vartags:
+    - Specify variable tags.
+  vartags: []
+  _help_proptags:
+    - Specify property tags.
+  proptags: []
+_help_format: Options affecting formatting.
+format:
+  _help_disable:
+    - Disable formatting entirely, making cmake-format a no-op
+  disable: false
+  _help_line_width:
+    - How wide to allow formatted cmake files
+  line_width: 120
+  _help_tab_size:
+    - How many spaces to tab for indent
+  tab_size: 4
+  _help_use_tabchars:
+    - If true, lines are indented using tab characters (utf-8
+    - 0x09) instead of <tab_size> space characters (utf-8 0x20).
+    - In cases where the layout would require a fractional tab
+    - character, the behavior of the  fractional indentation is
+    - governed by <fractional_tab_policy>
+  use_tabchars: false
+  _help_fractional_tab_policy:
+    - If <use_tabchars> is True, then the value of this variable
+    - indicates how fractional indentions are handled during
+    - whitespace replacement. If set to 'use-space', fractional
+    - indentation is left as spaces (utf-8 0x20). If set to
+    - "`round-up` fractional indentation is replaced with a single"
+    - tab character (utf-8 0x09) effectively shifting the column
+    - to the next tabstop
+  fractional_tab_policy: use-space
+  _help_max_subgroups_hwrap:
+    - If an argument group contains more than this many sub-groups
+    - (parg or kwarg groups) then force it to a vertical layout.
+  max_subgroups_hwrap: 4
+  _help_max_pargs_hwrap:
+    - If a positional argument group contains more than this many
+    - arguments, then force it to a vertical layout.
+  max_pargs_hwrap: 5
+  _help_max_rows_cmdline:
+    - If a cmdline positional group consumes more than this many
+    - lines without nesting, then invalidate the layout (and nest)
+  max_rows_cmdline: 2
+  _help_separate_ctrl_name_with_space:
+    - If true, separate flow control names from their parentheses
+    - with a space
+  separate_ctrl_name_with_space: true
+  _help_separate_fn_name_with_space:
+    - If true, separate function names from parentheses with a
+    - space
+  separate_fn_name_with_space: false
+  _help_dangle_parens:
+    - If a statement is wrapped to more than one line, than dangle
+    - the closing parenthesis on its own line.
+  dangle_parens: false
+  _help_dangle_align:
+    - If the trailing parenthesis must be 'dangled' on its on
+    - "line, then align it to this reference: `prefix`: the start"
+    - "of the statement, `prefix-indent`: the start of the"
+    - "statement, plus one indentation level, `child`: align to"
+    - the column of the arguments
+  dangle_align: prefix
+  _help_min_prefix_chars:
+    - If the statement spelling length (including space and
+    - parenthesis) is smaller than this amount, then force reject
+    - nested layouts.
+  min_prefix_chars: 18
+  _help_max_prefix_chars:
+    - If the statement spelling length (including space and
+    - parenthesis) is larger than the tab width by more than this
+    - amount, then force reject un-nested layouts.
+  max_prefix_chars: 10
+  _help_max_lines_hwrap:
+    - If a candidate layout is wrapped horizontally but it exceeds
+    - this many lines, then reject the layout.
+  max_lines_hwrap: 2
+  _help_line_ending:
+    - What style line endings to use in the output.
+  line_ending: unix
+  _help_command_case:
+    - Format command names consistently as 'lower' or 'upper' case
+  command_case: canonical
+  _help_keyword_case:
+    - Format keywords consistently as 'lower' or 'upper' case
+  keyword_case: unchanged
+  _help_always_wrap:
+    - A list of command names which should always be wrapped
+  always_wrap: []
+  _help_enable_sort:
+    - If true, the argument lists which are known to be sortable
+    - will be sorted lexicographicall
+  enable_sort: true
+  _help_autosort:
+    - If true, the parsers may infer whether or not an argument
+    - list is sortable (without annotation).
+  autosort: true
+  _help_require_valid_layout:
+    - By default, if cmake-format cannot successfully fit
+    - everything into the desired linewidth it will apply the
+    - last, most aggressive attempt that it made. If this flag is
+    - True, however, cmake-format will print error, exit with non-
+    - zero status code, and write-out nothing
+  require_valid_layout: false
+  _help_layout_passes:
+    - A dictionary mapping layout nodes to a list of wrap
+    - decisions. See the documentation for more information.
+  layout_passes: {}
+_help_markup: Options affecting comment reflow and formatting.
+markup:
+  _help_bullet_char:
+    - What character to use for bulleted lists
+  bullet_char: "-"
+  _help_enum_char:
+    - What character to use as punctuation after numerals in an
+    - enumerated list
+  enum_char: .
+  _help_first_comment_is_literal:
+    - If comment markup is enabled, don't reflow the first comment
+    - block in each listfile. Use this to preserve formatting of
+    - your copyright/license statements.
+  first_comment_is_literal: false
+  _help_literal_comment_pattern:
+    - If comment markup is enabled, don't reflow any comment block
+    - which matches this (regex) pattern. Default is `None`
+    - (disabled).
+  literal_comment_pattern: null
+  _help_fence_pattern:
+    - Regular expression to match preformat fences in comments
+    - default= ``r'^\s*([`~]{3}[`~]*)(.*)$'``
+  fence_pattern: ^\s*([`~]{3}[`~]*)(.*)$
+  _help_ruler_pattern:
+    - Regular expression to match rulers in comments default=
+    - '``r''^\s*[^\w\s]{3}.*[^\w\s]{3}$''``'
+  ruler_pattern: ^\s*[^\w\s]{3}.*[^\w\s]{3}$
+  _help_explicit_trailing_pattern:
+    - If a comment line matches starts with this pattern then it
+    - is explicitly a trailing comment for the preceding
+    - argument. Default is '#<'
+  explicit_trailing_pattern: "#<"
+  _help_hashruler_min_length:
+    - If a comment line starts with at least this many consecutive
+    - hash characters, then don't lstrip() them off. This allows
+    - for lazy hash rulers where the first hash char is not
+    - separated by space
+  hashruler_min_length: 10
+  _help_canonicalize_hashrulers:
+    - If true, then insert a space between the first hash char and
+    - remaining hash chars in a hash ruler, and normalize its
+    - length to fill the column
+  canonicalize_hashrulers: true
+  _help_enable_markup:
+    - enable comment markup parsing and reflow
+  enable_markup: false
+_help_lint: Options affecting the linter
+lint:
+  _help_disabled_codes:
+    - a list of lint codes to disable
+  disabled_codes: []
+  _help_function_pattern:
+    - regular expression pattern describing valid function names
+  function_pattern: "[0-9a-z_]+"
+  _help_macro_pattern:
+    - regular expression pattern describing valid macro names
+  macro_pattern: "[0-9A-Z_]+"
+  _help_global_var_pattern:
+    - regular expression pattern describing valid names for
+    - variables with global (cache) scope
+  global_var_pattern: "[A-Z][0-9A-Z_]+"
+  _help_internal_var_pattern:
+    - regular expression pattern describing valid names for
+    - variables with global scope (but internal semantic)
+  internal_var_pattern: _[A-Z][0-9A-Z_]+
+  _help_local_var_pattern:
+    - regular expression pattern describing valid names for
+    - variables with local scope
+  local_var_pattern: "[a-z][a-z0-9_]+"
+  _help_private_var_pattern:
+    - regular expression pattern describing valid names for
+    - privatedirectory variables
+  private_var_pattern: _[0-9a-z_]+
+  _help_public_var_pattern:
+    - regular expression pattern describing valid names for public
+    - directory variables
+  public_var_pattern: "[A-Z][0-9A-Z_]+"
+  _help_argument_var_pattern:
+    - regular expression pattern describing valid names for
+    - function/macro arguments and loop variables.
+  argument_var_pattern: "[a-z][a-z0-9_]+"
+  _help_keyword_pattern:
+    - regular expression pattern describing valid names for
+    - keywords used in functions or macros
+  keyword_pattern: "[A-Z][0-9A-Z_]+"
+  _help_max_conditionals_custom_parser:
+    - In the heuristic for C0201, how many conditionals to match
+    - within a loop in before considering the loop a parser.
+  max_conditionals_custom_parser: 2
+  _help_min_statement_spacing:
+    - Require at least this many newlines between statements
+  min_statement_spacing: 1
+  _help_max_statement_spacing:
+    - Require no more than this many newlines between statements
+  max_statement_spacing: 2
+  max_returns: 6
+  max_branches: 12
+  max_arguments: 5
+  max_localvars: 15
+  max_statements: 50
+_help_encode: Options affecting file encoding
+encode:
+  _help_emit_byteorder_mark:
+    - If true, emit the unicode byte-order mark (BOM) at the start
+    - of the file
+  emit_byteorder_mark: false
+  _help_input_encoding:
+    - Specify the encoding of the input file. Defaults to utf-8
+  input_encoding: utf-8
+  _help_output_encoding:
+    - Specify the encoding of the output file. Defaults to utf-8.
+    - Note that cmake only claims to support utf-8 so be careful
+    - when using anything else
+  output_encoding: utf-8
+_help_misc: Miscellaneous configurations options.
+misc:
+  _help_per_command:
+    - A dictionary containing any per-command configuration
+    - overrides. Currently only `command_case` is supported.
+  per_command: {}

.config/cspell.config.yaml

@@ -101,6 +101,7 @@ words:
   - gpgcheck
   - gpgkey
   - hotwallet
+  - hwrap
   - ifndef
   - inequation
   - insuf
@@ -114,6 +115,8 @@ words:
   - keylet
   - keylets
   - keyvadb
+  - kwarg
+  - kwargs
   - ledgerentry
   - ledgerhash
   - ledgerindex
@@ -163,6 +166,7 @@ words:
   - nunl
   - Nyffenegger
   - ostr
+  - pargs
   - partitioner
   - paychan
   - paychans

.github/actions/generate-version/action.yml

@@ -0,0 +1,44 @@
+name: Generate build version number
+description: "Generate build version number."
+
+outputs:
+  version:
+    description: "The generated build version number."
+    value: ${{ steps.version.outputs.version }}
+
+runs:
+  using: composite
+  steps:
+    # When a tag is pushed, the version is used as-is.
+    - name: Generate version for tag event
+      if: ${{ github.event_name == 'tag' }}
+      shell: bash
+      env:
+        VERSION: ${{ github.ref_name }}
+      run: echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
+
+    # When a tag is not pushed, then the version (e.g. 1.2.3-b0) is extracted
+    # from the BuildInfo.cpp file and the shortened commit hash appended to it.
+    # We use a plus sign instead of a hyphen because Conan recipe versions do
+    # not support two hyphens.
+    - name: Generate version for non-tag event
+      if: ${{ github.event_name != 'tag' }}
+      shell: bash
+      run: |
+        echo 'Extracting version from BuildInfo.cpp.'
+        VERSION="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')"
+        if [[ -z "${VERSION}" ]]; then
+          echo 'Unable to extract version from BuildInfo.cpp.'
+          exit 1
+        fi
+
+        echo 'Appending shortened commit hash to version.'
+        SHA='${{ github.sha }}'
+        VERSION="${VERSION}+${SHA:0:7}"
+
+        echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
+
+    - name: Output version
+      id: version
+      shell: bash
+      run: echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"

.github/actions/setup-conan/action.yml

@@ -2,11 +2,11 @@ name: Setup Conan
 description: "Set up Conan configuration, profile, and remote."
 
 inputs:
-  conan_remote_name:
+  remote_name:
     description: "The name of the Conan remote to use."
     required: false
     default: xrplf
-  conan_remote_url:
+  remote_url:
     description: "The URL of the Conan endpoint to use."
     required: false
     default: https://conan.ripplex.io
@@ -31,16 +31,16 @@ runs:
         conan config install conan/profiles/ -tf $(conan config home)/profiles/
 
         echo 'Conan profile:'
-        conan profile show
+        conan profile show --profile ci
 
     - name: Set up Conan remote
       shell: bash
       env:
-        CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
+        REMOTE_NAME: ${{ inputs.remote_name }}
-        CONAN_REMOTE_URL: ${{ inputs.conan_remote_url }}
+        REMOTE_URL: ${{ inputs.remote_url }}
       run: |
-        echo "Adding Conan remote '${CONAN_REMOTE_NAME}' at '${CONAN_REMOTE_URL}'."
+        echo "Adding Conan remote '${REMOTE_NAME}' at '${REMOTE_URL}'."
-        conan remote add --index 0 --force "${CONAN_REMOTE_NAME}" "${CONAN_REMOTE_URL}"
+        conan remote add --index 0 --force "${REMOTE_NAME}" "${REMOTE_URL}"
 
         echo 'Listing Conan remotes.'
         conan remote list

.github/workflows/on-pr.yml

@@ -1,7 +1,8 @@
 # This workflow runs all workflows to check, build and test the project on
 # various Linux flavors, as well as on MacOS and Windows, on every push to a
 # user branch. However, it will not run if the pull request is a draft unless it
-# has the 'DraftRunCI' label.
+# has the 'DraftRunCI' label. For commits to PRs that target a release branch,
+# it also uploads the libxrpl recipe to the Conan remote.
 name: PR
 
 on:
@@ -53,12 +54,12 @@ jobs:
             .github/scripts/rename/**
             .github/workflows/reusable-check-levelization.yml
             .github/workflows/reusable-check-rename.yml
-            .github/workflows/reusable-notify-clio.yml
             .github/workflows/on-pr.yml
 
             # Keep the paths below in sync with those in `on-trigger.yml`.
             .github/actions/build-deps/**
             .github/actions/build-test/**
+            .github/actions/generate-version/**
             .github/actions/setup-conan/**
             .github/scripts/strategy-matrix/**
             .github/workflows/reusable-build.yml
@@ -66,6 +67,7 @@ jobs:
             .github/workflows/reusable-build-test.yml
             .github/workflows/reusable-strategy-matrix.yml
             .github/workflows/reusable-test.yml
+            .github/workflows/reusable-upload-recipe.yml
             .codecov.yml
             cmake/**
             conan/**
@@ -121,22 +123,42 @@ jobs:
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-  notify-clio:
+  upload-recipe:
     needs:
       - should-run
       - build-test
-    if: ${{ needs.should-run.outputs.go == 'true' && startsWith(github.ref, 'refs/heads/release') }}
+    # Only run when committing to a PR that targets a release branch in the
-    uses: ./.github/workflows/reusable-notify-clio.yml
+    # XRPLF repository.
+    if: ${{ github.repository_owner == 'XRPLF' && needs.should-run.outputs.go == 'true' && startsWith(github.ref, 'refs/heads/release') }}
+    uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
-      clio_notify_token: ${{ secrets.CLIO_NOTIFY_TOKEN }}
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
-      conan_remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
-      conan_remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
+
+  notify-clio:
+    needs: upload-recipe
+    runs-on: ubuntu-latest
+    steps:
+      # Notify the Clio repository about the newly proposed release version, so
+      # it can be checked for compatibility before the release is actually made.
+      - name: Notify Clio
+        env:
+          GH_TOKEN: ${{ secrets.CLIO_NOTIFY_TOKEN }}
+          PR_URL: ${{ github.event.pull_request.html_url }}
+        run: |
+          gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
+          /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
+          -F "client_payload[ref]=${{ needs.upload-recipe.outputs.recipe_ref }}" \
+          -F "client_payload[pr_url]=${PR_URL}"
 
   passed:
     if: failure() || cancelled()
     needs:
-      - build-test
       - check-levelization
+      - check-rename
+      - build-test
+      - upload-recipe
+      - notify-clio
     runs-on: ubuntu-latest
     steps:
       - name: Fail

.github/workflows/on-tag.yml

@@ -0,0 +1,25 @@
+# This workflow uploads the libxrpl recipe to the Conan remote when a versioned
+# tag is pushed.
+name: Tag
+
+on:
+  push:
+    tags:
+      - "v*"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  upload-recipe:
+    # Only run when a tag is pushed to the XRPLF repository.
+    if: ${{ github.repository_owner == 'XRPLF' }}
+    uses: ./.github/workflows/reusable-upload-recipe.yml
+    secrets:
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}

.github/workflows/on-trigger.yml

@@ -1,8 +1,7 @@
 # This workflow runs all workflows to build and test the code on various Linux
 # flavors, as well as on MacOS and Windows, on a scheduled basis, on merge into
-# the 'develop' or 'release*' branches, or when requested manually. Upon
+# the 'develop' or 'release*' branches, or when requested manually. Upon pushes
-# successful completion, it also uploads the built libxrpl package to the Conan
+# to the develop branch it also uploads the libxrpl recipe to the Conan remote.
-# remote.
 name: Trigger
 
 on:
@@ -17,6 +16,7 @@ on:
       # Keep the paths below in sync with those in `on-pr.yml`.
       - ".github/actions/build-deps/**"
       - ".github/actions/build-test/**"
+      - ".github/actions/generate-version/**"
       - ".github/actions/setup-conan/**"
       - ".github/scripts/strategy-matrix/**"
       - ".github/workflows/reusable-build.yml"
@@ -24,6 +24,7 @@ on:
       - ".github/workflows/reusable-build-test.yml"
       - ".github/workflows/reusable-strategy-matrix.yml"
       - ".github/workflows/reusable-test.yml"
+      - ".github/workflows/reusable-upload-recipe.yml"
       - ".codecov.yml"
       - "cmake/**"
       - "conan/**"
@@ -76,3 +77,12 @@ jobs:
       strategy_matrix: ${{ github.event_name == 'schedule' && 'all' || 'minimal' }}
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  upload-recipe:
+    needs: build-test
+    # Only run when pushing to the develop branch in the XRPLF repository.
+    if: ${{ github.repository_owner == 'XRPLF' && github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
+    uses: ./.github/workflows/reusable-upload-recipe.yml
+    secrets:
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}

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

@@ -125,6 +125,8 @@ jobs:
           subtract: ${{ inputs.nproc_subtract }}
 
       - name: Setup Conan
+        env:
+          SANITIZERS: ${{ inputs.sanitizers }}
         uses: ./.github/actions/setup-conan
 
       - name: Build dependencies

.github/workflows/reusable-notify-clio.yml

@@ -1,91 +0,0 @@
-# This workflow exports the built libxrpl package to the Conan remote on a
-# a channel named after the pull request, and notifies the Clio repository about
-# the new version so it can check for compatibility.
-name: Notify Clio
-
-# This workflow can only be triggered by other workflows.
-on:
-  workflow_call:
-    inputs:
-      conan_remote_name:
-        description: "The name of the Conan remote to use."
-        required: false
-        type: string
-        default: xrplf
-      conan_remote_url:
-        description: "The URL of the Conan endpoint to use."
-        required: false
-        type: string
-        default: https://conan.ripplex.io
-    secrets:
-      clio_notify_token:
-        description: "The GitHub token to notify Clio about new versions."
-        required: true
-      conan_remote_username:
-        description: "The username for logging into the Conan remote."
-        required: true
-      conan_remote_password:
-        description: "The password for logging into the Conan remote."
-        required: true
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}-clio
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  upload:
-    if: ${{ github.event.pull_request.head.repo.full_name == github.repository }}
-    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13-sha-5dd7158
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
-      - name: Generate outputs
-        id: generate
-        env:
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-        run: |
-          echo 'Generating user and channel.'
-          echo "user=clio" >> "${GITHUB_OUTPUT}"
-          echo "channel=pr_${PR_NUMBER}" >> "${GITHUB_OUTPUT}"
-          echo 'Extracting version.'
-          echo "version=$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')" >> "${GITHUB_OUTPUT}"
-      - name: Calculate conan reference
-        id: conan_ref
-        run: |
-          echo "conan_ref=${{ steps.generate.outputs.version }}@${{ steps.generate.outputs.user }}/${{ steps.generate.outputs.channel }}" >> "${GITHUB_OUTPUT}"
-      - name: Set up Conan
-        uses: ./.github/actions/setup-conan
-        with:
-          conan_remote_name: ${{ inputs.conan_remote_name }}
-          conan_remote_url: ${{ inputs.conan_remote_url }}
-      - name: Log into Conan remote
-        env:
-          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
-        run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.conan_remote_username }}" --password "${{ secrets.conan_remote_password }}"
-      - name: Upload package
-        env:
-          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
-        run: |
-          conan export --user=${{ steps.generate.outputs.user }} --channel=${{ steps.generate.outputs.channel }} .
-          conan upload --confirm --check --remote="${CONAN_REMOTE_NAME}" xrpl/${{ steps.conan_ref.outputs.conan_ref }}
-    outputs:
-      conan_ref: ${{ steps.conan_ref.outputs.conan_ref }}
-
-  notify:
-    needs: upload
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify Clio
-        env:
-          GH_TOKEN: ${{ secrets.clio_notify_token }}
-          PR_URL: ${{ github.event.pull_request.html_url }}
-        run: |
-          gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
-          /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
-          -F "client_payload[conan_ref]=${{ needs.upload.outputs.conan_ref }}" \
-          -F "client_payload[pr_url]=${PR_URL}"

.github/workflows/reusable-upload-recipe.yml

@@ -0,0 +1,97 @@
+# This workflow exports the built libxrpl package to the Conan remote.
+name: Upload Conan recipe
+
+# This workflow can only be triggered by other workflows.
+on:
+  workflow_call:
+    inputs:
+      remote_name:
+        description: "The name of the Conan remote to use."
+        required: false
+        type: string
+        default: xrplf
+      remote_url:
+        description: "The URL of the Conan endpoint to use."
+        required: false
+        type: string
+        default: https://conan.ripplex.io
+
+    secrets:
+      remote_username:
+        description: "The username for logging into the Conan remote."
+        required: true
+      remote_password:
+        description: "The password for logging into the Conan remote."
+        required: true
+
+    outputs:
+      recipe_ref:
+        description: "The Conan recipe reference ('name/version') that was uploaded."
+        value: ${{ jobs.upload.outputs.ref }}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-upload-recipe
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  upload:
+    runs-on: ubuntu-latest
+    container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13-sha-5dd7158
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+
+      - name: Generate build version number
+        id: version
+        uses: ./.github/actions/generate-version
+
+      - name: Set up Conan
+        uses: ./.github/actions/setup-conan
+        with:
+          remote_name: ${{ inputs.remote_name }}
+          remote_url: ${{ inputs.remote_url }}
+
+      - name: Log into Conan remote
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+          REMOTE_USERNAME: ${{ secrets.remote_username }}
+          REMOTE_PASSWORD: ${{ secrets.remote_password }}
+        run: conan remote login "${REMOTE_NAME}" "${REMOTE_USERNAME}" --password "${REMOTE_PASSWORD}"
+
+      - name: Upload Conan recipe (version)
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=${{ steps.version.outputs.version }}
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.version.outputs.version }}
+
+      - name: Upload Conan recipe (develop)
+        if: ${{ github.ref == 'refs/heads/develop' }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=develop
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/develop
+
+      - name: Upload Conan recipe (rc)
+        if: ${{ startsWith(github.ref, 'refs/heads/release') }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=rc
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/rc
+
+      - name: Upload Conan recipe (release)
+        if: ${{ github.event_name == 'tag' }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+        run: |
+          conan export . --version=release
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/release
+
+    outputs:
+      ref: xrpl/${{ steps.version.outputs.version }}

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

@@ -84,10 +84,12 @@ jobs:
           subtract: ${{ env.NPROC_SUBTRACT }}
 
       - name: Setup Conan
+        env:
+          SANITIZERS: ${{ matrix.sanitizers }}
         uses: ./.github/actions/setup-conan
         with:
-          conan_remote_name: ${{ env.CONAN_REMOTE_NAME }}
+          remote_name: ${{ env.CONAN_REMOTE_NAME }}
-          conan_remote_url: ${{ env.CONAN_REMOTE_URL }}
+          remote_url: ${{ env.CONAN_REMOTE_URL }}
 
       - name: Build dependencies
         uses: ./.github/actions/build-deps
@@ -98,6 +100,7 @@ jobs:
           # Set the verbosity to "quiet" for Windows to avoid an excessive
           # amount of logs. For other OSes, the "verbose" logs are more useful.
           log_verbosity: ${{ runner.os == 'Windows' && 'quiet' || 'verbose' }}
+          sanitizers: ${{ matrix.sanitizers }}
 
       - name: Log into Conan remote
         if: ${{ github.repository_owner == 'XRPLF' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}

.pre-commit-config.yaml

@@ -26,6 +26,12 @@ repos:
         args: [--style=file]
         "types_or": [c++, c, proto]
 
+  - repo: https://github.com/cheshirekow/cmake-format-precommit
+    rev: e2c2116d86a80e72e7146a06e68b7c228afc6319 # frozen: v0.6.13
+    hooks:
+      - id: cmake-format
+        additional_dependencies: [PyYAML]
+
   - repo: https://github.com/rbubley/mirrors-prettier
     rev: 5ba47274f9b181bce26a5150a725577f3c336011 # frozen: v3.6.2
     hooks:

BUILD.md

@@ -148,8 +148,8 @@ function extract_version {
 }
 
 # Define which recipes to export.
-recipes=('ed25519' 'grpc' 'openssl' 'secp256k1' 'snappy' 'soci')
+recipes=('ed25519' 'grpc' 'nudb' 'openssl' 'secp256k1' 'snappy' 'soci')
-folders=('all'     'all'  '3.x.x'   'all'       'all'    'all')
+folders=('all'     'all'  'all'  '3.x.x'   'all'       'all'    'all')
 
 # Selectively check out the recipes from our CCI fork.
 cd external

CMakeLists.txt

@@ -1,14 +1,16 @@
 cmake_minimum_required(VERSION 3.16)
 
-if(POLICY CMP0074)
+if (POLICY CMP0074)
-  cmake_policy(SET CMP0074 NEW)
+    cmake_policy(SET CMP0074 NEW)
-endif()
+endif ()
-if(POLICY CMP0077)
+if (POLICY CMP0077)
-  cmake_policy(SET CMP0077 NEW)
+    cmake_policy(SET CMP0077 NEW)
-endif()
+endif ()
 
 # Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
-file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+if (DEFINED CMAKE_MODULE_PATH)
+    file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+endif ()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 project(xrpl)
@@ -18,65 +20,65 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include(CompilationEnv)
 
-if(is_gcc)
+if (is_gcc)
     # GCC-specific fixes
     add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
     # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif(is_clang)
+elseif (is_clang)
     # Clang-specific fixes
     add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif(is_msvc)
+elseif (is_msvc)
     # MSVC-specific fixes
     add_compile_options(/wd4068) # Ignore unknown pragmas
-endif()
+endif ()
 
 # Enable ccache to speed up builds.
 include(Ccache)
 
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
-if(Git_FOUND)
+if (Git_FOUND)
     execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse HEAD
-        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
+                    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
-    if(gch)
+    if (gch)
         set(GIT_COMMIT_HASH "${gch}")
         message(STATUS gch: ${GIT_COMMIT_HASH})
         add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
-    endif()
+    endif ()
 
     execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse --abbrev-ref HEAD
-        OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
+                    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
-    if(gb)
+    if (gb)
         set(GIT_BRANCH "${gb}")
         message(STATUS gb: ${GIT_BRANCH})
         add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
-    endif()
+    endif ()
-endif() #git
+endif () # git
 
-if(thread_safety_analysis)
+if (thread_safety_analysis)
-  add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS)
+    add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
-  add_compile_options("-stdlib=libc++")
+                        -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS)
-  add_link_options("-stdlib=libc++")
+    add_compile_options("-stdlib=libc++")
-endif()
+    add_link_options("-stdlib=libc++")
+endif ()
 
-include (CheckCXXCompilerFlag)
+include(CheckCXXCompilerFlag)
-include (FetchContent)
+include(FetchContent)
-include (ExternalProject)
+include(ExternalProject)
-include (CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
+include(CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
 if (target)
-  message (FATAL_ERROR "The target option has been removed - use native cmake options to control build")
+    message(FATAL_ERROR "The target option has been removed - use native cmake options to control build")
 endif ()
 
 include(XrplSanity)
 include(XrplVersion)
 include(XrplSettings)
-# this check has to remain in the top-level cmake
+# this check has to remain in the top-level cmake because of the early return statement
-# because of the early return statement
 if (packages_only)
-  if (NOT TARGET rpm)
+    if (NOT TARGET rpm)
-    message (FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?")
+        message(FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?")
-  endif()
+    endif ()
-  return ()
+    return()
 endif ()
 include(XrplCompiler)
 include(XrplSanitizers)
@@ -84,11 +86,9 @@ include(XrplInterface)
 
 option(only_docs "Include only the docs target?" FALSE)
 include(XrplDocs)
-if(only_docs)
+if (only_docs)
-  return()
+    return()
-endif()
+endif ()
-
-###
 
 include(deps/Boost)
 
@@ -105,45 +105,43 @@ find_package(SOCI REQUIRED)
 find_package(SQLite3 REQUIRED)
 find_package(xxHash REQUIRED)
 
-target_link_libraries(xrpl_libs INTERFACE
+target_link_libraries(
-  ed25519::ed25519
+    xrpl_libs
-  lz4::lz4
+    INTERFACE ed25519::ed25519
-  OpenSSL::Crypto
+              lz4::lz4
-  OpenSSL::SSL
+              OpenSSL::Crypto
-  secp256k1::secp256k1
+              OpenSSL::SSL
-  soci::soci
+              secp256k1::secp256k1
-  SQLite::SQLite3
+              soci::soci
-)
+              SQLite::SQLite3)
 
 option(rocksdb "Enable RocksDB" ON)
-if(rocksdb)
+if (rocksdb)
     find_package(RocksDB REQUIRED)
-    set_target_properties(RocksDB::rocksdb PROPERTIES
+    set_target_properties(RocksDB::rocksdb PROPERTIES INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1)
-            INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
-    )
     target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
-endif()
+endif ()
 
 # Work around changes to Conan recipe for now.
-if(TARGET nudb::core)
+if (TARGET nudb::core)
-  set(nudb nudb::core)
+    set(nudb nudb::core)
-elseif(TARGET NuDB::nudb)
+elseif (TARGET NuDB::nudb)
-  set(nudb NuDB::nudb)
+    set(nudb NuDB::nudb)
-else()
+else ()
-  message(FATAL_ERROR "unknown nudb target")
+    message(FATAL_ERROR "unknown nudb target")
-endif()
+endif ()
 target_link_libraries(xrpl_libs INTERFACE ${nudb})
 
-if(coverage)
+if (coverage)
-  include(XrplCov)
+    include(XrplCov)
-endif()
+endif ()
 
 set(PROJECT_EXPORT_SET XrplExports)
 include(XrplCore)
 include(XrplInstall)
 include(XrplValidatorKeys)
 
-if(tests)
+if (tests)
-  include(CTest)
+    include(CTest)
-  add_subdirectory(src/tests/libxrpl)
+    add_subdirectory(src/tests/libxrpl)
-endif()
+endif ()

SECURITY.md

@@ -78,72 +78,61 @@ To report a qualifying bug, please send a detailed report to:
 
 | Email Address | bugs@ripple.com                                     |
 | :-----------: | :-------------------------------------------------- |
-| Short Key ID  | `0xC57929BE`                                        |
+| Short Key ID  | `0xA9F514E0`                                        |
-|  Long Key ID  | `0xCD49A0AFC57929BE`                                |
+|  Long Key ID  | `0xD900855AA9F514E0`                                |
-|  Fingerprint  | `24E6 3B02 37E0 FA9C 5E96 8974 CD49 A0AF C579 29BE` |
+|  Fingerprint  | `B72C 0654 2F2A E250 2763 A268 D900 855A A9F5 14E0` |
 
 The full PGP key for this address, which is also available on several key servers (e.g. on [keyserver.ubuntu.com](https://keyserver.ubuntu.com)), is:
 
 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----
-mQINBFUwGHYBEAC0wpGpBPkd8W1UdQjg9+cEFzeIEJRaoZoeuJD8mofwI5Ejnjdt
+mQINBGkSZAQBEACprU199OhgdsOsygNjiQV4msuN3vDOUooehL+NwfsGfW79Tbqq
-kCpUYEDal0ygkKobu8SzOoATcDl18iCrScX39VpTm96vISFZMhmOryYCIp4QLJNN
+Q2u7uQ3NZjW+M2T4nsDwuhkr7pe7xSReR5W8ssaczvtUyxkvbMClilcgZ2OSCAuC
-4HKc2ZdBj6W4igNi6vj5Qo6JMyGpLY2mz4CZskbt0TNuUxWrGood+UrCzpY8x7/N
+N9tzJsqOqkwBvXoNXkn//T2jnPz0ZU2wSF+NrEibq5FeuyGdoX3yXXBxq9pW9HzK
-a93fcvNw+prgCr0rCH3hAPmAFfsOBbtGzNnmq7xf3jg5r4Z4sDiNIF1X1y53DAfV
+HkQll63QSl6BzVSGRQq+B6lGgaZGLwf3mzmIND9Z5VGLNK2jKynyz9z091whNG/M
-rWDx49IKsuCEJfPMp1MnBSvDvLaQ2hKXs+cOpx1BCZgHn3skouEUxxgqbtTzBLt1
+kV+E7/r/bujHk7WIVId07G5/COTXmSr7kFnNEkd2Umw42dkgfiNKvlmJ9M7c1wLK
-xXpmuijsaltWngPnGO7mOAzbpZSdBm82/Emrk9bPMuD0QaLQjWr7HkTSUs6ZsKt4
+KbL9Eb4ADuW6rRc5k4s1e6GT8R4/VPliWbCl9SE32hXH8uTkqVIFZP2eyM5WRRHs
-7CLPdWqxyY/QVw9UaxeHEtWGQGMIQGgVJGh1fjtUr5O1sC9z9jXcQ0HuIHnRCTls
+aKzitkQG9UK9gcb0kdgUkxOvvgPHAe5IuZlcHFzU4y0dBbU1VEFWVpiLU0q+IuNw
-GP7hklJmfH5V4SyAJQ06/hLuEhUJ7dn+BlqCsT0tLmYTgZYNzNcLHcqBFMEZHvHw
+5BRemeHc59YNsngkmAZ+/9zouoShRusZmC8Wzotv75C2qVBcjijPvmjWAUz0Zunm
-9GENMx/tDXgajKql4bJnzuTK0iGU/YepanANLd1JHECJ4jzTtmKOus9SOGlB2/l1
+Lsr+O71vqHE73pERjD07wuD/ISjiYRYYE/bVrXtXLZijC7qAH4RE3nID+2ojcZyO
-0t0ADDYAS3eqOdOcUvo9ElSLCI5vSVHhShSte/n2FMWU+kMUboTUisEG8CgQnrng
+/2jMQvt7un56RsGH4UBHi3aBHi9bUoDGCXKiQY981cEuNaOxpou7Mh3x/ONzzSvk
-g2CvvQvqDkeOtZeqMcC7HdiZS0q3LJUWtwA/ViwxrVlBDCxiTUXCotyBWwARAQAB
+sTV6nl1LOZHykN1JyKwaNbTSAiuyoN+7lOBqbV04DNYAHL88PrT21P83aQARAQAB
-tDBSaXBwbGUgTGFicyBCdWcgQm91bnR5IFByb2dyYW0gPGJ1Z3NAcmlwcGxlLmNv
+tB1SaXBwbGUgTGFicyA8YnVnc0ByaXBwbGUuY29tPokCTgQTAQgAOBYhBLcsBlQv
-bT6JAjcEEwEKACEFAlUwGHYCGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQ
+KuJQJ2OiaNkAhVqp9RTgBQJpEmQEAhsDBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheA
-zUmgr8V5Kb6R0g//SwY/mVJY59k87iL26/KayauSoOcz7xjcST26l4ZHVVX85gOY
+AAoJENkAhVqp9RTgBzgP/i7y+aDWl1maig1XMdyb+o0UGusumFSW4Hmj278wlKVv
-HYZl8k0+m8X3zxeYm9a3QAoAml8sfoaFRFQP8ynnefRrLUPaZ2MjbJ0SACMwZNef
+usgLPihYgHE0PKrv6WRyKOMC1tQEcYYN93M+OeQ1vFhS2YyURq6RCMmh4zq/awXG
-T6o7Mi8LBAaiNZdYVyIfX1oM6YXtqYkuJdav6ZCyvVYqc9OvMJPY2ZzJYuI/ZtvQ
+uZbG36OURB5NH8lGBOHiN/7O+nY0CgenBT2JWm+GW3nEOAVOVm4+r5GlpPlv+Dp1
-/lTndxCeg9ALNX/iezOLGdfMpf4HuIFVwcPPlwGi+HDlB9/bggDEHC8z434SXVFc
+NPBThcKXFMnH73++NpSQoDzTfRYHPxhDAX3jkLi/moXfSanOLlR6l94XNNN0jBHW
-aQatXAPcDkjMUweU7y0CZtYEj00HITd4pSX6MqGiHrxlDZTqinCOPs1Ieqp7qufs
+Quao0rzf4WSXq9g6AS224xhAA5JyIcFl8TX7hzj5HaFn3VWo3COoDu4U7H+BM0fl
-MzlM6irLGucxj1+wa16ieyYvEtGaPIsksUKkywx0O7cf8N2qKg+eIkUk6O0Uc6eO
+85yqiMQypp7EhN2gxpMMWaHY5TFM85U/bFXFYfEgihZ4/gt4uoIzsNI9jlX7mYvG
-CszizmiXIXy4O6OiLlVHGKkXHMSW9Nwe9GE95O8G9WR8OZCEuDv+mHPAutO+IjdP
+KFdDij+oTlRsuOxdIy60B3dKcwOH9nZZCz0SPsN/zlRWgKzK4gDKdGhFkU9OlvPu
-PDAAUvy+3XnkceO+HGWRpVvJZfFP2YH4A33InFL5yqlJmSoR/yVingGLxk55bZDM
+94ZqscanoiWKDoZkF96+sjgfjkuHsDK7Lwc1Xi+T4drHG/3aVpkYabXox+lrKB/S
-+HYGR3VeMb8Xj1rf/02qERsZyccMCFdAvKDbTwmvglyHdVLu5sPmktxbBYiemfyJ
+yxZjeqOIQzWPhnLgCaLyvsKo5hxKzL0w3eURu8F3IS7RgOOlljv4M+Me9sEVcdNV
-qxMxmYXCc9S0hWrWZW7edktBa9NpE58z1mx+hRIrDNbS2sDHrib9PULYCySyVYcF
+aN3/tQwbaomSX1X5D5YXqhBwC3rU3wXwamsscRTGEpkV+JCX6KUqGP7nWmxCpAly
-P+PWEe1CAS5jqkR2ker5td2/pHNnJIycynBEs7l6zbc9fu+nktFJz0q2B+GJAhwE
+FL05XuOd5SVHJjXLeuje0JqLUpN514uL+bThWwDbDTdAdwW3oK/2WbXz7IfJRLBj
-EAEKAAYFAlUwGaQACgkQ+tiY1qQ2QkjMFw//f2hNY3BPNe+1qbhzumMDCnbTnGif
+uQINBGkSZAQBEADdI3SL2F72qkrgFqXWE6HSRBu9bsAvTE5QrRPWk7ux6at537r4
-kLuAGl9OKt81VHG1f6RnaGiLpR696+6Ja45KzH15cQ5JJl5Bgs1YkR/noTGX8IAD
+S4sIw2dOwLvbyIrDgKNq3LQ5wCK88NO/NeCOFm4AiCJSl3pJHXYnTDoUxTrrxx+o
-c70eNwiFu8JXTaaeeJrsmFkF9Tueufb364risYkvPP8tNUD3InBFEZT3WN7JKwix
+vSRI4I3fHEql/MqzgiAb0YUezjgFdh3vYheMPp/309PFbOLhiFqEcx80Mx5h06UH
-coD4/BwekUwOZVDd/uCFEyhlhZsROxdKNisNo3VtAq2s+3tIBAmTrriFUl0K+ZC5
+gDzu1qNj3Ec+31NLic5zwkrAkvFvD54d6bqYR3SEgMau6aYEewpGHbWBi2pLqSi2
-zgavcpnPN57zMtW9aK+VO3wXqAKYLYmtgxkVzSLUZt2M7JuwOaAdyuYWAneKZPCu
+lQcAeOFixqGpTwDmAnYR8YtjBYepy0MojEAdTHcQQlOYSDk4q4elG+io2N8vECfU
-1AXkmyo+d84sd5mZaKOr5xArAFiNMWPUcZL4rkS1Fq4dKtGAqzzR7a7hWtA5o27T
+rD6ORecN48GXdZINYWTAdslrUeanmBdgQrYkSpce8TSghgT9P01SNaXxmyaehVUO
-6vynuxZ1n0PPh0er2O/zF4znIjm5RhTlfjp/VmhZdQfpulFEQ/dMxxGkQ9z5IYbX
+lqI4pcg5G2oojAE8ncNS3TwDtt7daTaTC3bAdr4PXDVAzNAiewjMNZPB7xidkDGQ
-mTlSDbCSb+FMsanRBJ7Drp5EmBIudVGY6SHI5Re1RQiEh7GoDfUMUwZO+TVDII5R
+Y4W1LxTMXyJVWxehYOH7tsbBRKninlfRnLgYzmtIbNRAAvNcsxU6ihv3AV0WFknN
-Ra7WyuimYleJgDo/+7HyfuIyGDaUCVj6pwVtYtYIdOI3tTw1R1Mr0V8yaNVnJghL
+YbSzotEv1Xq/5wk309x8zCDe+sP0cQicvbXafXmUzPAZzeqFg+VLFn7F9MP1WGlW
-CHcEJQL+YHSmiMM3ySil3O6tm1By6lFz8bVe/rgG/5uklQrnjMR37jYboi1orCC4
+B1u7VIvBF1Mp9Nd3EAGBAoLRdRu+0dVWIjPTQuPIuD9cCatJA0wVaKUrjYbBMl88
-yeIoQeV0ItlxeTyBwYIV/o1DBNxDevTZvJabC93WiGLw2XFjpZ0q/9+zI2rJUZJh
+a12LixNVGeSFS9N7ADHx0/o7GNT6l88YbaLP6zggUHpUD/bR+cDN7vllIQARAQAB
-qxmKP+D4e27lCI65Ag0EVTAYdgEQAMvttYNqeRNBRpSX8fk45WVIV8Fb21fWdwk6
+iQI2BBgBCAAgFiEEtywGVC8q4lAnY6Jo2QCFWqn1FOAFAmkSZAQCGwwACgkQ2QCF
-2SkZnJURbiC0LxQnOi7wrtii7DeFZtwM2kFHihS1VHekBnIKKZQSgGoKuFAQMGyu
+Wqn1FOAfAA/8CYq4p0p4bobY20CKEMsZrkBTFJyPDqzFwMeTjgpzqbD7Y3Qq5QCK
-a426H4ZsSmA9Ufd7kRbvdtEcp7/RTAanhrSL4lkBhaKJrXlxBJ27o3nd7/rh7r3a
+OBbvY02GWdiIsNOzKdBxiuam2xYP9WHZj4y7/uWEvT0qlPVmDFu+HXjoJ43oxwFd
-OszbPY6DJ5bWClX3KooPTDl/RF2lHn+fweFk58UvuunHIyo4BWJUdilSXIjLun+P
+CUp2gMuQ4cSL3X94VRJ3BkVL+tgBm8CNY0vnTLLOO3kum/R69VsGJS1JSGUWjNM+
-Qaik4ZAsZVwNhdNz05d+vtai4AwbYoO7adboMLRkYaXSQwGytkm+fM6r7OpXHYuS
+4qwS3mz+73xJu1HmERyN2RZF/DGIZI2PyONQQ6aH85G1Dd2ohu2/DBAkQAMBrPbj
-cR4zB/OK5hxCVEpWfiwN71N2NMvnEMaWd/9uhqxJzyvYgkVUXV9274TUe16pzXnW
+FrbDaBLyFhODxU3kTWqnfLlaElSm2EGdIU2yx7n4BggEa//NZRMm5kyeo4vzhtlQ
-ZLfmitjwc91e7mJBBfKNenDdhaLEIlDRwKTLj7k58f9srpMnyZFacntu5pUMNblB
+YIVUMLAOLZvnEqDnsLKp+22FzNR/O+htBQC4lPywl53oYSALdhz1IQlcAC1ru5KR
-cjXwWxz5ZaQikLnKYhIvrIEwtWPyjqOzNXNvYfZamve/LJ8HmWGCKao3QHoAIDvB
+XPzhIXV6IIzkcx9xNkEclZxmsuy5ERXyKEmLbIHAlzFmnrldlt2ZgXDtzaorLmxj
-9XBxrDyTJDpxbog6Qu4SY8AdgVlan6c/PsLDc7EUegeYiNTzsOK+eq3G5/E92eIu
+klKibxd5tF50qOpOivz+oPtFo7n+HmFa1nlVAMxlDCUdM0pEVeYDKI5zfVwalyhZ
-TsUXlciypFcRm1q8vLRr+HYYe2mJDo4GetB1zLkAFBcYJm/x9iJQbu0hn5NxJvZO
+NnjpakdZSXMwgc7NP/hH9buF35hKDp7EckT2y3JNYwHsDdy1icXN2q40XZw5tSIn
-R0Y5nOJQdyi+muJzKYwhkuzaOlswzqVXkq/7+QCjg7QsycdcwDjiQh3OrsgXHrwl
+zkPWdu3OUY8PISohN6Pw4h0RH4ZmoX97E8sEfmdKaT58U4Hf2aAv5r9IWCSrAVqY
-M7gyafL9ABEBAAGJAh8EGAEKAAkFAlUwGHYCGwwACgkQzUmgr8V5Kb50BxAAhj9T
+u5jvac29CzQR9Kal0A+8phHAXHNFD83SwzIC0syaT9ficAguwGH8X6Q=
-TwmNrgRldTHszj+Qc+v8RWqV6j+R+zc0cn5XlUa6XFaXI1OFFg71H4dhCPEiYeN0
+=nGuD
-IrnocyMNvCol+eKIlPKbPTmoixjQ4udPTR1DC1Bx1MyW5FqOrsgBl5t0e1VwEViM
-NspSStxu5Hsr6oWz2GD48lXZWJOgoL1RLs+uxjcyjySD/em2fOKASwchYmI+ezRv
-plfhAFIMKTSCN2pgVTEOaaz13M0U+MoprThqF1LWzkGkkC7n/1V1f5tn83BWiagG
-2N2Q4tHLfyouzMUKnX28kQ9sXfxwmYb2sA9FNIgxy+TdKU2ofLxivoWT8zS189z/
-Yj9fErmiMjns2FzEDX+bipAw55X4D/RsaFgC+2x2PDbxeQh6JalRA2Wjq32Ouubx
-u+I4QhEDJIcVwt9x6LPDuos1F+M5QW0AiUhKrZJ17UrxOtaquh/nPUL9T3l2qPUn
-1ChrZEEEhHO6vA8+jn0+cV9n5xEz30Str9iHnDQ5QyR5LyV4UBPgTdWyQzNVKA69
-KsSr9lbHEtQFRzGuBKwt6UlSFv9vPWWJkJit5XDKAlcKuGXj0J8OlltToocGElkF
-+gEBZfoOWi/IBjRLrFW2cT3p36DTR5O1Ud/1DLnWRqgWNBLrbs2/KMKE6EnHttyD
-7Tz8SQkuxltX/yBXMV3Ddy0t6nWV2SZEfuxJAQI=
-=spg4
 -----END PGP PUBLIC KEY BLOCK-----
 ```

cmake/CMakeFuncs.cmake

@@ -1,30 +1,29 @@
 macro (exclude_from_default target_)
-  set_target_properties (${target_} PROPERTIES EXCLUDE_FROM_ALL ON)
+    set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_ALL ON)
-  set_target_properties (${target_} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
+    set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
 endmacro ()
 
 macro (exclude_if_included target_)
-  get_directory_property(has_parent PARENT_DIRECTORY)
+    get_directory_property(has_parent PARENT_DIRECTORY)
-  if (has_parent)
+    if (has_parent)
-    exclude_from_default (${target_})
+        exclude_from_default(${target_})
-  endif ()
+    endif ()
 endmacro ()
 
 find_package(Git)
 
 function (git_branch branch_val)
-  if (NOT GIT_FOUND)
+    if (NOT GIT_FOUND)
-    return ()
+        return()
-  endif ()
+    endif ()
-  set (_branch "")
+    set(_branch "")
-  execute_process (COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
+    execute_process(COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
-                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                   RESULT_VARIABLE _git_exit_code
+                    RESULT_VARIABLE _git_exit_code
-                   OUTPUT_VARIABLE _temp_branch
+                    OUTPUT_VARIABLE _temp_branch
-                   OUTPUT_STRIP_TRAILING_WHITESPACE
+                    OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
-                   ERROR_QUIET)
+    if (_git_exit_code EQUAL 0)
-  if (_git_exit_code EQUAL 0)
+        set(_branch ${_temp_branch})
-    set (_branch ${_temp_branch})
+    endif ()
-  endif ()
+    set(${branch_val} "${_branch}" PARENT_SCOPE)
-  set (${branch_val} "${_branch}" PARENT_SCOPE)
 endfunction ()

cmake/Ccache.cmake

@@ -15,18 +15,17 @@ endif ()
 # https://github.com/ccache/ccache/wiki/MS-Visual-Studio#usage-with-cmake.
 if ("${CCACHE_PATH}" MATCHES "chocolatey")
     message(DEBUG "Ccache path: ${CCACHE_PATH}")
-    # Chocolatey uses a shim executable that we cannot use directly, in which
+    # Chocolatey uses a shim executable that we cannot use directly, in which case we have to find the executable it
-    # case we have to find the executable it points to. If we cannot find the
+    # points to. If we cannot find the target executable then we cannot use ccache.
-    # target executable then we cannot use ccache.
     find_program(BASH_PATH "bash")
     if (NOT BASH_PATH)
         message(WARNING "Could not find bash.")
         return()
     endif ()
 
-    execute_process(
+    execute_process(COMMAND bash -c
-            COMMAND bash -c "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
+                            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
-            OUTPUT_VARIABLE CCACHE_PATH)
+                    OUTPUT_VARIABLE CCACHE_PATH)
 
     if (NOT CCACHE_PATH)
         message(WARNING "Could not find ccache target.")
@@ -37,21 +36,14 @@ endif ()
 message(STATUS "Found ccache: ${CCACHE_PATH}")
 
 # Tell cmake to use ccache for compiling with Visual Studio.
-file(COPY_FILE
+file(COPY_FILE ${CCACHE_PATH} ${CMAKE_BINARY_DIR}/cl.exe ONLY_IF_DIFFERENT)
-        ${CCACHE_PATH} ${CMAKE_BINARY_DIR}/cl.exe
+set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "TrackFileAccess=false"
-        ONLY_IF_DIFFERENT)
+                     "UseMultiToolTask=true")
-set(CMAKE_VS_GLOBALS
-        "CLToolExe=cl.exe"
-        "CLToolPath=${CMAKE_BINARY_DIR}"
-        "TrackFileAccess=false"
-        "UseMultiToolTask=true")
 
-# By default Visual Studio generators will use /Zi to capture debug information,
+# By default Visual Studio generators will use /Zi to capture debug information, which is not compatible with ccache, so
-# which is not compatible with ccache, so tell it to use /Z7 instead.
+# tell it to use /Z7 instead.
 if (MSVC)
-    foreach (var_
+    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
-        CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+        string(REPLACE "/Zi" "/Z7" ${var_} "${${var_}}")
-        CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
-        string (REPLACE "/Zi" "/Z7" ${var_} "${${var_}}")
     endforeach ()
 endif ()

cmake/CodeCoverage.cmake

@@ -172,51 +172,47 @@ include(CMakeParseArguments)
 option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
 
 # Check prereqs
-find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
 
-if(DEFINED CODE_COVERAGE_GCOV_TOOL)
+if (DEFINED CODE_COVERAGE_GCOV_TOOL)
-  set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
+    set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
-elseif(DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
+elseif (DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
-  set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
+    set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
-elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-  if(APPLE)
+    if (APPLE)
-    execute_process( COMMAND xcrun -f llvm-cov
+        execute_process(COMMAND xcrun -f llvm-cov OUTPUT_VARIABLE LLVMCOV_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
-      OUTPUT_VARIABLE LLVMCOV_PATH
+    else ()
-      OUTPUT_STRIP_TRAILING_WHITESPACE
+        find_program(LLVMCOV_PATH llvm-cov)
-    )
+    endif ()
-  else()
+    if (LLVMCOV_PATH)
-    find_program( LLVMCOV_PATH llvm-cov )
+        set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
-  endif()
+    endif ()
-  if(LLVMCOV_PATH)
+elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-    set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
+    find_program(GCOV_PATH gcov)
-  endif()
+    set(GCOV_TOOL "${GCOV_PATH}")
-elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+endif ()
-  find_program( GCOV_PATH gcov )
-  set(GCOV_TOOL "${GCOV_PATH}")
-endif()
 
 # Check supported compiler (Clang, GNU and Flang)
 get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach(LANG ${LANGUAGES})
+foreach (LANG ${LANGUAGES})
-  if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if ("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+        if ("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
-      message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+            message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
-    endif()
+        endif ()
-  elseif(NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
+    elseif (NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU" AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES
-         AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang")
+                                                                 "(LLVM)?[Ff]lang")
-    message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
+        message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
-  endif()
+    endif ()
-endforeach()
+endforeach ()
 
-set(COVERAGE_COMPILER_FLAGS "-g --coverage"
+set(COVERAGE_COMPILER_FLAGS "-g --coverage" CACHE INTERNAL "")
-    CACHE INTERNAL "")
 
 set(COVERAGE_CXX_COMPILER_FLAGS "")
 set(COVERAGE_C_COMPILER_FLAGS "")
 set(COVERAGE_CXX_LINKER_FLAGS "")
 set(COVERAGE_C_LINKER_FLAGS "")
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
     include(CheckCCompilerFlag)
     include(CheckLinkerFlag)
@@ -227,51 +223,51 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     set(COVERAGE_C_LINKER_FLAGS ${COVERAGE_COMPILER_FLAGS})
 
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
-    if(HAVE_cxx_fprofile_abs_path)
+    if (HAVE_cxx_fprofile_abs_path)
         set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path")
-    endif()
+    endif ()
 
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
-    if(HAVE_c_fprofile_abs_path)
+    if (HAVE_c_fprofile_abs_path)
         set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path")
-    endif()
+    endif ()
 
     check_linker_flag(CXX -fprofile-abs-path HAVE_cxx_linker_fprofile_abs_path)
-    if(HAVE_cxx_linker_fprofile_abs_path)
+    if (HAVE_cxx_linker_fprofile_abs_path)
         set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path")
-    endif()
+    endif ()
 
     check_linker_flag(C -fprofile-abs-path HAVE_c_linker_fprofile_abs_path)
-    if(HAVE_c_linker_fprofile_abs_path)
+    if (HAVE_c_linker_fprofile_abs_path)
         set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path")
-    endif()
+    endif ()
 
     check_cxx_compiler_flag(-fprofile-update=atomic HAVE_cxx_fprofile_update)
-    if(HAVE_cxx_fprofile_update)
+    if (HAVE_cxx_fprofile_update)
         set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic")
-    endif()
+    endif ()
 
     check_c_compiler_flag(-fprofile-update=atomic HAVE_c_fprofile_update)
-    if(HAVE_c_fprofile_update)
+    if (HAVE_c_fprofile_update)
         set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic")
-    endif()
+    endif ()
 
     check_linker_flag(CXX -fprofile-update=atomic HAVE_cxx_linker_fprofile_update)
-    if(HAVE_cxx_linker_fprofile_update)
+    if (HAVE_cxx_linker_fprofile_update)
         set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic")
-    endif()
+    endif ()
 
     check_linker_flag(C -fprofile-update=atomic HAVE_c_linker_fprofile_update)
-    if(HAVE_c_linker_fprofile_update)
+    if (HAVE_c_linker_fprofile_update)
         set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic")
-    endif()
+    endif ()
 
-endif()
+endif ()
 
 get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+if (NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
     message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
-endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
@@ -295,193 +291,186 @@ endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 # )
 # The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
 # GCVOR command.
-function(setup_target_for_coverage_gcovr)
+function (setup_target_for_coverage_gcovr)
     set(options NONE)
     set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
     set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
     cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if(NOT GCOV_TOOL)
+    if (NOT GCOV_TOOL)
         message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
-    endif()
+    endif ()
 
-    if(NOT GCOVR_PATH)
+    if (NOT GCOVR_PATH)
         message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
-    endif()
+    endif ()
 
     # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
-    if(DEFINED Coverage_BASE_DIRECTORY)
+    if (DEFINED Coverage_BASE_DIRECTORY)
         get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
-    else()
+    else ()
         set(BASEDIR ${PROJECT_SOURCE_DIR})
-    endif()
+    endif ()
 
-    if(NOT DEFINED Coverage_FORMAT)
+    if (NOT DEFINED Coverage_FORMAT)
         set(Coverage_FORMAT xml)
-    endif()
+    endif ()
 
-    if(NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
+    if (NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
         message(FATAL_ERROR "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set")
-    endif()
+    endif ()
 
-    if("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
+    if ("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
         message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting...")
-    else()
+    else ()
-        if((Coverage_FORMAT STREQUAL "html-details")
+        if ((Coverage_FORMAT STREQUAL "html-details") OR (Coverage_FORMAT STREQUAL "html-nested"))
-            OR (Coverage_FORMAT STREQUAL "html-nested"))
             set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
             set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
-        elseif(Coverage_FORMAT STREQUAL "html-single")
+        elseif (Coverage_FORMAT STREQUAL "html-single")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
-        elseif((Coverage_FORMAT STREQUAL "json-summary")
+        elseif ((Coverage_FORMAT STREQUAL "json-summary") OR (Coverage_FORMAT STREQUAL "json-details")
-            OR (Coverage_FORMAT STREQUAL "json-details")
+                OR (Coverage_FORMAT STREQUAL "coveralls"))
-            OR (Coverage_FORMAT STREQUAL "coveralls"))
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
-        elseif(Coverage_FORMAT STREQUAL "txt")
+        elseif (Coverage_FORMAT STREQUAL "txt")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
-        elseif(Coverage_FORMAT STREQUAL "csv")
+        elseif (Coverage_FORMAT STREQUAL "csv")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
-        elseif(Coverage_FORMAT STREQUAL "lcov")
+        elseif (Coverage_FORMAT STREQUAL "lcov")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
-        else()
+        else ()
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
-        endif()
+        endif ()
-    endif()
+    endif ()
 
-    if((Coverage_FORMAT STREQUAL "cobertura")
+    if ((Coverage_FORMAT STREQUAL "cobertura") OR (Coverage_FORMAT STREQUAL "xml"))
-        OR (Coverage_FORMAT STREQUAL "xml"))
+        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty)
-        list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty )
         set(Coverage_FORMAT cobertura) # overwrite xml
-    elseif(Coverage_FORMAT STREQUAL "sonarqube")
+    elseif (Coverage_FORMAT STREQUAL "sonarqube")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}")
-    elseif(Coverage_FORMAT STREQUAL "jacoco")
+    elseif (Coverage_FORMAT STREQUAL "jacoco")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty)
-    elseif(Coverage_FORMAT STREQUAL "clover")
+    elseif (Coverage_FORMAT STREQUAL "clover")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty)
-    elseif(Coverage_FORMAT STREQUAL "lcov")
+    elseif (Coverage_FORMAT STREQUAL "lcov")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}")
-    elseif(Coverage_FORMAT STREQUAL "json-summary")
+    elseif (Coverage_FORMAT STREQUAL "json-summary")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
-    elseif(Coverage_FORMAT STREQUAL "json-details")
+    elseif (Coverage_FORMAT STREQUAL "json-details")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
-    elseif(Coverage_FORMAT STREQUAL "coveralls")
+    elseif (Coverage_FORMAT STREQUAL "coveralls")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls-pretty)
-    elseif(Coverage_FORMAT STREQUAL "csv")
+    elseif (Coverage_FORMAT STREQUAL "csv")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}")
-    elseif(Coverage_FORMAT STREQUAL "txt")
+    elseif (Coverage_FORMAT STREQUAL "txt")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}")
-    elseif(Coverage_FORMAT STREQUAL "html-single")
+    elseif (Coverage_FORMAT STREQUAL "html-single")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-self-contained)
-    elseif(Coverage_FORMAT STREQUAL "html-nested")
+    elseif (Coverage_FORMAT STREQUAL "html-nested")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}")
-    elseif(Coverage_FORMAT STREQUAL "html-details")
+    elseif (Coverage_FORMAT STREQUAL "html-details")
-        list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}")
-    else()
+    else ()
         message(FATAL_ERROR "Unsupported output style ${Coverage_FORMAT}! Aborting...")
-    endif()
+    endif ()
 
     # Collect excludes (CMake 3.4+: Also compute absolute paths)
     set(GCOVR_EXCLUDES "")
-    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
+    foreach (EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
-        if(CMAKE_VERSION VERSION_GREATER 3.4)
+        if (CMAKE_VERSION VERSION_GREATER 3.4)
             get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
-        endif()
+        endif ()
         list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
-    endforeach()
+    endforeach ()
     list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
 
     # Combine excludes to several -e arguments
     set(GCOVR_EXCLUDE_ARGS "")
-    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+    foreach (EXCLUDE ${GCOVR_EXCLUDES})
         list(APPEND GCOVR_EXCLUDE_ARGS "-e")
         list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
-    endforeach()
+    endforeach ()
 
     # Set up commands which will be run to generate coverage data
     # If EXECUTABLE is not set, the user is expected to run the tests manually
     # before running the coverage target NAME
-    if(DEFINED Coverage_EXECUTABLE)
+    if (DEFINED Coverage_EXECUTABLE)
-        set(GCOVR_EXEC_TESTS_CMD
+        set(GCOVR_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
-            ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    endif ()
-        )
-    endif()
 
     # Create folder
-    if(DEFINED GCOVR_CREATE_FOLDER)
+    if (DEFINED GCOVR_CREATE_FOLDER)
-        set(GCOVR_FOLDER_CMD
+        set(GCOVR_FOLDER_CMD ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
-            ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
+    endif ()
-    endif()
 
     # Running gcovr
     set(GCOVR_CMD
         ${GCOVR_PATH}
-        --gcov-executable ${GCOV_TOOL}
+        --gcov-executable
+        ${GCOV_TOOL}
         --gcov-ignore-parse-errors=negative_hits.warn_once_per_file
-        -r ${BASEDIR}
+        -r
+        ${BASEDIR}
         ${GCOVR_ADDITIONAL_ARGS}
         ${GCOVR_EXCLUDE_ARGS}
-        --object-directory=${PROJECT_BINARY_DIR}
+        --object-directory=${PROJECT_BINARY_DIR})
-    )
 
-    if(CODE_COVERAGE_VERBOSE)
+    if (CODE_COVERAGE_VERBOSE)
         message(STATUS "Executed command report")
 
-        if(NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
+        if (NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
             message(STATUS "Command to run tests: ")
             string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
             message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
-        endif()
+        endif ()
 
-        if(NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
+        if (NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
             message(STATUS "Command to create a folder: ")
             string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
             message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
-        endif()
+        endif ()
 
         message(STATUS "Command to generate gcovr coverage data: ")
         string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
         message(STATUS "${GCOVR_CMD_SPACED}")
-    endif()
+    endif ()
 
     add_custom_target(${Coverage_NAME}
-        COMMAND ${GCOVR_EXEC_TESTS_CMD}
+                      COMMAND ${GCOVR_EXEC_TESTS_CMD}
-        COMMAND ${GCOVR_FOLDER_CMD}
+                      COMMAND ${GCOVR_FOLDER_CMD}
-        COMMAND ${GCOVR_CMD}
+                      COMMAND ${GCOVR_CMD}
-
+                      BYPRODUCTS ${GCOVR_OUTPUT_FILE}
-        BYPRODUCTS ${GCOVR_OUTPUT_FILE}
+                      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+                      DEPENDS ${Coverage_DEPENDENCIES}
-        DEPENDS ${Coverage_DEPENDENCIES}
+                      VERBATIM # Protect arguments to commands
-        VERBATIM # Protect arguments to commands
+                      COMMENT "Running gcovr to produce code coverage report.")
-        COMMENT "Running gcovr to produce code coverage report."
-    )
 
     # Show info where to find the report
-    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD COMMAND echo
-        COMMAND echo
+                       COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}")
-        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+endfunction () # setup_target_for_coverage_gcovr
-    )
-endfunction() # setup_target_for_coverage_gcovr
 
-function(add_code_coverage_to_target name scope)
+function (add_code_coverage_to_target name scope)
     separate_arguments(COVERAGE_CXX_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_COMPILER_FLAGS}")
     separate_arguments(COVERAGE_C_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_C_COMPILER_FLAGS}")
     separate_arguments(COVERAGE_CXX_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_LINKER_FLAGS}")
     separate_arguments(COVERAGE_C_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_C_LINKER_FLAGS}")
 
     # Add compiler options to the target
-    target_compile_options(${name} ${scope}
+    target_compile_options(${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
-            $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
+                           $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
-            $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
 
-    target_link_libraries (${name} ${scope}
+    target_link_libraries(
-            $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS} gcov>
+        ${name}
-            $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS} gcov>
+        ${scope}
-    )
+        $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}
-endfunction() # add_code_coverage_to_target
+        gcov>
+        $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}
+        gcov>)
+endfunction () # add_code_coverage_to_target

cmake/CompilationEnv.cmake

@@ -1,8 +1,7 @@
- # Shared detection of compiler, operating system, and architecture.
+# Shared detection of compiler, operating system, and architecture.
- #
+#
- # This module centralizes environment detection so that other
+# This module centralizes environment detection so that other CMake modules can use the same variables instead of
- # CMake modules can use the same variables instead of repeating
+# repeating checks on CMAKE_* and built-in platform variables.
- # checks on CMAKE_* and built-in platform variables.
 
 # Only run once per configure step.
 include_guard(GLOBAL)
@@ -13,17 +12,22 @@ include_guard(GLOBAL)
 set(is_clang FALSE)
 set(is_gcc FALSE)
 set(is_msvc FALSE)
+set(is_xcode FALSE)
 
-if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
+if (CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
-  set(is_clang TRUE)
+    set(is_clang TRUE)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  set(is_gcc TRUE)
+    set(is_gcc TRUE)
-elseif(MSVC)
+elseif (MSVC)
-  set(is_msvc TRUE)
+    set(is_msvc TRUE)
-else()
+else ()
-  message(FATAL_ERROR "Unsupported C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
+    message(FATAL_ERROR "Unsupported C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
-endif()
+endif ()
 
+# Xcode generator detection
+if (CMAKE_GENERATOR STREQUAL "Xcode")
+    set(is_xcode TRUE)
+endif ()
 
 # --------------------------------------------------------------------
 # Operating system detection
@@ -32,23 +36,23 @@ set(is_linux FALSE)
 set(is_windows FALSE)
 set(is_macos FALSE)
 
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-  set(is_linux TRUE)
+    set(is_linux TRUE)
-elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
-  set(is_windows TRUE)
+    set(is_windows TRUE)
-elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-  set(is_macos TRUE)
+    set(is_macos TRUE)
-endif()
+endif ()
 
 # --------------------------------------------------------------------
 # Architecture
 # --------------------------------------------------------------------
 set(is_amd64 FALSE)
 set(is_arm64 FALSE)
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
-  set(is_amd64 TRUE)
+    set(is_amd64 TRUE)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64")
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64")
-  set(is_arm64 TRUE)
+    set(is_arm64 TRUE)
-else()
+else ()
-  message(FATAL_ERROR "Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}")
+    message(FATAL_ERROR "Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}")
-endif()
+endif ()

cmake/XrplAddTest.cmake

@@ -1,25 +1,16 @@
 include(isolate_headers)
 
-function(xrpl_add_test name)
+function (xrpl_add_test name)
-  set(target ${PROJECT_NAME}.test.${name})
+    set(target ${PROJECT_NAME}.test.${name})
 
-  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+         "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp")
-  "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+    add_executable(${target} ${ARGN} ${sources})
-  )
-  add_executable(${target} ${ARGN} ${sources})
 
-  isolate_headers(
+    isolate_headers(${target} "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/tests/${name}" PRIVATE)
-    ${target}
-    "${CMAKE_SOURCE_DIR}"
-    "${CMAKE_SOURCE_DIR}/tests/${name}"
-    PRIVATE
-  )
 
-  # Make sure the test isn't optimized away in unity builds
+    # Make sure the test isn't optimized away in unity builds
-  set_target_properties(${target} PROPERTIES
+    set_target_properties(${target} PROPERTIES UNITY_BUILD_MODE GROUP UNITY_BUILD_BATCH_SIZE 0) # Adjust as needed
-    UNITY_BUILD_MODE GROUP
-    UNITY_BUILD_BATCH_SIZE 0)  # Adjust as needed
 
-  add_test(NAME ${target} COMMAND ${target})
+    add_test(NAME ${target} COMMAND ${target})
-endfunction()
+endfunction ()

cmake/XrplCompiler.cmake

@@ -8,153 +8,155 @@ include(CompilationEnv)
    TODO some/most of these common settings belong in a
    toolchain file, especially the ABI-impacting ones
 #]=========================================================]
-add_library (common INTERFACE)
+add_library(common INTERFACE)
-add_library (Xrpl::common ALIAS common)
+add_library(Xrpl::common ALIAS common)
 include(XrplSanitizers)
 # add a single global dependency on this interface lib
-link_libraries (Xrpl::common)
+link_libraries(Xrpl::common)
 # Respect CMAKE_POSITION_INDEPENDENT_CODE setting (may be set by Conan toolchain)
-if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+if (NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
-  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif()
+endif ()
-set_target_properties (common
+set_target_properties(common PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
-  PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
 set(CMAKE_CXX_EXTENSIONS OFF)
-target_compile_definitions (common
+target_compile_definitions(
-  INTERFACE
+    common
-    $<$<CONFIG:Debug>:DEBUG _DEBUG>
+    INTERFACE $<$<CONFIG:Debug>:DEBUG
-    #[===[
+              _DEBUG>
+              #[===[
     NOTE: CMAKE release builds already have NDEBUG defined, so no need to add it
     explicitly except for the special case of (profile ON) and (assert OFF).
     Presumably this is because we don't want profile builds asserting unless
     asserts were specifically requested.
     ]===]
-    $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
+              $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
-    # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
+              # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
-    OPENSSL_SUPPRESS_DEPRECATED
+              OPENSSL_SUPPRESS_DEPRECATED)
-)
 
 if (MSVC)
-  # remove existing exception flag since we set it to -EHa
+    # remove existing exception flag since we set it to -EHa
-  string (REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    string(REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-  foreach (var_
+    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
-      CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
-      CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
 
-    # also remove dynamic runtime
+        # also remove dynamic runtime
-    string (REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
+        string(REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
 
-    # /ZI (Edit & Continue debugging information) is incompatible with Gy-
+        # /ZI (Edit & Continue debugging information) is incompatible with Gy-
-    string (REPLACE "/ZI" "/Zi" ${var_} "${${var_}}")
+        string(REPLACE "/ZI" "/Zi" ${var_} "${${var_}}")
 
-    # omit debug info completely under CI (not needed)
+        # omit debug info completely under CI (not needed)
-    if (is_ci)
+        if (is_ci)
-      string (REPLACE "/Zi" " " ${var_} "${${var_}}")
+            string(REPLACE "/Zi" " " ${var_} "${${var_}}")
-      string (REPLACE "/Z7" " " ${var_} "${${var_}}")
+            string(REPLACE "/Z7" " " ${var_} "${${var_}}")
-    endif ()
+        endif ()
-  endforeach ()
+    endforeach ()
 
-  target_compile_options (common
+    target_compile_options(
-    INTERFACE
+        common
-      -bigobj            # Increase object file max size
+        INTERFACE # Increase object file max size
-      -fp:precise        # Floating point behavior
+                  -bigobj
-      -Gd                # __cdecl calling convention
+                  # Floating point behavior
-      -Gm-               # Minimal rebuild: disabled
+                  -fp:precise
-      -Gy-               # Function level linking: disabled
+                  # __cdecl calling convention
-      -MP                # Multiprocessor compilation
+                  -Gd
-      -openmp-           # pragma omp: disabled
+                  # Minimal rebuild: disabled
-      -errorReport:none  # No error reporting to Internet
+                  -Gm-
-      -nologo            # Suppress login banner
+                  # Function level linking: disabled
-      -wd4018            # Disable signed/unsigned comparison warnings
+                  -Gy-
-      -wd4244            # Disable float to int possible loss of data warnings
+                  # Multiprocessor compilation
-      -wd4267            # Disable size_t to T possible loss of data warnings
+                  -MP
-      -wd4800            # Disable C4800(int to bool performance)
+                  # pragma omp: disabled
-      -wd4503            # Decorated name length exceeded, name was truncated
+                  -openmp-
-      $<$<COMPILE_LANGUAGE:CXX>:
+                  # No error reporting to Internet
-        -EHa
+                  -errorReport:none
-        -GR
+                  # Suppress login banner
-      >
+                  -nologo
-      $<$<CONFIG:Release>:-Ox>
+                  # Disable signed/unsigned comparison warnings
-      $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
+                  -wd4018
-        -GS
+                  # Disable float to int possible loss of data warnings
-        -Zc:forScope
+                  -wd4244
-      >
+                  # Disable size_t to T possible loss of data warnings
-      # static runtime
+                  -wd4267
-      $<$<CONFIG:Debug>:-MTd>
+                  # Disable C4800(int to bool performance)
-      $<$<NOT:$<CONFIG:Debug>>:-MT>
+                  -wd4800
-      $<$<BOOL:${werr}>:-WX>
+                  # Decorated name length exceeded, name was truncated
-      )
+                  -wd4503
-  target_compile_definitions (common
+                  $<$<COMPILE_LANGUAGE:CXX>:
-    INTERFACE
+                  -EHa
-      _WIN32_WINNT=0x6000
+                  -GR
-      _SCL_SECURE_NO_WARNINGS
+                  >
-      _CRT_SECURE_NO_WARNINGS
+                  $<$<CONFIG:Release>:-Ox>
-      WIN32_CONSOLE
+                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
-      WIN32_LEAN_AND_MEAN
+                  -GS
-      NOMINMAX
+                  -Zc:forScope
-      # TODO: Resolve these warnings, don't just silence them
+                  >
-      _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+                  # static runtime
-      $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>)
+                  $<$<CONFIG:Debug>:-MTd>
-  target_link_libraries (common
+                  $<$<NOT:$<CONFIG:Debug>>:-MT>
-    INTERFACE
+                  $<$<BOOL:${werr}>:-WX>)
-      -errorreport:none
+    target_compile_definitions(
-      -machine:X64)
+        common
+        INTERFACE _WIN32_WINNT=0x6000
+                  _SCL_SECURE_NO_WARNINGS
+                  _CRT_SECURE_NO_WARNINGS
+                  WIN32_CONSOLE
+                  WIN32_LEAN_AND_MEAN
+                  NOMINMAX
+                  # TODO: Resolve these warnings, don't just silence them
+                  _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>)
+    target_link_libraries(common INTERFACE -errorreport:none -machine:X64)
 else ()
-  target_compile_options (common
+    target_compile_options(
-    INTERFACE
+        common
-      -Wall
+        INTERFACE -Wall
-      -Wdeprecated
+                  -Wdeprecated
-      $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
+                  $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
-      $<$<BOOL:${wextra}>:-Wextra -Wno-unused-parameter>
+                  $<$<BOOL:${wextra}>:-Wextra
-      $<$<BOOL:${werr}>:-Werror>
+                  -Wno-unused-parameter>
-      -fstack-protector
+                  $<$<BOOL:${werr}>:-Werror>
-      -Wno-sign-compare
+                  -fstack-protector
-      -Wno-unused-but-set-variable
+                  -Wno-sign-compare
-      $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
+                  -Wno-unused-but-set-variable
-      # tweak gcc optimization for debug
+                  $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
-      $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
+                  # tweak gcc optimization for debug
-      # Add debug symbols to release config
+                  $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
-      $<$<CONFIG:Release>:-g>)
+                  # Add debug symbols to release config
-  target_link_libraries (common
+                  $<$<CONFIG:Release>:-g>)
-    INTERFACE
+    target_link_libraries(
-      -rdynamic
+        common
-      $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
+        INTERFACE -rdynamic
-      # link to static libc/c++ iff:
+                  $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
-      #   * static option set and
+                  # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
-      #   * NOT APPLE (AppleClang does not support static libc/c++) and
+                  # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
-      #   * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
+                  $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
-      $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
+                  -static-libstdc++
-      -static-libstdc++
+                  -static-libgcc
-      -static-libgcc
+                  >)
-      >)
 endif ()
 
 # Antithesis instrumentation will only be built and deployed using machines running Linux.
 if (voidstar)
-  if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-    message(FATAL_ERROR "Antithesis instrumentation requires Debug build type, aborting...")
+        message(FATAL_ERROR "Antithesis instrumentation requires Debug build type, aborting...")
-  elseif (NOT is_linux)
+    elseif (NOT is_linux)
-    message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
+        message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
-  elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
+    elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
-    message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting...")
+        message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting...")
-  endif ()
+    endif ()
 endif ()
 
 if (use_mold)
-  # use mold linker if available
+    # use mold linker if available
-  execute_process (
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version
+    if ("${LD_VERSION}" MATCHES "mold")
-    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+        target_link_libraries(common INTERFACE -fuse-ld=mold)
-  if ("${LD_VERSION}" MATCHES "mold")
+    endif ()
-    target_link_libraries (common INTERFACE -fuse-ld=mold)
+    unset(LD_VERSION)
-  endif ()
-  unset (LD_VERSION)
 elseif (use_gold AND is_gcc)
-  # use gold linker if available
+    # use gold linker if available
-  execute_process (
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
-    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
     #[=========================================================[
        NOTE: THE gold linker inserts -rpath as DT_RUNPATH by
        default instead of DT_RPATH, so you might have slightly
@@ -168,34 +170,31 @@ elseif (use_gold AND is_gcc)
        disabling would be to figure out all the settings
        required to make gold play nicely with jemalloc.
     #]=========================================================]
-  if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
+    if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
-    target_link_libraries (common
+        target_link_libraries(
-      INTERFACE
+            common
-        -fuse-ld=gold
+            INTERFACE -fuse-ld=gold
-        -Wl,--no-as-needed
+                      -Wl,--no-as-needed
-        #[=========================================================[
+                      #[=========================================================[
            see https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1253638/comments/5
            DT_RUNPATH does not work great for transitive
            dependencies (of which boost has a few) - so just
            switch to DT_RPATH if doing dynamic linking with gold
         #]=========================================================]
-        $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
+                      $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
-  endif ()
+    endif ()
-  unset (LD_VERSION)
+    unset(LD_VERSION)
 elseif (use_lld)
-  # use lld linker if available
+    # use lld linker if available
-  execute_process (
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
-    COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
+    if ("${LD_VERSION}" MATCHES "LLD")
-    ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+        target_link_libraries(common INTERFACE -fuse-ld=lld)
-  if ("${LD_VERSION}" MATCHES "LLD")
+    endif ()
-    target_link_libraries (common INTERFACE -fuse-ld=lld)
+    unset(LD_VERSION)
-  endif ()
+endif ()
-  unset (LD_VERSION)
-endif()
-
 
 if (assert)
-  foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
+    foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
-    STRING (REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
+        string(REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
-  endforeach ()
+    endforeach ()
 endif ()

cmake/XrplConfig.cmake

@@ -1,54 +1,52 @@
-include (CMakeFindDependencyMacro)
+include(CMakeFindDependencyMacro)
 # need to represent system dependencies of the lib here
 #[=========================================================[
   Boost
 #]=========================================================]
 if (static OR APPLE OR MSVC)
-  set (Boost_USE_STATIC_LIBS ON)
+    set(Boost_USE_STATIC_LIBS ON)
 endif ()
-set (Boost_USE_MULTITHREADED ON)
+set(Boost_USE_MULTITHREADED ON)
 if (static OR MSVC)
-  set (Boost_USE_STATIC_RUNTIME ON)
+    set(Boost_USE_STATIC_RUNTIME ON)
 else ()
-  set (Boost_USE_STATIC_RUNTIME OFF)
+    set(Boost_USE_STATIC_RUNTIME OFF)
 endif ()
-find_dependency (Boost
+find_dependency(Boost
-  COMPONENTS
+                COMPONENTS
-    chrono
+                chrono
-    container
+                container
-    context
+                context
-    coroutine
+                coroutine
-    date_time
+                date_time
-    filesystem
+                filesystem
-    program_options
+                program_options
-    regex
+                regex
-    system
+                system
-    thread)
+                thread)
 #[=========================================================[
   OpenSSL
 #]=========================================================]
 if (NOT DEFINED OPENSSL_ROOT_DIR)
-  if (DEFINED ENV{OPENSSL_ROOT})
+    if (DEFINED ENV{OPENSSL_ROOT})
-    set (OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
+        set(OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
-  elseif (APPLE)
+    elseif (APPLE)
-    find_program (homebrew brew)
+        find_program(homebrew brew)
-    if (homebrew)
+        if (homebrew)
-      execute_process (COMMAND ${homebrew} --prefix openssl
+            execute_process(COMMAND ${homebrew} --prefix openssl OUTPUT_VARIABLE OPENSSL_ROOT_DIR
-        OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+                            OUTPUT_STRIP_TRAILING_WHITESPACE)
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
+        endif ()
     endif ()
-  endif ()
+    file(TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
-  file (TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
 endif ()
 
 if (static OR APPLE OR MSVC)
-  set (OPENSSL_USE_STATIC_LIBS ON)
+    set(OPENSSL_USE_STATIC_LIBS ON)
 endif ()
-set (OPENSSL_MSVC_STATIC_RT ON)
+set(OPENSSL_MSVC_STATIC_RT ON)
-find_dependency (OpenSSL REQUIRED)
+find_dependency(OpenSSL REQUIRED)
-find_dependency (ZLIB)
+find_dependency(ZLIB)
-find_dependency (date)
+find_dependency(date)
 if (TARGET ZLIB::ZLIB)
-  set_target_properties(OpenSSL::Crypto PROPERTIES
+    set_target_properties(OpenSSL::Crypto PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
-    INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
 endif ()

cmake/XrplCore.cmake

@@ -10,63 +10,44 @@ include(target_protobuf_sources)
 # so we just build them as a separate library.
 add_library(xrpl.libpb)
 set_target_properties(xrpl.libpb PROPERTIES UNITY_BUILD OFF)
-target_protobuf_sources(xrpl.libpb xrpl/proto
+target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
-  LANGUAGE cpp
+                        PROTOS include/xrpl/proto/xrpl.proto)
-  IMPORT_DIRS include/xrpl/proto
-  PROTOS include/xrpl/proto/xrpl.proto
-)
 
 file(GLOB_RECURSE protos "include/xrpl/proto/org/*.proto")
-target_protobuf_sources(xrpl.libpb xrpl/proto
+target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto PROTOS "${protos}")
-  LANGUAGE cpp
+target_protobuf_sources(
-  IMPORT_DIRS include/xrpl/proto
+    xrpl.libpb xrpl/proto
-  PROTOS "${protos}"
+    LANGUAGE grpc
-)
+    IMPORT_DIRS include/xrpl/proto
-target_protobuf_sources(xrpl.libpb xrpl/proto
+    PROTOS "${protos}"
-  LANGUAGE grpc
+    PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
-  IMPORT_DIRS include/xrpl/proto
+    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc)
-  PROTOS "${protos}"
-  PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
-  GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
-)
 
-target_compile_options(xrpl.libpb
+target_compile_options(
-  PUBLIC
+    xrpl.libpb PUBLIC $<$<BOOL:${is_msvc}>:-wd4996> $<$<BOOL:${is_xcode}>: --system-header-prefix="google/protobuf"
-    $<$<BOOL:${MSVC}>:-wd4996>
+                      -Wno-deprecated-dynamic-exception-spec >
-    $<$<BOOL:${XCODE}>:
+    PRIVATE $<$<BOOL:${is_msvc}>:-wd4065> $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>)
-      --system-header-prefix="google/protobuf"
-      -Wno-deprecated-dynamic-exception-spec
-    >
-  PRIVATE
-    $<$<BOOL:${MSVC}>:-wd4065>
-    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
-)
 
-target_link_libraries(xrpl.libpb
+target_link_libraries(xrpl.libpb PUBLIC protobuf::libprotobuf gRPC::grpc++)
-  PUBLIC
-    protobuf::libprotobuf
-    gRPC::grpc++
-)
 
 # TODO: Clean up the number of library targets later.
 add_library(xrpl.imports.main INTERFACE)
 
-target_link_libraries(xrpl.imports.main
+target_link_libraries(
-  INTERFACE
+    xrpl.imports.main
-    absl::random_random
+    INTERFACE absl::random_random
-    date::date
+              date::date
-    ed25519::ed25519
+              ed25519::ed25519
-    LibArchive::LibArchive
+              LibArchive::LibArchive
-    OpenSSL::Crypto
+              OpenSSL::Crypto
-    Xrpl::boost
+              Xrpl::boost
-    Xrpl::libs
+              Xrpl::libs
-    Xrpl::opts
+              Xrpl::opts
-    Xrpl::syslibs
+              Xrpl::syslibs
-    secp256k1::secp256k1
+              secp256k1::secp256k1
-    xrpl.libpb
+              xrpl.libpb
-    xxHash::xxhash
+              xxHash::xxhash
-    $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
+              $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>)
-)
 
 include(add_module)
 include(target_link_modules)
@@ -88,18 +69,11 @@ target_link_libraries(xrpl.libxrpl.crypto PUBLIC xrpl.libxrpl.basics)
 
 # Level 04
 add_module(xrpl protocol)
-target_link_libraries(xrpl.libxrpl.protocol PUBLIC
+target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.json)
-  xrpl.libxrpl.crypto
-  xrpl.libxrpl.json
-)
 
 # Level 05
 add_module(xrpl core)
-target_link_libraries(xrpl.libxrpl.core PUBLIC
+target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
-  xrpl.libxrpl.basics
-  xrpl.libxrpl.json
-  xrpl.libxrpl.protocol
-)
 
 # Level 06
 add_module(xrpl resource)
@@ -107,62 +81,45 @@ target_link_libraries(xrpl.libxrpl.resource PUBLIC xrpl.libxrpl.protocol)
 
 # Level 07
 add_module(xrpl net)
-target_link_libraries(xrpl.libxrpl.net PUBLIC
+target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
-  xrpl.libxrpl.basics
+                                              xrpl.libxrpl.resource)
-  xrpl.libxrpl.json
-  xrpl.libxrpl.protocol
-  xrpl.libxrpl.resource
-)
 
 add_module(xrpl server)
 target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol)
 
 add_module(xrpl nodestore)
-target_link_libraries(xrpl.libxrpl.nodestore PUBLIC
+target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
-        xrpl.libxrpl.basics
-        xrpl.libxrpl.json
-        xrpl.libxrpl.protocol
-)
 
 add_module(xrpl shamap)
-target_link_libraries(xrpl.libxrpl.shamap PUBLIC
+target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto xrpl.libxrpl.protocol
-        xrpl.libxrpl.basics
+                                                 xrpl.libxrpl.nodestore)
-        xrpl.libxrpl.crypto
-        xrpl.libxrpl.protocol
-        xrpl.libxrpl.nodestore
-)
 
 add_module(xrpl ledger)
-target_link_libraries(xrpl.libxrpl.ledger PUBLIC
+target_link_libraries(xrpl.libxrpl.ledger PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
-  xrpl.libxrpl.basics
-  xrpl.libxrpl.json
-  xrpl.libxrpl.protocol
-)
 
 add_library(xrpl.libxrpl)
 set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
 
 add_library(xrpl::libxrpl ALIAS xrpl.libxrpl)
 
-file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp")
-  "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp"
-)
 target_sources(xrpl.libxrpl PRIVATE ${sources})
 
-target_link_modules(xrpl PUBLIC
+target_link_modules(
-  basics
+    xrpl
-  beast
+    PUBLIC
-  core
+    basics
-  crypto
+    beast
-  json
+    core
-  protocol
+    crypto
-  resource
+    json
-  server
+    protocol
-  nodestore
+    resource
-  shamap
+    server
-  net
+    nodestore
-  ledger
+    shamap
-)
+    net
+    ledger)
 
 # All headers in libxrpl are in modules.
 # Uncomment this stanza if you have not yet moved new headers into a module.
@@ -173,63 +130,42 @@ target_link_modules(xrpl PUBLIC
 #     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 #     $<INSTALL_INTERFACE:include>)
 
-if(xrpld)
+if (xrpld)
-  add_executable(xrpld)
+    add_executable(xrpld)
-  if(tests)
+    if (tests)
-    target_compile_definitions(xrpld PUBLIC ENABLE_TESTS)
+        target_compile_definitions(xrpld PUBLIC ENABLE_TESTS)
-    target_compile_definitions(xrpld PRIVATE
+        target_compile_definitions(xrpld PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE})
-                                       UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
+    endif ()
-    )
+    target_include_directories(xrpld PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
-  endif()
-  target_include_directories(xrpld
-    PRIVATE
-      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-  )
 
-  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp")
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp"
-  )
-  target_sources(xrpld PRIVATE ${sources})
-
-  if(tests)
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS
-      "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
-    )
     target_sources(xrpld PRIVATE ${sources})
-  endif()
 
-  target_link_libraries(xrpld
+    if (tests)
-    Xrpl::boost
+        file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp")
-    Xrpl::opts
+        target_sources(xrpld PRIVATE ${sources})
-    Xrpl::libs
+    endif ()
-    xrpl.libxrpl
-  )
-  exclude_if_included(xrpld)
-  # define a macro for tests that might need to
-  # be excluded or run differently in CI environment
-  if(is_ci)
-    target_compile_definitions(xrpld PRIVATE XRPL_RUNNING_IN_CI)
-  endif ()
 
-  if(voidstar)
+    target_link_libraries(xrpld Xrpl::boost Xrpl::opts Xrpl::libs xrpl.libxrpl)
-    target_compile_options(xrpld
+    exclude_if_included(xrpld)
-      PRIVATE
+    # define a macro for tests that might need to
-        -fsanitize-coverage=trace-pc-guard
+    # be excluded or run differently in CI environment
-    )
+    if (is_ci)
-    # xrpld requires access to antithesis-sdk-cpp implementation file
+        target_compile_definitions(xrpld PRIVATE XRPL_RUNNING_IN_CI)
-    # antithesis_instrumentation.h, which is not exported as INTERFACE
+    endif ()
-    target_include_directories(xrpld
-      PRIVATE
-        ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
-    )
-  endif()
 
-  # any files that don't play well with unity should be added here
+    if (voidstar)
-  if(tests)
+        target_compile_options(xrpld PRIVATE -fsanitize-coverage=trace-pc-guard)
-    set_source_files_properties(
+        # xrpld requires access to antithesis-sdk-cpp implementation file
-      # these two seem to produce conflicts in beast teardown template methods
+        # antithesis_instrumentation.h, which is not exported as INTERFACE
-      src/test/rpc/ValidatorRPC_test.cpp
+        target_include_directories(xrpld PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk)
-      src/test/ledger/Invariants_test.cpp
+    endif ()
-      PROPERTIES SKIP_UNITY_BUILD_INCLUSION TRUE)
+
-  endif()
+    # any files that don't play well with unity should be added here
-endif()
+    if (tests)
+        set_source_files_properties(
+            # these two seem to produce conflicts in beast teardown template methods
+            src/test/rpc/ValidatorRPC_test.cpp src/test/ledger/Invariants_test.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION
+                                                                                              TRUE)
+    endif ()
+endif ()

cmake/XrplCov.cmake

@@ -2,40 +2,51 @@
    coverage report target
 #]===================================================================]
 
-if(NOT coverage)
+if (NOT coverage)
-  message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
+    message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
-endif()
+endif ()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-  message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+    message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
-  return()
+    return()
-endif()
+endif ()
 
 include(ProcessorCount)
 ProcessorCount(PROCESSOR_COUNT)
 
 include(CodeCoverage)
 
-# The instructions for these commands come from the `CodeCoverage` module,
+# The instructions for these commands come from the `CodeCoverage` module, which was copied from
-# which was copied from https://github.com/bilke/cmake-modules, commit fb7d2a3,
+# https://github.com/bilke/cmake-modules, commit fb7d2a3, then locally changed (see CHANGES: section in
-# then locally changed (see CHANGES: section in `CodeCoverage.cmake`)
+# `CodeCoverage.cmake`)
 
 set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
-if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+if (NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
-  separate_arguments(GCOVR_ADDITIONAL_ARGS)
+    separate_arguments(GCOVR_ADDITIONAL_ARGS)
-endif()
+endif ()
 
-list(APPEND GCOVR_ADDITIONAL_ARGS
+list(APPEND
-  --exclude-throw-branches
+     GCOVR_ADDITIONAL_ARGS
-  --exclude-noncode-lines
+     --exclude-throw-branches
-  --exclude-unreachable-branches -s
+     --exclude-noncode-lines
-  -j ${PROCESSOR_COUNT})
+     --exclude-unreachable-branches
+     -s
+     -j
+     ${PROCESSOR_COUNT})
 
 setup_target_for_coverage_gcovr(
-  NAME coverage
+    NAME
-  FORMAT ${coverage_format}
+    coverage
-  EXCLUDE "src/test" "src/tests" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    FORMAT
-  DEPENDENCIES xrpld xrpl.tests
+    ${coverage_format}
-)
+    EXCLUDE
+    "src/test"
+    "src/tests"
+    "include/xrpl/beast/test"
+    "include/xrpl/beast/unit_test"
+    "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    DEPENDENCIES
+    xrpld
+    xrpl.tests)
 
 add_code_coverage_to_target(opts INTERFACE)

cmake/XrplDocs.cmake

@@ -2,45 +2,44 @@
    docs target (optional)
 #]===================================================================]
 
-if(NOT only_docs)
+if (NOT only_docs)
-  return()
+    return()
-endif()
+endif ()
 
 find_package(Doxygen)
-if(NOT TARGET Doxygen::doxygen)
+if (NOT TARGET Doxygen::doxygen)
-  message(STATUS "doxygen executable not found -- skipping docs target")
+    message(STATUS "doxygen executable not found -- skipping docs target")
-  return()
+    return()
-endif()
+endif ()
 
 set(doxygen_output_directory "${CMAKE_BINARY_DIR}/docs")
 set(doxygen_include_path "${CMAKE_CURRENT_SOURCE_DIR}/src")
 set(doxygen_index_file "${doxygen_output_directory}/html/index.html")
 set(doxyfile "${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile")
 
-file(GLOB_RECURSE doxygen_input
+file(GLOB_RECURSE
-  docs/*.md
+     doxygen_input
-  include/*.h
+     docs/*.md
-  include/*.cpp
+     include/*.h
-  include/*.md
+     include/*.cpp
-  src/*.h
+     include/*.md
-  src/*.cpp
+     src/*.h
-  src/*.md
+     src/*.cpp
-  Builds/*.md
+     src/*.md
-  *.md)
+     Builds/*.md
-list(APPEND doxygen_input
+     *.md)
-  external/README.md
+list(APPEND doxygen_input external/README.md)
-  )
 set(dependencies "${doxygen_input}" "${doxyfile}")
 
-function(verbose_find_path variable name)
+function (verbose_find_path variable name)
-  # find_path sets a CACHE variable, so don't try using a "local" variable.
+    # find_path sets a CACHE variable, so don't try using a "local" variable.
-  find_path(${variable} "${name}" ${ARGN})
+    find_path(${variable} "${name}" ${ARGN})
-  if(NOT ${variable})
+    if (NOT ${variable})
-    message(NOTICE "could not find ${name}")
+        message(NOTICE "could not find ${name}")
-  else()
+    else ()
-    message(STATUS "found ${name}: ${${variable}}/${name}")
+        message(STATUS "found ${name}: ${${variable}}/${name}")
-  endif()
+    endif ()
-endfunction()
+endfunction ()
 
 verbose_find_path(doxygen_plantuml_jar_path plantuml.jar PATH_SUFFIXES share/plantuml)
 verbose_find_path(doxygen_dot_path dot)
@@ -48,36 +47,26 @@ verbose_find_path(doxygen_dot_path dot)
 # https://en.cppreference.com/w/Cppreference:Archives
 # https://stackoverflow.com/questions/60822559/how-to-move-a-file-download-from-configure-step-to-build-step
 set(download_script "${CMAKE_BINARY_DIR}/docs/download-cppreference.cmake")
-file(WRITE
+file(WRITE "${download_script}"
-  "${download_script}"
+     "file(DOWNLOAD \
-  "file(DOWNLOAD \
     https://github.com/PeterFeicht/cppreference-doc/releases/download/v20250209/html-book-20250209.zip \
     ${CMAKE_BINARY_DIR}/docs/cppreference.zip \
     EXPECTED_HASH MD5=bda585f72fbca4b817b29a3d5746567b \
   )\n \
   execute_process( \
     COMMAND \"${CMAKE_COMMAND}\" -E tar -xf cppreference.zip \
-  )\n"
+  )\n")
-)
 set(tagfile "${CMAKE_BINARY_DIR}/docs/cppreference-doxygen-web.tag.xml")
-add_custom_command(
+add_custom_command(OUTPUT "${tagfile}" COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
-  OUTPUT "${tagfile}"
+                   WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs")
-  COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
-  WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs"
-)
 set(doxygen_tagfiles "${tagfile}=http://en.cppreference.com/w/")
 
 add_custom_command(
-  OUTPUT "${doxygen_index_file}"
+    OUTPUT "${doxygen_index_file}"
-  COMMAND "${CMAKE_COMMAND}" -E env
+    COMMAND "${CMAKE_COMMAND}" -E env "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
-    "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
+            "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}" "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
-    "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}"
+            "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}" "DOXYGEN_DOT_PATH=${doxygen_dot_path}"
-    "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
+            "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
-    "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
+    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    "DOXYGEN_DOT_PATH=${doxygen_dot_path}"
+    DEPENDS "${dependencies}" "${tagfile}")
-    "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
+add_custom_target(docs DEPENDS "${doxygen_index_file}" SOURCES "${dependencies}")
-  WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-  DEPENDS "${dependencies}" "${tagfile}")
-add_custom_target(docs
-  DEPENDS "${doxygen_index_file}"
-  SOURCES "${dependencies}")

cmake/XrplInstall.cmake

@@ -4,57 +4,53 @@
 
 include(create_symbolic_link)
 
-install (
+# If no suffix is defined for executables (e.g. Windows uses .exe but Linux
-  TARGETS
+# and macOS use none), then explicitly set it to the empty string.
-    common
+if (NOT DEFINED suffix)
-    opts
+    set(suffix "")
-    xrpl_boost
+endif ()
-    xrpl_libs
-    xrpl_syslibs
-    xrpl.imports.main
-    xrpl.libpb
-    xrpl.libxrpl
-    xrpl.libxrpl.basics
-    xrpl.libxrpl.beast
-    xrpl.libxrpl.core
-    xrpl.libxrpl.crypto
-    xrpl.libxrpl.json
-    xrpl.libxrpl.ledger
-    xrpl.libxrpl.net
-    xrpl.libxrpl.nodestore
-    xrpl.libxrpl.protocol
-    xrpl.libxrpl.resource
-    xrpl.libxrpl.server
-    xrpl.libxrpl.shamap
-    antithesis-sdk-cpp
-  EXPORT XrplExports
-  LIBRARY DESTINATION lib
-  ARCHIVE DESTINATION lib
-  RUNTIME DESTINATION bin
-  INCLUDES DESTINATION include)
 
-install(
+install(TARGETS common
-  DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
+                opts
-  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+                xrpl_boost
-)
+                xrpl_libs
+                xrpl_syslibs
+                xrpl.imports.main
+                xrpl.libpb
+                xrpl.libxrpl
+                xrpl.libxrpl.basics
+                xrpl.libxrpl.beast
+                xrpl.libxrpl.core
+                xrpl.libxrpl.crypto
+                xrpl.libxrpl.json
+                xrpl.libxrpl.ledger
+                xrpl.libxrpl.net
+                xrpl.libxrpl.nodestore
+                xrpl.libxrpl.protocol
+                xrpl.libxrpl.resource
+                xrpl.libxrpl.server
+                xrpl.libxrpl.shamap
+                antithesis-sdk-cpp
+        EXPORT XrplExports
+        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION lib
+        RUNTIME DESTINATION bin
+        INCLUDES
+        DESTINATION include)
 
-install (EXPORT XrplExports
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-  FILE XrplTargets.cmake
+
-  NAMESPACE Xrpl::
+install(EXPORT XrplExports FILE XrplTargets.cmake NAMESPACE Xrpl:: DESTINATION lib/cmake/xrpl)
-  DESTINATION lib/cmake/xrpl)
+include(CMakePackageConfigHelpers)
-include (CMakePackageConfigHelpers)
+write_basic_package_version_file(XrplConfigVersion.cmake VERSION ${xrpld_version} COMPATIBILITY SameMajorVersion)
-write_basic_package_version_file (
-  XrplConfigVersion.cmake
-  VERSION ${xrpld_version}
-  COMPATIBILITY SameMajorVersion)
 
 if (is_root_project AND TARGET xrpld)
-  install (TARGETS xrpld RUNTIME DESTINATION bin)
+    install(TARGETS xrpld RUNTIME DESTINATION bin)
-  set_target_properties(xrpld PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
+    set_target_properties(xrpld PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
-  # sample configs should not overwrite existing files
+    # sample configs should not overwrite existing files
-  # install if-not-exists workaround as suggested by
+    # install if-not-exists workaround as suggested by
-  # https://cmake.org/Bug/view.php?id=12646
+    # https://cmake.org/Bug/view.php?id=12646
-  install(CODE "
+    install(CODE "
     macro (copy_if_not_exists SRC DEST NEWNAME)
       if (NOT EXISTS \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
         file (INSTALL FILE_PERMISSIONS OWNER_READ OWNER_WRITE DESTINATION \"\${CMAKE_INSTALL_PREFIX}/\${DEST}\" FILES \"\${SRC}\" RENAME \"\${NEWNAME}\")
@@ -65,7 +61,7 @@ if (is_root_project AND TARGET xrpld)
     copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/xrpld-example.cfg\" etc xrpld.cfg)
     copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/validators-example.txt\" etc validators.txt)
   ")
-  install(CODE "
+    install(CODE "
     set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
     include(create_symbolic_link)
     create_symbolic_link(xrpld${suffix} \
@@ -73,8 +69,5 @@ if (is_root_project AND TARGET xrpld)
   ")
 endif ()
 
-install (
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake
-  FILES
+        DESTINATION lib/cmake/xrpl)
-    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake
-    ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake
-  DESTINATION lib/cmake/xrpl)

cmake/XrplInterface.cmake

@@ -4,80 +4,80 @@
 
 include(CompilationEnv)
 
-add_library (opts INTERFACE)
+# Set defaults for optional variables to avoid uninitialized variable warnings
-add_library (Xrpl::opts ALIAS opts)
+if (NOT DEFINED voidstar)
-target_compile_definitions (opts
+    set(voidstar OFF)
-  INTERFACE
+endif ()
-    BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
-    BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
-    BOOST_CONTAINER_FWD_BAD_DEQUE
-    HAS_UNCAUGHT_EXCEPTIONS=1
-    $<$<BOOL:${boost_show_deprecated}>:
-      BOOST_ASIO_NO_DEPRECATED
-      BOOST_FILESYSTEM_NO_DEPRECATED
-    >
-    $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
-      BOOST_COROUTINES_NO_DEPRECATION_WARNING
-      BOOST_BEAST_ALLOW_DEPRECATED
-      BOOST_FILESYSTEM_DEPRECATED
-    >
-    $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
-    $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
-    $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
-    $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
-target_compile_options (opts
-  INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
-    $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
-    $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<BOOL:${profile}>:-pg>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
-target_link_libraries (opts
+add_library(opts INTERFACE)
-  INTERFACE
+add_library(Xrpl::opts ALIAS opts)
-    $<$<BOOL:${profile}>:-pg>
+target_compile_definitions(
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+    opts
+    INTERFACE BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
+              BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+              BOOST_CONTAINER_FWD_BAD_DEQUE
+              HAS_UNCAUGHT_EXCEPTIONS=1
+              $<$<BOOL:${boost_show_deprecated}>:
+              BOOST_ASIO_NO_DEPRECATED
+              BOOST_FILESYSTEM_NO_DEPRECATED
+              >
+              $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
+              BOOST_COROUTINES_NO_DEPRECATION_WARNING
+              BOOST_BEAST_ALLOW_DEPRECATED
+              BOOST_FILESYSTEM_DEPRECATED
+              >
+              $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
+              $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
+              $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
+              $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
+target_compile_options(
+    opts
+    INTERFACE $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
+              $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized> $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+              $<$<BOOL:${profile}>:-pg> $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
-if(jemalloc)
+target_link_libraries(opts INTERFACE $<$<BOOL:${profile}>:-pg> $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
-  find_package(jemalloc REQUIRED)
+
-  target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
+if (jemalloc)
-  target_link_libraries(opts INTERFACE jemalloc::jemalloc)
+    find_package(jemalloc REQUIRED)
+    target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
+    target_link_libraries(opts INTERFACE jemalloc::jemalloc)
 endif ()
 
 #[===================================================================[
    xrpld transitive library deps via an interface library
 #]===================================================================]
 
-add_library (xrpl_syslibs INTERFACE)
+add_library(xrpl_syslibs INTERFACE)
-add_library (Xrpl::syslibs ALIAS xrpl_syslibs)
+add_library(Xrpl::syslibs ALIAS xrpl_syslibs)
-target_link_libraries (xrpl_syslibs
+target_link_libraries(
-  INTERFACE
+    xrpl_syslibs
-    $<$<BOOL:${MSVC}>:
+    INTERFACE $<$<BOOL:${is_msvc}>:
-      legacy_stdio_definitions.lib
+              legacy_stdio_definitions.lib
-      Shlwapi
+              Shlwapi
-      kernel32
+              kernel32
-      user32
+              user32
-      gdi32
+              gdi32
-      winspool
+              winspool
-      comdlg32
+              comdlg32
-      advapi32
+              advapi32
-      shell32
+              shell32
-      ole32
+              ole32
-      oleaut32
+              oleaut32
-      uuid
+              uuid
-      odbc32
+              odbc32
-      odbccp32
+              odbccp32
-      crypt32
+              crypt32
-    >
+              >
-    $<$<NOT:$<BOOL:${MSVC}>>:dl>
+              $<$<NOT:$<BOOL:${is_msvc}>>:dl>
-    $<$<NOT:$<OR:$<BOOL:${MSVC}>,$<BOOL:${APPLE}>>>:rt>)
+              $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>)
 
-if (NOT MSVC)
+if (NOT is_msvc)
-  set (THREADS_PREFER_PTHREAD_FLAG ON)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
-  find_package (Threads)
+    find_package(Threads)
-  target_link_libraries (xrpl_syslibs INTERFACE Threads::Threads)
+    target_link_libraries(xrpl_syslibs INTERFACE Threads::Threads)
 endif ()
 
-add_library (xrpl_libs INTERFACE)
+add_library(xrpl_libs INTERFACE)
-add_library (Xrpl::libs ALIAS xrpl_libs)
+add_library(Xrpl::libs ALIAS xrpl_libs)
-target_link_libraries (xrpl_libs INTERFACE Xrpl::syslibs)
+target_link_libraries(xrpl_libs INTERFACE Xrpl::syslibs)

cmake/XrplSanitizers.cmake

@@ -43,21 +43,24 @@
 include(CompilationEnv)
 
 # Read environment variable
-set(SANITIZERS $ENV{SANITIZERS})
+set(SANITIZERS "")
+if (DEFINED ENV{SANITIZERS})
+    set(SANITIZERS "$ENV{SANITIZERS}")
+endif ()
 
 # Set SANITIZERS_ENABLED flag for use in other modules
-if(SANITIZERS MATCHES "address|thread|undefinedbehavior")
+if (SANITIZERS MATCHES "address|thread|undefinedbehavior")
     set(SANITIZERS_ENABLED TRUE)
-else()
+else ()
     set(SANITIZERS_ENABLED FALSE)
     return()
-endif()
+endif ()
 
 # Sanitizers are not supported on Windows/MSVC
-if(is_msvc)
+if (is_msvc)
     message(FATAL_ERROR "Sanitizers are not supported on Windows/MSVC. "
-            "Please unset the SANITIZERS environment variable.")
+                        "Please unset the SANITIZERS environment variable.")
-endif()
+endif ()
 
 message(STATUS "Configuring sanitizers: ${SANITIZERS}")
 
@@ -71,24 +74,24 @@ set(san_list "${SANITIZERS}")
 string(REPLACE "," ";" san_list "${san_list}")
 separate_arguments(san_list)
 
-foreach(san IN LISTS san_list)
+foreach (san IN LISTS san_list)
-    if(san STREQUAL "address")
+    if (san STREQUAL "address")
         set(enable_asan TRUE)
-    elseif(san STREQUAL "thread")
+    elseif (san STREQUAL "thread")
         set(enable_tsan TRUE)
-    elseif(san STREQUAL "undefinedbehavior")
+    elseif (san STREQUAL "undefinedbehavior")
         set(enable_ubsan TRUE)
-    else()
+    else ()
         message(FATAL_ERROR "Unsupported sanitizer type: ${san}"
-              "Supported: address, thread, undefinedbehavior and their combinations.")
+                            "Supported: address, thread, undefinedbehavior and their combinations.")
-    endif()
+    endif ()
-endforeach()
+endforeach ()
 
 # Validate sanitizer compatibility
-if(enable_asan AND enable_tsan)
+if (enable_asan AND enable_tsan)
     message(FATAL_ERROR "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
-          "Use 'address' or 'thread', optionally with 'undefinedbehavior'.")
+                        "Use 'address' or 'thread', optionally with 'undefinedbehavior'.")
-endif()
+endif ()
 
 # Frame pointer is required for meaningful stack traces. Sanitizers recommend minimum of -O1 for reasonable performance
 set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
@@ -96,31 +99,31 @@ set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
 # Build the sanitizer flags list
 set(SANITIZER_TYPES)
 
-if(enable_asan)
+if (enable_asan)
     list(APPEND SANITIZER_TYPES "address")
-elseif(enable_tsan)
+elseif (enable_tsan)
     list(APPEND SANITIZER_TYPES "thread")
-endif()
+endif ()
 
-if(enable_ubsan)
+if (enable_ubsan)
     # UB sanitizer flags
     list(APPEND SANITIZER_TYPES "undefined" "float-divide-by-zero")
-    if(is_clang)
+    if (is_clang)
-        # Clang supports additional UB checks. More info here https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
+        # Clang supports additional UB checks. More info here
+        # https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
         list(APPEND SANITIZER_TYPES "unsigned-integer-overflow")
-    endif()
+    endif ()
-endif()
+endif ()
 
-# Configure code model for GCC on amd64
+# Configure code model for GCC on amd64 Use large code model for ASAN to avoid relocation errors Use medium code model
-# Use large code model for ASAN to avoid relocation errors
+# for TSAN (large is not compatible with TSAN)
-# Use medium code model for TSAN (large is not compatible with TSAN)
 set(SANITIZERS_RELOCATION_FLAGS)
 
 # Compiler-specific configuration
-if(is_gcc)
+if (is_gcc)
-    # Disable mold, gold and lld linkers for GCC with sanitizers
+    # Disable mold, gold and lld linkers for GCC with sanitizers Use default linker (bfd/ld) which is more lenient with
-    # Use default linker (bfd/ld) which is more lenient with mixed code models
+    # mixed code models This is needed since the size of instrumented binary exceeds the limits set by mold, lld and
-    # This is needed since the size of instrumented binary exceeds the limits set by mold, lld and gold linkers
+    # gold linkers
     set(use_mold OFF CACHE BOOL "Use mold linker" FORCE)
     set(use_gold OFF CACHE BOOL "Use gold linker" FORCE)
     set(use_lld OFF CACHE BOOL "Use lld linker" FORCE)
@@ -129,17 +132,17 @@ if(is_gcc)
     # Suppress false positive warnings in GCC with stringop-overflow
     list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-stringop-overflow")
 
-    if(is_amd64 AND enable_asan)
+    if (is_amd64 AND enable_asan)
         message(STATUS "  Using large code model (-mcmodel=large)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=large")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=large")
-    elseif(enable_tsan)
+    elseif (enable_tsan)
         # GCC doesn't support atomic_thread_fence with tsan. Suppress warnings.
         list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-tsan")
         message(STATUS "  Using medium code model (-mcmodel=medium)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=medium")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=medium")
-    endif()
+    endif ()
 
     # Join sanitizer flags with commas for -fsanitize option
     list(JOIN SANITIZER_TYPES "," SANITIZER_TYPES_STR)
@@ -148,13 +151,12 @@ if(is_gcc)
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
     set(SANITIZERS_LINK_FLAGS "${SANITIZERS_RELOCATION_FLAGS}" "-fsanitize=${SANITIZER_TYPES_STR}")
 
-elseif(is_clang)
+elseif (is_clang)
-    # Add ignorelist for Clang (GCC doesn't support this)
+    # Add ignorelist for Clang (GCC doesn't support this) Use CMAKE_SOURCE_DIR to get the path to the ignorelist
-    # Use CMAKE_SOURCE_DIR to get the path to the ignorelist
     set(IGNORELIST_PATH "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt")
-    if(NOT EXISTS "${IGNORELIST_PATH}")
+    if (NOT EXISTS "${IGNORELIST_PATH}")
         message(FATAL_ERROR "Sanitizer ignorelist not found: ${IGNORELIST_PATH}")
-    endif()
+    endif ()
 
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize-ignorelist=${IGNORELIST_PATH}")
     message(STATUS "  Using sanitizer ignorelist: ${IGNORELIST_PATH}")
@@ -165,34 +167,31 @@ elseif(is_clang)
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
     set(SANITIZERS_LINK_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-endif()
+endif ()
 
 message(STATUS "  Compile flags: ${SANITIZERS_COMPILE_FLAGS}")
 message(STATUS "  Link flags: ${SANITIZERS_LINK_FLAGS}")
 
-# Apply the sanitizer flags to the 'common' interface library
+# Apply the sanitizer flags to the 'common' interface library This is the same library used by XrplCompiler.cmake
-# This is the same library used by XrplCompiler.cmake
+target_compile_options(common INTERFACE $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
-target_compile_options(common INTERFACE
+                                        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>)
-    $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
-    $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>
-)
 
 # Apply linker flags
 target_link_options(common INTERFACE ${SANITIZERS_LINK_FLAGS})
 
 # Define SANITIZERS macro for BuildInfo.cpp
 set(sanitizers_list)
-if(enable_asan)
+if (enable_asan)
     list(APPEND sanitizers_list "ASAN")
-endif()
+endif ()
-if(enable_tsan)
+if (enable_tsan)
     list(APPEND sanitizers_list "TSAN")
-endif()
+endif ()
-if(enable_ubsan)
+if (enable_ubsan)
     list(APPEND sanitizers_list "UBSAN")
-endif()
+endif ()
 
-if(sanitizers_list)
+if (sanitizers_list)
     list(JOIN sanitizers_list "." sanitizers_str)
     target_compile_definitions(common INTERFACE SANITIZERS=${sanitizers_str})
-endif()
+endif ()

cmake/XrplSanity.cmake

@@ -6,40 +6,39 @@ include(CompilationEnv)
 
 get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 
-set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
+set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
 if (NOT is_multiconfig)
-  if (NOT CMAKE_BUILD_TYPE)
+    if (NOT CMAKE_BUILD_TYPE)
-    message (STATUS "Build type not specified - defaulting to Release")
+        message(STATUS "Build type not specified - defaulting to Release")
-    set (CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
+        set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
-  elseif (NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release))
+    elseif (NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release))
-    # for simplicity, these are the only two config types we care about. Limiting
+        # for simplicity, these are the only two config types we care about. Limiting the build types simplifies dealing
-    # the build types simplifies dealing with external project builds especially
+        # with external project builds especially
-    message (FATAL_ERROR " *** Only Debug or Release build types are currently supported ***")
+        message(FATAL_ERROR " *** Only Debug or Release build types are currently supported ***")
-  endif ()
+    endif ()
 endif ()
 
 if (is_clang) # both Clang and AppleClang
-  if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND
+    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
-         CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
+        message(FATAL_ERROR "This project requires clang 16 or later")
-    message (FATAL_ERROR "This project requires clang 16 or later")
+    endif ()
-  endif ()
 elseif (is_gcc)
-  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
-    message (FATAL_ERROR "This project requires GCC 12 or later")
+        message(FATAL_ERROR "This project requires GCC 12 or later")
-  endif ()
+    endif ()
 endif ()
 
 # check for in-source build and fail
 if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-  message (FATAL_ERROR "Builds (in-source) are not allowed in "
+    message(FATAL_ERROR "Builds (in-source) are not allowed in "
-    "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
+                        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
-    "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory.")
+                        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory.")
 endif ()
 
 if (MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
-  message (FATAL_ERROR "Visual Studio 32-bit build is not supported.")
+    message(FATAL_ERROR "Visual Studio 32-bit build is not supported.")
 endif ()
 
 if (APPLE AND NOT HOMEBREW)
-  find_program (HOMEBREW brew)
+    find_program(HOMEBREW brew)
 endif ()

cmake/XrplSettings.cmake

@@ -4,125 +4,111 @@
 
 include(CompilationEnv)
 
-if("$ENV{CI}" STREQUAL "true" OR "$ENV{CONTINUOUS_INTEGRATION}" STREQUAL "true")
+set(is_ci FALSE)
-  set(is_ci TRUE)
+if (DEFINED ENV{CI})
-else()
+    if ("$ENV{CI}" STREQUAL "true")
-  set(is_ci FALSE)
+        set(is_ci TRUE)
-endif()
+    endif ()
+endif ()
 
 get_directory_property(has_parent PARENT_DIRECTORY)
-if(has_parent)
+if (has_parent)
-  set(is_root_project OFF)
+    set(is_root_project OFF)
-else()
+else ()
-  set(is_root_project ON)
+    set(is_root_project ON)
-endif()
+endif ()
 
 option(assert "Enables asserts, even in release builds" OFF)
 
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if(tests)
+if (tests)
-  # This setting allows making a separate workflow to test fees other than default 10
+    # This setting allows making a separate workflow to test fees other than default 10
-  if(NOT UNIT_TEST_REFERENCE_FEE)
+    if (NOT UNIT_TEST_REFERENCE_FEE)
-    set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
+        set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-  endif()
+    endif ()
-endif()
+endif ()
 
 option(unity "Creates a build using UNITY support in cmake." OFF)
-if(unity)
+if (unity)
-  if(NOT is_ci)
+    if (NOT is_ci)
-    set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
+        set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-  endif()
+    endif ()
-  set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
+    set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
-endif()
+endif ()
 
-if(is_clang AND is_linux)
+if (is_clang AND is_linux)
-  option(voidstar "Enable Antithesis instrumentation." OFF)
+    option(voidstar "Enable Antithesis instrumentation." OFF)
-endif()
+endif ()
 
-if(is_gcc OR is_clang)
+if (is_gcc OR is_clang)
-  include(ProcessorCount)
+    include(ProcessorCount)
-  ProcessorCount(PROCESSOR_COUNT)
+    ProcessorCount(PROCESSOR_COUNT)
 
-  option(coverage "Generates coverage info." OFF)
+    option(coverage "Generates coverage info." OFF)
-  option(profile "Add profiling flags" OFF)
+    option(profile "Add profiling flags" OFF)
-  set(coverage_format "html-details" CACHE STRING
+    set(coverage_format "html-details" CACHE STRING "Output format of the coverage report.")
-    "Output format of the coverage report.")
+    set(coverage_extra_args "" CACHE STRING "Additional arguments to pass to gcovr.")
-  set(coverage_extra_args "" CACHE STRING
+    option(wextra "compile with extra gcc/clang warnings enabled" ON)
-    "Additional arguments to pass to gcovr.")
+else ()
-  option(wextra "compile with extra gcc/clang warnings enabled" ON)
+    set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
-else()
+    set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
-  set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
+    set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-  set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
+endif ()
-  set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-endif()
 
-if(is_linux AND NOT SANITIZER)
+if (is_linux AND NOT SANITIZER)
-  option(BUILD_SHARED_LIBS "build shared xrpl libraries" OFF)
+    option(BUILD_SHARED_LIBS "build shared xrpl libraries" OFF)
-  option(static "link protobuf, openssl, libc++, and boost statically" ON)
+    option(static "link protobuf, openssl, libc++, and boost statically" ON)
-  option(perf "Enables flags that assist with perf recording" OFF)
+    option(perf "Enables flags that assist with perf recording" OFF)
-  option(use_gold "enables detection of gold (binutils) linker" ON)
+    option(use_gold "enables detection of gold (binutils) linker" ON)
-  option(use_mold "enables detection of mold (binutils) linker" ON)
+    option(use_mold "enables detection of mold (binutils) linker" ON)
-  # Set a default value for the log flag based on the build type.
+    # Set a default value for the log flag based on the build type. This provides a sensible default (on for debug, off
-  # This provides a sensible default (on for debug, off for release)
+    # for release) while still allowing the user to override it for any build.
-  # while still allowing the user to override it for any build.
+    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(TRUNCATED_LOGS_DEFAULT ON)
-    set(TRUNCATED_LOGS_DEFAULT ON)
+    else ()
-  else()
+        set(TRUNCATED_LOGS_DEFAULT OFF)
-    set(TRUNCATED_LOGS_DEFAULT OFF)
+    endif ()
-  endif()
+    option(TRUNCATED_THREAD_NAME_LOGS "Show warnings about truncated thread names on Linux." ${TRUNCATED_LOGS_DEFAULT})
-  option(TRUNCATED_THREAD_NAME_LOGS
+    if (TRUNCATED_THREAD_NAME_LOGS)
-    "Show warnings about truncated thread names on Linux."
+        add_compile_definitions(TRUNCATED_THREAD_NAME_LOGS)
-    ${TRUNCATED_LOGS_DEFAULT}
+    endif ()
-  )
+else ()
-  if(TRUNCATED_THREAD_NAME_LOGS)
+    # we are not ready to allow shared-libs on windows because it would require export declarations. On macos it's more
-    add_compile_definitions(TRUNCATED_THREAD_NAME_LOGS)
+    # feasible, but static openssl produces odd linker errors, thus we disable shared lib builds for now.
-  endif()
+    set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared xrpl libraries - OFF for win/macos" FORCE)
-else()
+    set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
-  # we are not ready to allow shared-libs on windows because it would require
+    set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
-  # export declarations. On macos it's more feasible, but static openssl
+    set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
-  # produces odd linker errors, thus we disable shared lib builds for now.
+    set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
-  set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared xrpl libraries - OFF for win/macos" FORCE)
+endif ()
-  set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
-  set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
-  set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
-  set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
-endif()
 
-if(is_clang)
+if (is_clang)
-  option(use_lld "enables detection of lld linker" ON)
+    option(use_lld "enables detection of lld linker" ON)
-else()
+else ()
-  set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
+    set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif()
+endif ()
 
 option(jemalloc "Enables jemalloc for heap profiling" OFF)
 option(werr "treat warnings as errors" OFF)
-option(local_protobuf
+option(local_protobuf "Force a local build of protobuf instead of looking for an installed version." OFF)
-  "Force a local build of protobuf instead of looking for an installed version." OFF)
+option(local_grpc "Force a local build of gRPC instead of looking for an installed version." OFF)
-option(local_grpc
-  "Force a local build of gRPC instead of looking for an installed version." OFF)
 
 # the remaining options are obscure and rarely used
-option(beast_no_unit_test_inline
+option(beast_no_unit_test_inline "Prevents unit test definitions from being inserted into global table" OFF)
-  "Prevents unit test definitions from being inserted into global table"
+option(single_io_service_thread "Restricts the number of threads calling io_context::run to one. \
-  OFF)
+  This can be useful when debugging." OFF)
-option(single_io_service_thread
+option(boost_show_deprecated "Allow boost to fail on deprecated usage. Only useful if you're trying\
-  "Restricts the number of threads calling io_context::run to one. \
+  to find deprecated calls." OFF)
-  This can be useful when debugging."
-  OFF)
-option(boost_show_deprecated
-  "Allow boost to fail on deprecated usage. Only useful if you're trying\
-  to find deprecated calls."
-  OFF)
 
-if(WIN32)
+if (WIN32)
-  option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
+    option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
-else()
+else ()
-  set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
+    set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
-endif()
+endif ()
 
-if(coverage)
+if (coverage)
-  message(STATUS "coverage build requested - forcing Debug build")
+    message(STATUS "coverage build requested - forcing Debug build")
-  set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif()
+endif ()

cmake/XrplValidatorKeys.cmake

@@ -1,20 +1,17 @@
-option (validator_keys "Enables building of validator-keys tool as a separate target (imported via FetchContent)" OFF)
+option(validator_keys "Enables building of validator-keys tool as a separate target (imported via FetchContent)" OFF)
 
 if (validator_keys)
-  git_branch (current_branch)
+    git_branch(current_branch)
-  # default to tracking VK master branch unless we are on release
+    # default to tracking VK master branch unless we are on release
-  if (NOT (current_branch STREQUAL "release"))
+    if (NOT (current_branch STREQUAL "release"))
-    set (current_branch "master")
+        set(current_branch "master")
-  endif ()
+    endif ()
-  message (STATUS "Tracking ValidatorKeys branch: ${current_branch}")
+    message(STATUS "Tracking ValidatorKeys branch: ${current_branch}")
 
-  FetchContent_Declare (
+    FetchContent_Declare(validator_keys GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
-    validator_keys
+                         GIT_TAG "${current_branch}")
-    GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
+    FetchContent_MakeAvailable(validator_keys)
-    GIT_TAG        "${current_branch}"
+    set_target_properties(validator-keys PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
-  )
+    install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-  FetchContent_MakeAvailable(validator_keys)
-  set_target_properties(validator-keys PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
-  install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 endif ()

cmake/XrplVersion.cmake

@@ -3,13 +3,13 @@
 #]===================================================================]
 
 file(STRINGS src/libxrpl/protocol/BuildInfo.cpp BUILD_INFO)
-foreach(line_ ${BUILD_INFO})
+foreach (line_ ${BUILD_INFO})
-  if(line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
+    if (line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
-    set(xrpld_version ${CMAKE_MATCH_1})
+        set(xrpld_version ${CMAKE_MATCH_1})
-  endif()
+    endif ()
-endforeach()
+endforeach ()
-if(xrpld_version)
+if (xrpld_version)
-  message(STATUS "xrpld version: ${xrpld_version}")
+    message(STATUS "xrpld version: ${xrpld_version}")
-else()
+else ()
-  message(FATAL_ERROR "unable to determine xrpld version")
+    message(FATAL_ERROR "unable to determine xrpld version")
-endif()
+endif ()

cmake/add_module.cmake

@@ -12,26 +12,14 @@ include(isolate_headers)
 # add_module(parent a)
 # add_module(parent b)
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
-function(add_module parent name)
+function (add_module parent name)
-  set(target ${PROJECT_NAME}.lib${parent}.${name})
+    set(target ${PROJECT_NAME}.lib${parent}.${name})
-  add_library(${target} OBJECT)
+    add_library(${target} OBJECT)
-  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp")
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp"
+    target_sources(${target} PRIVATE ${sources})
-  )
+    target_include_directories(${target} PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-  target_sources(${target} PRIVATE ${sources})
+    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/include"
-  target_include_directories(${target} PUBLIC
+                    "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}" PUBLIC)
-    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/src" "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
-  )
+                    PRIVATE)
-  isolate_headers(
+endfunction ()
-    ${target}
-    "${CMAKE_CURRENT_SOURCE_DIR}/include"
-    "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
-    PUBLIC
-  )
-  isolate_headers(
-    ${target}
-    "${CMAKE_CURRENT_SOURCE_DIR}/src"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
-    PRIVATE
-  )
-endfunction()

cmake/create_symbolic_link.cmake

@@ -1,20 +1,19 @@
-# file(CREATE_SYMLINK) only works on Windows with administrator privileges.
+# file(CREATE_SYMLINK) only works on Windows with administrator privileges. https://stackoverflow.com/a/61244115/618906
-# https://stackoverflow.com/a/61244115/618906
+function (create_symbolic_link target link)
-function(create_symbolic_link target link)
+    if (WIN32)
-  if(WIN32)
+        if (NOT IS_SYMLINK "${link}")
-    if(NOT IS_SYMLINK "${link}")
+            if (NOT IS_ABSOLUTE "${target}")
-      if(NOT IS_ABSOLUTE "${target}")
+                # Relative links work do not work on Windows.
-        # Relative links work do not work on Windows.
+                set(target "${link}/../${target}")
-        set(target "${link}/../${target}")
+            endif ()
-      endif()
+            file(TO_NATIVE_PATH "${target}" target)
-      file(TO_NATIVE_PATH "${target}" target)
+            file(TO_NATIVE_PATH "${link}" link)
-      file(TO_NATIVE_PATH "${link}" link)
+            execute_process(COMMAND cmd.exe /c mklink /J "${link}" "${target}")
-      execute_process(COMMAND cmd.exe /c mklink /J "${link}" "${target}")
+        endif ()
-    endif()
+    else ()
-  else()
+        file(CREATE_LINK "${target}" "${link}" SYMBOLIC)
-    file(CREATE_LINK "${target}" "${link}" SYMBOLIC)
+    endif ()
-  endif()
+    if (NOT IS_SYMLINK "${link}")
-  if(NOT IS_SYMLINK "${link}")
+        message(ERROR "failed to create symlink: <${link}>")
-    message(ERROR "failed to create symlink: <${link}>")
+    endif ()
-  endif()
+endfunction ()
-endfunction()

cmake/deps/Boost.cmake

@@ -2,49 +2,43 @@ include(CompilationEnv)
 include(XrplSanitizers)
 
 find_package(Boost REQUIRED
-  COMPONENTS
+             COMPONENTS chrono
-    chrono
+                        container
-    container
+                        coroutine
-    coroutine
+                        date_time
-    date_time
+                        filesystem
-    filesystem
+                        json
-    json
+                        program_options
-    program_options
+                        regex
-    regex
+                        system
-    system
+                        thread)
-    thread
-)
 
 add_library(xrpl_boost INTERFACE)
 add_library(Xrpl::boost ALIAS xrpl_boost)
 
-target_link_libraries(xrpl_boost
+target_link_libraries(
-  INTERFACE
+    xrpl_boost
-    Boost::headers
+    INTERFACE Boost::headers
-    Boost::chrono
+              Boost::chrono
-    Boost::container
+              Boost::container
-    Boost::coroutine
+              Boost::coroutine
-    Boost::date_time
+              Boost::date_time
-    Boost::filesystem
+              Boost::filesystem
-    Boost::json
+              Boost::json
-    Boost::process
+              Boost::process
-    Boost::program_options
+              Boost::program_options
-    Boost::regex
+              Boost::regex
-    Boost::system
+              Boost::thread)
-    Boost::thread)
+if (Boost_COMPILER)
-if(Boost_COMPILER)
+    target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
-  target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
+endif ()
-endif()
+if (SANITIZERS_ENABLED AND is_clang)
-if(SANITIZERS_ENABLED AND is_clang)
+    # TODO: gcc does not support -fsanitize-blacklist...can we do something else for gcc ?
-  # TODO: gcc does not support -fsanitize-blacklist...can we do something else
+    if (NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
-  # for gcc ?
+        get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
-  if(NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+    endif ()
-    get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
+    message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
-  endif()
+    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
-  message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
+    target_compile_options(opts INTERFACE # ignore boost headers for sanitizing
-  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
+                                          -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
-  target_compile_options(opts
+endif ()
-    INTERFACE
-      # ignore boost headers for sanitizing
-      -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
-endif()

cmake/isolate_headers.cmake

@@ -37,12 +37,12 @@ include(create_symbolic_link)
 # `${CMAKE_CURRENT_BINARY_DIR}/include/${target}`.
 #
 # isolate_headers(target A B scope)
-function(isolate_headers target A B scope)
+function (isolate_headers target A B scope)
-  file(RELATIVE_PATH C "${A}" "${B}")
+    file(RELATIVE_PATH C "${A}" "${B}")
-  set(X "${CMAKE_CURRENT_BINARY_DIR}/modules/${target}")
+    set(X "${CMAKE_CURRENT_BINARY_DIR}/modules/${target}")
-  set(Y "${X}/${C}")
+    set(Y "${X}/${C}")
-  cmake_path(GET Y PARENT_PATH parent)
+    cmake_path(GET Y PARENT_PATH parent)
-  file(MAKE_DIRECTORY "${parent}")
+    file(MAKE_DIRECTORY "${parent}")
-  create_symbolic_link("${B}" "${Y}")
+    create_symbolic_link("${B}" "${Y}")
-  target_include_directories(${target} ${scope} "$<BUILD_INTERFACE:${X}>")
+    target_include_directories(${target} ${scope} "$<BUILD_INTERFACE:${X}>")
-endfunction()
+endfunction ()

cmake/target_link_modules.cmake

@@ -6,19 +6,19 @@
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
 # add_library(project.libparent)
 # target_link_modules(parent PUBLIC a b)
-function(target_link_modules parent scope)
+function (target_link_modules parent scope)
-  set(library ${PROJECT_NAME}.lib${parent})
+    set(library ${PROJECT_NAME}.lib${parent})
-  foreach(name ${ARGN})
+    foreach (name ${ARGN})
-    set(module ${library}.${name})
+        set(module ${library}.${name})
-    get_target_property(sources ${library} SOURCES)
+        get_target_property(sources ${library} SOURCES)
-    list(LENGTH sources before)
+        list(LENGTH sources before)
-    get_target_property(dupes ${module} SOURCES)
+        get_target_property(dupes ${module} SOURCES)
-    list(LENGTH dupes expected)
+        list(LENGTH dupes expected)
-    list(REMOVE_ITEM sources ${dupes})
+        list(REMOVE_ITEM sources ${dupes})
-    list(LENGTH sources after)
+        list(LENGTH sources after)
-    math(EXPR actual "${before} - ${after}")
+        math(EXPR actual "${before} - ${after}")
-    message(STATUS "${module} with ${expected} sources took ${actual} sources from ${library}")
+        message(STATUS "${module} with ${expected} sources took ${actual} sources from ${library}")
-    set_target_properties(${library} PROPERTIES SOURCES "${sources}")
+        set_target_properties(${library} PROPERTIES SOURCES "${sources}")
-    target_link_libraries(${library} ${scope} ${module})
+        target_link_libraries(${library} ${scope} ${module})
-  endforeach()
+    endforeach ()
-endfunction()
+endfunction ()

cmake/target_protobuf_sources.cmake

@@ -35,28 +35,20 @@ find_package(Protobuf REQUIRED)
 #     This prefix should appear at the start of all your consumer includes.
 # ARGN:
 #     A list of .proto files.
-function(target_protobuf_sources target prefix)
+function (target_protobuf_sources target prefix)
-  set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
+    set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
-  file(MAKE_DIRECTORY "${dir}/${prefix}")
+    file(MAKE_DIRECTORY "${dir}/${prefix}")
 
-  protobuf_generate(
+    protobuf_generate(TARGET ${target} PROTOC_OUT_DIR "${dir}/${prefix}" "${ARGN}")
-    TARGET ${target}
+    target_include_directories(
-    PROTOC_OUT_DIR "${dir}/${prefix}"
+        ${target} SYSTEM
-    "${ARGN}"
+        PUBLIC # Allows #include <package/path/to/file.proto> used by consumer files.
-  )
+               $<BUILD_INTERFACE:${dir}>
-  target_include_directories(${target} SYSTEM PUBLIC
+               # Allows #include "path/to/file.proto" used by generated files.
-    # Allows #include <package/path/to/file.proto> used by consumer files.
+               $<BUILD_INTERFACE:${dir}/${prefix}>
-    $<BUILD_INTERFACE:${dir}>
+               # Allows #include <package/path/to/file.proto> used by consumer files.
-    # Allows #include "path/to/file.proto" used by generated files.
+               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-    $<BUILD_INTERFACE:${dir}/${prefix}>
+               # Allows #include "path/to/file.proto" used by generated files.
-    # Allows #include <package/path/to/file.proto> used by consumer files.
+               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>)
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    install(DIRECTORY ${dir}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
-    # Allows #include "path/to/file.proto" used by generated files.
+endfunction ()
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>
-  )
-  install(
-    DIRECTORY ${dir}/
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-    FILES_MATCHING PATTERN "*.h"
-  )
-endfunction()

conan.lock

@@ -11,7 +11,7 @@
         "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1765850148.103",
         "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1765850161.038",
         "openssl/3.5.4#1b986e61b38fdfda3b40bebc1b234393%1768312656.257",
-        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1765850143.957",
+        "nudb/2.0.9#0432758a24204da08fee953ec9ea03cb%1769436073.32",
         "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914",
         "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492",
         "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03",
@@ -23,7 +23,7 @@
         "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772",
         "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1765850144.336",
         "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
-        "boost/1.88.0#8852c0b72ce8271fb8ff7c53456d4983%1765850172.862",
+        "boost/1.90.0#d5e8defe7355494953be18524a7f135b%1765955095.179",
         "abseil/20250127.0#99262a368bd01c0ccca8790dfced9719%1766517936.993"
     ],
     "build_requires": [
@@ -42,18 +42,22 @@
     ],
     "python_requires": [],
     "overrides": {
+        "boost/1.90.0#d5e8defe7355494953be18524a7f135b": [
+            null,
+            "boost/1.90.0"
+        ],
         "protobuf/5.27.0": [
             "protobuf/6.32.1"
         ],
         "lz4/1.9.4": [
             "lz4/1.10.0"
         ],
-        "boost/1.83.0": [
-            "boost/1.88.0"
-        ],
         "sqlite3/3.44.2": [
             "sqlite3/3.49.1"
         ],
+        "boost/1.83.0": [
+            "boost/1.90.0"
+        ],
         "lz4/[>=1.9.4 <2]": [
             "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504"
         ]

conanfile.py

@@ -131,7 +131,7 @@ class Xrpl(ConanFile):
         transitive_headers_opt = (
             {"transitive_headers": True} if conan_version.split(".")[0] == "2" else {}
         )
-        self.requires("boost/1.88.0", force=True, **transitive_headers_opt)
+        self.requires("boost/1.90.0", force=True, **transitive_headers_opt)
         self.requires("date/3.0.4", **transitive_headers_opt)
         self.requires("lz4/1.10.0", force=True)
         self.requires("protobuf/6.32.1", force=True)
@@ -203,7 +203,6 @@ class Xrpl(ConanFile):
             "boost::program_options",
             "boost::process",
             "boost::regex",
-            "boost::system",
             "boost::thread",
             "date::date",
             "ed25519::ed25519",

include/xrpl/basics/Archive.h

@@ -13,9 +13,7 @@ namespace xrpl {
     @throws runtime_error
 */
 void
-extractTarLz4(
+extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const& dst);
-    boost::filesystem::path const& src,
-    boost::filesystem::path const& dst);
 
 }  // namespace xrpl
 

include/xrpl/basics/BasicConfig.h

@@ -14,8 +14,7 @@
 
 namespace xrpl {
 
-using IniFileSections =
+using IniFileSections = std::unordered_map<std::string, std::vector<std::string>>;
-    std::unordered_map<std::string, std::vector<std::string>>;
 
 //------------------------------------------------------------------------------
 
@@ -86,8 +85,7 @@ public:
         if (lines_.empty())
             return "";
         if (lines_.size() > 1)
-            Throw<std::runtime_error>(
+            Throw<std::runtime_error>("A legacy value must have exactly one line. Section: " + name_);
-                "A legacy value must have exactly one line. Section: " + name_);
         return lines_[0];
     }
 
@@ -233,10 +231,7 @@ public:
         The previous value, if any, is overwritten.
     */
     void
-    overwrite(
+    overwrite(std::string const& section, std::string const& key, std::string const& value);
-        std::string const& section,
-        std::string const& key,
-        std::string const& value);
 
     /** Remove all the key/value pairs from the section.
      */
@@ -274,9 +269,7 @@ public:
     bool
     had_trailing_comments() const
     {
-        return std::any_of(map_.cbegin(), map_.cend(), [](auto s) {
+        return std::any_of(map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
-            return s.second.had_trailing_comments();
-        });
     }
 
 protected:
@@ -315,10 +308,7 @@ set(T& target, std::string const& name, Section const& section)
 */
 template <class T>
 bool
-set(T& target,
+set(T& target, T const& defaultValue, std::string const& name, Section const& section)
-    T const& defaultValue,
-    std::string const& name,
-    Section const& section)
 {
     bool found_and_valid = set<T>(target, name, section);
     if (!found_and_valid)
@@ -333,9 +323,7 @@ set(T& target,
 // NOTE This routine might be more clumsy than the previous two
 template <class T = std::string>
 T
-get(Section const& section,
+get(Section const& section, std::string const& name, T const& defaultValue = T{})
-    std::string const& name,
-    T const& defaultValue = T{})
 {
     try
     {

include/xrpl/basics/Buffer.h

@@ -25,8 +25,7 @@ public:
     Buffer() = default;
 
     /** Create an uninitialized buffer with the given size. */
-    explicit Buffer(std::size_t size)
+    explicit Buffer(std::size_t size) : p_(size ? new std::uint8_t[size] : nullptr), size_(size)
-        : p_(size ? new std::uint8_t[size] : nullptr), size_(size)
     {
     }
 
@@ -62,8 +61,7 @@ public:
     /** Move-construct.
         The other buffer is reset.
     */
-    Buffer(Buffer&& other) noexcept
+    Buffer(Buffer&& other) noexcept : p_(std::move(other.p_)), size_(other.size_)
-        : p_(std::move(other.p_)), size_(other.size_)
     {
         other.size_ = 0;
     }
@@ -94,8 +92,7 @@ public:
     {
         // Ensure the slice isn't a subset of the buffer.
         XRPL_ASSERT(
-            s.size() == 0 || size_ == 0 || s.data() < p_.get() ||
+            s.size() == 0 || size_ == 0 || s.data() < p_.get() || s.data() >= p_.get() + size_,
-                s.data() >= p_.get() + size_,
             "xrpl::Buffer::operator=(Slice) : input not a subset");
 
         if (auto p = alloc(s.size()))

include/xrpl/basics/CompressionAlgorithms.h

@@ -36,10 +36,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in),
+        reinterpret_cast<char const*>(in), reinterpret_cast<char*>(compressed), inSize, outCapacity);
-        reinterpret_cast<char*>(compressed),
-        inSize,
-        outCapacity);
     if (compressedSize == 0)
         Throw<std::runtime_error>("lz4 compress: failed");
 
@@ -70,10 +67,8 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in),
+            reinterpret_cast<char const*>(in), reinterpret_cast<char*>(decompressed), inSize, decompressedSize) !=
-            reinterpret_cast<char*>(decompressed),
+        decompressedSize)
-            inSize,
-            decompressedSize) != decompressedSize)
         Throw<std::runtime_error>("lz4Decompress: failed");
 
     return decompressedSize;
@@ -89,11 +84,7 @@ lz4Decompress(
  */
 template <typename InputStream>
 std::size_t
-lz4Decompress(
+lz4Decompress(InputStream& in, std::size_t inSize, std::uint8_t* decompressed, std::size_t decompressedSize)
-    InputStream& in,
-    std::size_t inSize,
-    std::uint8_t* decompressed,
-    std::size_t decompressedSize)
 {
     std::vector<std::uint8_t> compressed;
     std::uint8_t const* chunk = nullptr;
@@ -116,9 +107,7 @@ lz4Decompress(
             compressed.resize(inSize);
         }
 
-        chunkSize = chunkSize < (inSize - copiedInSize)
+        chunkSize = chunkSize < (inSize - copiedInSize) ? chunkSize : (inSize - copiedInSize);
-            ? chunkSize
-            : (inSize - copiedInSize);
 
         std::copy(chunk, chunk + chunkSize, compressed.data() + copiedInSize);
 
@@ -135,8 +124,7 @@ lz4Decompress(
     if (in.ByteCount() > (currentBytes + copiedInSize))
         in.BackUp(in.ByteCount() - currentBytes - copiedInSize);
 
-    if ((copiedInSize == 0 && chunkSize < inSize) ||
+    if ((copiedInSize == 0 && chunkSize < inSize) || (copiedInSize > 0 && copiedInSize != inSize))
-        (copiedInSize > 0 && copiedInSize != inSize))
         Throw<std::runtime_error>("lz4 decompress: insufficient input size");
 
     return lz4Decompress(chunk, inSize, decompressed, decompressedSize);

include/xrpl/basics/DecayingSample.h

@@ -56,9 +56,7 @@ private:
 
         if (m_value != value_type())
         {
-            std::size_t elapsed =
+            std::size_t elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - m_when).count();
-                std::chrono::duration_cast<std::chrono::seconds>(now - m_when)
-                    .count();
 
             // A span larger than four times the window decays the
             // value to an insignificant amount so just reset it.

include/xrpl/basics/Expected.h

@@ -108,23 +108,20 @@ Unexpected(E (&)[N]) -> Unexpected<E const*>;
 
 // Definition of Expected.  All of the machinery comes from boost::result.
 template <class T, class E>
-class [[nodiscard]] Expected
+class [[nodiscard]] Expected : private boost::outcome_v2::result<T, E, detail::throw_policy>
-    : private boost::outcome_v2::result<T, E, detail::throw_policy>
 {
     using Base = boost::outcome_v2::result<T, E, detail::throw_policy>;
 
 public:
     template <typename U>
         requires std::convertible_to<U, T>
-    constexpr Expected(U&& r)
+    constexpr Expected(U&& r) : Base(boost::outcome_v2::in_place_type_t<T>{}, std::forward<U>(r))
-        : Base(boost::outcome_v2::in_place_type_t<T>{}, std::forward<U>(r))
     {
     }
 
     template <typename U>
         requires std::convertible_to<U, E> && (!std::is_reference_v<U>)
-    constexpr Expected(Unexpected<U> e)
+    constexpr Expected(Unexpected<U> e) : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
-        : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
     {
     }
 
@@ -195,8 +192,7 @@ public:
 // Specialization of Expected<void, E>.  Allows returning either success
 // (without a value) or the reason for the failure.
 template <class E>
-class [[nodiscard]] Expected<void, E>
+class [[nodiscard]] Expected<void, E> : private boost::outcome_v2::result<void, E, detail::throw_policy>
-    : private boost::outcome_v2::result<void, E, detail::throw_policy>
 {
     using Base = boost::outcome_v2::result<void, E, detail::throw_policy>;
 

include/xrpl/basics/FileUtilities.h

@@ -15,10 +15,7 @@ getFileContents(
     std::optional<std::size_t> maxSize = std::nullopt);
 
 void
-writeFileContents(
+writeFileContents(boost::system::error_code& ec, boost::filesystem::path const& destPath, std::string const& contents);
-    boost::system::error_code& ec,
-    boost::filesystem::path const& destPath,
-    std::string const& contents);
 
 }  // namespace xrpl
 

include/xrpl/basics/IntrusivePointer.h

@@ -45,8 +45,8 @@ struct SharedIntrusiveAdoptNoIncrementTag
 //
 
 template <class T>
-concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
+concept CAdoptTag =
-    std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
+    std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> || std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
 
 //------------------------------------------------------------------------------
 
@@ -122,9 +122,7 @@ public:
         controlled by the rhs param.
     */
     template <class TT>
-    SharedIntrusive(
+    SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs);
-        StaticCastTagSharedIntrusive,
-        SharedIntrusive<TT> const& rhs);
 
     /** Create a new SharedIntrusive by statically casting the pointer
        controlled by the rhs param.
@@ -136,9 +134,7 @@ public:
        controlled by the rhs param.
     */
     template <class TT>
-    SharedIntrusive(
+    SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs);
-        DynamicCastTagSharedIntrusive,
-        SharedIntrusive<TT> const& rhs);
 
     /** Create a new SharedIntrusive by dynamically casting the pointer
        controlled by the rhs param.
@@ -304,9 +300,7 @@ class SharedWeakUnion
     // Tagged pointer. Low bit determines if this is a strong or a weak
     // pointer. The low bit must be masked to zero when converting back to a
     // pointer. If the low bit is '1', this is a weak pointer.
-    static_assert(
+    static_assert(alignof(T) >= 2, "Bad alignment: Combo pointer requires low bit to be zero");
-        alignof(T) >= 2,
-        "Bad alignment: Combo pointer requires low bit to be zero");
 
 public:
     SharedWeakUnion() = default;
@@ -450,9 +444,7 @@ make_SharedIntrusive(Args&&... args)
     auto p = new TT(std::forward<Args>(args)...);
 
     static_assert(
-        noexcept(SharedIntrusive<TT>(
+        noexcept(SharedIntrusive<TT>(std::declval<TT*>(), std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
-            std::declval<TT*>(),
-            std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
         "SharedIntrusive constructor should not throw or this can leak "
         "memory");
 

include/xrpl/basics/IntrusivePointer.ipp

@@ -12,9 +12,7 @@ template <class T>
 template <CAdoptTag TAdoptTag>
 SharedIntrusive<T>::SharedIntrusive(T* p, TAdoptTag) noexcept : ptr_{p}
 {
-    if constexpr (std::is_same_v<
+    if constexpr (std::is_same_v<TAdoptTag, SharedIntrusiveAdoptIncrementStrongTag>)
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
     {
         if (p)
             p->addStrongRef();
@@ -46,16 +44,14 @@ SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT> const& rhs)
 }
 
 template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs)
+SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs) : ptr_{rhs.unsafeExchange(nullptr)}
-    : ptr_{rhs.unsafeExchange(nullptr)}
 {
 }
 
 template <class T>
 template <class TT>
     requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs)
+SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs) : ptr_{rhs.unsafeExchange(nullptr)}
-    : ptr_{rhs.unsafeExchange(nullptr)}
 {
 }
 template <class T>
@@ -112,9 +108,7 @@ requires std::convertible_to<TT*, T*>
 SharedIntrusive<T>&
 SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
 {
-    static_assert(
+    static_assert(!std::is_same_v<T, TT>, "This overload should not be instantiated for T == TT");
-        !std::is_same_v<T, TT>,
-        "This overload should not be instantiated for T == TT");
 
     unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
     return *this;
@@ -139,9 +133,7 @@ template <CAdoptTag TAdoptTag>
 void
 SharedIntrusive<T>::adopt(T* p)
 {
-    if constexpr (std::is_same_v<
+    if constexpr (std::is_same_v<TAdoptTag, SharedIntrusiveAdoptIncrementStrongTag>)
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
     {
         if (p)
             p->addStrongRef();
@@ -157,9 +149,7 @@ SharedIntrusive<T>::~SharedIntrusive()
 
 template <class T>
 template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
+SharedIntrusive<T>::SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs)
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
     : ptr_{[&] {
         auto p = static_cast<T*>(rhs.unsafeGetRawPtr());
         if (p)
@@ -171,18 +161,14 @@ SharedIntrusive<T>::SharedIntrusive(
 
 template <class T>
 template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
+SharedIntrusive<T>::SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs)
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
     : ptr_{static_cast<T*>(rhs.unsafeExchange(nullptr))}
 {
 }
 
 template <class T>
 template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
+SharedIntrusive<T>::SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs)
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
     : ptr_{[&] {
         auto p = dynamic_cast<T*>(rhs.unsafeGetRawPtr());
         if (p)
@@ -194,9 +180,7 @@ SharedIntrusive<T>::SharedIntrusive(
 
 template <class T>
 template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
+SharedIntrusive<T>::SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs)
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
 {
     // This can be simplified without the `exchange`, but the `exchange` is kept
     // in anticipation of supporting atomic operations.
@@ -315,8 +299,7 @@ WeakIntrusive<T>::WeakIntrusive(WeakIntrusive&& rhs) : ptr_{rhs.ptr_}
 }
 
 template <class T>
-WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs)
+WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs) : ptr_{rhs.unsafeGetRawPtr()}
-    : ptr_{rhs.unsafeGetRawPtr()}
 {
     if (ptr_)
         ptr_->addWeakRef();

include/xrpl/basics/IntrusiveRefCounts.h

@@ -160,22 +160,19 @@ private:
          See description of the `refCounts` field for a fuller description of
          this field.
       */
-    static constexpr FieldType partialDestroyStartedMask =
+    static constexpr FieldType partialDestroyStartedMask = (one << (FieldTypeBits - 1));
-        (one << (FieldTypeBits - 1));
 
     /**  Flag that is set when the partialDestroy function has finished running
 
          See description of the `refCounts` field for a fuller description of
          this field.
       */
-    static constexpr FieldType partialDestroyFinishedMask =
+    static constexpr FieldType partialDestroyFinishedMask = (one << (FieldTypeBits - 2));
-        (one << (FieldTypeBits - 2));
 
     /** Mask that will zero out all the `count` bits and leave the tag bits
         unchanged.
       */
-    static constexpr FieldType tagMask =
+    static constexpr FieldType tagMask = partialDestroyStartedMask | partialDestroyFinishedMask;
-        partialDestroyStartedMask | partialDestroyFinishedMask;
 
     /** Mask that will zero out the `tag` bits and leave the count bits
         unchanged.
@@ -184,13 +181,11 @@ private:
 
     /** Mask that will zero out everything except the strong count.
      */
-    static constexpr FieldType strongMask =
+    static constexpr FieldType strongMask = ((one << StrongCountNumBits) - 1) & valueMask;
-        ((one << StrongCountNumBits) - 1) & valueMask;
 
     /** Mask that will zero out everything except the weak count.
      */
-    static constexpr FieldType weakMask =
+    static constexpr FieldType weakMask = (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
-        (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
 
     /** Unpack the count and tag fields from the packed atomic integer form. */
     struct RefCountPair
@@ -215,10 +210,8 @@ private:
         FieldType
         combinedValue() const noexcept;
 
-        static constexpr CountType maxStrongValue =
+        static constexpr CountType maxStrongValue = static_cast<CountType>((one << StrongCountNumBits) - 1);
-            static_cast<CountType>((one << StrongCountNumBits) - 1);
+        static constexpr CountType maxWeakValue = static_cast<CountType>((one << WeakCountNumBits) - 1);
-        static constexpr CountType maxWeakValue =
-            static_cast<CountType>((one << WeakCountNumBits) - 1);
         /**  Put an extra margin to detect when running up against limits.
              This is only used in debug code, and is useful if we reduce the
              number of bits in the strong and weak counts (to 16 and 14 bits).
@@ -274,8 +267,7 @@ IntrusiveRefCounts::releaseStrongRef() const
             }
         }
 
-        if (refCounts.compare_exchange_weak(
+        if (refCounts.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
         {
             // Can't be in partial destroy because only decrementing the strong
             // count to zero can start a partial destroy, and that can't happen
@@ -331,8 +323,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
                 action = partialDestroy;
             }
         }
-        if (refCounts.compare_exchange_weak(
+        if (refCounts.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
         {
             XRPL_ASSERT(
                 (!(prevIntVal & partialDestroyStartedMask)),
@@ -376,8 +367,7 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
     auto curValue = RefCountPair{1, 1}.combinedValue();
     auto desiredValue = RefCountPair{2, 1}.combinedValue();
 
-    while (!refCounts.compare_exchange_weak(
+    while (!refCounts.compare_exchange_weak(curValue, desiredValue, std::memory_order_acq_rel))
-        curValue, desiredValue, std::memory_order_acq_rel))
     {
         RefCountPair const prev{curValue};
         if (!prev.strong)
@@ -406,20 +396,15 @@ inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
 {
 #ifndef NDEBUG
     auto v = refCounts.load(std::memory_order_acquire);
-    XRPL_ASSERT(
+    XRPL_ASSERT((!(v & valueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
-        (!(v & valueMask)),
-        "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
     auto t = v & tagMask;
-    XRPL_ASSERT(
+    XRPL_ASSERT((!t || t == tagMask), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
-        (!t || t == tagMask),
-        "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
 #endif
 }
 
 //------------------------------------------------------------------------------
 
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
+inline IntrusiveRefCounts::RefCountPair::RefCountPair(IntrusiveRefCounts::FieldType v) noexcept
-    IntrusiveRefCounts::FieldType v) noexcept
     : strong{static_cast<CountType>(v & strongMask)}
     , weak{static_cast<CountType>((v & weakMask) >> StrongCountNumBits)}
     , partialDestroyStartedBit{v & partialDestroyStartedMask}
@@ -449,10 +434,8 @@ IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
         (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
         "xrpl::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
         "inside range");
-    return (static_cast<IntrusiveRefCounts::FieldType>(weak)
+    return (static_cast<IntrusiveRefCounts::FieldType>(weak) << IntrusiveRefCounts::StrongCountNumBits) |
-            << IntrusiveRefCounts::StrongCountNumBits) |
+        static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit | partialDestroyFinishedBit;
-        static_cast<IntrusiveRefCounts::FieldType>(strong) |
-        partialDestroyStartedBit | partialDestroyFinishedBit;
 }
 
 template <class T>
@@ -460,11 +443,9 @@ inline void
 partialDestructorFinished(T** o)
 {
     T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
+    IntrusiveRefCounts::RefCountPair p = self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
-        self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
     XRPL_ASSERT(
-        (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit &&
+        (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),
-         !p.strong),
         "xrpl::partialDestructorFinished : not a weak ref");
     if (!p.weak)
     {

include/xrpl/basics/LocalValue.h

@@ -55,8 +55,7 @@ template <class = void>
 boost::thread_specific_ptr<detail::LocalValues>&
 getLocalValues()
 {
-    static boost::thread_specific_ptr<detail::LocalValues> tsp(
+    static boost::thread_specific_ptr<detail::LocalValues> tsp(&detail::LocalValues::cleanup);
-        &detail::LocalValues::cleanup);
     return tsp;
 }
 
@@ -105,9 +104,7 @@ LocalValue<T>::operator*()
     }
 
     return *reinterpret_cast<T*>(
-        lvs->values
+        lvs->values.emplace(this, std::make_unique<detail::LocalValues::Value<T>>(t_)).first->second->get());
-            .emplace(this, std::make_unique<detail::LocalValues::Value<T>>(t_))
-            .first->second->get());
 }
 }  // namespace xrpl
 

include/xrpl/basics/Log.h

@@ -39,22 +39,17 @@ private:
         std::string partition_;
 
     public:
-        Sink(
+        Sink(std::string const& partition, beast::severities::Severity thresh, Logs& logs);
-            std::string const& partition,
-            beast::severities::Severity thresh,
-            Logs& logs);
 
         Sink(Sink const&) = delete;
         Sink&
         operator=(Sink const&) = delete;
 
         void
-        write(beast::severities::Severity level, std::string const& text)
+        write(beast::severities::Severity level, std::string const& text) override;
-            override;
 
         void
-        writeAlways(beast::severities::Severity level, std::string const& text)
+        writeAlways(beast::severities::Severity level, std::string const& text) override;
-            override;
     };
 
     /** Manages a system file containing logged output.
@@ -140,11 +135,7 @@ private:
     };
 
     std::mutex mutable mutex_;
-    std::map<
+    std::map<std::string, std::unique_ptr<beast::Journal::Sink>, boost::beast::iless> sinks_;
-        std::string,
-        std::unique_ptr<beast::Journal::Sink>,
-        boost::beast::iless>
-        sinks_;
     beast::severities::Severity thresh_;
     File file_;
     bool silent_ = false;
@@ -180,11 +171,7 @@ public:
     partition_severities() const;
 
     void
-    write(
+    write(beast::severities::Severity level, std::string const& partition, std::string const& text, bool console);
-        beast::severities::Severity level,
-        std::string const& partition,
-        std::string const& text,
-        bool console);
 
     std::string
     rotate();
@@ -201,9 +188,7 @@ public:
     }
 
     virtual std::unique_ptr<beast::Journal::Sink>
-    makeSink(
+    makeSink(std::string const& partition, beast::severities::Severity startingLevel);
-        std::string const& partition,
-        beast::severities::Severity startingLevel);
 
 public:
     static LogSeverity

include/xrpl/basics/Number.h

@@ -4,6 +4,7 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <cstdint>
+#include <functional>
 #include <limits>
 #include <optional>
 #include <ostream>
@@ -73,10 +74,7 @@ struct MantissaRange
     enum mantissa_scale { small, large };
 
     explicit constexpr MantissaRange(mantissa_scale scale_)
-        : min(getMin(scale_))
+        : min(getMin(scale_)), max(min * 10 - 1), log(logTen(min).value_or(-1)), scale(scale_)
-        , max(min * 10 - 1)
-        , log(logTen(min).value_or(-1))
-        , scale(scale_)
     {
     }
 
@@ -106,8 +104,7 @@ private:
 
 // Like std::integral, but only 64-bit integral types.
 template <class T>
-concept Integral64 =
+concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>;
-    std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>;
 
 /** Number is a floating point type that can represent a wide range of values.
  *
@@ -244,22 +241,11 @@ public:
 
     Number(rep mantissa);
     explicit Number(rep mantissa, int exponent);
-    explicit constexpr Number(
+    explicit constexpr Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept;
-        bool negative,
-        internalrep mantissa,
-        int exponent,
-        unchecked) noexcept;
     // Assume unsigned values are... unsigned. i.e. positive
-    explicit constexpr Number(
+    explicit constexpr Number(internalrep mantissa, int exponent, unchecked) noexcept;
-        internalrep mantissa,
-        int exponent,
-        unchecked) noexcept;
     // Only unit tests are expected to use this ctor
-    explicit Number(
+    explicit Number(bool negative, internalrep mantissa, int exponent, normalized);
-        bool negative,
-        internalrep mantissa,
-        int exponent,
-        normalized);
     // Assume unsigned values are... unsigned. i.e. positive
     explicit Number(internalrep mantissa, int exponent, normalized);
 
@@ -309,8 +295,7 @@ public:
     friend constexpr bool
     operator==(Number const& x, Number const& y) noexcept
     {
-        return x.negative_ == y.negative_ && x.mantissa_ == y.mantissa_ &&
+        return x.negative_ == y.negative_ && x.mantissa_ == y.mantissa_ && x.exponent_ == y.exponent_;
-            x.exponent_ == y.exponent_;
     }
 
     friend constexpr bool
@@ -518,37 +503,25 @@ private:
     class Guard;
 };
 
-inline constexpr Number::Number(
+inline constexpr Number::Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept
-    bool negative,
-    internalrep mantissa,
-    int exponent,
-    unchecked) noexcept
     : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
 {
 }
 
-inline constexpr Number::Number(
+inline constexpr Number::Number(internalrep mantissa, int exponent, unchecked) noexcept
-    internalrep mantissa,
-    int exponent,
-    unchecked) noexcept
     : Number(false, mantissa, exponent, unchecked{})
 {
 }
 
 constexpr static Number numZero{};
 
-inline Number::Number(
+inline Number::Number(bool negative, internalrep mantissa, int exponent, normalized)
-    bool negative,
-    internalrep mantissa,
-    int exponent,
-    normalized)
     : Number(negative, mantissa, exponent, unchecked{})
 {
     normalize();
 }
 
-inline Number::Number(internalrep mantissa, int exponent, normalized)
+inline Number::Number(internalrep mantissa, int exponent, normalized) : Number(false, mantissa, exponent, normalized{})
-    : Number(false, mantissa, exponent, normalized{})
 {
 }
 
@@ -695,15 +668,13 @@ Number::min() noexcept
 inline Number
 Number::max() noexcept
 {
-    return Number{
+    return Number{false, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
-        false, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
 }
 
 inline Number
 Number::lowest() noexcept
 {
-    return Number{
+    return Number{true, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
-        true, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
 }
 
 inline bool
@@ -712,8 +683,7 @@ Number::isnormal() const noexcept
     MantissaRange const& range = range_;
     auto const abs_m = mantissa_;
     return *this == Number{} ||
-        (range.min <= abs_m && abs_m <= range.max &&
+        (range.min <= abs_m && abs_m <= range.max && (abs_m <= maxRep || abs_m % 10 == 0) && minExponent <= exponent_ &&
-         (abs_m <= maxRep || abs_m % 10 == 0) && minExponent <= exponent_ &&
          exponent_ <= maxExponent);
 }
 
@@ -726,10 +696,7 @@ Number::normalizeToRange(T minMantissa, T maxMantissa) const
     int exponent = exponent_;
 
     if constexpr (std::is_unsigned_v<T>)
-        XRPL_ASSERT_PARTS(
+        XRPL_ASSERT_PARTS(!negative, "xrpl::Number::normalizeToRange", "Number is non-negative for unsigned range.");
-            !negative,
-            "xrpl::Number::normalizeToRange",
-            "Number is non-negative for unsigned range.");
     Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);
 
     auto const sign = negative ? -1 : 1;
@@ -798,8 +765,7 @@ public:
     {
         Number::setround(mode_);
     }
-    explicit saveNumberRoundMode(Number::rounding_mode mode) noexcept
+    explicit saveNumberRoundMode(Number::rounding_mode mode) noexcept : mode_{mode}
-        : mode_{mode}
     {
     }
     saveNumberRoundMode(saveNumberRoundMode const&) = delete;
@@ -816,8 +782,7 @@ class NumberRoundModeGuard
     saveNumberRoundMode saved_;
 
 public:
-    explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept
+    explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept : saved_{Number::setround(mode)}
-        : saved_{Number::setround(mode)}
     {
     }
 
@@ -837,9 +802,7 @@ class NumberMantissaScaleGuard
     MantissaRange::mantissa_scale const saved_;
 
 public:
-    explicit NumberMantissaScaleGuard(
+    explicit NumberMantissaScaleGuard(MantissaRange::mantissa_scale scale) noexcept : saved_{Number::getMantissaScale()}
-        MantissaRange::mantissa_scale scale) noexcept
-        : saved_{Number::getMantissaScale()}
     {
         Number::setMantissaScale(scale);
     }

include/xrpl/basics/Resolver.h

@@ -11,8 +11,7 @@ namespace xrpl {
 class Resolver
 {
 public:
-    using HandlerType =
+    using HandlerType = std::function<void(std::string, std::vector<beast::IP::Endpoint>)>;
-        std::function<void(std::string, std::vector<beast::IP::Endpoint>)>;
 
     virtual ~Resolver() = 0;
 
@@ -41,9 +40,7 @@ public:
     }
 
     virtual void
-    resolve(
+    resolve(std::vector<std::string> const& names, HandlerType const& handler) = 0;
-        std::vector<std::string> const& names,
-        HandlerType const& handler) = 0;
     /** @} */
 };
 

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -5,34 +5,28 @@
 
 namespace xrpl {
 template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
+SharedWeakCachePointer<T>::SharedWeakCachePointer(SharedWeakCachePointer const& rhs) = default;
-    SharedWeakCachePointer const& rhs) = default;
 
 template <class T>
 template <class TT>
     requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
+SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT> const& rhs) : combo_{rhs}
-    std::shared_ptr<TT> const& rhs)
-    : combo_{rhs}
 {
 }
 
 template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
+SharedWeakCachePointer<T>::SharedWeakCachePointer(SharedWeakCachePointer&& rhs) = default;
-    SharedWeakCachePointer&& rhs) = default;
 
 template <class T>
 template <class TT>
     requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs)
+SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs) : combo_{std::move(rhs)}
-    : combo_{std::move(rhs)}
 {
 }
 
 template <class T>
 SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(SharedWeakCachePointer const& rhs) =
+SharedWeakCachePointer<T>::operator=(SharedWeakCachePointer const& rhs) = default;
-    default;
 
 template <class T>
 template <class TT>

include/xrpl/basics/SlabAllocator.h

@@ -51,11 +51,7 @@ class SlabAllocator
         // The extent of the underlying memory block:
         std::size_t const size_;
 
-        SlabBlock(
+        SlabBlock(SlabBlock* next, std::uint8_t* data, std::size_t size, std::size_t item)
-            SlabBlock* next,
-            std::uint8_t* data,
-            std::size_t size,
-            std::size_t item)
             : next_(next), p_(data), size_(size)
         {
             // We don't need to grab the mutex here, since we're the only
@@ -126,9 +122,7 @@ class SlabAllocator
         void
         deallocate(std::uint8_t* ptr) noexcept
         {
-            XRPL_ASSERT(
+            XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
-                own(ptr),
-                "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
 
             std::lock_guard l(m_);
 
@@ -162,18 +156,13 @@ public:
                      contexts (e.g. when minimal memory usage is needed) and
                      allows for graceful failure.
      */
-    constexpr explicit SlabAllocator(
+    constexpr explicit SlabAllocator(std::size_t extra, std::size_t alloc = 0, std::size_t align = 0)
-        std::size_t extra,
-        std::size_t alloc = 0,
-        std::size_t align = 0)
         : itemAlignment_(align ? align : alignof(Type))
-        , itemSize_(
+        , itemSize_(boost::alignment::align_up(sizeof(Type) + extra, itemAlignment_))
-              boost::alignment::align_up(sizeof(Type) + extra, itemAlignment_))
         , slabSize_(alloc)
     {
         XRPL_ASSERT(
-            (itemAlignment_ & (itemAlignment_ - 1)) == 0,
+            (itemAlignment_ & (itemAlignment_ - 1)) == 0, "xrpl::SlabAllocator::SlabAllocator : valid alignment");
-            "xrpl::SlabAllocator::SlabAllocator : valid alignment");
     }
 
     SlabAllocator(SlabAllocator const& other) = delete;
@@ -222,8 +211,7 @@ public:
 
         // We want to allocate the memory at a 2 MiB boundary, to make it
         // possible to use hugepage mappings on Linux:
-        auto buf =
+        auto buf = boost::alignment::aligned_alloc(megabytes(std::size_t(2)), size);
-            boost::alignment::aligned_alloc(megabytes(std::size_t(2)), size);
 
         // clang-format off
         if (!buf) [[unlikely]]
@@ -241,31 +229,21 @@ public:
 
         // We need to carve out a bit of memory for the slab header
         // and then align the rest appropriately:
-        auto slabData = reinterpret_cast<void*>(
+        auto slabData = reinterpret_cast<void*>(reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
-            reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
         auto slabSize = size - sizeof(SlabBlock);
 
         // This operation is essentially guaranteed not to fail but
         // let's be careful anyways.
-        if (!boost::alignment::align(
+        if (!boost::alignment::align(itemAlignment_, itemSize_, slabData, slabSize))
-                itemAlignment_, itemSize_, slabData, slabSize))
         {
             boost::alignment::aligned_free(buf);
             return nullptr;
         }
 
-        slab = new (buf) SlabBlock(
+        slab = new (buf) SlabBlock(slabs_.load(), reinterpret_cast<std::uint8_t*>(slabData), slabSize, itemSize_);
-            slabs_.load(),
-            reinterpret_cast<std::uint8_t*>(slabData),
-            slabSize,
-            itemSize_);
 
         // Link the new slab
-        while (!slabs_.compare_exchange_weak(
+        while (!slabs_.compare_exchange_weak(slab->next_, slab, std::memory_order_release, std::memory_order_relaxed))
-            slab->next_,
-            slab,
-            std::memory_order_release,
-            std::memory_order_relaxed))
         {
             ;  // Nothing to do
         }
@@ -322,10 +300,7 @@ public:
         std::size_t align;
 
     public:
-        constexpr SlabConfig(
+        constexpr SlabConfig(std::size_t extra_, std::size_t alloc_ = 0, std::size_t align_ = alignof(Type))
-            std::size_t extra_,
-            std::size_t alloc_ = 0,
-            std::size_t align_ = alignof(Type))
             : extra(extra_), alloc(alloc_), align(align_)
         {
         }
@@ -336,23 +311,14 @@ public:
         // Ensure that the specified allocators are sorted from smallest to
         // largest by size:
         std::sort(
-            std::begin(cfg),
+            std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) { return a.extra < b.extra; });
-            std::end(cfg),
-            [](SlabConfig const& a, SlabConfig const& b) {
-                return a.extra < b.extra;
-            });
 
         // We should never have two slabs of the same size
-        if (std::adjacent_find(
+        if (std::adjacent_find(std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
-                std::begin(cfg),
+                return a.extra == b.extra;
-                std::end(cfg),
+            }) != cfg.end())
-                [](SlabConfig const& a, SlabConfig const& b) {
-                    return a.extra == b.extra;
-                }) != cfg.end())
         {
-            throw std::runtime_error(
+            throw std::runtime_error("SlabAllocatorSet<" + beast::type_name<Type>() + ">: duplicate slab size");
-                "SlabAllocatorSet<" + beast::type_name<Type>() +
-                ">: duplicate slab size");
         }
 
         for (auto const& c : cfg)

include/xrpl/basics/Slice.h

@@ -41,8 +41,7 @@ public:
     operator=(Slice const&) noexcept = default;
 
     /** Create a slice pointing to existing memory. */
-    Slice(void const* data, std::size_t size) noexcept
+    Slice(void const* data, std::size_t size) noexcept : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
-        : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
     {
     }
 
@@ -85,9 +84,7 @@ public:
     std::uint8_t
     operator[](std::size_t i) const noexcept
     {
-        XRPL_ASSERT(
+        XRPL_ASSERT(i < size_, "xrpl::Slice::operator[](std::size_t) const : valid input");
-            i < size_,
-            "xrpl::Slice::operator[](std::size_t) const : valid input");
         return data_[i];
     }
 
@@ -162,9 +159,7 @@ public:
         @throws std::out_of_range if pos > size()
      */
     Slice
-    substr(
+    substr(std::size_t pos, std::size_t count = std::numeric_limits<std::size_t>::max()) const
-        std::size_t pos,
-        std::size_t count = std::numeric_limits<std::size_t>::max()) const
     {
         if (pos > size())
             throw std::out_of_range("Requested sub-slice is out of bounds");
@@ -203,11 +198,7 @@ operator!=(Slice const& lhs, Slice const& rhs) noexcept
 inline bool
 operator<(Slice const& lhs, Slice const& rhs) noexcept
 {
-    return std::lexicographical_compare(
+    return std::lexicographical_compare(lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
-        lhs.data(),
-        lhs.data() + lhs.size(),
-        rhs.data(),
-        rhs.data() + rhs.size());
 }
 
 template <class Stream>
@@ -219,18 +210,14 @@ operator<<(Stream& s, Slice const& v)
 }
 
 template <class T, std::size_t N>
-std::enable_if_t<
+std::enable_if_t<std::is_same<T, char>::value || std::is_same<T, unsigned char>::value, Slice>
-    std::is_same<T, char>::value || std::is_same<T, unsigned char>::value,
-    Slice>
 makeSlice(std::array<T, N> const& a)
 {
     return Slice(a.data(), a.size());
 }
 
 template <class T, class Alloc>
-std::enable_if_t<
+std::enable_if_t<std::is_same<T, char>::value || std::is_same<T, unsigned char>::value, Slice>
-    std::is_same<T, char>::value || std::is_same<T, unsigned char>::value,
-    Slice>
 makeSlice(std::vector<T, Alloc> const& v)
 {
     return Slice(v.data(), v.size());

include/xrpl/basics/StringUtilities.h

@@ -109,8 +109,7 @@ struct parsedURL
     bool
     operator==(parsedURL const& other) const
     {
-        return scheme == other.scheme && domain == other.domain &&
+        return scheme == other.scheme && domain == other.domain && port == other.port && path == other.path;
-            port == other.port && path == other.path;
     }
 };
 

include/xrpl/basics/TaggedCache.h

@@ -56,8 +56,7 @@ public:
         clock_type::duration expiration,
         clock_type& clock,
         beast::Journal journal,
-        beast::insight::Collector::ptr const& collector =
+        beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::New());
-            beast::insight::NullCollector::New());
 
 public:
     /** Return the clock associated with the cache. */
@@ -114,15 +113,10 @@ public:
     */
     template <class R>
     bool
-    canonicalize(
+    canonicalize(key_type const& key, SharedPointerType& data, R&& replaceCallback);
-        key_type const& key,
-        SharedPointerType& data,
-        R&& replaceCallback);
 
     bool
-    canonicalize_replace_cache(
+    canonicalize_replace_cache(key_type const& key, SharedPointerType const& data);
-        key_type const& key,
-        SharedPointerType const& data);
 
     bool
     canonicalize_replace_client(key_type const& key, SharedPointerType& data);
@@ -136,8 +130,7 @@ public:
     */
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key, T const& value)
+    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>;
-        -> std::enable_if_t<!IsKeyCache, ReturnType>;
 
     template <class ReturnType = bool>
     auto
@@ -183,10 +176,7 @@ private:
     struct Stats
     {
         template <class Handler>
-        Stats(
+        Stats(std::string const& prefix, Handler const& handler, beast::insight::Collector::ptr const& collector)
-            std::string const& prefix,
-            Handler const& handler,
-            beast::insight::Collector::ptr const& collector)
             : hook(collector->make_hook(handler))
             , size(collector->make_gauge(prefix, "size"))
             , hit_rate(collector->make_gauge(prefix, "hit_rate"))
@@ -208,8 +198,7 @@ private:
     public:
         clock_type::time_point last_access;
 
-        explicit KeyOnlyEntry(clock_type::time_point const& last_access_)
+        explicit KeyOnlyEntry(clock_type::time_point const& last_access_) : last_access(last_access_)
-            : last_access(last_access_)
         {
         }
 
@@ -226,9 +215,7 @@ private:
         shared_weak_combo_pointer_type ptr;
         clock_type::time_point last_access;
 
-        ValueEntry(
+        ValueEntry(clock_type::time_point const& last_access_, shared_pointer_type const& ptr_)
-            clock_type::time_point const& last_access_,
-            shared_pointer_type const& ptr_)
             : ptr(ptr_), last_access(last_access_)
         {
         }
@@ -262,18 +249,13 @@ private:
         }
     };
 
-    typedef
+    typedef typename std::conditional<IsKeyCache, KeyOnlyEntry, ValueEntry>::type Entry;
-        typename std::conditional<IsKeyCache, KeyOnlyEntry, ValueEntry>::type
-            Entry;
 
-    using KeyOnlyCacheType =
+    using KeyOnlyCacheType = hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>;
-        hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>;
 
-    using KeyValueCacheType =
+    using KeyValueCacheType = hardened_partitioned_hash_map<key_type, ValueEntry, Hash, KeyEqual>;
-        hardened_partitioned_hash_map<key_type, ValueEntry, Hash, KeyEqual>;
 
-    using cache_type =
+    using cache_type = hardened_partitioned_hash_map<key_type, Entry, Hash, KeyEqual>;
-        hardened_partitioned_hash_map<key_type, Entry, Hash, KeyEqual>;
 
     [[nodiscard]] std::thread
     sweepHelper(

include/xrpl/basics/TaggedCache.ipp

@@ -15,22 +15,13 @@ template <
     class Hash,
     class KeyEqual,
     class Mutex>
-inline TaggedCache<
+inline TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::TaggedCache(
-    Key,
+    std::string const& name,
-    T,
+    int size,
-    IsKeyCache,
+    clock_type::duration expiration,
-    SharedWeakUnionPointer,
+    clock_type& clock,
-    SharedPointerType,
+    beast::Journal journal,
-    Hash,
+    beast::insight::Collector::ptr const& collector)
-    KeyEqual,
-    Mutex>::
-    TaggedCache(
-        std::string const& name,
-        int size,
-        clock_type::duration expiration,
-        clock_type& clock,
-        beast::Journal journal,
-        beast::insight::Collector::ptr const& collector)
     : m_journal(journal)
     , m_clock(clock)
     , m_stats(name, std::bind(&TaggedCache::collect_metrics, this), collector)
@@ -53,15 +44,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::clock()
-    Key,
+    -> clock_type&
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::clock() -> clock_type&
 {
     return m_clock;
 }
@@ -76,15 +60,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::size_t
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::size() const
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::size() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache.size();
@@ -100,15 +76,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline int
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getCacheSize() const
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::getCacheSize() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache_count;
@@ -124,15 +92,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline int
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getTrackSize() const
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::getTrackSize() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache.size();
@@ -148,15 +108,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline float
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getHitRate()
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::getHitRate()
 {
     std::lock_guard lock(m_mutex);
     auto const total = static_cast<float>(m_hits + m_misses);
@@ -173,15 +125,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::clear()
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::clear()
 {
     std::lock_guard lock(m_mutex);
     m_cache.clear();
@@ -198,15 +142,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::reset()
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::reset()
 {
     std::lock_guard lock(m_mutex);
     m_cache.clear();
@@ -226,15 +162,8 @@ template <
     class Mutex>
 template <class KeyComparable>
 inline bool
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::touch_if_exists(
-    Key,
+    KeyComparable const& key)
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::touch_if_exists(KeyComparable const& key)
 {
     std::lock_guard lock(m_mutex);
     auto const iter(m_cache.find(key));
@@ -258,15 +187,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweep()
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::sweep()
 {
     // Keep references to all the stuff we sweep
     // For performance, each worker thread should exit before the swept data
@@ -280,8 +201,7 @@ TaggedCache<
     {
         std::lock_guard lock(m_mutex);
 
-        if (m_target_size == 0 ||
+        if (m_target_size == 0 || (static_cast<int>(m_cache.size()) <= m_target_size))
-            (static_cast<int>(m_cache.size()) <= m_target_size))
         {
             when_expire = now - m_target_age;
         }
@@ -293,10 +213,8 @@ TaggedCache<
             if (when_expire > (now - minimumAge))
                 when_expire = now - minimumAge;
 
-            JLOG(m_journal.trace())
+            JLOG(m_journal.trace()) << m_name << " is growing fast " << m_cache.size() << " of " << m_target_size
-                << m_name << " is growing fast " << m_cache.size() << " of "
+                                    << " aging at " << (now - when_expire).count() << " of " << m_target_age.count();
-                << m_target_size << " aging at " << (now - when_expire).count()
-                << " of " << m_target_age.count();
         }
 
         std::vector<std::thread> workers;
@@ -305,13 +223,7 @@ TaggedCache<
 
         for (std::size_t p = 0; p < m_cache.partitions(); ++p)
         {
-            workers.push_back(sweepHelper(
+            workers.push_back(sweepHelper(when_expire, now, m_cache.map()[p], allStuffToSweep[p], allRemovals, lock));
-                when_expire,
-                now,
-                m_cache.map()[p],
-                allStuffToSweep[p],
-                allRemovals,
-                lock));
         }
         for (std::thread& worker : workers)
             worker.join();
@@ -322,9 +234,7 @@ TaggedCache<
     // and decrement the reference count on each strong pointer.
     JLOG(m_journal.debug())
         << m_name << " TaggedCache sweep lock duration "
-        << std::chrono::duration_cast<std::chrono::milliseconds>(
+        << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count()
-               std::chrono::steady_clock::now() - start)
-               .count()
         << "ms";
 }
 
@@ -338,15 +248,9 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::del(
-    Key,
+    key_type const& key,
-    T,
+    bool valid)
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::del(key_type const& key, bool valid)
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
@@ -385,19 +289,10 @@ template <
     class Mutex>
 template <class R>
 inline bool
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::canonicalize(
-    Key,
+    key_type const& key,
-    T,
+    SharedPointerType& data,
-    IsKeyCache,
+    R&& replaceCallback)
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::
-    canonicalize(
-        key_type const& key,
-        SharedPointerType& data,
-        R&& replaceCallback)
 {
     // Return canonical value, store if needed, refresh in cache
     // Return values: true=we had the data already
@@ -408,9 +303,7 @@ TaggedCache<
     if (cit == m_cache.end())
     {
         m_cache.emplace(
-            std::piecewise_construct,
+            std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(m_clock.now(), data));
-            std::forward_as_tuple(key),
-            std::forward_as_tuple(m_clock.now(), data));
         ++m_cache_count;
         return false;
     }
@@ -480,21 +373,10 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    Key,
+    canonicalize_replace_cache(key_type const& key, SharedPointerType const& data)
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::
-    canonicalize_replace_cache(
-        key_type const& key,
-        SharedPointerType const& data)
 {
-    return canonicalize(
+    return canonicalize(key, const_cast<SharedPointerType&>(data), []() { return true; });
-        key, const_cast<SharedPointerType&>(data), []() { return true; });
 }
 
 template <
@@ -507,15 +389,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::
     canonicalize_replace_client(key_type const& key, SharedPointerType& data)
 {
     return canonicalize(key, data, []() { return false; });
@@ -531,15 +405,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline SharedPointerType
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::fetch(
-    Key,
+    key_type const& key)
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::fetch(key_type const& key)
 {
     std::lock_guard<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
@@ -559,16 +426,9 @@ template <
     class Mutex>
 template <class ReturnType>
 inline auto
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::insert(
-    Key,
+    key_type const& key,
-    T,
+    T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::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> ||
@@ -597,23 +457,13 @@ template <
     class Mutex>
 template <class ReturnType>
 inline auto
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::insert(
-    Key,
+    key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::insert(key_type const& key)
-    -> std::enable_if_t<IsKeyCache, ReturnType>
 {
     std::lock_guard lock(m_mutex);
     clock_type::time_point const now(m_clock.now());
-    auto [it, inserted] = m_cache.emplace(
+    auto [it, inserted] =
-        std::piecewise_construct,
+        m_cache.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
-        std::forward_as_tuple(key),
-        std::forward_as_tuple(now));
     if (!inserted)
         it->second.last_access = now;
     return inserted;
@@ -629,15 +479,9 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::retrieve(
-    Key,
+    key_type const& key,
-    T,
+    T& data)
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::retrieve(key_type const& key, T& data)
 {
     // retrieve the value of the stored data
     auto entry = fetch(key);
@@ -659,15 +503,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::peekMutex()
-    Key,
+    -> mutex_type&
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::peekMutex() -> mutex_type&
 {
     return m_mutex;
 }
@@ -682,15 +519,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getKeys() const
-    Key,
+    -> std::vector<key_type>
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::getKeys() const -> std::vector<key_type>
 {
     std::vector<key_type> v;
 
@@ -714,15 +544,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline double
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::rate() const
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::rate() const
 {
     std::lock_guard lock(m_mutex);
     auto const tot = m_hits + m_misses;
@@ -742,15 +564,9 @@ template <
     class Mutex>
 template <class Handler>
 inline SharedPointerType
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::fetch(
-    Key,
+    key_type const& digest,
-    T,
+    Handler const& h)
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::fetch(key_type const& digest, Handler const& h)
 {
     {
         std::lock_guard l(m_mutex);
@@ -764,8 +580,7 @@ TaggedCache<
 
     std::lock_guard l(m_mutex);
     ++m_misses;
-    auto const [it, inserted] =
+    auto const [it, inserted] = m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
-        m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
     if (!inserted)
         it->second.touch(m_clock.now());
     return it->second.ptr.getStrong();
@@ -782,16 +597,9 @@ template <
     class KeyEqual,
     class Mutex>
 inline SharedPointerType
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::initialFetch(
-    Key,
+    key_type const& key,
-    T,
+    std::lock_guard<mutex_type> const& l)
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
 {
     auto cit = m_cache.find(key);
     if (cit == m_cache.end())
@@ -827,15 +635,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::collect_metrics()
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::collect_metrics()
 {
     m_stats.size.set(getCacheSize());
 
@@ -861,22 +661,13 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::thread
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweepHelper(
-    Key,
+    clock_type::time_point const& when_expire,
-    T,
+    [[maybe_unused]] clock_type::time_point const& now,
-    IsKeyCache,
+    typename KeyValueCacheType::map_type& partition,
-    SharedWeakUnionPointer,
+    SweptPointersVector& stuffToSweep,
-    SharedPointerType,
+    std::atomic<int>& allRemovals,
-    Hash,
+    std::lock_guard<std::recursive_mutex> const&)
-    KeyEqual,
-    Mutex>::
-    sweepHelper(
-        clock_type::time_point const& when_expire,
-        [[maybe_unused]] clock_type::time_point const& now,
-        typename KeyValueCacheType::map_type& partition,
-        SweptPointersVector& stuffToSweep,
-        std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -930,10 +721,8 @@ TaggedCache<
 
         if (mapRemovals || cacheRemovals)
         {
-            JLOG(m_journal.debug())
+            JLOG(m_journal.debug()) << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
-                << "TaggedCache partition sweep " << m_name
+                                    << "-" << cacheRemovals << ", map-=" << mapRemovals;
-                << ": cache = " << partition.size() << "-" << cacheRemovals
-                << ", map-=" << mapRemovals;
         }
 
         allRemovals += cacheRemovals;
@@ -950,22 +739,13 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::thread
-TaggedCache<
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweepHelper(
-    Key,
+    clock_type::time_point const& when_expire,
-    T,
+    clock_type::time_point const& now,
-    IsKeyCache,
+    typename KeyOnlyCacheType::map_type& partition,
-    SharedWeakUnionPointer,
+    SweptPointersVector&,
-    SharedPointerType,
+    std::atomic<int>& allRemovals,
-    Hash,
+    std::lock_guard<std::recursive_mutex> const&)
-    KeyEqual,
-    Mutex>::
-    sweepHelper(
-        clock_type::time_point const& when_expire,
-        clock_type::time_point const& now,
-        typename KeyOnlyCacheType::map_type& partition,
-        SweptPointersVector&,
-        std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -995,10 +775,8 @@ TaggedCache<
 
         if (mapRemovals || cacheRemovals)
         {
-            JLOG(m_journal.debug())
+            JLOG(m_journal.debug()) << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
-                << "TaggedCache partition sweep " << m_name
+                                    << "-" << cacheRemovals << ", map-=" << mapRemovals;
-                << ": cache = " << partition.size() << "-" << cacheRemovals
-                << ", map-=" << mapRemovals;
         }
 
         allRemovals += cacheRemovals;

include/xrpl/basics/UnorderedContainers.h

@@ -40,8 +40,7 @@ template <
     class Hash = beast::uhash<>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hash_multimap =
+using hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
-    std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Value,
@@ -75,8 +74,7 @@ template <
     class Hash = hardened_hash<strong_hash>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hardened_partitioned_hash_map =
+using hardened_partitioned_hash_map = partitioned_unordered_map<Key, Value, Hash, Pred, Allocator>;
-    partitioned_unordered_map<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Key,
@@ -84,8 +82,7 @@ template <
     class Hash = hardened_hash<strong_hash>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hardened_hash_multimap =
+using hardened_hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
-    std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Value,
@@ -99,8 +96,7 @@ template <
     class Hash = hardened_hash<strong_hash>,
     class Pred = std::equal_to<Value>,
     class Allocator = std::allocator<Value>>
-using hardened_hash_multiset =
+using hardened_hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
-    std::unordered_multiset<Value, Hash, Pred, Allocator>;
 
 }  // namespace xrpl
 

include/xrpl/basics/algorithm.h

@@ -52,13 +52,7 @@ generalized_set_intersection(
 // std::set_intersection.
 template <class FwdIter1, class InputIter2, class Pred, class Comp>
 FwdIter1
-remove_if_intersect_or_match(
+remove_if_intersect_or_match(FwdIter1 first1, FwdIter1 last1, InputIter2 first2, InputIter2 last2, Pred pred, Comp comp)
-    FwdIter1 first1,
-    FwdIter1 last1,
-    InputIter2 first2,
-    InputIter2 last2,
-    Pred pred,
-    Comp comp)
 {
     // [original-first1, current-first1) is the set of elements to be preserved.
     // [current-first1, i) is the set of elements that have been removed.

include/xrpl/basics/base64.h

@@ -46,8 +46,7 @@ base64_encode(std::uint8_t const* data, std::size_t len);
 inline std::string
 base64_encode(std::string const& s)
 {
-    return base64_encode(
+    return base64_encode(reinterpret_cast<std::uint8_t const*>(s.data()), s.size());
-        reinterpret_cast<std::uint8_t const*>(s.data()), s.size());
 }
 
 std::string

include/xrpl/basics/base_uint.h

@@ -65,13 +65,9 @@ struct is_contiguous_container<Slice> : std::true_type
 template <std::size_t Bits, class Tag = void>
 class base_uint
 {
-    static_assert(
+    static_assert((Bits % 32) == 0, "The length of a base_uint in bits must be a multiple of 32.");
-        (Bits % 32) == 0,
-        "The length of a base_uint in bits must be a multiple of 32.");
 
-    static_assert(
+    static_assert(Bits >= 64, "The length of a base_uint in bits must be at least 64.");
-        Bits >= 64,
-        "The length of a base_uint in bits must be at least 64.");
 
     static constexpr std::size_t WIDTH = Bits / 32;
 
@@ -182,9 +178,7 @@ private:
     {
         // Local lambda that converts a single hex char to four bits and
         // ORs those bits into a uint32_t.
-        auto hexCharToUInt = [](char c,
+        auto hexCharToUInt = [](char c, std::uint32_t shift, std::uint32_t& accum) -> ParseResult {
-                                std::uint32_t shift,
-                                std::uint32_t& accum) -> ParseResult {
             std::uint32_t nibble = 0xFFu;
             if (c < '0' || c > 'f')
                 return ParseResult::badChar;
@@ -221,8 +215,7 @@ private:
             std::uint32_t accum = {};
             for (std::uint32_t shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
             {
-                if (auto const result = hexCharToUInt(*in++, shift, accum);
+                if (auto const result = hexCharToUInt(*in++, shift, accum); result != ParseResult::okay)
-                    result != ParseResult::okay)
                     return Unexpected(result);
             }
             ret[i++] = accum;
@@ -261,8 +254,7 @@ public:
     // This constructor is intended to be used at compile time since it might
     // throw at runtime.  Consider declaring this constructor consteval once
     // we get to C++23.
-    explicit constexpr base_uint(std::string_view sv) noexcept(false)
+    explicit constexpr base_uint(std::string_view sv) noexcept(false) : data_(parseFromStringViewThrows(sv))
-        : data_(parseFromStringViewThrows(sv))
     {
     }
 
@@ -387,8 +379,7 @@ public:
         // prefix operator
         for (int i = WIDTH - 1; i >= 0; --i)
         {
-            data_[i] = boost::endian::native_to_big(
+            data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) + 1);
-                boost::endian::big_to_native(data_[i]) + 1);
             if (data_[i] != 0)
                 break;
         }
@@ -412,8 +403,7 @@ public:
         for (int i = WIDTH - 1; i >= 0; --i)
         {
             auto prev = data_[i];
-            data_[i] = boost::endian::native_to_big(
+            data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) - 1);
-                boost::endian::big_to_native(data_[i]) - 1);
 
             if (prev != 0)
                 break;
@@ -453,11 +443,9 @@ public:
 
         for (int i = WIDTH; i--;)
         {
-            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) +
+            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) + boost::endian::big_to_native(b.data_[i]);
-                boost::endian::big_to_native(b.data_[i]);
 
-            data_[i] =
+            data_[i] = boost::endian::native_to_big(static_cast<std::uint32_t>(n));
-                boost::endian::native_to_big(static_cast<std::uint32_t>(n));
             carry = n >> 32;
         }
 
@@ -557,8 +545,7 @@ operator<=>(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
     if (ret.first == lhs.cend())
         return std::strong_ordering::equivalent;
 
-    return (*ret.first > *ret.second) ? std::strong_ordering::greater
+    return (*ret.first > *ret.second) ? std::strong_ordering::greater : std::strong_ordering::less;
-                                      : std::strong_ordering::less;
 }
 
 template <std::size_t Bits, typename Tag>
@@ -617,9 +604,7 @@ template <std::size_t Bits, class Tag>
 inline std::string
 to_short_string(base_uint<Bits, Tag> const& a)
 {
-    static_assert(
+    static_assert(base_uint<Bits, Tag>::bytes > 4, "For 4 bytes or less, use a native type");
-        base_uint<Bits, Tag>::bytes > 4,
-        "For 4 bytes or less, use a native type");
     return strHex(a.cbegin(), a.cbegin() + 4) + "...";
 }
 
@@ -653,8 +638,7 @@ static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
 namespace beast {
 
 template <std::size_t Bits, class Tag>
-struct is_uniquely_represented<xrpl::base_uint<Bits, Tag>>
+struct is_uniquely_represented<xrpl::base_uint<Bits, Tag>> : public std::true_type
-    : public std::true_type
 {
     explicit is_uniquely_represented() = default;
 };

include/xrpl/basics/chrono.h

@@ -16,12 +16,9 @@ namespace xrpl {
 
 // A few handy aliases
 
-using days = std::chrono::duration<
+using days = std::chrono::duration<int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
-    int,
-    std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
 
-using weeks = std::chrono::
+using weeks = std::chrono::duration<int, std::ratio_multiply<days::period, std::ratio<7>>>;
-    duration<int, std::ratio_multiply<days::period, std::ratio<7>>>;
 
 /** Clock for measuring the network time.
 
@@ -34,8 +31,7 @@ using weeks = std::chrono::
 */
 
 constexpr static std::chrono::seconds epoch_offset =
-    date::sys_days{date::year{2000} / 1 / 1} -
+    date::sys_days{date::year{2000} / 1 / 1} - date::sys_days{date::year{1970} / 1 / 1};
-    date::sys_days{date::year{1970} / 1 / 1};
 
 static_assert(epoch_offset.count() == 946684800);
 
@@ -64,8 +60,7 @@ to_string(NetClock::time_point tp)
 {
     // 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC
     using namespace std::chrono;
-    return to_string(
+    return to_string(system_clock::time_point{tp.time_since_epoch() + epoch_offset});
-        system_clock::time_point{tp.time_since_epoch() + epoch_offset});
 }
 
 template <class Duration>
@@ -82,8 +77,7 @@ to_string_iso(NetClock::time_point tp)
     // 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC
     // Note, NetClock::duration is seconds, as checked by static_assert
     static_assert(std::is_same_v<NetClock::duration::period, std::ratio<1>>);
-    return to_string_iso(date::sys_time<NetClock::duration>{
+    return to_string_iso(date::sys_time<NetClock::duration>{tp.time_since_epoch() + epoch_offset});
-        tp.time_since_epoch() + epoch_offset});
 }
 
 /** A clock for measuring elapsed time.

include/xrpl/basics/contract.h

@@ -36,15 +36,10 @@ template <class E, class... Args>
 [[noreturn]] inline void
 Throw(Args&&... args)
 {
-    static_assert(
+    static_assert(std::is_convertible<E*, std::exception*>::value, "Exception must derive from std::exception.");
-        std::is_convertible<E*, std::exception*>::value,
-        "Exception must derive from std::exception.");
 
     E e(std::forward<Args>(args)...);
-    LogThrow(
+    LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());
-        std::string(
-            "Throwing exception of type " + beast::type_name<E>() + ": ") +
-        e.what());
     throw e;
 }
 

include/xrpl/basics/join.h

@@ -24,8 +24,7 @@ public:
     Collection const& collection;
     std::string const delimiter;
 
-    explicit CollectionAndDelimiter(Collection const& c, std::string delim)
+    explicit CollectionAndDelimiter(Collection const& c, std::string delim) : collection(c), delimiter(std::move(delim))
-        : collection(c), delimiter(std::move(delim))
     {
     }
 
@@ -33,11 +32,7 @@ public:
     friend Stream&
     operator<<(Stream& s, CollectionAndDelimiter const& cd)
     {
-        return join(
+        return join(s, std::begin(cd.collection), std::end(cd.collection), cd.delimiter);
-            s,
-            std::begin(cd.collection),
-            std::end(cd.collection),
-            cd.delimiter);
     }
 };
 
@@ -69,8 +64,7 @@ public:
     char const* collection;
     std::string const delimiter;
 
-    explicit CollectionAndDelimiter(char const c[N], std::string delim)
+    explicit CollectionAndDelimiter(char const c[N], std::string delim) : collection(c), delimiter(std::move(delim))
-        : collection(c), delimiter(std::move(delim))
     {
     }
 

include/xrpl/basics/partitioned_unordered_map.h

@@ -51,8 +51,7 @@ public:
     using const_reference = value_type const&;
     using pointer = value_type*;
     using const_pointer = value_type const*;
-    using map_type = std::
+    using map_type = std::unordered_map<key_type, mapped_type, hasher, key_equal, allocator_type>;
-        unordered_map<key_type, mapped_type, hasher, key_equal, allocator_type>;
     using partition_map_type = std::vector<map_type>;
 
     struct iterator
@@ -113,8 +112,7 @@ public:
         friend bool
         operator==(iterator const& lhs, iterator const& rhs)
         {
-            return lhs.map_ == rhs.map_ && lhs.ait_ == rhs.ait_ &&
+            return lhs.map_ == rhs.map_ && lhs.ait_ == rhs.ait_ && lhs.mit_ == rhs.mit_;
-                lhs.mit_ == rhs.mit_;
         }
 
         friend bool
@@ -190,8 +188,7 @@ public:
         friend bool
         operator==(const_iterator const& lhs, const_iterator const& rhs)
         {
-            return lhs.map_ == rhs.map_ && lhs.ait_ == rhs.ait_ &&
+            return lhs.map_ == rhs.map_ && lhs.ait_ == rhs.ait_ && lhs.mit_ == rhs.mit_;
-                lhs.mit_ == rhs.mit_;
         }
 
         friend bool
@@ -231,14 +228,11 @@ private:
     }
 
 public:
-    partitioned_unordered_map(
+    partitioned_unordered_map(std::optional<std::size_t> partitions = std::nullopt)
-        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
+        partitions_ = partitions && *partitions ? *partitions : std::thread::hardware_concurrency();
-            ? *partitions
-            : std::thread::hardware_concurrency();
         map_.resize(partitions_);
         XRPL_ASSERT(
             partitions_,
@@ -337,10 +331,8 @@ public:
         auto const& key = std::get<0>(keyTuple);
         iterator it(&map_);
         it.ait_ = it.map_->begin() + partitioner(key);
-        auto [eit, inserted] = it.ait_->emplace(
+        auto [eit, inserted] =
-            std::piecewise_construct,
+            it.ait_->emplace(std::piecewise_construct, std::forward<T>(keyTuple), std::forward<U>(valueTuple));
-            std::forward<T>(keyTuple),
-            std::forward<U>(valueTuple));
         it.mit_ = eit;
         return {it, inserted};
     }
@@ -351,8 +343,7 @@ public:
     {
         iterator it(&map_);
         it.ait_ = it.map_->begin() + partitioner(key);
-        auto [eit, inserted] =
+        auto [eit, inserted] = it.ait_->emplace(std::forward<T>(key), std::forward<U>(val));
-            it.ait_->emplace(std::forward<T>(key), std::forward<U>(val));
         it.mit_ = eit;
         return {it, inserted};
     }

include/xrpl/basics/random.h

@@ -20,8 +20,7 @@ static_assert(
     "The Ripple default PRNG engine must return an unsigned integral type.");
 
 static_assert(
-    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
+    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >= std::numeric_limits<std::uint64_t>::max(),
-        std::numeric_limits<std::uint64_t>::max(),
     "The Ripple default PRNG engine return must be at least 64 bits wide.");
 #endif
 
@@ -90,9 +89,7 @@ default_prng()
 */
 /** @{ */
 template <class Engine, class Integral>
-std::enable_if_t<
+std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
-    std::is_integral<Integral>::value && detail::is_engine<Engine>::value,
-    Integral>
 rand_int(Engine& engine, Integral min, Integral max)
 {
     XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
@@ -111,9 +108,7 @@ rand_int(Integral min, Integral max)
 }
 
 template <class Engine, class Integral>
-std::enable_if_t<
+std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
-    std::is_integral<Integral>::value && detail::is_engine<Engine>::value,
-    Integral>
 rand_int(Engine& engine, Integral max)
 {
     return rand_int(engine, Integral(0), max);
@@ -127,9 +122,7 @@ rand_int(Integral max)
 }
 
 template <class Integral, class Engine>
-std::enable_if_t<
+std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
-    std::is_integral<Integral>::value && detail::is_engine<Engine>::value,
-    Integral>
 rand_int(Engine& engine)
 {
     return rand_int(engine, std::numeric_limits<Integral>::max());
@@ -147,23 +140,17 @@ rand_int()
 /** @{ */
 template <class Byte, class Engine>
 std::enable_if_t<
-    (std::is_same<Byte, unsigned char>::value ||
+    (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value) &&
-     std::is_same<Byte, std::uint8_t>::value) &&
         detail::is_engine<Engine>::value,
     Byte>
 rand_byte(Engine& engine)
 {
-    return static_cast<Byte>(rand_int<Engine, std::uint32_t>(
+    return static_cast<Byte>(
-        engine,
+        rand_int<Engine, std::uint32_t>(engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
-        std::numeric_limits<Byte>::min(),
-        std::numeric_limits<Byte>::max()));
 }
 
 template <class Byte = std::uint8_t>
-std::enable_if_t<
+std::enable_if_t<(std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value), Byte>
-    (std::is_same<Byte, unsigned char>::value ||
-     std::is_same<Byte, std::uint8_t>::value),
-    Byte>
 rand_byte()
 {
     return rand_byte<Byte>(default_prng());

include/xrpl/basics/safe_cast.h

@@ -12,38 +12,29 @@ namespace xrpl {
 template <class Src, class Dest>
 concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
     (std::is_signed<Src>::value || std::is_unsigned<Dest>::value) &&
-    (std::is_signed<Src>::value != std::is_signed<Dest>::value
+    (std::is_signed<Src>::value != std::is_signed<Dest>::value ? sizeof(Dest) > sizeof(Src)
-         ? sizeof(Dest) > sizeof(Src)
+                                                               : sizeof(Dest) >= sizeof(Src));
-         : sizeof(Dest) >= sizeof(Src));
 
 template <class Dest, class Src>
-inline constexpr std::
+inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
-    enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
+safe_cast(Src s) noexcept
-    safe_cast(Src s) noexcept
 {
-    static_assert(
+    static_assert(std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
-        std::is_signed_v<Dest> || std::is_unsigned_v<Src>,
+    constexpr unsigned not_same = std::is_signed_v<Dest> != std::is_signed_v<Src>;
-        "Cannot cast signed to unsigned");
+    static_assert(sizeof(Dest) >= sizeof(Src) + not_same, "Destination is too small to hold all values of source");
-    constexpr unsigned not_same =
-        std::is_signed_v<Dest> != std::is_signed_v<Src>;
-    static_assert(
-        sizeof(Dest) >= sizeof(Src) + not_same,
-        "Destination is too small to hold all values of source");
     return static_cast<Dest>(s);
 }
 
 template <class Dest, class Src>
-inline constexpr std::
+inline constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
-    enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
+safe_cast(Src s) noexcept
-    safe_cast(Src s) noexcept
 {
     return static_cast<Dest>(safe_cast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-inline constexpr std::
+inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
-    enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
+safe_cast(Src s) noexcept
-    safe_cast(Src s) noexcept
 {
     return safe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
@@ -53,9 +44,8 @@ inline constexpr std::
 // underlying types become safe, it can be converted to a safe_cast.
 
 template <class Dest, class Src>
-inline constexpr std::
+inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
-    enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
+unsafe_cast(Src s) noexcept
-    unsafe_cast(Src s) noexcept
 {
     static_assert(
         !SafeToCast<Src, Dest>,
@@ -65,17 +55,15 @@ inline constexpr std::
 }
 
 template <class Dest, class Src>
-inline constexpr std::
+inline constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
-    enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
+unsafe_cast(Src s) noexcept
-    unsafe_cast(Src s) noexcept
 {
     return static_cast<Dest>(unsafe_cast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-inline constexpr std::
+inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
-    enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
+unsafe_cast(Src s) noexcept
-    unsafe_cast(Src s) noexcept
 {
     return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }

include/xrpl/basics/scope.h

@@ -36,10 +36,8 @@ public:
     }
 
     scope_exit(scope_exit&& rhs) noexcept(
-        std::is_nothrow_move_constructible_v<EF> ||
+        std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        std::is_nothrow_copy_constructible_v<EF>)
+        : exit_function_{std::forward<EF>(rhs.exit_function_)}, execute_on_destruction_{rhs.execute_on_destruction_}
-        : exit_function_{std::forward<EF>(rhs.exit_function_)}
-        , execute_on_destruction_{rhs.execute_on_destruction_}
     {
         rhs.release();
     }
@@ -50,14 +48,11 @@ public:
     template <class EFP>
     explicit scope_exit(
         EFP&& f,
-        std::enable_if_t<
+        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_exit> && std::is_constructible_v<EF, EFP>>* =
-            !std::is_same_v<std::remove_cv_t<EFP>, scope_exit> &&
+            0) noexcept
-            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exit_function_{std::forward<EFP>(f)}
     {
-        static_assert(
+        static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
-            std::
-                is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
     }
 
     void
@@ -80,14 +75,12 @@ class scope_fail
 public:
     ~scope_fail()
     {
-        if (execute_on_destruction_ &&
+        if (execute_on_destruction_ && std::uncaught_exceptions() > uncaught_on_creation_)
-            std::uncaught_exceptions() > uncaught_on_creation_)
             exit_function_();
     }
 
     scope_fail(scope_fail&& rhs) noexcept(
-        std::is_nothrow_move_constructible_v<EF> ||
+        std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        std::is_nothrow_copy_constructible_v<EF>)
         : exit_function_{std::forward<EF>(rhs.exit_function_)}
         , execute_on_destruction_{rhs.execute_on_destruction_}
         , uncaught_on_creation_{rhs.uncaught_on_creation_}
@@ -101,14 +94,11 @@ public:
     template <class EFP>
     explicit scope_fail(
         EFP&& f,
-        std::enable_if_t<
+        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_fail> && std::is_constructible_v<EF, EFP>>* =
-            !std::is_same_v<std::remove_cv_t<EFP>, scope_fail> &&
+            0) noexcept
-            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exit_function_{std::forward<EFP>(f)}
     {
-        static_assert(
+        static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
-            std::
-                is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
     }
 
     void
@@ -131,14 +121,12 @@ class scope_success
 public:
     ~scope_success() noexcept(noexcept(exit_function_()))
     {
-        if (execute_on_destruction_ &&
+        if (execute_on_destruction_ && std::uncaught_exceptions() <= uncaught_on_creation_)
-            std::uncaught_exceptions() <= uncaught_on_creation_)
             exit_function_();
     }
 
     scope_success(scope_success&& rhs) noexcept(
-        std::is_nothrow_move_constructible_v<EF> ||
+        std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        std::is_nothrow_copy_constructible_v<EF>)
         : exit_function_{std::forward<EF>(rhs.exit_function_)}
         , execute_on_destruction_{rhs.execute_on_destruction_}
         , uncaught_on_creation_{rhs.uncaught_on_creation_}
@@ -152,9 +140,7 @@ public:
     template <class EFP>
     explicit scope_success(
         EFP&& f,
-        std::enable_if_t<
+        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_success> && std::is_constructible_v<EF, EFP>>* =
-            !std::is_same_v<std::remove_cv_t<EFP>, scope_success> &&
-            std::is_constructible_v<EF, EFP>>* =
             0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
         : exit_function_{std::forward<EFP>(f)}
     {
@@ -213,12 +199,9 @@ class scope_unlock
     std::unique_lock<Mutex>* plock;
 
 public:
-    explicit scope_unlock(std::unique_lock<Mutex>& lock) noexcept(true)
+    explicit scope_unlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock(&lock)
-        : plock(&lock)
     {
-        XRPL_ASSERT(
+        XRPL_ASSERT(plock->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked");
-            plock->owns_lock(),
-            "xrpl::scope_unlock::scope_unlock : mutex must be locked");
         plock->unlock();
     }
 

include/xrpl/basics/spinlock.h

@@ -100,12 +100,9 @@ public:
         @note For performance reasons, you should strive to have `lock` be
               on a cacheline by itself.
      */
-    packed_spinlock(std::atomic<T>& lock, int index)
+    packed_spinlock(std::atomic<T>& lock, int index) : bits_(lock), mask_(static_cast<T>(1) << index)
-        : bits_(lock), mask_(static_cast<T>(1) << index)
     {
-        XRPL_ASSERT(
+        XRPL_ASSERT(index >= 0 && (mask_ != 0), "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
-            index >= 0 && (mask_ != 0),
-            "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
     }
 
     [[nodiscard]] bool
@@ -178,10 +175,7 @@ public:
         T expected = 0;
 
         return lock_.compare_exchange_weak(
-            expected,
+            expected, std::numeric_limits<T>::max(), std::memory_order_acquire, std::memory_order_relaxed);
-            std::numeric_limits<T>::max(),
-            std::memory_order_acquire,
-            std::memory_order_relaxed);
     }
 
     void

include/xrpl/basics/strHex.h

@@ -11,9 +11,7 @@ std::string
 strHex(FwdIt begin, FwdIt end)
 {
     static_assert(
-        std::is_convertible<
+        std::is_convertible<typename std::iterator_traits<FwdIt>::iterator_category, std::forward_iterator_tag>::value,
-            typename std::iterator_traits<FwdIt>::iterator_category,
-            std::forward_iterator_tag>::value,
         "FwdIt must be a forward iterator");
     std::string result;
     result.reserve(2 * std::distance(begin, end));

include/xrpl/basics/tagged_integer.h

@@ -31,9 +31,7 @@ class tagged_integer
               tagged_integer<Int, Tag>,
               boost::bitwise<
                   tagged_integer<Int, Tag>,
-                  boost::unit_steppable<
+                  boost::unit_steppable<tagged_integer<Int, Tag>, boost::shiftable<tagged_integer<Int, Tag>>>>>>
-                      tagged_integer<Int, Tag>,
-                      boost::shiftable<tagged_integer<Int, Tag>>>>>>
 {
 private:
     Int m_value;
@@ -46,14 +44,10 @@ public:
 
     template <
         class OtherInt,
-        class = typename std::enable_if<
+        class = typename std::enable_if<std::is_integral<OtherInt>::value && sizeof(OtherInt) <= sizeof(Int)>::type>
-            std::is_integral<OtherInt>::value &&
-            sizeof(OtherInt) <= sizeof(Int)>::type>
     explicit constexpr tagged_integer(OtherInt value) noexcept : m_value(value)
     {
-        static_assert(
+        static_assert(sizeof(tagged_integer) == sizeof(Int), "tagged_integer is adding padding");
-            sizeof(tagged_integer) == sizeof(Int),
-            "tagged_integer is adding padding");
     }
 
     bool

include/xrpl/beast/asio/io_latency_probe.h

@@ -32,11 +32,7 @@ private:
 
 public:
     io_latency_probe(duration const& period, boost::asio::io_context& ios)
-        : m_count(1)
+        : m_count(1), m_period(period), m_ios(ios), m_timer(m_ios), m_cancel(false)
-        , m_period(period)
-        , m_ios(ios)
-        , m_timer(m_ios)
-        , m_cancel(false)
     {
     }
 
@@ -91,10 +87,7 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(
+        boost::asio::post(m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
-            m_ios,
-            sample_op<Handler>(
-                std::forward<Handler>(handler), Clock::now(), false, this));
     }
 
     /** Initiate continuous i/o latency sampling.
@@ -108,10 +101,7 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(
+        boost::asio::post(m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
-            m_ios,
-            sample_op<Handler>(
-                std::forward<Handler>(handler), Clock::now(), true, this));
     }
 
 private:
@@ -151,15 +141,8 @@ private:
         bool m_repeat;
         io_latency_probe* m_probe;
 
-        sample_op(
+        sample_op(Handler const& handler, time_point const& start, bool repeat, io_latency_probe* probe)
-            Handler const& handler,
+            : m_handler(handler), m_start(start), m_repeat(repeat), m_probe(probe)
-            time_point const& start,
-            bool repeat,
-            io_latency_probe* probe)
-            : m_handler(handler)
-            , m_start(start)
-            , m_repeat(repeat)
-            , m_probe(probe)
         {
             XRPL_ASSERT(
                 m_probe,
@@ -214,23 +197,19 @@ private:
                 // Calculate when we want to sample again, and
                 // adjust for the expected latency.
                 //
-                typename Clock::time_point const when(
+                typename Clock::time_point const when(now + m_probe->m_period - 2 * elapsed);
-                    now + m_probe->m_period - 2 * elapsed);
 
                 if (when <= now)
                 {
                     // The latency is too high to maintain the desired
                     // period so don't bother with a timer.
                     //
-                    boost::asio::post(
+                    boost::asio::post(m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
-                        m_probe->m_ios,
-                        sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
                 else
                 {
                     m_probe->m_timer.expires_after(when - now);
-                    m_probe->m_timer.async_wait(
+                    m_probe->m_timer.async_wait(sample_op<Handler>(m_handler, now, m_repeat, m_probe));
-                        sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
             }
         }
@@ -241,9 +220,7 @@ private:
             if (!m_probe)
                 return;
             typename Clock::time_point const now(Clock::now());
-            boost::asio::post(
+            boost::asio::post(m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
-                m_probe->m_ios,
-                sample_op<Handler>(m_handler, now, m_repeat, m_probe));
         }
     };
 };

include/xrpl/beast/clock/manual_clock.h

@@ -29,8 +29,7 @@ private:
     time_point now_;
 
 public:
-    explicit manual_clock(time_point const& now = time_point(duration(0)))
+    explicit manual_clock(time_point const& now = time_point(duration(0))) : now_(now)
-        : now_(now)
     {
     }
 
@@ -44,9 +43,7 @@ public:
     void
     set(time_point const& when)
     {
-        XRPL_ASSERT(
+        XRPL_ASSERT(!Clock::is_steady || when >= now_, "beast::manual_clock::set(time_point) : forward input");
-            !Clock::is_steady || when >= now_,
-            "beast::manual_clock::set(time_point) : forward input");
         now_ = when;
     }
 
@@ -64,8 +61,7 @@ public:
     advance(std::chrono::duration<Rep, Period> const& elapsed)
     {
         XRPL_ASSERT(
-            !Clock::is_steady || (now_ + elapsed) >= now_,
+            !Clock::is_steady || (now_ + elapsed) >= now_, "beast::manual_clock::advance(duration) : forward input");
-            "beast::manual_clock::advance(duration) : forward input");
         now_ += elapsed;
     }
 

include/xrpl/beast/container/aged_container_utility.h

@@ -10,14 +10,12 @@ namespace beast {
 
 /** Expire aged container items past the specified age. */
 template <class AgedContainer, class Rep, class Period>
-typename std::enable_if<is_aged_container<AgedContainer>::value, std::size_t>::
+typename std::enable_if<is_aged_container<AgedContainer>::value, std::size_t>::type
-    type
+expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
-    expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);
-    for (auto iter(c.chronological.cbegin());
+    for (auto iter(c.chronological.cbegin()); iter != c.chronological.cend() && iter.when() <= expired;)
-         iter != c.chronological.cend() && iter.when() <= expired;)
     {
         iter = c.erase(iter);
         ++n;

include/xrpl/beast/container/aged_map.h

@@ -15,8 +15,7 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_map = detail::
+using aged_map = detail::aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>;
-    aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>;
 
 }
 

include/xrpl/beast/container/aged_multimap.h

@@ -15,8 +15,7 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_multimap = detail::
+using aged_multimap = detail::aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>;
-    aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>;
 
 }
 

include/xrpl/beast/container/aged_multiset.h

@@ -14,8 +14,7 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<Key>>
-using aged_multiset = detail::
+using aged_multiset = detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
-    aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
 
 }
 

include/xrpl/beast/container/aged_set.h

@@ -14,8 +14,7 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<Key>>
-using aged_set = detail::
+using aged_set = detail::aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>;
-    aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>;
 
 }
 

include/xrpl/beast/container/aged_unordered_map.h

@@ -16,15 +16,7 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_unordered_map = detail::aged_unordered_container<
+using aged_unordered_map = detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-    false,
-    true,
-    Key,
-    T,
-    Clock,
-    Hash,
-    KeyEqual,
-    Allocator>;
 
 }
 

include/xrpl/beast/container/aged_unordered_multimap.h

@@ -16,15 +16,7 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_unordered_multimap = detail::aged_unordered_container<
+using aged_unordered_multimap = detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-    true,
-    true,
-    Key,
-    T,
-    Clock,
-    Hash,
-    KeyEqual,
-    Allocator>;
 
 }
 

include/xrpl/beast/container/aged_unordered_multiset.h

@@ -15,15 +15,8 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<Key>>
-using aged_unordered_multiset = detail::aged_unordered_container<
+using aged_unordered_multiset =
-    true,
+    detail::aged_unordered_container<true, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
-    false,
-    Key,
-    void,
-    Clock,
-    Hash,
-    KeyEqual,
-    Allocator>;
 
 }
 

include/xrpl/beast/container/aged_unordered_set.h

@@ -15,15 +15,7 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<Key>>
-using aged_unordered_set = detail::aged_unordered_container<
+using aged_unordered_set = detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
-    false,
-    false,
-    Key,
-    void,
-    Clock,
-    Hash,
-    KeyEqual,
-    Allocator>;
 
 }
 

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

@@ -16,14 +16,12 @@ template <bool is_const, class Iterator>
 class aged_container_iterator
 {
 public:
-    using iterator_category =
+    using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
-        typename std::iterator_traits<Iterator>::iterator_category;
     using value_type = typename std::conditional<
         is_const,
         typename Iterator::value_type::stashed::value_type const,
         typename Iterator::value_type::stashed::value_type>::type;
-    using difference_type =
+    using difference_type = typename std::iterator_traits<Iterator>::difference_type;
-        typename std::iterator_traits<Iterator>::difference_type;
     using pointer = value_type*;
     using reference = value_type&;
     using time_point = typename Iterator::value_type::stashed::time_point;
@@ -38,31 +36,22 @@ public:
         class = typename std::enable_if<
             (other_is_const == false || is_const == true) &&
             std::is_same<Iterator, OtherIterator>::value == false>::type>
-    explicit aged_container_iterator(
+    explicit aged_container_iterator(aged_container_iterator<other_is_const, OtherIterator> const& other)
-        aged_container_iterator<other_is_const, OtherIterator> const& other)
         : m_iter(other.m_iter)
     {
     }
 
     // Disable constructing a const_iterator from a non-const_iterator.
-    template <
+    template <bool other_is_const, class = typename std::enable_if<other_is_const == false || is_const == true>::type>
-        bool other_is_const,
+    aged_container_iterator(aged_container_iterator<other_is_const, Iterator> const& other) : m_iter(other.m_iter)
-        class = typename std::enable_if<
-            other_is_const == false || is_const == true>::type>
-    aged_container_iterator(
-        aged_container_iterator<other_is_const, Iterator> const& other)
-        : m_iter(other.m_iter)
     {
     }
 
     // Disable assigning a const_iterator to a non-const iterator
     template <bool other_is_const, class OtherIterator>
     auto
-    operator=(
+    operator=(aged_container_iterator<other_is_const, OtherIterator> const& other) ->
-        aged_container_iterator<other_is_const, OtherIterator> const& other) ->
+        typename std::enable_if<other_is_const == false || is_const == true, aged_container_iterator&>::type
-        typename std::enable_if<
-            other_is_const == false || is_const == true,
-            aged_container_iterator&>::type
     {
         m_iter = other.m_iter;
         return *this;
@@ -70,16 +59,14 @@ public:
 
     template <bool other_is_const, class OtherIterator>
     bool
-    operator==(aged_container_iterator<other_is_const, OtherIterator> const&
+    operator==(aged_container_iterator<other_is_const, OtherIterator> const& other) const
-                   other) const
     {
         return m_iter == other.m_iter;
     }
 
     template <bool other_is_const, class OtherIterator>
     bool
-    operator!=(aged_container_iterator<other_is_const, OtherIterator> const&
+    operator!=(aged_container_iterator<other_is_const, OtherIterator> const& other) const
-                   other) const
     {
         return m_iter != other.m_iter;
     }

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

@@ -17,16 +17,11 @@ namespace detail {
 
 template <class T>
 struct is_empty_base_optimization_derived
-    : std::integral_constant<
+    : std::integral_constant<bool, std::is_empty<T>::value && !boost::is_final<T>::value>
-          bool,
-          std::is_empty<T>::value && !boost::is_final<T>::value>
 {
 };
 
-template <
+template <class T, int UniqueID = 0, bool isDerived = is_empty_base_optimization_derived<T>::value>
-    class T,
-    int UniqueID = 0,
-    bool isDerived = is_empty_base_optimization_derived<T>::value>
 class empty_base_optimization : private T
 {
 public:

include/xrpl/beast/core/CurrentThreadName.h

@@ -35,9 +35,7 @@ template <std::size_t N>
 void
 setCurrentThreadName(char const (&newThreadName)[N])
 {
-    static_assert(
+    static_assert(N <= maxThreadNameLength + 1, "Thread name cannot exceed 15 characters");
-        N <= maxThreadNameLength + 1,
-        "Thread name cannot exceed 15 characters");
 
     setCurrentThreadName(std::string_view(newThreadName, N - 1));
 }

include/xrpl/beast/core/LexicalCast.h

@@ -40,8 +40,7 @@ struct LexicalCast<std::string, In>
     std::enable_if_t<std::is_enum_v<Enumeration>, bool>
     operator()(std::string& out, Enumeration in)
     {
-        out = std::to_string(
+        out = std::to_string(static_cast<std::underlying_type_t<Enumeration>>(in));
-            static_cast<std::underlying_type_t<Enumeration>>(in));
         return true;
     }
 };
@@ -52,14 +51,10 @@ struct LexicalCast<Out, std::string_view>
 {
     explicit LexicalCast() = default;
 
-    static_assert(
+    static_assert(std::is_integral_v<Out>, "beast::LexicalCast can only be used with integral types");
-        std::is_integral_v<Out>,
-        "beast::LexicalCast can only be used with integral types");
 
     template <class Integral = Out>
-    std::enable_if_t<
+    std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, bool>
-        std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>,
-        bool>
     operator()(Integral& out, std::string_view in) const
     {
         auto first = in.data();
@@ -79,10 +74,9 @@ struct LexicalCast<Out, std::string_view>
         std::string result;
 
         // Convert the input to lowercase
-        std::transform(
+        std::transform(in.begin(), in.end(), std::back_inserter(result), [](auto c) {
-            in.begin(), in.end(), std::back_inserter(result), [](auto c) {
+            return std::tolower(static_cast<unsigned char>(c));
-                return std::tolower(static_cast<unsigned char>(c));
+        });
-            });
 
         if (result == "1" || result == "true")
         {
@@ -140,8 +134,7 @@ struct LexicalCast<Out, char const*>
     bool
     operator()(Out& out, char const* in) const
     {
-        XRPL_ASSERT(
+        XRPL_ASSERT(in, "beast::detail::LexicalCast(char const*) : non-null input");
-            in, "beast::detail::LexicalCast(char const*) : non-null input");
         return LexicalCast<Out, std::string_view>()(out, in);
     }
 };

include/xrpl/beast/core/List.h

@@ -55,8 +55,7 @@ class ListIterator
 {
 public:
     using iterator_category = std::bidirectional_iterator_tag;
-    using value_type =
+    using value_type = typename beast::detail::CopyConst<N, typename N::value_type>::type;
-        typename beast::detail::CopyConst<N, typename N::value_type>::type;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
     using reference = value_type&;

include/xrpl/beast/core/LockFreeStack.h

@@ -14,21 +14,16 @@ class LockFreeStackIterator
 {
 protected:
     using Node = typename Container::Node;
-    using NodePtr =
+    using NodePtr = typename std::conditional<IsConst, Node const*, Node*>::type;
-        typename std::conditional<IsConst, Node const*, Node*>::type;
 
 public:
     using iterator_category = std::forward_iterator_tag;
     using value_type = typename Container::value_type;
     using difference_type = typename Container::difference_type;
-    using pointer = typename std::conditional<
+    using pointer =
-        IsConst,
+        typename std::conditional<IsConst, typename Container::const_pointer, typename Container::pointer>::type;
-        typename Container::const_pointer,
+    using reference =
-        typename Container::pointer>::type;
+        typename std::conditional<IsConst, typename Container::const_reference, typename Container::reference>::type;
-    using reference = typename std::conditional<
-        IsConst,
-        typename Container::const_reference,
-        typename Container::reference>::type;
 
     LockFreeStackIterator() : m_node()
     {
@@ -39,9 +34,7 @@ public:
     }
 
     template <bool OtherIsConst>
-    explicit LockFreeStackIterator(
+    explicit LockFreeStackIterator(LockFreeStackIterator<Container, OtherIsConst> const& other) : m_node(other.m_node)
-        LockFreeStackIterator<Container, OtherIsConst> const& other)
-        : m_node(other.m_node)
     {
     }
 
@@ -160,8 +153,7 @@ public:
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
     using iterator = LockFreeStackIterator<LockFreeStack<Element, Tag>, false>;
-    using const_iterator =
+    using const_iterator = LockFreeStackIterator<LockFreeStack<Element, Tag>, true>;
-        LockFreeStackIterator<LockFreeStack<Element, Tag>, true>;
 
     LockFreeStack() : m_end(nullptr), m_head(&m_end)
     {
@@ -199,11 +191,7 @@ public:
         {
             first = (old_head == &m_end);
             node->m_next = old_head;
-        } while (!m_head.compare_exchange_strong(
+        } while (!m_head.compare_exchange_strong(old_head, node, std::memory_order_release, std::memory_order_relaxed));
-            old_head,
-            node,
-            std::memory_order_release,
-            std::memory_order_relaxed));
         return first;
     }
 
@@ -226,11 +214,7 @@ public:
             if (node == &m_end)
                 return nullptr;
             new_head = node->m_next.load();
-        } while (!m_head.compare_exchange_strong(
+        } while (!m_head.compare_exchange_strong(node, new_head, std::memory_order_release, std::memory_order_relaxed));
-            node,
-            new_head,
-            std::memory_order_release,
-            std::memory_order_relaxed));
         return static_cast<Element*>(node);
     }
 

include/xrpl/beast/hash/hash_append.h

@@ -27,8 +27,7 @@ template <class T>
 inline void
 reverse_bytes(T& t)
 {
-    unsigned char* bytes = static_cast<unsigned char*>(
+    unsigned char* bytes = static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
-        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]);
 }
@@ -53,11 +52,7 @@ template <class T, class Hasher>
 inline void
 maybe_reverse_bytes(T& t, Hasher&)
 {
-    maybe_reverse_bytes(
+    maybe_reverse_bytes(t, std::integral_constant<bool, Hasher::endian != boost::endian::order::native>{});
-        t,
-        std::integral_constant<
-            bool,
-            Hasher::endian != boost::endian::order::native>{});
 }
 
 }  // namespace detail
@@ -71,10 +66,8 @@ maybe_reverse_bytes(T& t, Hasher&)
 
 template <class T>
 struct is_uniquely_represented
-    : public std::integral_constant<
+    : public std::
-          bool,
+          integral_constant<bool, std::is_integral<T>::value || std::is_enum<T>::value || std::is_pointer<T>::value>
-          std::is_integral<T>::value || std::is_enum<T>::value ||
-              std::is_pointer<T>::value>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -92,8 +85,7 @@ struct is_uniquely_represented<T volatile> : public is_uniquely_represented<T>
 };
 
 template <class T>
-struct is_uniquely_represented<T const volatile>
+struct is_uniquely_represented<T const volatile> : public is_uniquely_represented<T>
-    : public is_uniquely_represented<T>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -104,8 +96,7 @@ template <class T, class U>
 struct is_uniquely_represented<std::pair<T, U>>
     : public std::integral_constant<
           bool,
-          is_uniquely_represented<T>::value &&
+          is_uniquely_represented<T>::value && is_uniquely_represented<U>::value &&
-              is_uniquely_represented<U>::value &&
               sizeof(T) + sizeof(U) == sizeof(std::pair<T, U>)>
 {
     explicit is_uniquely_represented() = default;
@@ -117,8 +108,7 @@ template <class... T>
 struct is_uniquely_represented<std::tuple<T...>>
     : public std::integral_constant<
           bool,
-          std::conjunction_v<is_uniquely_represented<T>...> &&
+          std::conjunction_v<is_uniquely_represented<T>...> && sizeof(std::tuple<T...>) == (sizeof(T) + ...)>
-              sizeof(std::tuple<T...>) == (sizeof(T) + ...)>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -135,10 +125,8 @@ struct is_uniquely_represented<T[N]> : public is_uniquely_represented<T>
 
 template <class T, std::size_t N>
 struct is_uniquely_represented<std::array<T, N>>
-    : public std::integral_constant<
+    : public std::
-          bool,
+          integral_constant<bool, is_uniquely_represented<T>::value && sizeof(T) * N == sizeof(std::array<T, N>)>
-          is_uniquely_represented<T>::value &&
-              sizeof(T) * N == sizeof(std::array<T, N>)>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -158,12 +146,10 @@ struct is_uniquely_represented<std::array<T, N>>
 */
 /** @{ */
 template <class T, class HashAlgorithm>
-struct is_contiguously_hashable
+struct is_contiguously_hashable : public std::integral_constant<
-    : public std::integral_constant<
+                                      bool,
-          bool,
+                                      is_uniquely_represented<T>::value &&
-          is_uniquely_represented<T>::value &&
+                                          (sizeof(T) == 1 || HashAlgorithm::endian == boost::endian::order::native)>
-              (sizeof(T) == 1 ||
-               HashAlgorithm::endian == boost::endian::order::native)>
 {
     explicit is_contiguously_hashable() = default;
 };
@@ -173,8 +159,7 @@ struct is_contiguously_hashable<T[N], HashAlgorithm>
     : public std::integral_constant<
           bool,
           is_uniquely_represented<T[N]>::value &&
-              (sizeof(T) == 1 ||
+              (sizeof(T) == 1 || HashAlgorithm::endian == boost::endian::order::native)>
-               HashAlgorithm::endian == boost::endian::order::native)>
 {
     explicit is_contiguously_hashable() = default;
 };
@@ -219,8 +204,7 @@ hash_append(Hasher& h, T const& t) noexcept
 template <class Hasher, class T>
 inline std::enable_if_t<
     !is_contiguously_hashable<T, Hasher>::value &&
-    (std::is_integral<T>::value || std::is_pointer<T>::value ||
+    (std::is_integral<T>::value || std::is_pointer<T>::value || std::is_enum<T>::value)>
-     std::is_enum<T>::value)>
 hash_append(Hasher& h, T t) noexcept
 {
     detail::reverse_bytes(t);
@@ -254,15 +238,11 @@ hash_append(Hasher& h, T (&a)[N]) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
 std::enable_if_t<!is_contiguously_hashable<CharT, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
-    Hasher& h,
-    std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
 std::enable_if_t<is_contiguously_hashable<CharT, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
-    Hasher& h,
-    std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class T, class U>
 std::enable_if_t<!is_contiguously_hashable<std::pair<T, U>, Hasher>::value>
@@ -294,14 +274,10 @@ hash_append(Hasher& h, std::unordered_set<Key, Hash, Pred, Alloc> const& s);
 
 template <class Hasher, class Key, class Compare, class Alloc>
 std::enable_if_t<!is_contiguously_hashable<Key, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
-    Hasher& h,
-    boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
 template <class Hasher, class Key, class Compare, class Alloc>
 std::enable_if_t<is_contiguously_hashable<Key, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
-    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;
@@ -320,9 +296,7 @@ hash_append(Hasher& h, T (&a)[N]) noexcept
 
 template <class Hasher, class CharT, class Traits, class Alloc>
 inline std::enable_if_t<!is_contiguously_hashable<CharT, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    Hasher& h,
-    std::basic_string<CharT, Traits, Alloc> const& s) noexcept
 {
     for (auto c : s)
         hash_append(h, c);
@@ -331,9 +305,7 @@ hash_append(
 
 template <class Hasher, class CharT, class Traits, class Alloc>
 inline std::enable_if_t<is_contiguously_hashable<CharT, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    Hasher& h,
-    std::basic_string<CharT, Traits, Alloc> const& s) noexcept
 {
     h(s.data(), s.size() * sizeof(CharT));
     hash_append(h, s.size());
@@ -342,8 +314,7 @@ hash_append(
 // pair
 
 template <class Hasher, class T, class U>
-inline std::enable_if_t<
+inline std::enable_if_t<!is_contiguously_hashable<std::pair<T, U>, Hasher>::value>
-    !is_contiguously_hashable<std::pair<T, U>, Hasher>::value>
 hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
 {
     hash_append(h, p.first, p.second);
@@ -380,18 +351,14 @@ hash_append(Hasher& h, std::array<T, N> const& a) noexcept
 
 template <class Hasher, class Key, class Compare, class Alloc>
 std::enable_if_t<!is_contiguously_hashable<Key, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    Hasher& h,
-    boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
 {
     for (auto const& t : v)
         hash_append(h, t);
 }
 template <class Hasher, class Key, class Compare, class Alloc>
 std::enable_if_t<is_contiguously_hashable<Key, Hasher>::value>
-hash_append(
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    Hasher& h,
-    boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
 {
     h(&(v.begin()), v.size() * sizeof(Key));
 }
@@ -414,10 +381,7 @@ hash_one(Hasher& h, T const& t) noexcept
 
 template <class Hasher, class... T, std::size_t... I>
 inline void
-tuple_hash(
+tuple_hash(Hasher& h, std::tuple<T...> const& t, std::index_sequence<I...>) noexcept
-    Hasher& h,
-    std::tuple<T...> const& t,
-    std::index_sequence<I...>) noexcept
 {
     for_each_item(hash_one(h, std::get<I>(t))...);
 }
@@ -425,8 +389,7 @@ tuple_hash(
 }  // namespace detail
 
 template <class Hasher, class... T>
-inline std::enable_if_t<
+inline std::enable_if_t<!is_contiguously_hashable<std::tuple<T...>, Hasher>::value>
-    !is_contiguously_hashable<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...>{});
@@ -452,9 +415,7 @@ hash_append(Hasher& h, std::chrono::duration<Rep, Period> const& d) noexcept
 
 template <class Hasher, class Clock, class Duration>
 inline void
-hash_append(
+hash_append(Hasher& h, std::chrono::time_point<Clock, Duration> const& tp) noexcept
-    Hasher& h,
-    std::chrono::time_point<Clock, Duration> const& tp) noexcept
 {
     hash_append(h, tp.time_since_epoch());
 }

include/xrpl/beast/hash/xxhasher.h

@@ -49,8 +49,7 @@ private:
         {
             std::memcpy(writeBuffer_.data(), data, len);
             writeBuffer_ = writeBuffer_.subspan(len);
-            readBuffer_ = std::span{
+            readBuffer_ = std::span{std::begin(buffer_), buffer_.size() - writeBuffer_.size()};
-                std::begin(buffer_), buffer_.size() - writeBuffer_.size()};
         }
     }
 
@@ -98,8 +97,7 @@ private:
         {
             if (seed_.has_value())
             {
-                return XXH3_64bits_withSeed(
+                return XXH3_64bits_withSeed(readBuffer_.data(), readBuffer_.size(), *seed_);
-                    readBuffer_.data(), readBuffer_.size(), *seed_);
             }
             else
             {
@@ -128,17 +126,13 @@ public:
         }
     }
 
-    template <
+    template <class Seed, std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
-        class Seed,
-        std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
     explicit xxhasher(Seed seed) : seed_(seed)
     {
         resetBuffers();
     }
 
-    template <
+    template <class Seed, std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
-        class Seed,
-        std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
     xxhasher(Seed seed, Seed) : seed_(seed)
     {
         resetBuffers();

include/xrpl/beast/insight/StatsDCollector.h

@@ -23,9 +23,7 @@ public:
         @param journal Destination for logging output.
     */
     static std::shared_ptr<StatsDCollector>
-    New(IP::Endpoint const& address,
+    New(IP::Endpoint const& address, std::string const& prefix, Journal journal);
-        std::string const& prefix,
-        Journal journal);
 };
 
 }  // namespace insight

include/xrpl/beast/rfc2616.h

@@ -26,8 +26,7 @@ struct ci_equal_pred
     operator()(char c1, char c2)
     {
         // VFALCO TODO Use a table lookup here
-        return std::tolower(static_cast<unsigned char>(c1)) ==
+        return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2));
-            std::tolower(static_cast<unsigned char>(c2));
     }
 };
 
@@ -97,8 +96,7 @@ trim_right(String const& s)
 */
 template <
     class FwdIt,
-    class Result = std::vector<
+    class Result = std::vector<std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>,
-        std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>,
     class Char>
 Result
 split(FwdIt first, FwdIt last, Char delim)
@@ -172,10 +170,7 @@ split(FwdIt first, FwdIt last, Char delim)
     return result;
 }
 
-template <
+template <class FwdIt, class Result = std::vector<std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>>
-    class FwdIt,
-    class Result = std::vector<
-        std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>>
 Result
 split_commas(FwdIt first, FwdIt last)
 {
@@ -223,8 +218,7 @@ public:
     bool
     operator==(list_iterator const& other) const
     {
-        return other.it_ == it_ && other.end_ == end_ &&
+        return other.it_ == it_ && other.end_ == end_ && other.value_.size() == value_.size();
-            other.value_.size() == value_.size();
     }
 
     bool
@@ -288,14 +282,12 @@ list_iterator::increment()
                     ++it_;
                     if (it_ == end_)
                     {
-                        value_ = boost::string_ref(
+                        value_ = boost::string_ref(&*start, std::distance(start, it_));
-                            &*start, std::distance(start, it_));
                         return;
                     }
                     if (*it_ == '"')
                     {
-                        value_ = boost::string_ref(
+                        value_ = boost::string_ref(&*start, std::distance(start, it_));
-                            &*start, std::distance(start, it_));
                         ++it_;
                         return;
                     }
@@ -321,8 +313,7 @@ list_iterator::increment()
                 ++it_;
                 if (it_ == end_ || *it_ == ',' || is_lws(*it_))
                 {
-                    value_ =
+                    value_ = boost::string_ref(&*start, std::distance(start, it_));
-                        boost::string_ref(&*start, std::distance(start, it_));
                     return;
                 }
             }
@@ -344,8 +335,7 @@ inline boost::iterator_range<list_iterator>
 make_list(boost::string_ref const& field)
 {
     return boost::iterator_range<list_iterator>{
-        list_iterator{field.begin(), field.end()},
+        list_iterator{field.begin(), field.end()}, list_iterator{field.end(), field.end()}};
-        list_iterator{field.end(), field.end()}};
 }
 
 /** Returns true if the specified token exists in the list.
@@ -367,12 +357,8 @@ bool
 is_keep_alive(boost::beast::http::message<isRequest, Body, Fields> const& m)
 {
     if (m.version() <= 10)
-        return boost::beast::http::token_list{
+        return boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists("keep-alive");
-            m[boost::beast::http::field::connection]}
+    return !boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists("close");
-            .exists("keep-alive");
-    return !boost::beast::http::token_list{
-        m[boost::beast::http::field::connection]}
-                .exists("close");
 }
 
 }  // namespace rfc2616

include/xrpl/beast/test/yield_to.h

@@ -31,9 +31,7 @@ protected:
     boost::asio::io_context ios_;
 
 private:
-    boost::optional<boost::asio::executor_work_guard<
+    boost::optional<boost::asio::executor_work_guard<boost::asio::io_context::executor_type>> work_;
-        boost::asio::io_context::executor_type>>
-        work_;
     std::vector<std::thread> threads_;
     std::mutex m_;
     std::condition_variable cv_;
@@ -43,8 +41,7 @@ public:
     /// The type of yield context passed to functions.
     using yield_context = boost::asio::yield_context;
 
-    explicit enable_yield_to(std::size_t concurrency = 1)
+    explicit enable_yield_to(std::size_t concurrency = 1) : work_(boost::asio::make_work_guard(ios_))
-        : work_(boost::asio::make_work_guard(ios_))
     {
         threads_.reserve(concurrency);
         while (concurrency--)

include/xrpl/beast/unit_test/global_suites.h

@@ -23,12 +23,7 @@ global_suites()
 template <class Suite>
 struct insert_suite
 {
-    insert_suite(
+    insert_suite(char const* name, char const* module, char const* library, bool manual, int priority)
-        char const* name,
-        char const* module,
-        char const* library,
-        bool manual,
-        int priority)
     {
         global_suites().insert<Suite>(name, module, library, manual, priority);
     }