fix clang-tidy issues

Co-authored-by: Bart <11445373+bthomee@users.noreply.github.com>
Co-authored-by: Bart <bthomee@users.noreply.github.com>

.clang-tidy

@@ -97,9 +97,21 @@ Checks: "-*,
   misc-throw-by-value-catch-by-reference,
   misc-unused-alias-decls,
   misc-unused-using-decls,
-  modernize-deprecated-headers,
+  modernize-concat-nested-namespaces,
   modernize-make-shared,
   modernize-make-unique,
+  modernize-pass-by-value,
+  modernize-type-traits,
+  modernize-use-designated-initializers,
+  modernize-use-emplace,
+  modernize-use-equals-default,
+  modernize-use-equals-delete,
+  modernize-use-override,
+  modernize-use-ranges,
+  modernize-use-starts-ends-with,
+  modernize-use-std-numbers,
+  modernize-use-using,
+  modernize-deprecated-headers,
   llvm-namespace-comment,
   performance-faster-string-find,
   performance-for-range-copy,
@@ -141,19 +153,6 @@ Checks: "-*,
 # readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names
 # readability-static-accessed-through-instance,        # this check is probably unnecessary. it makes the code less readable
 # readability-identifier-naming,                       # https://github.com/XRPLF/rippled/pull/6571
-#
-# modernize-concat-nested-namespaces,
-# modernize-pass-by-value,
-# modernize-type-traits,
-# modernize-use-designated-initializers,
-# modernize-use-emplace,
-# modernize-use-equals-default,
-# modernize-use-equals-delete,
-# modernize-use-override,
-# modernize-use-ranges,
-# modernize-use-starts-ends-with,
-# modernize-use-std-numbers,
-# modernize-use-using,
 # ---
 #
 CheckOptions:

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

@@ -90,8 +90,21 @@ jobs:
           path: clang-tidy-output.txt
           retention-days: 30
 
+      - name: Generate git diff
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
+        run: |
+          git diff | tee clang-tidy-git-diff.txt
+
+      - name: Upload clang-tidy diff output
+        if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: clang-tidy-git-diff
+          path: clang-tidy-git-diff.txt
+          retention-days: 30
+
       - name: Create an issue
-        if: steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure
+        if: ${{ steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure }}
         id: create_issue
         shell: bash
         env:
@@ -156,7 +169,7 @@ jobs:
           rm -f create_issue.log issue.md clang-tidy-output.txt
 
       - name: Fail the workflow if clang-tidy failed
-        if: steps.run_clang_tidy.outcome != 'success'
+        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
         run: |
           echo "Clang-tidy check failed!"
           exit 1

cfg/xrpld-example.cfg

@@ -1416,6 +1416,12 @@
 #       in this section to a comma-separated list of the addresses
 #       of your Clio servers, in order to bypass xrpld's rate limiting.
 #
+#       TLS/SSL can be enabled for gRPC by specifying ssl_cert and ssl_key.
+#       Both parameters must be provided together. The ssl_cert_chain parameter
+#       is optional and provides intermediate CA certificates for the certificate
+#       chain. The ssl_client_ca parameter is optional and enables mutual TLS
+#       (client certificate verification).
+#
 #   This port is commented out but can be enabled by removing
 #   the '#' from each corresponding line including the entry under [server]
 #
@@ -1465,11 +1471,74 @@ admin = 127.0.0.1
 protocol = ws
 send_queue_limit = 500
 
+# gRPC TLS/SSL Configuration
+#
+#   The gRPC port supports optional TLS/SSL encryption. When TLS is not
+#   configured, the gRPC server will accept unencrypted connections.
+#
+#   ssl_cert = <filename>
+#   ssl_key = <filename>
+#
+#       To enable TLS for gRPC, both ssl_cert and ssl_key must be specified.
+#       If only one is provided, xrpld will fail to start.
+#
+#       ssl_cert: Path to the server's SSL certificate file in PEM format.
+#       ssl_key:  Path to the server's SSL private key file in PEM format.
+#
+#       When configured, the gRPC server will only accept TLS-encrypted
+#       connections. Clients must use TLS (secure) channel credentials rather
+#       than plaintext / insecure connections.
+#
+#   ssl_cert_chain = <filename>
+#
+#       Optional. Path to intermediate CA certificate(s) in PEM format that
+#       complete the server's certificate chain.
+#
+#       This file should contain the intermediate CA certificate(s) needed
+#       to build a trust chain from the server certificate (ssl_cert) to a
+#       root CA that clients trust. Multiple certificates should be
+#       concatenated in PEM format.
+#
+#       This is needed when your server certificate was signed by an
+#       intermediate CA rather than directly by a root CA. Without this,
+#       clients may fail to verify your server certificate.
+#
+#       If not specified, only the server certificate from ssl_cert will be
+#       presented to clients.
+#
+#   ssl_client_ca = <filename>
+#
+#       Optional. Path to a CA certificate file in PEM format for verifying
+#       client certificates (mutual TLS / mTLS).
+#
+#       When specified, the gRPC server will verify client certificates
+#       against this CA. This enables mutual authentication where both the
+#       server and client verify each other's identity.
+#
+#       This is typically NOT needed for public-facing gRPC servers. Only
+#       use this if you want to restrict access to clients with valid
+#       certificates signed by the specified CA.
+#
+#       If not specified, the server will use one-way TLS (server
+#       authentication only) and will accept connections from any client.
+#
 [port_grpc]
 port = 50051
 ip = 127.0.0.1
 secure_gateway = 127.0.0.1
 
+# Optional TLS/SSL configuration for gRPC
+# To enable TLS, uncomment and configure both ssl_cert and ssl_key:
+#ssl_cert = /etc/ssl/certs/grpc-server.crt
+#ssl_key = /etc/ssl/private/grpc-server.key
+
+# Optional: Include intermediate CA certificates for complete certificate chain
+#ssl_cert_chain = /etc/ssl/certs/grpc-intermediate-ca.crt
+
+# Optional: Enable mutual TLS (client certificate verification)
+# Uncomment to require and verify client certificates:
+#ssl_client_ca = /etc/ssl/certs/grpc-client-ca.crt
+
 #[port_ws_public]
 #port = 6005
 #ip = 127.0.0.1

include/xrpl/basics/BasicConfig.h

@@ -33,7 +33,7 @@ private:
 
 public:
     /** Create an empty section. */
-    explicit Section(std::string const& name = "");
+    explicit Section(std::string name = "");
 
     /** Returns the name of this section. */
     std::string const&
@@ -275,8 +275,7 @@ public:
     bool
     had_trailing_comments() const
     {
-        return std::any_of(
-            map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
+        return std::ranges::any_of(map_, [](auto s) { return s.second.had_trailing_comments(); });
     }
 
 protected:

include/xrpl/basics/Buffer.h

@@ -92,7 +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.data() >= p_.get() + size_,
+            s.empty() || size_ == 0 || s.data() < p_.get() || s.data() >= p_.get() + size_,
             "xrpl::Buffer::operator=(Slice) : input not a subset");
 
         if (auto p = alloc(s.size()))

include/xrpl/basics/CompressionAlgorithms.h

@@ -9,9 +9,7 @@
 #include <stdexcept>
 #include <vector>
 
-namespace xrpl {
-
-namespace compression_algorithms {
+namespace xrpl::compression_algorithms {
 
 /** LZ4 block compression.
  * @tparam BufferFactory Callable object or lambda.
@@ -141,6 +139,4 @@ lz4Decompress(
     return lz4Decompress(chunk, inSize, decompressed, decompressedSize);
 }
 
-}  // namespace compression_algorithms
-
-}  // namespace xrpl
+}  // namespace xrpl::compression_algorithms

include/xrpl/basics/Expected.h

@@ -61,7 +61,7 @@ template <class E>
 class Unexpected
 {
 public:
-    static_assert(!std::is_same<E, void>::value, "E must not be void");
+    static_assert(!std::is_same_v<E, void>, "E must not be void");
 
     Unexpected() = delete;
 

include/xrpl/basics/LocalValue.h

@@ -4,6 +4,7 @@
 
 #include <memory>
 #include <unordered_map>
+#include <utility>
 
 namespace xrpl {
 
@@ -28,7 +29,7 @@ struct LocalValues
         T t_;
 
         Value() = default;
-        explicit Value(T const& t) : t_(t)
+        explicit Value(T t) : t_(std::move(t))
         {
         }
 

include/xrpl/basics/Log.h

@@ -38,7 +38,7 @@ private:
         std::string partition_;
 
     public:
-        Sink(std::string const& partition, beast::severities::Severity thresh, Logs& logs);
+        Sink(std::string partition, beast::severities::Severity thresh, Logs& logs);
 
         Sink(Sink const&) = delete;
         Sink&

include/xrpl/basics/SlabAllocator.h

@@ -66,12 +66,10 @@ class SlabAllocator
             }
         }
 
-        ~SlabBlock()
-        {
-            // Calling this destructor will release the allocated memory but
-            // will not properly destroy any objects that are constructed in
-            // the block itself.
-        }
+        // Calling this destructor will release the allocated memory but
+        // will not properly destroy any objects that are constructed in
+        // the block itself.
+        ~SlabBlock() = default;
 
         SlabBlock(SlabBlock const& other) = delete;
         SlabBlock&
@@ -176,12 +174,10 @@ public:
     SlabAllocator&
     operator=(SlabAllocator&& other) = delete;
 
-    ~SlabAllocator()
-    {
-        // FIXME: We can't destroy the memory blocks we've allocated, because
-        //        we can't be sure that they are not being used. Cleaning the
-        //        shutdown process up could make this possible.
-    }
+    // FIXME: We can't destroy the memory blocks we've allocated, because
+    //        we can't be sure that they are not being used. Cleaning the
+    //        shutdown process up could make this possible.
+    ~SlabAllocator() = default;
 
     /** Returns the size of the memory block this allocator returns. */
     constexpr std::size_t
@@ -347,9 +343,7 @@ public:
     SlabAllocatorSet&
     operator=(SlabAllocatorSet&& other) = delete;
 
-    ~SlabAllocatorSet()
-    {
-    }
+    ~SlabAllocatorSet() = default;
 
     /** Returns a suitably aligned pointer, if one is available.
 

include/xrpl/basics/Slice.h

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

include/xrpl/basics/TaggedCache.h

@@ -251,7 +251,7 @@ private:
         }
     };
 
-    typedef typename std::conditional<IsKeyCache, KeyOnlyEntry, ValueEntry>::type Entry;
+    using Entry = std::conditional_t<IsKeyCache, KeyOnlyEntry, ValueEntry>;
 
     using KeyOnlyCacheType = hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>;
 

include/xrpl/basics/ToString.h

@@ -12,7 +12,7 @@ namespace xrpl {
  */
 
 template <class T>
-typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type
+std::enable_if_t<std::is_arithmetic_v<T>, std::string>
 to_string(T t)
 {
     return std::to_string(t);

include/xrpl/basics/base_uint.h

@@ -269,7 +269,7 @@ public:
         class Container,
         class = std::enable_if_t<
             detail::is_contiguous_container<Container>::value &&
-            std::is_trivially_copyable<typename Container::value_type>::value>>
+            std::is_trivially_copyable_v<typename Container::value_type>>>
     explicit base_uint(Container const& c)
     {
         XRPL_ASSERT(
@@ -281,7 +281,7 @@ public:
     template <class Container>
     std::enable_if_t<
         detail::is_contiguous_container<Container>::value &&
-            std::is_trivially_copyable<typename Container::value_type>::value,
+            std::is_trivially_copyable_v<typename Container::value_type>,
         base_uint&>
     operator=(Container const& c)
     {

include/xrpl/basics/contract.h

@@ -49,8 +49,7 @@ template <class E, class... Args>
 Throw(Args&&... args)
 {
     static_assert(
-        std::is_convertible<E*, std::exception*>::value,
-        "Exception must derive from std::exception.");
+        std::is_convertible_v<E*, std::exception*>, "Exception must derive from std::exception.");
 
     E e(std::forward<Args>(args)...);
     LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());

include/xrpl/basics/random.h

@@ -15,8 +15,8 @@ namespace xrpl {
 #ifndef __INTELLISENSE__
 static_assert(
     // NOLINTNEXTLINE(misc-redundant-expression)
-    std::is_integral<beast::xor_shift_engine::result_type>::value &&
-        std::is_unsigned<beast::xor_shift_engine::result_type>::value,
+    std::is_integral_v<beast::xor_shift_engine::result_type> &&
+        std::is_unsigned_v<beast::xor_shift_engine::result_type>,
     "The XRPL default PRNG engine must return an unsigned integral type.");
 
 static_assert(
@@ -91,7 +91,7 @@ default_prng()
 */
 /** @{ */
 template <class Engine, class Integral>
-std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
+std::enable_if_t<std::is_integral_v<Integral> && 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");
@@ -103,35 +103,35 @@ rand_int(Engine& engine, Integral min, Integral max)
 }
 
 template <class Integral>
-std::enable_if_t<std::is_integral<Integral>::value, Integral>
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 rand_int(Integral min, Integral max)
 {
     return rand_int(default_prng(), min, max);
 }
 
 template <class Engine, class Integral>
-std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 rand_int(Engine& engine, Integral max)
 {
     return rand_int(engine, Integral(0), max);
 }
 
 template <class Integral>
-std::enable_if_t<std::is_integral<Integral>::value, Integral>
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 rand_int(Integral max)
 {
     return rand_int(default_prng(), max);
 }
 
 template <class Integral, class Engine>
-std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 rand_int(Engine& engine)
 {
     return rand_int(engine, std::numeric_limits<Integral>::max());
 }
 
 template <class Integral = int>
-std::enable_if_t<std::is_integral<Integral>::value, Integral>
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 rand_int()
 {
     return rand_int(default_prng(), std::numeric_limits<Integral>::max());
@@ -142,7 +142,7 @@ rand_int()
 /** @{ */
 template <class Byte, class Engine>
 std::enable_if_t<
-    (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value) &&
+    (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
         detail::is_engine<Engine>::value,
     Byte>
 rand_byte(Engine& engine)
@@ -152,9 +152,7 @@ rand_byte(Engine& engine)
 }
 
 template <class Byte = std::uint8_t>
-std::enable_if_t<
-    (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value),
-    Byte>
+std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
 rand_byte()
 {
     return rand_byte<Byte>(default_prng());

include/xrpl/basics/safe_cast.h

@@ -12,9 +12,9 @@ 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 ? sizeof(Dest) > sizeof(Src)
-                                                               : sizeof(Dest) >= sizeof(Src));
+    (std::is_signed_v<Src> || std::is_unsigned_v<Dest>) &&
+    (std::is_signed_v<Src> != std::is_signed_v<Dest> ? sizeof(Dest) > sizeof(Src)
+                                                     : sizeof(Dest) >= sizeof(Src));
 
 template <class Dest, class Src>
 constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>

include/xrpl/basics/strHex.h

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

include/xrpl/basics/tagged_integer.h

@@ -44,8 +44,7 @@ public:
 
     template <
         class OtherInt,
-        class = typename std::enable_if<
-            std::is_integral<OtherInt>::value && sizeof(OtherInt) <= sizeof(Int)>::type>
+        class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
     explicit constexpr tagged_integer(OtherInt value) noexcept : m_value(value)
     {
         static_assert(sizeof(tagged_integer) == sizeof(Int), "tagged_integer is adding padding");

include/xrpl/beast/container/aged_container_utility.h

@@ -9,7 +9,7 @@ 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>::type
+std::enable_if_t<is_aged_container<AgedContainer>::value, std::size_t>
 expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
 {
     std::size_t n(0);

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

@@ -1,7 +1,6 @@
 #pragma once
 
-namespace beast {
-namespace detail {
+namespace beast::detail {
 
 // Extracts the key portion of value
 template <bool maybe_map>
@@ -30,5 +29,4 @@ struct aged_associative_container_extract_t<false>
     }
 };
 
-}  // namespace detail
-}  // namespace beast
+}  // namespace beast::detail

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

@@ -2,6 +2,7 @@
 
 #include <iterator>
 #include <type_traits>
+#include <utility>
 
 namespace beast {
 
@@ -131,7 +132,7 @@ private:
     friend class aged_container_iterator;
 
     template <class OtherIterator>
-    aged_container_iterator(OtherIterator const& iter) : m_iter(iter)
+    aged_container_iterator(OtherIterator iter) : m_iter(std::move(iter))
     {
     }
 

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

@@ -57,8 +57,7 @@ template <
     class T,
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
-    class Allocator =
-        std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
+    class Allocator = std::allocator<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>
 class aged_ordered_container
 {
 public:
@@ -67,7 +66,7 @@ public:
     using duration = typename clock_type::duration;
     using key_type = Key;
     using mapped_type = T;
-    using value_type = typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type;
+    using value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>;
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
 
@@ -110,8 +109,7 @@ private:
 
         template <
             class... Args,
-            class =
-                typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
+            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
         element(time_point const& when_, Args&&... args)
             : value(std::forward<Args>(args)...), when(when_)
         {
@@ -135,9 +133,7 @@ private:
             return Compare::operator()(lhs.first, rhs.first);
         }
 
-        pair_value_compare()
-        {
-        }
+        pair_value_compare() = default;
 
         pair_value_compare(pair_value_compare const& other) : Compare(other)
         {
@@ -200,7 +196,7 @@ private:
     using list_type = typename boost::intrusive::
         make_list<element, boost::intrusive::constant_time_size<false>>::type;
 
-    using cont_type = typename std::conditional<
+    using cont_type = std::conditional_t<
         IsMulti,
         typename boost::intrusive::make_multiset<
             element,
@@ -209,7 +205,7 @@ private:
         typename boost::intrusive::make_set<
             element,
             boost::intrusive::constant_time_size<true>,
-            boost::intrusive::compare<KeyValueCompare>>::type>::type;
+            boost::intrusive::compare<KeyValueCompare>>::type>;
 
     using ElementAllocator =
         typename std::allocator_traits<Allocator>::template rebind_alloc<element>;
@@ -374,7 +370,7 @@ private:
 
 public:
     using key_compare = Compare;
-    using value_compare = typename std::conditional<IsMap, pair_value_compare, Compare>::type;
+    using value_compare = std::conditional_t<IsMap, pair_value_compare, Compare>;
     using allocator_type = Allocator;
     using reference = value_type&;
     using const_reference = value_type const&;
@@ -402,6 +398,8 @@ public:
 
     class chronological_t
     {
+        chronological_t() = default;
+
     public:
         // A set iterator (IsMap==false) is always const
         // because the elements of a set are immutable.
@@ -489,7 +487,7 @@ public:
         iterator
         iterator_to(value_type& value)
         {
-            static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+            static_assert(std::is_standard_layout_v<element>, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element*>(
                 reinterpret_cast<uint8_t*>(&value) -
                 ((std::size_t)std::addressof(((element*)0)->member))));
@@ -498,20 +496,16 @@ public:
         const_iterator
         iterator_to(value_type const& value) const
         {
-            static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+            static_assert(std::is_standard_layout_v<element>, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element const*>(
                 reinterpret_cast<uint8_t const*>(&value) -
                 ((std::size_t)std::addressof(((element*)0)->member))));
         }
 
-    private:
-        chronological_t()
-        {
-        }
-
         chronological_t(chronological_t const&) = delete;
         chronological_t(chronological_t&&) = delete;
 
+    private:
         friend class aged_ordered_container;
         list_type mutable list;
     } chronological;
@@ -617,30 +611,30 @@ public:
         class K,
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
-    typename std::conditional<IsMap, T, void*>::type&
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
+    std::conditional_t<IsMap, T, void*>&
     at(K const& k);
 
     template <
         class K,
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
     typename std::conditional<IsMap, T, void*>::type const&
     at(K const& k) const;
 
     template <
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
-    typename std::conditional<IsMap, T, void*>::type&
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
+    std::conditional_t<IsMap, T, void*>&
     operator[](Key const& key);
 
     template <
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
-    typename std::conditional<IsMap, T, void*>::type&
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
+    std::conditional_t<IsMap, T, void*>&
     operator[](Key&& key);
 
     //--------------------------------------------------------------------------
@@ -724,7 +718,7 @@ public:
     iterator
     iterator_to(value_type& value)
     {
-        static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+        static_assert(std::is_standard_layout_v<element>, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element*>(
             reinterpret_cast<uint8_t*>(&value) -
             ((std::size_t)std::addressof(((element*)0)->member))));
@@ -733,7 +727,7 @@ public:
     const_iterator
     iterator_to(value_type const& value) const
     {
-        static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+        static_assert(std::is_standard_layout_v<element>, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element const*>(
             reinterpret_cast<uint8_t const*>(&value) -
             ((std::size_t)std::addressof(((element*)0)->member))));
@@ -775,37 +769,35 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(value_type const& value) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    insert(value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
     auto
-    insert(value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type;
+    insert(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>;
 
     // set
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) ->
-        typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
+    insert(value_type&& value)
+        -> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>;
 
     // multiset
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) ->
-        typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
+    insert(value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>;
 
     //---
 
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(const_iterator hint, value_type const& value) ->
-        typename std::enable_if<!maybe_multi, iterator>::type;
+    insert(const_iterator hint, value_type const& value)
+        -> std::enable_if_t<!maybe_multi, iterator>;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
-    typename std::enable_if<maybe_multi, iterator>::type
+    std::enable_if_t<maybe_multi, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
     {
         // VFALCO TODO Figure out how to utilize 'hint'
@@ -815,12 +807,11 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(const_iterator hint, value_type&& value) ->
-        typename std::enable_if<!maybe_multi, iterator>::type;
+    insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!maybe_multi, iterator>;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
-    typename std::enable_if<maybe_multi, iterator>::type
+    std::enable_if_t<maybe_multi, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
     {
         // VFALCO TODO Figure out how to utilize 'hint'
@@ -829,9 +820,9 @@ public:
 
     // map, multimap
     template <class P, bool maybe_map = IsMap>
-    typename std::enable_if<
-        maybe_map && std::is_constructible<value_type, P&&>::value,
-        typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
+    std::enable_if_t<
+        maybe_map && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(P&& value)
     {
         return emplace(std::forward<P>(value));
@@ -839,9 +830,9 @@ public:
 
     // map, multimap
     template <class P, bool maybe_map = IsMap>
-    typename std::enable_if<
-        maybe_map && std::is_constructible<value_type, P&&>::value,
-        typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
+    std::enable_if_t<
+        maybe_map && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(const_iterator hint, P&& value)
     {
         return emplace_hint(hint, std::forward<P>(value));
@@ -864,23 +855,22 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    emplace(Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> typename std::enable_if<maybe_multi, iterator>::type;
+    emplace(Args&&... args) -> std::enable_if_t<maybe_multi, iterator>;
 
     // map, set
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace_hint(const_iterator hint, Args&&... args) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    emplace_hint(const_iterator hint, Args&&... args)
+        -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool maybe_multi = IsMulti, class... Args>
-    typename std::enable_if<maybe_multi, iterator>::type
+    std::enable_if_t<maybe_multi, iterator>
     emplace_hint(const_iterator /*hint*/, Args&&... args)
     {
         // VFALCO TODO Figure out how to utilize 'hint'
@@ -1164,12 +1154,12 @@ private:
 
     template <
         bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    typename std::enable_if<maybe_propagate>::type
+    std::enable_if_t<maybe_propagate>
     swap_data(aged_ordered_container& other) noexcept;
 
     template <
         bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    typename std::enable_if<!maybe_propagate>::type
+    std::enable_if_t<!maybe_propagate>
     swap_data(aged_ordered_container& other) noexcept;
 
 private:
@@ -1396,7 +1386,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <class K, bool maybe_multi, bool maybe_map, class>
-typename std::conditional<IsMap, T, void*>::type&
+std::conditional_t<IsMap, T, void*>&
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k)
 {
     auto const iter(m_cont.find(k, std::cref(m_config.key_compare())));
@@ -1418,7 +1408,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
-typename std::conditional<IsMap, T, void*>::type&
+std::conditional_t<IsMap, T, void*>&
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](
     Key const& key)
 {
@@ -1437,7 +1427,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
-typename std::conditional<IsMap, T, void*>::type&
+std::conditional_t<IsMap, T, void*>&
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
 {
     typename cont_type::insert_commit_data d;
@@ -1472,8 +1462,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool maybe_multi>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) ->
-    typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(m_cont.insert_check(extract(value), std::cref(m_config.key_compare()), d));
@@ -1492,7 +1481,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool maybe_multi>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type
+    value_type const& value) -> std::enable_if_t<maybe_multi, iterator>
 {
     auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
     element* const p(new_element(value));
@@ -1506,8 +1495,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool maybe_multi, bool maybe_map>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type&& value) ->
-    typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type
+    value_type&& value) -> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(m_cont.insert_check(extract(value), std::cref(m_config.key_compare()), d));
@@ -1526,7 +1514,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool maybe_multi, bool maybe_map>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
+    value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>
 {
     auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
     element* const p(new_element(std::move(value)));
@@ -1543,7 +1531,7 @@ template <bool maybe_multi>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type const& value) -> typename std::enable_if<!maybe_multi, iterator>::type
+    value_type const& value) -> std::enable_if_t<!maybe_multi, iterator>
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1564,7 +1552,7 @@ template <bool maybe_multi>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type&& value) -> typename std::enable_if<!maybe_multi, iterator>::type
+    value_type&& value) -> std::enable_if_t<!maybe_multi, iterator>
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1584,7 +1572,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool maybe_multi, class... Args>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1606,7 +1594,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool maybe_multi, class... Args>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> typename std::enable_if<maybe_multi, iterator>::type
+    -> std::enable_if_t<maybe_multi, iterator>
 {
     element* const p(new_element(std::forward<Args>(args)...));
     auto const before(m_cont.upper_bound(extract(p->value), std::cref(m_config.key_compare())));
@@ -1621,7 +1609,7 @@ template <bool maybe_multi, class... Args>
 auto
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace_hint(
     const_iterator hint,
-    Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1771,7 +1759,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_propagate>
-typename std::enable_if<maybe_propagate>::type
+std::enable_if_t<maybe_propagate>
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_data(
     aged_ordered_container& other) noexcept
 {
@@ -1782,7 +1770,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_propagate>
-typename std::enable_if<!maybe_propagate>::type
+std::enable_if_t<!maybe_propagate>
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_data(
     aged_ordered_container& other) noexcept
 {

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

@@ -62,8 +62,7 @@ template <
     class Clock = std::chrono::steady_clock,
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
-    class Allocator =
-        std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
+    class Allocator = std::allocator<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>
 class aged_unordered_container
 {
 public:
@@ -72,7 +71,7 @@ public:
     using duration = typename clock_type::duration;
     using key_type = Key;
     using mapped_type = T;
-    using value_type = typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type;
+    using value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>;
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
 
@@ -115,8 +114,7 @@ private:
 
         template <
             class... Args,
-            class =
-                typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
+            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
         element(time_point const& when_, Args&&... args)
             : value(std::forward<Args>(args)...), when(when_)
         {
@@ -133,9 +131,7 @@ private:
         using argument_type = element;
         using result_type = size_t;
 
-        ValueHash()
-        {
-        }
+        ValueHash() = default;
 
         ValueHash(Hash const& h) : Hash(h)
         {
@@ -169,9 +165,7 @@ private:
         using second_argument_type = element;
         using result_type = bool;
 
-        KeyValueEqual()
-        {
-        }
+        KeyValueEqual() = default;
 
         KeyValueEqual(KeyEqual const& keyEqual) : KeyEqual(keyEqual)
         {
@@ -211,7 +205,7 @@ private:
     using list_type = typename boost::intrusive::
         make_list<element, boost::intrusive::constant_time_size<false>>::type;
 
-    using cont_type = typename std::conditional<
+    using cont_type = std::conditional_t<
         IsMulti,
         typename boost::intrusive::make_unordered_multiset<
             element,
@@ -224,7 +218,7 @@ private:
             boost::intrusive::constant_time_size<true>,
             boost::intrusive::hash<ValueHash>,
             boost::intrusive::equal<KeyValueEqual>,
-            boost::intrusive::cache_begin<true>>::type>::type;
+            boost::intrusive::cache_begin<true>>::type>;
 
     using bucket_type = typename cont_type::bucket_type;
     using bucket_traits = typename cont_type::bucket_traits;
@@ -662,7 +656,7 @@ public:
         iterator
         iterator_to(value_type& value)
         {
-            static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+            static_assert(std::is_standard_layout_v<element>, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element*>(
                 reinterpret_cast<uint8_t*>(&value) -
                 ((std::size_t)std::addressof(((element*)0)->member))));
@@ -671,20 +665,17 @@ public:
         const_iterator
         iterator_to(value_type const& value) const
         {
-            static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+            static_assert(std::is_standard_layout_v<element>, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element const*>(
                 reinterpret_cast<uint8_t const*>(&value) -
                 ((std::size_t)std::addressof(((element*)0)->member))));
         }
 
-    private:
-        chronological_t()
-        {
-        }
-
         chronological_t(chronological_t const&) = delete;
         chronological_t(chronological_t&&) = delete;
+        chronological_t() = default;
 
+    private:
         friend class aged_unordered_container;
         list_type mutable list;
     } chronological;
@@ -862,30 +853,30 @@ public:
         class K,
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
-    typename std::conditional<IsMap, T, void*>::type&
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
+    std::conditional_t<IsMap, T, void*>&
     at(K const& k);
 
     template <
         class K,
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
     typename std::conditional<IsMap, T, void*>::type const&
     at(K const& k) const;
 
     template <
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
-    typename std::conditional<IsMap, T, void*>::type&
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
+    std::conditional_t<IsMap, T, void*>&
     operator[](Key const& key);
 
     template <
         bool maybe_multi = IsMulti,
         bool maybe_map = IsMap,
-        class = typename std::enable_if<maybe_map && !maybe_multi>::type>
-    typename std::conditional<IsMap, T, void*>::type&
+        class = std::enable_if_t<maybe_map && !maybe_multi>>
+    std::conditional_t<IsMap, T, void*>&
     operator[](Key&& key);
 
     //--------------------------------------------------------------------------
@@ -933,7 +924,7 @@ public:
     iterator
     iterator_to(value_type& value)
     {
-        static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+        static_assert(std::is_standard_layout_v<element>, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element*>(
             reinterpret_cast<uint8_t*>(&value) -
             ((std::size_t)std::addressof(((element*)0)->member))));
@@ -942,7 +933,7 @@ public:
     const_iterator
     iterator_to(value_type const& value) const
     {
-        static_assert(std::is_standard_layout<element>::value, "must be standard layout");
+        static_assert(std::is_standard_layout_v<element>, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element const*>(
             reinterpret_cast<uint8_t const*>(&value) -
             ((std::size_t)std::addressof(((element*)0)->member))));
@@ -984,29 +975,27 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(value_type const& value) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    insert(value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
     auto
-    insert(value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type;
+    insert(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>;
 
     // map, set
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) ->
-        typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
+    insert(value_type&& value)
+        -> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) ->
-        typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
+    insert(value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>;
 
     // map, set
     template <bool maybe_multi = IsMulti>
-    typename std::enable_if<!maybe_multi, iterator>::type
+    std::enable_if_t<!maybe_multi, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
     {
         // Hint is ignored but we provide the interface so
@@ -1016,7 +1005,7 @@ public:
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
-    typename std::enable_if<maybe_multi, iterator>::type
+    std::enable_if_t<maybe_multi, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
     {
         // VFALCO TODO The hint could be used to let
@@ -1026,7 +1015,7 @@ public:
 
     // map, set
     template <bool maybe_multi = IsMulti>
-    typename std::enable_if<!maybe_multi, iterator>::type
+    std::enable_if_t<!maybe_multi, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
     {
         // Hint is ignored but we provide the interface so
@@ -1036,7 +1025,7 @@ public:
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
-    typename std::enable_if<maybe_multi, iterator>::type
+    std::enable_if_t<maybe_multi, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
     {
         // VFALCO TODO The hint could be used to let
@@ -1046,9 +1035,9 @@ public:
 
     // map, multimap
     template <class P, bool maybe_map = IsMap>
-    typename std::enable_if<
-        maybe_map && std::is_constructible<value_type, P&&>::value,
-        typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
+    std::enable_if_t<
+        maybe_map && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(P&& value)
     {
         return emplace(std::forward<P>(value));
@@ -1056,9 +1045,9 @@ public:
 
     // map, multimap
     template <class P, bool maybe_map = IsMap>
-    typename std::enable_if<
-        maybe_map && std::is_constructible<value_type, P&&>::value,
-        typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
+    std::enable_if_t<
+        maybe_map && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(const_iterator hint, P&& value)
     {
         return emplace_hint(hint, std::forward<P>(value));
@@ -1080,23 +1069,22 @@ public:
     // set, map
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    emplace(Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> typename std::enable_if<maybe_multi, iterator>::type;
+    emplace(Args&&... args) -> std::enable_if_t<maybe_multi, iterator>;
 
     // set, map
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace_hint(const_iterator /*hint*/, Args&&... args) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    emplace_hint(const_iterator /*hint*/, Args&&... args)
+        -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool maybe_multi = IsMulti, class... Args>
-    typename std::enable_if<maybe_multi, iterator>::type
+    std::enable_if_t<maybe_multi, iterator>
     emplace_hint(const_iterator /*hint*/, Args&&... args)
     {
         // VFALCO TODO The hint could be used for multi, to let
@@ -1328,7 +1316,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool maybe_multi = IsMulti>
-    typename std::enable_if<!maybe_multi, bool>::type
+    std::enable_if_t<!maybe_multi, bool>
     operator==(aged_unordered_container<
                false,
                OtherIsMap,
@@ -1347,7 +1335,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool maybe_multi = IsMulti>
-    typename std::enable_if<maybe_multi, bool>::type
+    std::enable_if_t<maybe_multi, bool>
     operator==(aged_unordered_container<
                true,
                OtherIsMap,
@@ -1401,14 +1389,13 @@ private:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert_unchecked(value_type const& value) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    insert_unchecked(value_type const& value)
+        -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
     auto
-    insert_unchecked(value_type const& value) ->
-        typename std::enable_if<maybe_multi, iterator>::type;
+    insert_unchecked(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>;
 
     template <class InputIt>
     void
@@ -1449,7 +1436,7 @@ private:
 
     template <
         bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    typename std::enable_if<maybe_propagate>::type
+    std::enable_if_t<maybe_propagate>
     swap_data(aged_unordered_container& other) noexcept
     {
         std::swap(m_config.key_compare(), other.m_config.key_compare());
@@ -1459,7 +1446,7 @@ private:
 
     template <
         bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    typename std::enable_if<!maybe_propagate>::type
+    std::enable_if_t<!maybe_propagate>
     swap_data(aged_unordered_container& other) noexcept
     {
         std::swap(m_config.key_compare(), other.m_config.key_compare());
@@ -2114,7 +2101,7 @@ template <
     class KeyEqual,
     class Allocator>
 template <class K, bool maybe_multi, bool maybe_map, class>
-typename std::conditional<IsMap, T, void*>::type&
+std::conditional_t<IsMap, T, void*>&
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(K const& k)
 {
     auto const iter(
@@ -2155,7 +2142,7 @@ template <
     class KeyEqual,
     class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
-typename std::conditional<IsMap, T, void*>::type&
+std::conditional_t<IsMap, T, void*>&
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key const& key)
 {
@@ -2184,7 +2171,7 @@ template <
     class KeyEqual,
     class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
-typename std::conditional<IsMap, T, void*>::type&
+std::conditional_t<IsMap, T, void*>&
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key&& key)
 {
@@ -2239,8 +2226,7 @@ template <
 template <bool maybe_multi>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) ->
-    typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     maybe_rehash(1);
     typename cont_type::insert_commit_data d;
@@ -2272,7 +2258,7 @@ template <
 template <bool maybe_multi>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type
+    value_type const& value) -> std::enable_if_t<maybe_multi, iterator>
 {
     maybe_rehash(1);
     element* const p(new_element(value));
@@ -2294,8 +2280,7 @@ template <
 template <bool maybe_multi, bool maybe_map>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) ->
-    typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type
+    value_type&& value) -> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>
 {
     maybe_rehash(1);
     typename cont_type::insert_commit_data d;
@@ -2327,7 +2312,7 @@ template <
 template <bool maybe_multi, bool maybe_map>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
+    value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>
 {
     maybe_rehash(1);
     element* const p(new_element(std::move(value)));
@@ -2350,7 +2335,7 @@ template <
 template <bool maybe_multi, class... Args>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     maybe_rehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2415,7 +2400,7 @@ template <
 template <bool maybe_multi, class... Args>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> typename std::enable_if<maybe_multi, iterator>::type
+    Args&&... args) -> std::enable_if_t<maybe_multi, iterator>
 {
     maybe_rehash(1);
     element* const p(new_element(std::forward<Args>(args)...));
@@ -2438,7 +2423,7 @@ template <bool maybe_multi, class... Args>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace_hint(
     const_iterator /*hint*/,
-    Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     maybe_rehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2590,7 +2575,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool maybe_multi>
-typename std::enable_if<!maybe_multi, bool>::type
+std::enable_if_t<!maybe_multi, bool>
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     aged_unordered_container<
         false,
@@ -2630,7 +2615,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool maybe_multi>
-typename std::enable_if<maybe_multi, bool>::type
+std::enable_if_t<maybe_multi, bool>
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     aged_unordered_container<
         true,
@@ -2677,8 +2662,8 @@ template <
 template <bool maybe_multi>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    insert_unchecked(value_type const& value) ->
-    typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+    insert_unchecked(value_type const& value)
+        -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(m_cont.insert_check(
@@ -2709,8 +2694,7 @@ template <
 template <bool maybe_multi>
 auto
 aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    insert_unchecked(value_type const& value) ->
-    typename std::enable_if<maybe_multi, iterator>::type
+    insert_unchecked(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>
 {
     element* const p(new_element(value));
     chronological.list.push_back(*p);

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

@@ -11,12 +11,11 @@
 #include <type_traits>
 #include <utility>
 
-namespace beast {
-namespace detail {
+namespace beast::detail {
 
 template <class T>
 struct is_empty_base_optimization_derived
-    : std::integral_constant<bool, std::is_empty<T>::value && !boost::is_final<T>::value>
+    : std::integral_constant<bool, std::is_empty_v<T> && !boost::is_final<T>::value>
 {
 };
 
@@ -86,5 +85,4 @@ public:
     }
 };
 
-}  // namespace detail
-}  // namespace beast
+}  // namespace beast::detail

include/xrpl/beast/core/List.h

@@ -16,7 +16,7 @@ struct CopyConst
 {
     explicit CopyConst() = default;
 
-    using type = typename std::remove_const<U>::type;
+    using type = std::remove_const_t<U>;
 };
 
 template <typename T, typename U>

include/xrpl/beast/core/LockFreeStack.h

@@ -13,18 +13,16 @@ class LockFreeStackIterator
 {
 protected:
     using Node = typename Container::Node;
-    using NodePtr = typename std::conditional<IsConst, Node const*, Node*>::type;
+    using NodePtr = std::conditional_t<IsConst, Node const*, Node*>;
 
 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<IsConst, typename Container::const_pointer, typename Container::pointer>::type;
-    using reference = typename std::conditional<
-        IsConst,
-        typename Container::const_reference,
-        typename Container::reference>::type;
+    using pointer =
+        std::conditional_t<IsConst, typename Container::const_pointer, typename Container::pointer>;
+    using reference = std::
+        conditional_t<IsConst, typename Container::const_reference, typename Container::reference>;
 
     LockFreeStackIterator() : m_node()
     {

include/xrpl/beast/hash/hash_append.h

@@ -69,7 +69,7 @@ template <class T>
 struct is_uniquely_represented
     : public std::integral_constant<
           bool,
-          std::is_integral<T>::value || std::is_enum<T>::value || std::is_pointer<T>::value>
+          std::is_integral_v<T> || std::is_enum_v<T> || std::is_pointer_v<T>>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -210,7 +210,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_enum<T>::value)>
+    (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
 hash_append(Hasher& h, T t) noexcept
 {
     detail::reverse_bytes(t);
@@ -218,7 +218,7 @@ hash_append(Hasher& h, T t) noexcept
 }
 
 template <class Hasher, class T>
-inline std::enable_if_t<std::is_floating_point<T>::value>
+inline std::enable_if_t<std::is_floating_point_v<T>>
 hash_append(Hasher& h, T t) noexcept
 {
     if (t == 0)

include/xrpl/beast/hash/xxhasher.h

@@ -121,13 +121,13 @@ public:
         }
     }
 
-    template <class Seed, std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
+    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
     explicit xxhasher(Seed seed) : seed_(seed)
     {
         resetBuffers();
     }
 
-    template <class Seed, std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
+    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
     xxhasher(Seed seed, Seed) : seed_(seed)
     {
         resetBuffers();

include/xrpl/beast/insight/Collector.h

@@ -8,8 +8,7 @@
 
 #include <string>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** Interface for a manager that allows collection of metrics.
 
@@ -117,5 +116,4 @@ public:
     /** @} */
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Counter.h

@@ -4,8 +4,7 @@
 
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A metric for measuring an integral value.
 
@@ -23,9 +22,7 @@ public:
     /** Create a null metric.
         A null metric reports no information.
     */
-    Counter()
-    {
-    }
+    Counter() = default;
 
     /** Create the metric reference the specified implementation.
         Normally this won't be called directly. Instead, call the appropriate
@@ -91,5 +88,4 @@ private:
     std::shared_ptr<CounterImpl> m_impl;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/CounterImpl.h

@@ -3,8 +3,7 @@
 #include <cstdint>
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 class Counter;
 
@@ -18,5 +17,4 @@ public:
     increment(value_type amount) = 0;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Event.h

@@ -5,8 +5,7 @@
 #include <chrono>
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A metric for reporting event timing.
 
@@ -25,9 +24,7 @@ public:
     /** Create a null metric.
         A null metric reports no information.
     */
-    Event()
-    {
-    }
+    Event() = default;
 
     /** Create the metric reference the specified implementation.
         Normally this won't be called directly. Instead, call the appropriate
@@ -58,5 +55,4 @@ private:
     std::shared_ptr<EventImpl> m_impl;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/EventImpl.h

@@ -3,8 +3,7 @@
 #include <chrono>
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 class Event;
 
@@ -18,5 +17,4 @@ public:
     notify(value_type const& value) = 0;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Gauge.h

@@ -4,8 +4,7 @@
 
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A metric for measuring an integral value.
 
@@ -25,9 +24,7 @@ public:
     /** Create a null metric.
         A null metric reports no information.
     */
-    Gauge()
-    {
-    }
+    Gauge() = default;
 
     /** Create the metric reference the specified implementation.
         Normally this won't be called directly. Instead, call the appropriate
@@ -121,5 +118,4 @@ private:
     std::shared_ptr<GaugeImpl> m_impl;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/GaugeImpl.h

@@ -3,8 +3,7 @@
 #include <cstdint>
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 class Gauge;
 
@@ -21,5 +20,4 @@ public:
     increment(difference_type amount) = 0;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Group.h

@@ -5,8 +5,7 @@
 #include <memory>
 #include <string>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A collector front-end that manages a group of metrics. */
 class Group : public Collector
@@ -19,5 +18,4 @@ public:
     name() const = 0;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Groups.h

@@ -6,8 +6,7 @@
 #include <memory>
 #include <string>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A container for managing a set of metric groups. */
 class Groups
@@ -32,5 +31,4 @@ public:
 std::unique_ptr<Groups>
 make_Groups(Collector::ptr const& collector);
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Hook.h

@@ -4,8 +4,7 @@
 
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A reference to a handler for performing polled collection. */
 class Hook final
@@ -14,9 +13,7 @@ public:
     /** Create a null hook.
         A null hook has no associated handler.
     */
-    Hook()
-    {
-    }
+    Hook() = default;
 
     /** Create a hook referencing the specified implementation.
         Normally this won't be called directly. Instead, call the appropriate
@@ -37,5 +34,4 @@ private:
     std::shared_ptr<HookImpl> m_impl;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/HookImpl.h

@@ -3,8 +3,7 @@
 #include <functional>
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 class HookImpl : public std::enable_shared_from_this<HookImpl>
 {
@@ -14,5 +13,4 @@ public:
     virtual ~HookImpl() = 0;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/Meter.h

@@ -4,8 +4,7 @@
 
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A metric for measuring an integral value.
 
@@ -22,9 +21,7 @@ public:
     /** Create a null metric.
         A null metric reports no information.
     */
-    Meter()
-    {
-    }
+    Meter() = default;
 
     /** Create the metric reference the specified implementation.
         Normally this won't be called directly. Instead, call the appropriate
@@ -76,5 +73,4 @@ private:
     std::shared_ptr<MeterImpl> m_impl;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/MeterImpl.h

@@ -3,8 +3,7 @@
 #include <cstdint>
 #include <memory>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 class Meter;
 
@@ -18,5 +17,4 @@ public:
     increment(value_type amount) = 0;
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/NullCollector.h

@@ -2,8 +2,7 @@
 
 #include <xrpl/beast/insight/Collector.h>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A Collector which does not collect metrics. */
 class NullCollector : public Collector
@@ -15,5 +14,4 @@ public:
     New();
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/insight/StatsDCollector.h

@@ -4,8 +4,7 @@
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/Journal.h>
 
-namespace beast {
-namespace insight {
+namespace beast::insight {
 
 /** A Collector that reports metrics to a StatsD server.
     Reference:
@@ -25,5 +24,4 @@ public:
     New(IP::Endpoint const& address, std::string const& prefix, Journal journal);
 };
 
-}  // namespace insight
-}  // namespace beast
+}  // namespace beast::insight

include/xrpl/beast/net/IPAddressConversion.h

@@ -4,8 +4,7 @@
 
 #include <boost/asio.hpp>
 
-namespace beast {
-namespace IP {
+namespace beast::IP {
 
 /** Convert to Endpoint.
     The port is set to zero.
@@ -27,8 +26,7 @@ to_asio_address(Endpoint const& endpoint);
 boost::asio::ip::tcp::endpoint
 to_asio_endpoint(Endpoint const& endpoint);
 
-}  // namespace IP
-}  // namespace beast
+}  // namespace beast::IP
 
 namespace beast {
 

include/xrpl/beast/net/IPAddressV4.h

@@ -4,8 +4,7 @@
 
 #include <boost/asio/ip/address_v4.hpp>
 
-namespace beast {
-namespace IP {
+namespace beast::IP {
 
 using AddressV4 = boost::asio::ip::address_v4;
 
@@ -23,5 +22,4 @@ is_public(AddressV4 const& addr);
 char
 get_class(AddressV4 const& address);
 
-}  // namespace IP
-}  // namespace beast
+}  // namespace beast::IP

include/xrpl/beast/net/IPAddressV6.h

@@ -4,8 +4,7 @@
 
 #include <boost/asio/ip/address_v6.hpp>
 
-namespace beast {
-namespace IP {
+namespace beast::IP {
 
 using AddressV6 = boost::asio::ip::address_v6;
 
@@ -17,5 +16,4 @@ is_private(AddressV6 const& addr);
 bool
 is_public(AddressV6 const& addr);
 
-}  // namespace IP
-}  // namespace beast
+}  // namespace beast::IP

include/xrpl/beast/net/IPEndpoint.h

@@ -8,8 +8,7 @@
 #include <optional>
 #include <string>
 
-namespace beast {
-namespace IP {
+namespace beast::IP {
 
 using Port = std::uint16_t;
 
@@ -21,7 +20,7 @@ public:
     Endpoint();
 
     /** Create an endpoint from the address and optional port. */
-    explicit Endpoint(Address const& addr, Port port = 0);
+    explicit Endpoint(Address addr, Port port = 0);
 
     /** Create an Endpoint from a string.
         If the port is omitted, the endpoint will have a zero port.
@@ -184,8 +183,7 @@ operator<<(OutputStream& os, Endpoint const& endpoint)
 std::istream&
 operator>>(std::istream& is, Endpoint& endpoint);
 
-}  // namespace IP
-}  // namespace beast
+}  // namespace beast::IP
 
 //------------------------------------------------------------------------------
 

include/xrpl/beast/rfc2616.h

@@ -12,8 +12,7 @@
 #include <string>
 #include <vector>
 
-namespace beast {
-namespace rfc2616 {
+namespace beast::rfc2616 {
 
 namespace detail {
 
@@ -370,5 +369,4 @@ is_keep_alive(boost::beast::http::message<isRequest, Body, Fields> const& m)
         "close");
 }
 
-}  // namespace rfc2616
-}  // namespace beast
+}  // namespace beast::rfc2616

include/xrpl/beast/test/yield_to.h

@@ -15,8 +15,7 @@
 #include <thread>
 #include <vector>
 
-namespace beast {
-namespace test {
+namespace beast::test {
 
 /** Mix-in to support tests using asio coroutines.
 
@@ -125,5 +124,4 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
     spawn(fn...);
 }
 
-}  // namespace test
-}  // namespace beast
+}  // namespace beast::test

include/xrpl/beast/type_name.h

@@ -15,7 +15,7 @@ template <typename T>
 std::string
 type_name()
 {
-    using TR = typename std::remove_reference<T>::type;
+    using TR = std::remove_reference_t<T>;
 
     std::string name = typeid(TR).name();
 
@@ -27,15 +27,15 @@ type_name()
     }
 #endif
 
-    if (std::is_const<TR>::value)
+    if (std::is_const_v<TR>)
         name += " const";
-    if (std::is_volatile<TR>::value)
+    if (std::is_volatile_v<TR>)
         name += " volatile";
-    if (std::is_lvalue_reference<T>::value)
+    if (std::is_lvalue_reference_v<T>)
     {
         name += "&";
     }
-    else if (std::is_rvalue_reference<T>::value)
+    else if (std::is_rvalue_reference_v<T>)
     {
         name += "&&";
     }

include/xrpl/beast/unit_test/amount.h

@@ -8,8 +8,7 @@
 #include <ostream>
 #include <string>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 /** Utility for producing nicely composed output of amounts with units. */
 class amount
@@ -42,5 +41,4 @@ operator<<(std::ostream& s, amount const& t)
     return s;
 }
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/detail/const_container.h

@@ -4,9 +4,7 @@
 
 #pragma once
 
-namespace beast {
-namespace unit_test {
-namespace detail {
+namespace beast::unit_test::detail {
 
 /** Adapter to constrain a container interface.
     The interface allows for limited read only operations. Derived classes
@@ -82,6 +80,4 @@ public:
     /** @} */
 };
 
-}  // namespace detail
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test::detail

include/xrpl/beast/unit_test/global_suites.h

@@ -6,8 +6,7 @@
 
 #include <xrpl/beast/unit_test/suite_list.h>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 namespace detail {
 
@@ -42,5 +41,4 @@ global_suites()
     return detail::global_suites();
 }
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/match.h

@@ -8,8 +8,7 @@
 
 #include <string>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 // Predicate for implementing matches
 class selector
@@ -163,5 +162,4 @@ match_library(std::string const& name)
     return selector(selector::library, name);
 }
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/recorder.h

@@ -7,8 +7,7 @@
 #include <xrpl/beast/unit_test/results.h>
 #include <xrpl/beast/unit_test/runner.h>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 /** A test runner that stores the results. */
 class recorder : public runner
@@ -29,49 +28,48 @@ public:
     }
 
 private:
-    virtual void
+    void
     on_suite_begin(suite_info const& info) override
     {
         m_suite = suite_results(info.full_name());
     }
 
-    virtual void
+    void
     on_suite_end() override
     {
         m_results.insert(std::move(m_suite));
     }
 
-    virtual void
+    void
     on_case_begin(std::string const& name) override
     {
         m_case = case_results(name);
     }
 
-    virtual void
+    void
     on_case_end() override
     {
         if (!m_case.tests.empty())
             m_suite.insert(std::move(m_case));
     }
 
-    virtual void
+    void
     on_pass() override
     {
         m_case.tests.pass();
     }
 
-    virtual void
+    void
     on_fail(std::string const& reason) override
     {
         m_case.tests.fail(reason);
     }
 
-    virtual void
+    void
     on_log(std::string const& s) override
     {
         m_case.log.insert(s);
     }
 };
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/reporter.h

@@ -18,8 +18,7 @@
 #include <string>
 #include <utility>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 namespace detail {
 
@@ -86,7 +85,7 @@ public:
     reporter&
     operator=(reporter const&) = delete;
 
-    ~reporter();
+    ~reporter() override;
 
     explicit reporter(std::ostream& os = std::cout);
 
@@ -94,25 +93,25 @@ private:
     static std::string
     fmtdur(typename clock_type::duration const& d);
 
-    virtual void
+    void
     on_suite_begin(suite_info const& info) override;
 
-    virtual void
+    void
     on_suite_end() override;
 
-    virtual void
+    void
     on_case_begin(std::string const& name) override;
 
-    virtual void
+    void
     on_case_end() override;
 
-    virtual void
+    void
     on_pass() override;
 
-    virtual void
+    void
     on_fail(std::string const& reason) override;
 
-    virtual void
+    void
     on_log(std::string const& s) override;
 };
 
@@ -251,5 +250,4 @@ reporter<Unused>::on_log(std::string const& s)
 
 using reporter = detail::reporter<>;
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/results.h

@@ -7,10 +7,10 @@
 #include <xrpl/beast/unit_test/detail/const_container.h>
 
 #include <string>
+#include <utility>
 #include <vector>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 /** Holds a set of test condition outcomes in a testcase. */
 class case_results
@@ -23,7 +23,7 @@ public:
         {
         }
 
-        test(bool pass_, std::string const& reason_) : pass(pass_), reason(reason_)
+        test(bool pass_, std::string reason_) : pass(pass_), reason(std::move(reason_))
         {
         }
 
@@ -38,9 +38,7 @@ private:
         std::size_t failed_{0};
 
     public:
-        tests_t()
-        {
-        }
+        tests_t() = default;
 
         /** Returns the total number of test conditions. */
         std::size_t
@@ -86,7 +84,7 @@ private:
     std::string name_;
 
 public:
-    explicit case_results(std::string const& name = "") : name_(name)
+    explicit case_results(std::string name = "") : name_(std::move(name))
     {
     }
 
@@ -115,7 +113,7 @@ private:
     std::size_t failed_ = 0;
 
 public:
-    explicit suite_results(std::string const& name = "") : name_(name)
+    explicit suite_results(std::string name = "") : name_(std::move(name))
     {
     }
 
@@ -172,9 +170,7 @@ private:
     std::size_t failed_{0};
 
 public:
-    results()
-    {
-    }
+    results() = default;
 
     /** Returns the total number of test cases. */
     std::size_t
@@ -219,5 +215,4 @@ public:
     /** @} */
 };
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/runner.h

@@ -11,8 +11,7 @@
 #include <mutex>
 #include <string>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 /** Unit test runner interface.
 
@@ -277,5 +276,4 @@ runner::log(std::string const& s)
     on_log(s);
 }
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/suite.h

@@ -14,8 +14,7 @@
 #include <sstream>
 #include <string>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 namespace detail {
 
@@ -75,7 +74,7 @@ private:
         {
         }
 
-        ~log_buf()
+        ~log_buf() override
         {
             sync();
         }
@@ -573,8 +572,7 @@ suite::run(runner& r)
     ((cond) ? (pass(), true) : (fail((reason), __FILE__, __LINE__), false))
 #endif
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test
 
 //------------------------------------------------------------------------------
 

include/xrpl/beast/unit_test/suite_info.h

@@ -9,8 +9,7 @@
 #include <string>
 #include <utility>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 class runner;
 
@@ -110,5 +109,4 @@ make_suite_info(
         });
 }
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/suite_list.h

@@ -13,8 +13,7 @@
 #include <typeindex>
 #include <unordered_set>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 /// A container of test suites.
 class suite_list : public detail::const_container<std::set<suite_info>>
@@ -62,5 +61,4 @@ suite_list::insert(
     cont().emplace(make_suite_info<Suite>(name, module, library, manual, priority));
 }
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/unit_test/thread.h

@@ -10,8 +10,7 @@
 #include <thread>
 #include <utility>
 
-namespace beast {
-namespace unit_test {
+namespace beast::unit_test {
 
 /** Replacement for std::thread that handles exceptions in unit tests. */
 class Thread
@@ -108,5 +107,4 @@ private:
     }
 };
 
-}  // namespace unit_test
-}  // namespace beast
+}  // namespace beast::unit_test

include/xrpl/beast/utility/Journal.h

@@ -55,15 +55,16 @@ public:
     class Sink
     {
     protected:
-        Sink() = delete;
         explicit Sink(Sink const& sink) = default;
         Sink(Severity thresh, bool console);
-        Sink&
-        operator=(Sink const& lhs) = delete;
 
     public:
         virtual ~Sink() = 0;
 
+        Sink() = delete;
+        Sink&
+        operator=(Sink const& lhs) = delete;
+
         /** Returns `true` if text at the passed severity produces output. */
         virtual bool
         active(Severity level) const;
@@ -371,10 +372,6 @@ class logstream_buf : public std::basic_stringbuf<CharT, Traits>
 {
     beast::Journal::Stream strm_;
 
-    template <class T>
-    void
-    write(T const*) = delete;
-
     void
     write(char const* s)
     {
@@ -394,7 +391,7 @@ public:
     {
     }
 
-    ~logstream_buf()
+    ~logstream_buf() override
     {
         sync();
     }
@@ -406,6 +403,10 @@ public:
         this->str("");
         return 0;
     }
+
+    template <class T>
+    void
+    write(T const*) = delete;
 };
 
 }  // namespace detail
@@ -413,11 +414,11 @@ public:
 template <class CharT, class Traits = std::char_traits<CharT>>
 class basic_logstream : public std::basic_ostream<CharT, Traits>
 {
-    typedef CharT char_type;
-    typedef Traits traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+    using char_type = CharT;
+    using traits_type = Traits;
+    using int_type = typename traits_type::int_type;
+    using pos_type = typename traits_type::pos_type;
+    using off_type = typename traits_type::off_type;
 
     detail::logstream_buf<CharT, Traits> buf_;
 

include/xrpl/beast/utility/PropertyStream.h

@@ -174,7 +174,7 @@ private:
     std::ostringstream mutable m_ostream;
 
 public:
-    Proxy(Map const& map, std::string const& key);
+    Proxy(Map const& map, std::string key);
     Proxy(Proxy const& other);
     ~Proxy();
 
@@ -315,7 +315,7 @@ private:
     List<Item> children_;
 
 public:
-    explicit Source(std::string const& name);
+    explicit Source(std::string name);
     virtual ~Source();
 
     Source(Source const&) = delete;

include/xrpl/beast/utility/WrappedSink.h

@@ -2,6 +2,8 @@
 
 #include <xrpl/beast/utility/Journal.h>
 
+#include <utility>
+
 namespace beast {
 
 /** Wraps a Journal::Sink to prefix its output with a string. */
@@ -17,8 +19,8 @@ private:
     std::string prefix_;
 
 public:
-    explicit WrappedSink(beast::Journal::Sink& sink, std::string const& prefix = "")
-        : Sink(sink), sink_(sink), prefix_(prefix)
+    explicit WrappedSink(beast::Journal::Sink& sink, std::string prefix = "")
+        : Sink(sink), sink_(sink), prefix_(std::move(prefix))
     {
     }
 

include/xrpl/beast/utility/Zero.h

@@ -38,8 +38,7 @@ signum(T const& t)
     return t.signum();
 }
 
-namespace detail {
-namespace zero_helper {
+namespace detail::zero_helper {
 
 // For argument dependent lookup to function properly, calls to signum must
 // be made from a namespace that does not include overloads of the function..
@@ -50,8 +49,7 @@ call_signum(T const& t)
     return signum(t);
 }
 
-}  // namespace zero_helper
-}  // namespace detail
+}  // namespace detail::zero_helper
 
 // Handle operators where T is on the left side using signum.
 

include/xrpl/beast/utility/maybe_const.h

@@ -9,10 +9,8 @@ template <bool IsConst, class T>
 struct maybe_const
 {
     explicit maybe_const() = default;
-    using type = typename std::conditional<
-        IsConst,
-        typename std::remove_const<T>::type const,
-        typename std::remove_const<T>::type>::type;
+    using type = std::
+        conditional_t<IsConst, typename std::remove_const<T>::type const, std::remove_const_t<T>>;
 };
 
 /** Alias for omitting `typename`. */

include/xrpl/conditions/Condition.h

@@ -7,8 +7,7 @@
 #include <cstdint>
 #include <set>
 
-namespace xrpl {
-namespace cryptoconditions {
+namespace xrpl::cryptoconditions {
 
 enum class Type : std::uint8_t {
     preimageSha256 = 0,
@@ -88,6 +87,4 @@ operator!=(Condition const& lhs, Condition const& rhs)
     return !(lhs == rhs);
 }
 
-}  // namespace cryptoconditions
-
-}  // namespace xrpl
+}  // namespace xrpl::cryptoconditions

include/xrpl/conditions/Fulfillment.h

@@ -4,8 +4,7 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/conditions/Condition.h>
 
-namespace xrpl {
-namespace cryptoconditions {
+namespace xrpl::cryptoconditions {
 
 struct Fulfillment
 {
@@ -119,5 +118,4 @@ validate(Fulfillment const& f, Condition const& c, Slice m);
 bool
 validate(Fulfillment const& f, Condition const& c);
 
-}  // namespace cryptoconditions
-}  // namespace xrpl
+}  // namespace xrpl::cryptoconditions

include/xrpl/conditions/detail/PreimageSha256.h

@@ -9,8 +9,7 @@
 
 #include <memory>
 
-namespace xrpl {
-namespace cryptoconditions {
+namespace xrpl::cryptoconditions {
 
 class PreimageSha256 final : public Fulfillment
 {
@@ -127,5 +126,4 @@ public:
     }
 };
 
-}  // namespace cryptoconditions
-}  // namespace xrpl
+}  // namespace xrpl::cryptoconditions

include/xrpl/conditions/detail/error.h

@@ -2,8 +2,7 @@
 
 #include <system_error>
 
-namespace xrpl {
-namespace cryptoconditions {
+namespace xrpl::cryptoconditions {
 
 enum class error {
     generic = 1,
@@ -28,8 +27,7 @@ enum class error {
 std::error_code
 make_error_code(error ev);
 
-}  // namespace cryptoconditions
-}  // namespace xrpl
+}  // namespace xrpl::cryptoconditions
 
 namespace std {
 

include/xrpl/conditions/detail/utils.h

@@ -8,15 +8,12 @@
 
 #include <limits>
 
-namespace xrpl {
-namespace cryptoconditions {
-
 // A collection of functions to decode binary blobs
 // encoded with X.690 Distinguished Encoding Rules.
 //
 // This is a very trivial decoder and only implements
 // the bare minimum needed to support PreimageSha256.
-namespace der {
+namespace xrpl::cryptoconditions::der {
 
 // The preamble encapsulates the DER identifier and
 // length octets:
@@ -204,6 +201,4 @@ parseInteger(Slice& s, std::size_t count, std::error_code& ec)
     return v;
 }
 
-}  // namespace der
-}  // namespace cryptoconditions
-}  // namespace xrpl
+}  // namespace xrpl::cryptoconditions::der

include/xrpl/core/ClosureCounter.h

@@ -75,7 +75,7 @@ private:
         std::remove_reference_t<Closure> closure_;
 
         static_assert(
-            std::is_same<decltype(closure_(std::declval<Args_t>()...)), Ret_t>::value,
+            std::is_same_v<decltype(closure_(std::declval<Args_t>()...)), Ret_t>,
             "Closure arguments don't match ClosureCounter Ret_t or Args_t");
 
     public:
@@ -86,7 +86,7 @@ private:
             ++counter_;
         }
 
-        Substitute(Substitute&& rhs) noexcept(std::is_nothrow_move_constructible<Closure>::value)
+        Substitute(Substitute&& rhs) noexcept(std::is_nothrow_move_constructible_v<Closure>)
             : counter_(rhs.counter_), closure_(std::move(rhs.closure_))
         {
             ++counter_;

include/xrpl/core/HashRouter.h

@@ -109,9 +109,7 @@ private:
     class Entry : public CountedObject<Entry>
     {
     public:
-        Entry()
-        {
-        }
+        Entry() = default;
 
         void
         addPeer(PeerShortID peer)

include/xrpl/core/JobQueue.h

@@ -128,7 +128,7 @@ public:
         beast::Journal journal,
         Logs& logs,
         perf::PerfLog& perfLog);
-    ~JobQueue();
+    ~JobQueue() override;
 
     /** Adds a job to the JobQueue.
 
@@ -141,8 +141,7 @@ public:
     */
     template <
         typename JobHandler,
-        typename =
-            std::enable_if_t<std::is_same<decltype(std::declval<JobHandler&&>()()), void>::value>>
+        typename = std::enable_if_t<std::is_same_v<decltype(std::declval<JobHandler&&>()()), void>>>
     bool
     addJob(JobType type, std::string const& name, JobHandler&& jobHandler)
     {

include/xrpl/core/JobTypeData.h

@@ -4,6 +4,8 @@
 #include <xrpl/beast/insight/Collector.h>
 #include <xrpl/core/JobTypeInfo.h>
 
+#include <utility>
+
 namespace xrpl {
 
 struct JobTypeData
@@ -33,9 +35,9 @@ public:
 
     JobTypeData(
         JobTypeInfo const& info_,
-        beast::insight::Collector::ptr const& collector,
+        beast::insight::Collector::ptr collector,
         Logs& logs) noexcept
-        : m_load(logs.journal("LoadMonitor")), m_collector(collector), info(info_)
+        : m_load(logs.journal("LoadMonitor")), m_collector(std::move(collector)), info(info_)
 
     {
         m_load.setTargetLatency(info.getAverageLatency(), info.getPeakLatency());

include/xrpl/core/LoadEvent.h

@@ -16,7 +16,7 @@ class LoadEvent
 {
 public:
     // VFALCO TODO remove the dependency on LoadMonitor. Is that possible?
-    LoadEvent(LoadMonitor& monitor, std::string const& name, bool shouldStart);
+    LoadEvent(LoadMonitor& monitor, std::string name, bool shouldStart);
     LoadEvent(LoadEvent const&) = delete;
 
     ~LoadEvent();

include/xrpl/core/detail/Workers.h

@@ -93,7 +93,7 @@ public:
     explicit Workers(
         Callback& callback,
         perf::PerfLog* perfLog,
-        std::string const& threadNames = "Worker",
+        std::string threadNames = "Worker",
         int numberOfThreads = static_cast<int>(std::thread::hardware_concurrency()));
 
     ~Workers();
@@ -164,7 +164,7 @@ private:
                    public beast::LockFreeStack<Worker, PausedTag>::Node
     {
     public:
-        Worker(Workers& workers, std::string const& threadName, int const instance);
+        Worker(Workers& workers, std::string threadName, int const instance);
 
         ~Worker();
 

include/xrpl/json/json_writer.h

@@ -15,9 +15,7 @@ class Value;
 class WriterBase
 {
 public:
-    virtual ~WriterBase()
-    {
-    }
+    virtual ~WriterBase() = default;
     virtual std::string
     write(Value const& root) = 0;
 };
@@ -34,9 +32,7 @@ class FastWriter : public WriterBase
 {
 public:
     FastWriter() = default;
-    virtual ~FastWriter()
-    {
-    }
+    ~FastWriter() override = default;
 
 public:  // overridden from Writer
     std::string
@@ -71,9 +67,7 @@ class StyledWriter : public WriterBase
 {
 public:
     StyledWriter();
-    virtual ~StyledWriter()
-    {
-    }
+    ~StyledWriter() override = default;
 
 public:  // overridden from Writer
     /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a>
@@ -136,9 +130,7 @@ class StyledStreamWriter
 {
 public:
     StyledStreamWriter(std::string indentation = "\t");
-    ~StyledStreamWriter()
-    {
-    }
+    ~StyledStreamWriter() = default;
 
 public:
     /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a>

include/xrpl/ledger/AmendmentTable.h

@@ -8,6 +8,7 @@
 #include <xrpl/shamap/SHAMap.h>
 
 #include <optional>
+#include <utility>
 
 namespace xrpl {
 
@@ -23,8 +24,8 @@ public:
     struct FeatureInfo
     {
         FeatureInfo() = delete;
-        FeatureInfo(std::string const& n, uint256 const& f, VoteBehavior v)
-            : name(n), feature(f), vote(v)
+        FeatureInfo(std::string n, uint256 const& f, VoteBehavior v)
+            : name(std::move(n)), feature(f), vote(v)
         {
         }
 

include/xrpl/ledger/BookListeners.h

@@ -14,9 +14,7 @@ class BookListeners
 public:
     using pointer = std::shared_ptr<BookListeners>;
 
-    BookListeners()
-    {
-    }
+    BookListeners() = default;
 
     /** Add a new subscription for this book
      */

include/xrpl/ledger/CachedView.h

@@ -132,7 +132,7 @@ template <class Base>
 class CachedView : public detail::CachedViewImpl
 {
 private:
-    static_assert(std::is_base_of<DigestAwareReadView, Base>::value, "");
+    static_assert(std::is_base_of_v<DigestAwareReadView, Base>, "");
 
     std::shared_ptr<Base const> sp_;
 

include/xrpl/ledger/Ledger.h

@@ -82,12 +82,12 @@ public:
     */
     Ledger(
         create_genesis_t,
-        Rules const& rules,
+        Rules rules,
         Fees const& fees,
         std::vector<uint256> const& amendments,
         Family& family);
 
-    Ledger(LedgerHeader const& info, Rules const& rules, Family& family);
+    Ledger(LedgerHeader const& info, Rules rules, Family& family);
 
     /** Used for ledgers loaded from JSON files
 
@@ -100,7 +100,7 @@ public:
         LedgerHeader const& info,
         bool& loaded,
         bool acquire,
-        Rules const& rules,
+        Rules rules,
         Fees const& fees,
         Family& family,
         beast::Journal j);
@@ -117,11 +117,11 @@ public:
     Ledger(
         std::uint32_t ledgerSeq,
         NetClock::time_point closeTime,
-        Rules const& rules,
+        Rules rules,
         Fees const& fees,
         Family& family);
 
-    ~Ledger() = default;
+    ~Ledger() override = default;
 
     //
     // ReadView

include/xrpl/ledger/OpenView.h

@@ -135,7 +135,7 @@ public:
     OpenView(
         open_ledger_t,
         ReadView const* base,
-        Rules const& rules,
+        Rules rules,
         std::shared_ptr<void const> hold = nullptr);
 
     OpenView(open_ledger_t, Rules const& rules, std::shared_ptr<ReadView const> const& base)

include/xrpl/ledger/PaymentSandbox.h

@@ -6,6 +6,7 @@
 #include <xrpl/protocol/AccountID.h>
 
 #include <map>
+#include <utility>
 
 namespace xrpl {
 
@@ -20,9 +21,8 @@ private:
     struct ValueIOU
     {
         explicit ValueIOU() = default;
-
-        STAmount lowAcctCredits;
-        STAmount highAcctCredits;
+        STAmount lowAcctDebits;
+        STAmount highAcctDebits;
         STAmount lowAcctOrigBalance;
     };
 
@@ -63,8 +63,8 @@ private:
 public:
     struct AdjustmentIOU
     {
-        AdjustmentIOU(STAmount const& d, STAmount const& c, STAmount const& b)
-            : debits(d), credits(c), origBalance(b)
+        AdjustmentIOU(STAmount d, STAmount c, STAmount b)
+            : debits(std::move(d)), credits(std::move(c)), origBalance(std::move(b))
         {
         }
         STAmount debits;
@@ -229,13 +229,6 @@ public:
     apply(PaymentSandbox& to);
     /** @} */
 
-    // Return a map of balance changes on trust lines. The low account is the
-    // first account in the key. If the two accounts are equal, the map contains
-    // the total changes in currency regardless of issuer. This is useful to get
-    // the total change in XRP balances.
-    std::map<std::tuple<AccountID, AccountID, Currency>, STAmount>
-    balanceChanges(ReadView const& view) const;
-
     XRPAmount
     xrpDestroyed() const;
 

include/xrpl/ledger/detail/ApplyStateTable.h

@@ -10,8 +10,7 @@
 
 #include <memory>
 
-namespace xrpl {
-namespace detail {
+namespace xrpl::detail {
 
 // Helper class that buffers modifications
 class ApplyStateTable
@@ -125,5 +124,4 @@ private:
         beast::Journal j);
 };
 
-}  // namespace detail
-}  // namespace xrpl
+}  // namespace xrpl::detail

include/xrpl/ledger/detail/ApplyViewBase.h

@@ -5,8 +5,7 @@
 #include <xrpl/ledger/detail/ApplyStateTable.h>
 #include <xrpl/protocol/XRPAmount.h>
 
-namespace xrpl {
-namespace detail {
+namespace xrpl::detail {
 
 class ApplyViewBase : public ApplyView, public RawView
 {
@@ -102,5 +101,4 @@ protected:
     detail::ApplyStateTable items_;
 };
 
-}  // namespace detail
-}  // namespace xrpl
+}  // namespace xrpl::detail

include/xrpl/ledger/detail/RawStateTable.h

@@ -9,8 +9,7 @@
 #include <map>
 #include <utility>
 
-namespace xrpl {
-namespace detail {
+namespace xrpl::detail {
 
 // Helper class that buffers raw modifications
 class RawStateTable
@@ -108,5 +107,4 @@ private:
     XRPAmount dropsDestroyed_{0};
 };
 
-}  // namespace detail
-}  // namespace xrpl
+}  // namespace xrpl::detail

include/xrpl/ledger/helpers/NFTokenHelpers.h

@@ -8,9 +8,9 @@
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/nft.h>
 
-namespace xrpl {
+#include <utility>
 
-namespace nft {
+namespace xrpl::nft {
 
 /** Delete up to a specified number of offers from the specified token offer
  * directory. */
@@ -30,8 +30,8 @@ struct TokenAndPage
     STObject token;
     std::shared_ptr<SLE> page;
 
-    TokenAndPage(STObject const& token_, std::shared_ptr<SLE> page_)
-        : token(token_), page(std::move(page_))
+    TokenAndPage(STObject token_, std::shared_ptr<SLE> page_)
+        : token(std::move(token_)), page(std::move(page_))
     {
     }
 };
@@ -136,6 +136,4 @@ checkTrustlineDeepFrozen(
     beast::Journal const j,
     Issue const& issue);
 
-}  // namespace nft
-
-}  // namespace xrpl
+}  // namespace xrpl::nft

include/xrpl/ledger/helpers/PermissionedDEXHelpers.h

@@ -1,8 +1,7 @@
 #pragma once
 #include <xrpl/ledger/View.h>
 
-namespace xrpl {
-namespace permissioned_dex {
+namespace xrpl::permissioned_dex {
 
 // Check if an account is in a permissioned domain
 [[nodiscard]] bool
@@ -16,6 +15,4 @@ offerInDomain(
     Domain const& domainID,
     beast::Journal j);
 
-}  // namespace permissioned_dex
-
-}  // namespace xrpl
+}  // namespace xrpl::permissioned_dex

include/xrpl/net/HTTPClientSSLContext.h

@@ -79,8 +79,8 @@ public:
     template <
         class T,
         class = std::enable_if_t<
-            std::is_same<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>::value ||
-            std::is_same<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>::value>>
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>>>
     boost::system::error_code
     preConnectVerify(T& strm, std::string const& host)
     {
@@ -99,8 +99,8 @@ public:
     template <
         class T,
         class = std::enable_if_t<
-            std::is_same<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>>::value ||
-            std::is_same<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>::value>>
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>>>
     /**
      * @brief invoked after connect/async_connect but before sending data
      * on an ssl stream - to setup name verification.

include/xrpl/nodestore/Backend.h

@@ -4,8 +4,7 @@
 
 #include <cstdint>
 
-namespace xrpl {
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /** A backend used for the NodeStore.
 
@@ -140,5 +139,4 @@ public:
     fdRequired() const = 0;
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/Database.h

@@ -10,9 +10,7 @@
 
 #include <condition_variable>
 
-namespace xrpl {
-
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /** Persistency layer for NodeObject
 
@@ -274,5 +272,4 @@ private:
     threadEntry();
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/DatabaseRotating.h

@@ -2,8 +2,7 @@
 
 #include <xrpl/nodestore/Database.h>
 
-namespace xrpl {
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /* This class has two key-value store Backend objects for persisting SHAMap
  * records. This facilitates online deletion of data. New backends are
@@ -36,5 +35,4 @@ public:
             f) = 0;
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/DummyScheduler.h

@@ -2,15 +2,14 @@
 
 #include <xrpl/nodestore/Scheduler.h>
 
-namespace xrpl {
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /** Simple NodeStore Scheduler that just performs the tasks synchronously. */
 class DummyScheduler : public Scheduler
 {
 public:
     DummyScheduler() = default;
-    ~DummyScheduler() = default;
+    ~DummyScheduler() override = default;
     void
     scheduleTask(Task& task) override;
     void
@@ -19,5 +18,4 @@ public:
     onBatchWrite(BatchWriteReport const& report) override;
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/Factory.h

@@ -7,9 +7,7 @@
 
 #include <nudb/store.hpp>
 
-namespace xrpl {
-
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /** Base class for backend factories. */
 class Factory
@@ -59,5 +57,4 @@ public:
     }
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/Manager.h

@@ -3,9 +3,7 @@
 #include <xrpl/nodestore/DatabaseRotating.h>
 #include <xrpl/nodestore/Factory.h>
 
-namespace xrpl {
-
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /** Singleton for managing NodeStore factories and back ends. */
 class Manager
@@ -81,5 +79,4 @@ public:
         beast::Journal journal) = 0;
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/Scheduler.h

@@ -4,8 +4,7 @@
 
 #include <chrono>
 
-namespace xrpl {
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 enum class FetchType { synchronous, async };
 
@@ -64,5 +63,4 @@ public:
     onBatchWrite(BatchWriteReport const& report) = 0;
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore

include/xrpl/nodestore/Task.h

@@ -1,7 +1,6 @@
 #pragma once
 
-namespace xrpl {
-namespace NodeStore {
+namespace xrpl::NodeStore {
 
 /** Derived classes perform scheduled tasks. */
 struct Task
@@ -15,5 +14,4 @@ struct Task
     performScheduledTask() = 0;
 };
 
-}  // namespace NodeStore
-}  // namespace xrpl
+}  // namespace xrpl::NodeStore