ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-07-23 23:20:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'xrplf/sponsor' into mvadari/sponsor/fixes2

Browse Source
This commit is contained in:
Mayukha Vadari
2026-07-08 11:19:33 -04:00
committed by GitHub
parent 7c9a6d515e 5be01f06ce
commit 5dbd2e885c
251 changed files with 7030 additions and 6478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/xrpl/basics/Slice.h
View File

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

6
include/xrpl/basics/TaggedCache.h
View File

@@ -212,13 +212,11 @@ public:
*/
template <class ReturnType = bool>
auto
insert(key_type const& key, T const& value) -> ReturnType
requires(!IsKeyCache);
insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>;
template <class ReturnType = bool>
auto
insert(key_type const& key) -> ReturnType
requires IsKeyCache;
insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
// VFALCO NOTE It looks like this returns a copy of the data in
// the output parameter 'data'. This could be expensive.

11
include/xrpl/basics/TaggedCache.ipp
View File

@@ -57,10 +57,7 @@ inline TaggedCache<
beast::insight::Collector::ptr const& collector)
: journal_(journal)
, clock_(clock)
, stats_(
name,
[this] { collectMetrics(); },
collector)
, stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
, name_(name)
, targetSize_(size)
, targetAge_(expiration)
@@ -503,8 +500,7 @@ template <
template <class ReturnType>
inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
insert(key_type const& key, T const& value) -> ReturnType
requires(!IsKeyCache)
insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
{
static_assert(
std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -534,8 +530,7 @@ template <
template <class ReturnType>
inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
insert(key_type const& key) -> ReturnType
requires IsKeyCache
insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
{
std::scoped_lock const lock(mutex_);
clock_type::time_point const now(clock_.now());

3
include/xrpl/basics/ToString.h
View File

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

28
include/xrpl/basics/base_uint.h
View File

@@ -97,7 +97,7 @@ public:
//
static constexpr std::size_t kBytes = Bits / 8;
static_assert(sizeof(data_) == kBytes);
static_assert(sizeof(data_) == kBytes, "");
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
@@ -280,11 +280,12 @@ public:
{
}
template <class Container>
explicit BaseUInt(Container const& c)
requires(
template <
class Container,
class = std::enable_if_t<
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>)
std::is_trivially_copyable_v<typename Container::value_type>>>
explicit BaseUInt(Container const& c)
{
// Use AlwaysFalseT so the static_assert condition is dependent
// and only triggers when this constructor template is instantiated.
@@ -294,12 +295,13 @@ public:
"Use base_uint::fromRaw instead.");
}
template <class Container>
template <
class Container,
class = std::enable_if_t<
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>>>
static BaseUInt
fromRaw(Container const& c)
requires(
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>)
{
BaseUInt result;
XRPL_ASSERT(
@@ -310,11 +312,11 @@ public:
}
template <class Container>
BaseUInt&
std::enable_if_t<
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>,
BaseUInt&>
operator=(Container const& c)
requires(
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>)
{
XRPL_ASSERT(
c.size() * sizeof(typename Container::value_type) == size(),

54
include/xrpl/basics/comparators.h Normal file
View File

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

11
include/xrpl/basics/partitioned_unordered_map.h
View File

@@ -138,8 +138,11 @@ public:
{
}
ConstIterator(Iterator const& orig) : map(orig.map), ait(orig.ait), mit(orig.mit)
ConstIterator(Iterator const& orig)
{
map = orig.map;
ait = orig.ait;
mit = orig.mit;
}
const_reference
@@ -228,11 +231,11 @@ private:
public:
PartitionedUnorderedMap(std::optional<std::size_t> partitions = std::nullopt)
{
// Set partitions to the number of hardware threads if the parameter
// is either empty or set to 0.
: partitions_(
partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency())
{
partitions_ =
partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency();
map_.resize(partitions_);
XRPL_ASSERT(
partitions_,

29
include/xrpl/basics/random.h
View File

@@ -91,9 +91,8 @@ defaultPrng()
*/
/** @{ */
template <class Engine, class Integral>
Integral
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
randInt(Engine& engine, Integral min, Integral max)
requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
{
XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
@@ -104,41 +103,36 @@ randInt(Engine& engine, Integral min, Integral max)
}
template <class Integral>
Integral
std::enable_if_t<std::is_integral_v<Integral>, Integral>
randInt(Integral min, Integral max)
requires(std::is_integral_v<Integral>)
{
return randInt(defaultPrng(), min, max);
}
template <class Engine, class Integral>
Integral
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
randInt(Engine& engine, Integral max)
requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
{
return randInt(engine, Integral(0), max);
}
template <class Integral>
Integral
std::enable_if_t<std::is_integral_v<Integral>, Integral>
randInt(Integral max)
requires(std::is_integral_v<Integral>)
{
return randInt(defaultPrng(), max);
}
template <class Integral, class Engine>
Integral
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
randInt(Engine& engine)
requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
{
return randInt(engine, std::numeric_limits<Integral>::max());
}
template <class Integral = int>
Integral
std::enable_if_t<std::is_integral_v<Integral>, Integral>
randInt()
requires(std::is_integral_v<Integral>)
{
return randInt(defaultPrng(), std::numeric_limits<Integral>::max());
}
@@ -147,20 +141,19 @@ randInt()
/** Return a random byte */
/** @{ */
template <class Byte, class Engine>
Byte
std::enable_if_t<
(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
detail::is_engine<Engine>::value,
Byte>
randByte(Engine& engine)
requires(
(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
detail::is_engine<Engine>::value)
{
return static_cast<Byte>(randInt<Engine, std::uint32_t>(
engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
}
template <class Byte = std::uint8_t>
Byte
std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
randByte()
requires(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>)
{
return randByte<Byte>(defaultPrng());
}

20
include/xrpl/basics/safe_cast.h
View File

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

25
include/xrpl/basics/scope.h
View File

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

8
include/xrpl/basics/tagged_integer.h
View File

@@ -43,10 +43,10 @@ public:
TaggedInteger() = default;
template <class OtherInt>
explicit constexpr TaggedInteger(OtherInt value) noexcept
requires(std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int))
: value_(value)
template <
class OtherInt,
class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
explicit constexpr TaggedInteger(OtherInt value) noexcept : value_(value)
{
static_assert(sizeof(TaggedInteger) == sizeof(Int), "tagged_integer is adding padding");
}

4
include/xrpl/beast/container/aged_container_utility.h
View File

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

16
include/xrpl/beast/container/detail/aged_container_iterator.h
View File

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

190
include/xrpl/beast/container/detail/aged_ordered_container.h
View File

@@ -111,9 +111,10 @@ private:
{
}
template <class... Args>
template <
class... Args,
class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
Element(time_point const& when, Args&&... args)
requires(std::is_constructible_v<value_type, Args...>)
: value(std::forward<Args>(args)...), when(when)
{
}
@@ -359,7 +360,6 @@ private:
deleteElement(Element const* p)
{
ElementAllocatorTraits::destroy(config_.alloc(), p);
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
ElementAllocatorTraits::deallocate(config_.alloc(), const_cast<Element*>(p), 1);
}
@@ -608,25 +608,35 @@ public:
//
//--------------------------------------------------------------------------
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t<IsMap, T, void*>&
at(K const& k)
requires(MaybeMap && !MaybeMulti);
at(K const& k);
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional<IsMap, T, void*>::type const&
at(K const& k) const
requires(MaybeMap && !MaybeMulti);
at(K const& k) const;
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t<IsMap, T, void*>&
operator[](Key const& key)
requires(MaybeMap && !MaybeMulti);
operator[](Key const& key);
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t<IsMap, T, void*>&
operator[](Key&& key)
requires(MaybeMap && !MaybeMulti);
operator[](Key&& key);
//--------------------------------------------------------------------------
//
@@ -760,40 +770,35 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti);
insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multimap, multiset
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> iterator
requires MaybeMulti;
insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
// set
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value) -> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap);
insert(value_type&& value)
-> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
// multiset
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value) -> iterator
requires(MaybeMulti && !MaybeMap);
insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
//---
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(const_iterator hint, value_type const& value) -> iterator
requires(!MaybeMulti);
insert(const_iterator hint, value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>;
// multimap, multiset
template <bool MaybeMulti = IsMulti>
iterator
std::enable_if_t<MaybeMulti, iterator>
insert(const_iterator /*hint*/, value_type const& value)
requires MaybeMulti
{
// VFALCO TODO Figure out how to utilize 'hint'
return insert(value);
@@ -802,14 +807,12 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(const_iterator hint, value_type&& value) -> iterator
requires(!MaybeMulti);
insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>;
// multimap, multiset
template <bool MaybeMulti = IsMulti>
iterator
std::enable_if_t<MaybeMulti, iterator>
insert(const_iterator /*hint*/, value_type&& value)
requires MaybeMulti
{
// VFALCO TODO Figure out how to utilize 'hint'
return insert(std::move(value));
@@ -817,18 +820,20 @@ public:
// map, multimap
template <class P, bool MaybeMap = IsMap>
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
std::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(P&& value)
requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
{
return emplace(std::forward<P>(value));
}
// map, multimap
template <class P, bool MaybeMap = IsMap>
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
std::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(const_iterator hint, P&& value)
requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
{
return emplaceHint(hint, std::forward<P>(value));
}
@@ -850,45 +855,46 @@ public:
// map, set
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> iterator
requires MaybeMulti;
emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
// map, set
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplaceHint(const_iterator hint, Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
emplaceHint(const_iterator hint, Args&&... args)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
iterator
std::enable_if_t<MaybeMulti, iterator>
emplaceHint(const_iterator /*hint*/, Args&&... args)
requires MaybeMulti
{
// VFALCO TODO Figure out how to utilize 'hint'
return emplace<MaybeMulti>(std::forward<Args>(args)...);
}
// The constraint prevents erase (reverse_iterator pos) from compiling
template <bool IsConst, class Iterator>
// enable_if prevents erase (reverse_iterator pos) from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
beast::detail::AgedContainerIterator<false, Iterator>
erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
requires(!IsBoostReverseIterator<Iterator>::value);
erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos);
// The constraint prevents erase (reverse_iterator first, reverse_iterator last)
// enable_if prevents erase (reverse_iterator first, reverse_iterator last)
// from compiling
template <bool IsConst, class Iterator>
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
beast::detail::AgedContainerIterator<false, Iterator>
erase(
beast::detail::AgedContainerIterator<IsConst, Iterator> first,
beast::detail::AgedContainerIterator<IsConst, Iterator> last)
requires(!IsBoostReverseIterator<Iterator>::value);
beast::detail::AgedContainerIterator<IsConst, Iterator> last);
template <class K>
auto
@@ -899,11 +905,13 @@ public:
//--------------------------------------------------------------------------
// The constraint prevents touch (reverse_iterator pos) from compiling
template <bool IsConst, class Iterator>
// enable_if prevents touch (reverse_iterator pos) from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
void
touch(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
requires(!IsBoostReverseIterator<Iterator>::value)
{
touch(pos, clock().now());
}
@@ -1134,25 +1142,25 @@ public:
}
private:
// The constraint prevents erase (reverse_iterator pos, now) from compiling
template <bool IsConst, class Iterator>
// enable_if prevents erase (reverse_iterator pos, now) from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
void
touch(
beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
clock_type::time_point const& now)
requires(!IsBoostReverseIterator<Iterator>::value);
clock_type::time_point const& now);
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
void
swapData(AgedOrderedContainer& other) noexcept
requires MaybePropagate;
std::enable_if_t<MaybePropagate>
swapData(AgedOrderedContainer& other) noexcept;
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
void
swapData(AgedOrderedContainer& other) noexcept
requires(!MaybePropagate);
std::enable_if_t<!MaybePropagate>
swapData(AgedOrderedContainer& other) noexcept;
private:
ConfigT config_;
@@ -1361,10 +1369,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
//------------------------------------------------------------------------------
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <class K, bool MaybeMulti, bool MaybeMap>
template <class K, bool MaybeMulti, bool MaybeMap, class>
std::conditional_t<IsMap, T, void*>&
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k)
requires(MaybeMap && !MaybeMulti)
{
auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
if (iter == cont_.end())
@@ -1373,10 +1380,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
}
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <class K, bool MaybeMulti, bool MaybeMap>
template <class K, bool MaybeMulti, bool MaybeMap, class>
std::conditional<IsMap, T, void*>::type const&
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k) const
requires(MaybeMap && !MaybeMulti)
{
auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
if (iter == cont_.end())
@@ -1385,10 +1391,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
}
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool MaybeMulti, bool MaybeMap>
template <bool MaybeMulti, bool MaybeMap, class>
std::conditional_t<IsMap, T, void*>&
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
requires(MaybeMap && !MaybeMulti)
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1404,10 +1409,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
}
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool MaybeMulti, bool MaybeMap>
template <bool MaybeMulti, bool MaybeMap, class>
std::conditional_t<IsMap, T, void*>&
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
requires(MaybeMap && !MaybeMulti)
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1441,8 +1445,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool MaybeMulti>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti)
value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1461,8 +1464,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool MaybeMulti>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
value_type const& value) -> iterator
requires MaybeMulti
value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
{
auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
Element* const p(newElement(value));
@@ -1476,8 +1478,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool MaybeMulti, bool MaybeMap>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap)
-> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1496,8 +1497,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool MaybeMulti, bool MaybeMap>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-> iterator
requires(MaybeMulti && !MaybeMap)
-> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
{
auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
Element* const p(newElement(std::move(value)));
@@ -1514,8 +1514,7 @@ template <bool MaybeMulti>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
const_iterator hint,
value_type const& value) -> iterator
requires(!MaybeMulti)
value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>
{
typename cont_type::insert_commit_data d;
auto const result(
@@ -1536,8 +1535,7 @@ template <bool MaybeMulti>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
const_iterator hint,
value_type&& value) -> iterator
requires(!MaybeMulti)
value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>
{
typename cont_type::insert_commit_data d;
auto const result(
@@ -1557,8 +1555,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool MaybeMulti, class... Args>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-> std::pair<iterator, bool>
requires(!MaybeMulti)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
// VFALCO NOTE Its unfortunate that we need to
// construct element here
@@ -1580,8 +1577,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool MaybeMulti, class... Args>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-> iterator
requires MaybeMulti
-> std::enable_if_t<MaybeMulti, iterator>
{
Element* const p(newElement(std::forward<Args>(args)...));
auto const before(cont_.upper_bound(extract(p->value), std::cref(config_.keyCompare())));
@@ -1596,8 +1592,7 @@ template <bool MaybeMulti, class... Args>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplaceHint(
const_iterator hint,
Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti)
Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
// VFALCO NOTE Its unfortunate that we need to
// construct element here
@@ -1616,23 +1611,21 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace
}
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool IsConst, class Iterator>
template <bool IsConst, class Iterator, class>
beast::detail::AgedContainerIterator<false, Iterator>
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
requires(!IsBoostReverseIterator<Iterator>::value)
{
unlinkAndDeleteElement(&*((pos++).iterator()));
return beast::detail::AgedContainerIterator<false, Iterator>(pos.iterator());
}
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool IsConst, class Iterator>
template <bool IsConst, class Iterator, class>
beast::detail::AgedContainerIterator<false, Iterator>
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
beast::detail::AgedContainerIterator<IsConst, Iterator> first,
beast::detail::AgedContainerIterator<IsConst, Iterator> last)
requires(!IsBoostReverseIterator<Iterator>::value)
{
for (; first != last;)
unlinkAndDeleteElement(&*((first++).iterator()));
@@ -1735,12 +1728,11 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
//------------------------------------------------------------------------------
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool IsConst, class Iterator>
template <bool IsConst, class Iterator, class>
void
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
clock_type::time_point const& now)
requires(!IsBoostReverseIterator<Iterator>::value)
{
auto& e(*pos.iterator());
e.when = now;
@@ -1750,10 +1742,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool MaybePropagate>
void
std::enable_if_t<MaybePropagate>
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
AgedOrderedContainer& other) noexcept
requires MaybePropagate
{
std::swap(config_.keyCompare(), other.config_.keyCompare());
std::swap(config_.alloc(), other.config_.alloc());
@@ -1762,10 +1753,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapDat
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool MaybePropagate>
void
std::enable_if_t<!MaybePropagate>
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
AgedOrderedContainer& other) noexcept
requires(!MaybePropagate)
{
std::swap(config_.keyCompare(), other.config_.keyCompare());
std::swap(config_.clock, other.config_.clock);

193
include/xrpl/beast/container/detail/aged_unordered_container.h
View File

@@ -117,9 +117,10 @@ private:
{
}
template <class... Args>
template <
class... Args,
class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
Element(time_point const& when, Args&&... args)
requires(std::is_constructible_v<value_type, Args...>)
: value(std::forward<Args>(args)...), when(when)
{
}
@@ -528,7 +529,6 @@ private:
deleteElement(Element const* p)
{
ElementAllocatorTraits::destroy(config_.alloc(), p);
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
ElementAllocatorTraits::deallocate(config_.alloc(), const_cast<Element*>(p), 1);
}
@@ -841,25 +841,35 @@ public:
//
//--------------------------------------------------------------------------
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t<IsMap, T, void*>&
at(K const& k)
requires(MaybeMap && !MaybeMulti);
at(K const& k);
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional<IsMap, T, void*>::type const&
at(K const& k) const
requires(MaybeMap && !MaybeMulti);
at(K const& k) const;
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t<IsMap, T, void*>&
operator[](Key const& key)
requires(MaybeMap && !MaybeMulti);
operator[](Key const& key);
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
std::conditional_t<IsMap, T, void*>&
operator[](Key&& key)
requires(MaybeMap && !MaybeMulti);
operator[](Key&& key);
//--------------------------------------------------------------------------
//
@@ -957,32 +967,28 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti);
insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multimap, multiset
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> iterator
requires MaybeMulti;
insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
// map, set
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value) -> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap);
insert(value_type&& value)
-> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
// multimap, multiset
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value) -> iterator
requires(MaybeMulti && !MaybeMap);
insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
// map, set
template <bool MaybeMulti = IsMulti>
iterator
std::enable_if_t<!MaybeMulti, iterator>
insert(const_iterator /*hint*/, value_type const& value)
requires(!MaybeMulti)
{
// Hint is ignored but we provide the interface so
// callers may use ordered and unordered interchangeably.
@@ -991,9 +997,8 @@ public:
// multimap, multiset
template <bool MaybeMulti = IsMulti>
iterator
std::enable_if_t<MaybeMulti, iterator>
insert(const_iterator /*hint*/, value_type const& value)
requires MaybeMulti
{
// VFALCO TODO The hint could be used to let
// the client order equal ranges
@@ -1002,9 +1007,8 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
iterator
std::enable_if_t<!MaybeMulti, iterator>
insert(const_iterator /*hint*/, value_type&& value)
requires(!MaybeMulti)
{
// Hint is ignored but we provide the interface so
// callers may use ordered and unordered interchangeably.
@@ -1013,9 +1017,8 @@ public:
// multimap, multiset
template <bool MaybeMulti = IsMulti>
iterator
std::enable_if_t<MaybeMulti, iterator>
insert(const_iterator /*hint*/, value_type&& value)
requires MaybeMulti
{
// VFALCO TODO The hint could be used to let
// the client order equal ranges
@@ -1024,18 +1027,20 @@ public:
// map, multimap
template <class P, bool MaybeMap = IsMap>
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
std::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(P&& value)
requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
{
return emplace(std::forward<P>(value));
}
// map, multimap
template <class P, bool MaybeMap = IsMap>
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
std::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(const_iterator hint, P&& value)
requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
{
return emplaceHint(hint, std::forward<P>(value));
}
@@ -1056,26 +1061,23 @@ public:
// set, map
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> iterator
requires MaybeMulti;
emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
// set, map
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplaceHint(const_iterator /*hint*/, Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
emplaceHint(const_iterator /*hint*/, Args&&... args)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
iterator
std::enable_if_t<MaybeMulti, iterator>
emplaceHint(const_iterator /*hint*/, Args&&... args)
requires MaybeMulti
{
// VFALCO TODO The hint could be used for multi, to let
// the client order equal ranges
@@ -1306,7 +1308,7 @@ public:
class OtherHash,
class OtherAllocator,
bool MaybeMulti = IsMulti>
bool
std::enable_if_t<!MaybeMulti, bool>
operator==(AgedUnorderedContainer<
false,
OtherIsMap,
@@ -1315,8 +1317,7 @@ public:
OtherDuration,
OtherHash,
KeyEqual,
OtherAllocator> const& other) const
requires(!MaybeMulti);
OtherAllocator> const& other) const;
template <
bool OtherIsMap,
@@ -1326,7 +1327,7 @@ public:
class OtherHash,
class OtherAllocator,
bool MaybeMulti = IsMulti>
bool
std::enable_if_t<MaybeMulti, bool>
operator==(AgedUnorderedContainer<
true,
OtherIsMap,
@@ -1335,8 +1336,7 @@ public:
OtherDuration,
OtherHash,
KeyEqual,
OtherAllocator> const& other) const
requires MaybeMulti;
OtherAllocator> const& other) const;
template <
bool OtherIsMulti,
@@ -1381,14 +1381,13 @@ private:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insertUnchecked(value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti);
insertUnchecked(value_type const& value)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
// multimap, multiset
template <bool MaybeMulti = IsMulti>
auto
insertUnchecked(value_type const& value) -> iterator
requires MaybeMulti;
insertUnchecked(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
template <class InputIt>
void
@@ -1429,9 +1428,8 @@ private:
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
void
std::enable_if_t<MaybePropagate>
swapData(AgedUnorderedContainer& other) noexcept
requires MaybePropagate
{
std::swap(config_.hashFunction(), other.config_.hashFunction());
std::swap(config_.keyEq(), other.config_.keyEq());
@@ -1441,9 +1439,8 @@ private:
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
void
std::enable_if_t<!MaybePropagate>
swapData(AgedUnorderedContainer& other) noexcept
requires(!MaybePropagate)
{
std::swap(config_.hashFunction(), other.config_.hashFunction());
std::swap(config_.keyEq(), other.config_.keyEq());
@@ -2097,10 +2094,9 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <class K, bool MaybeMulti, bool MaybeMap>
template <class K, bool MaybeMulti, bool MaybeMap, class>
std::conditional_t<IsMap, T, void*>&
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(K const& k)
requires(MaybeMap && !MaybeMulti)
{
auto const iter(
cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2118,11 +2114,10 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <class K, bool MaybeMulti, bool MaybeMap>
template <class K, bool MaybeMulti, bool MaybeMap, class>
std::conditional<IsMap, T, void*>::type const&
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(
K const& k) const
requires(MaybeMap && !MaybeMulti)
{
auto const iter(
cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2140,11 +2135,10 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <bool MaybeMulti, bool MaybeMap>
template <bool MaybeMulti, bool MaybeMap, class>
std::conditional_t<IsMap, T, void*>&
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
Key const& key)
requires(MaybeMap && !MaybeMulti)
{
maybeRehash(1);
typename cont_type::insert_commit_data d;
@@ -2170,11 +2164,10 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <bool MaybeMulti, bool MaybeMap>
template <bool MaybeMulti, bool MaybeMap, class>
std::conditional_t<IsMap, T, void*>&
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
Key&& key)
requires(MaybeMap && !MaybeMulti)
{
maybeRehash(1);
typename cont_type::insert_commit_data d;
@@ -2227,8 +2220,7 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti)
value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
maybeRehash(1);
typename cont_type::insert_commit_data d;
@@ -2257,8 +2249,7 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type const& value) -> iterator
requires MaybeMulti
value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
{
maybeRehash(1);
Element* const p(newElement(value));
@@ -2280,8 +2271,7 @@ template <
template <bool MaybeMulti, bool MaybeMap>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type&& value) -> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap)
value_type&& value) -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
{
maybeRehash(1);
typename cont_type::insert_commit_data d;
@@ -2310,8 +2300,7 @@ template <
template <bool MaybeMulti, bool MaybeMap>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type&& value) -> iterator
requires(MaybeMulti && !MaybeMap)
value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
{
maybeRehash(1);
Element* const p(newElement(std::move(value)));
@@ -2320,6 +2309,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
return iterator(iter);
}
#if 1 // Use insert() instead of insert_check() insert_commit()
// set, map
template <
bool IsMulti,
@@ -2333,8 +2323,7 @@ template <
template <bool MaybeMulti, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti)
Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
maybeRehash(1);
// VFALCO NOTE Its unfortunate that we need to
@@ -2349,6 +2338,42 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
deleteElement(p);
return std::make_pair(iterator(result.first), false);
}
#else // As original, use insert_check() / insert_commit () pair.
// set, map
template <
bool IsMulti,
bool IsMap,
class Key,
class T,
class Clock,
class Hash,
class KeyEqual,
class Allocator>
template <bool maybe_multi, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
{
maybe_rehash(1);
// VFALCO NOTE Its unfortunate that we need to
// construct element here
element* const p(new_element(std::forward<Args>(args)...));
typename cont_type::insert_commit_data d;
auto const result(m_cont.insert_check(
extract(p->value),
std::cref(m_config.hashFunction()),
std::cref(m_config.keyValueEqual()),
d));
if (result.second)
{
auto const iter(m_cont.insert_commit(*p, d));
chronological.list.push_back(*p);
return std::make_pair(iterator(iter), true);
}
delete_element(p);
return std::make_pair(iterator(result.first), false);
}
#endif // 0
// multiset, multimap
template <
@@ -2363,8 +2388,7 @@ template <
template <bool MaybeMulti, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> iterator
requires MaybeMulti
Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>
{
maybeRehash(1);
Element* const p(newElement(std::forward<Args>(args)...));
@@ -2387,8 +2411,7 @@ template <bool MaybeMulti, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplaceHint(
const_iterator /*hint*/,
Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti)
Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
maybeRehash(1);
// VFALCO NOTE Its unfortunate that we need to
@@ -2539,7 +2562,7 @@ template <
class OtherHash,
class OtherAllocator,
bool MaybeMulti>
bool
std::enable_if_t<!MaybeMulti, bool>
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
AgedUnorderedContainer<
false,
@@ -2550,7 +2573,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
OtherHash,
KeyEqual,
OtherAllocator> const& other) const
requires(!MaybeMulti)
{
if (size() != other.size())
return false;
@@ -2580,7 +2602,7 @@ template <
class OtherHash,
class OtherAllocator,
bool MaybeMulti>
bool
std::enable_if_t<MaybeMulti, bool>
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
AgedUnorderedContainer<
true,
@@ -2591,7 +2613,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
OtherHash,
KeyEqual,
OtherAllocator> const& other) const
requires MaybeMulti
{
if (size() != other.size())
return false;
@@ -2628,8 +2649,7 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti)
value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(
@@ -2657,8 +2677,7 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
value_type const& value) -> iterator
requires MaybeMulti
value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
{
Element* const p(newElement(value));
chronological.list_.push_back(*p);

9
include/xrpl/beast/core/LexicalCast.h
View File

@@ -29,18 +29,16 @@ struct LexicalCast<std::string, In>
explicit LexicalCast() = default;
template <class Arithmetic = In>
bool
std::enable_if_t<std::is_arithmetic_v<Arithmetic>, bool>
operator()(std::string& out, Arithmetic in)
requires(std::is_arithmetic_v<Arithmetic>)
{
out = std::to_string(in);
return true;
}
template <class Enumeration = In>
bool
std::enable_if_t<std::is_enum_v<Enumeration>, bool>
operator()(std::string& out, Enumeration in)
requires(std::is_enum_v<Enumeration>)
{
out = std::to_string(static_cast<std::underlying_type_t<Enumeration>>(in));
return true;
@@ -58,9 +56,8 @@ struct LexicalCast<Out, std::string_view>
"beast::LexicalCast can only be used with integral types");
template <class Integral = Out>
bool
std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, bool>
operator()(Integral& out, std::string_view in) const
requires(std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>)
{
auto first = in.data();
auto last = in.data() + in.size();

2
include/xrpl/beast/core/LockFreeStack.h
View File

@@ -41,7 +41,7 @@ public:
operator=(NodePtr node)
{
node_ = node;
return *this;
return static_cast<LockFreeStackIterator&>(*this);
}
LockFreeStackIterator&

123
include/xrpl/beast/hash/hash_append.h
View File

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

12
include/xrpl/beast/hash/xxhasher.h
View File

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

5
include/xrpl/beast/insight/Gauge.h
View File

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

1
include/xrpl/beast/type_name.h
View File

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

6
include/xrpl/beast/unit_test/suite_list.h
View File

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

5
include/xrpl/beast/unit_test/thread.h
View File

@@ -45,10 +45,7 @@ public:
template <class F, class... Args>
explicit Thread(Suite& s, F&& f, Args&&... args) : s_(&s)
{
std::function<void(void)> b = [f = std::forward<F>(f),
... args = std::forward<Args>(args)]() mutable {
std::invoke(f, args...);
};
std::function<void(void)> b = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
t_ = std::thread(&Thread::run, this, std::move(b));
}

48
include/xrpl/beast/utility/Journal.h
View File

@@ -108,12 +108,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(!std::is_default_constructible_v<Sink>);
static_assert(!std::is_copy_constructible_v<Sink>);
static_assert(!std::is_move_constructible_v<Sink>);
static_assert(!std::is_copy_assignable_v<Sink>);
static_assert(!std::is_move_assignable_v<Sink>);
static_assert(std::is_nothrow_destructible_v<Sink>);
static_assert(!std::is_default_constructible_v<Sink>, "");
static_assert(!std::is_copy_constructible_v<Sink>, "");
static_assert(!std::is_move_constructible_v<Sink>, "");
static_assert(!std::is_copy_assignable_v<Sink>, "");
static_assert(!std::is_move_assignable_v<Sink>, "");
static_assert(std::is_nothrow_destructible_v<Sink>, "");
#endif
/** Returns a Sink which does nothing. */
@@ -164,12 +164,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(!std::is_default_constructible_v<ScopedStream>);
static_assert(std::is_copy_constructible_v<ScopedStream>);
static_assert(std::is_move_constructible_v<ScopedStream>);
static_assert(!std::is_copy_assignable_v<ScopedStream>);
static_assert(!std::is_move_assignable_v<ScopedStream>);
static_assert(std::is_nothrow_destructible_v<ScopedStream>);
static_assert(!std::is_default_constructible_v<ScopedStream>, "");
static_assert(std::is_copy_constructible_v<ScopedStream>, "");
static_assert(std::is_move_constructible_v<ScopedStream>, "");
static_assert(!std::is_copy_assignable_v<ScopedStream>, "");
static_assert(!std::is_move_assignable_v<ScopedStream>, "");
static_assert(std::is_nothrow_destructible_v<ScopedStream>, "");
#endif
//--------------------------------------------------------------------------
@@ -246,12 +246,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(std::is_default_constructible_v<Stream>);
static_assert(std::is_copy_constructible_v<Stream>);
static_assert(std::is_move_constructible_v<Stream>);
static_assert(!std::is_copy_assignable_v<Stream>);
static_assert(!std::is_move_assignable_v<Stream>);
static_assert(std::is_nothrow_destructible_v<Stream>);
static_assert(std::is_default_constructible_v<Stream>, "");
static_assert(std::is_copy_constructible_v<Stream>, "");
static_assert(std::is_move_constructible_v<Stream>, "");
static_assert(!std::is_copy_assignable_v<Stream>, "");
static_assert(!std::is_move_assignable_v<Stream>, "");
static_assert(std::is_nothrow_destructible_v<Stream>, "");
#endif
//--------------------------------------------------------------------------
@@ -329,12 +329,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(!std::is_default_constructible_v<Journal>);
static_assert(std::is_copy_constructible_v<Journal>);
static_assert(std::is_move_constructible_v<Journal>);
static_assert(std::is_copy_assignable_v<Journal>);
static_assert(std::is_move_assignable_v<Journal>);
static_assert(std::is_nothrow_destructible_v<Journal>);
static_assert(!std::is_default_constructible_v<Journal>, "");
static_assert(std::is_copy_constructible_v<Journal>, "");
static_assert(std::is_move_constructible_v<Journal>, "");
static_assert(std::is_copy_assignable_v<Journal>, "");
static_assert(std::is_move_assignable_v<Journal>, "");
static_assert(std::is_nothrow_destructible_v<Journal>, "");
#endif
//------------------------------------------------------------------------------

4
include/xrpl/beast/utility/Zero.h
View File

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

11
include/xrpl/beast/utility/rngfill.h
View File

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

2
include/xrpl/core/HashRouter.h
View File

@@ -127,7 +127,7 @@ private:
}
[[nodiscard]] HashRouterFlags
getFlags() const
getFlags(void) const
{
return flags_;
}

8
include/xrpl/core/JobQueue.h
View File

@@ -154,14 +154,16 @@ public:
@param type The type of job.
@param name Name of the job.
@param jobHandler Callable with signature void(). Called when the job is executed.
@param jobHandler Lambda with signature void (Job&). Called when the
job is executed.
@return true if jobHandler added to queue.
*/
template <typename JobHandler>
template <
typename JobHandler,
typename = std::enable_if_t<std::is_same_v<decltype(std::declval<JobHandler&&>()()), void>>>
bool
addJob(JobType type, std::string const& name, JobHandler&& jobHandler)
requires(std::is_void_v<std::invoke_result_t<JobHandler>>)
{
if (auto optionalCountedJob = jobCounter_.wrap(std::forward<JobHandler>(jobHandler)))
{

2
include/xrpl/core/JobTypes.h
View File

@@ -118,7 +118,7 @@ public:
[[nodiscard]] JobTypeInfo const&
get(JobType jt) const
{
auto const iter = map.find(jt);
Map::const_iterator const iter(map.find(jt));
XRPL_ASSERT(iter != map.end(), "xrpl::JobTypes::get : valid input");
if (iter != map.end())

2
include/xrpl/json/json_reader.h
View File

@@ -154,7 +154,7 @@ private:
Location end,
unsigned int& unicode);
bool
addError(std::string const& message, Token& token, Location extra = nullptr);
addError(std::string const& message, Token& token, Location extra = 0);
bool
recoverFromError(TokenType skipUntilToken);
bool

2
include/xrpl/ledger/ApplyView.h
View File

@@ -5,7 +5,7 @@
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Issue.h> // IWYU pragma: keep
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/MPTIssue.h>

2
include/xrpl/ledger/CachedView.h
View File

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

2
include/xrpl/ledger/OpenView.h
View File

@@ -82,7 +82,7 @@ private:
using txs_map = std::map<
key_type,
TxData,
std::less<>,
std::less<key_type>,
boost::container::pmr::polymorphic_allocator<std::pair<key_type const, TxData>>>;
// monotonic_resource_ must outlive `items_`. Make a pointer so it may be

2
include/xrpl/ledger/ReadView.h
View File

@@ -7,7 +7,7 @@
#include <xrpl/ledger/detail/ReadViewFwdRange.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Fees.h>
#include <xrpl/protocol/Issue.h> // IWYU pragma: keep
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/LedgerHeader.h>

2
include/xrpl/ledger/detail/RawStateTable.h
View File

@@ -105,7 +105,7 @@ private:
using items_t = std::map<
key_type,
SleAction,
std::less<>,
std::less<key_type>,
boost::container::pmr::polymorphic_allocator<std::pair<key_type const, SleAction>>>;
// monotonic_resource_ must outlive `items_`. Make a pointer so it may be
// easily moved.

4
include/xrpl/ledger/detail/ReadViewFwdRange.h
View File

@@ -108,8 +108,8 @@ public:
std::optional<value_type> mutable cache_;
};
static_assert(std::is_nothrow_move_constructible<Iterator>{});
static_assert(std::is_nothrow_move_assignable<Iterator>{});
static_assert(std::is_nothrow_move_constructible<Iterator>{}, "");
static_assert(std::is_nothrow_move_assignable<Iterator>{}, "");
using const_iterator = Iterator;

14
include/xrpl/ledger/helpers/DirectoryHelpers.h
View File

@@ -19,7 +19,11 @@ namespace xrpl {
namespace detail {
template <class V, class N>
template <
class V,
class N,
class = std::enable_if_t<
std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
bool
internalDirNext(
V& view,
@@ -27,7 +31,6 @@ internalDirNext(
std::shared_ptr<N>& page,
unsigned int& index,
uint256& entry)
requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
{
auto const& svIndexes = page->getFieldV256(sfIndexes);
XRPL_ASSERT(index <= svIndexes.size(), "xrpl::detail::internalDirNext : index inside range");
@@ -65,7 +68,11 @@ internalDirNext(
return true;
}
template <class V, class N>
template <
class V,
class N,
class = std::enable_if_t<
std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
bool
internalDirFirst(
V& view,
@@ -73,7 +80,6 @@ internalDirFirst(
std::shared_ptr<N>& page,
unsigned int& index,
uint256& entry)
requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
{
if constexpr (std::is_const_v<N>)
{

2
include/xrpl/ledger/helpers/EscrowHelpers.h
View File

@@ -53,7 +53,7 @@ escrowUnlockApplyHelper<Issue>(
bool createAsset,
beast::Journal journal)
{
auto const& issue = amount.get<Issue>();
Issue const& issue = amount.get<Issue>();
Keylet const trustLineKey = keylet::trustLine(receiver, issue);
bool const recvLow = issuer > receiver;
bool const senderIssuer = issuer == sender;

2
include/xrpl/ledger/helpers/LendingHelpers.h
View File

@@ -8,7 +8,7 @@
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/LedgerFormats.h> // IWYU pragma: keep
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/SField.h>

9
include/xrpl/net/AutoSocket.h
View File

@@ -120,9 +120,12 @@ public:
socket_->next_layer().async_receive(
boost::asio::buffer(buffer_),
boost::asio::socket_base::message_peek,
[this, cbFunc](error_code const& ec, size_t bytesTransferred) {
handleAutodetect(cbFunc, ec, bytesTransferred);
});
std::bind(
&AutoSocket::handleAutodetect,
this,
cbFunc,
std::placeholders::_1,
std::placeholders::_2));
}
}

24
include/xrpl/net/HTTPClientSSLContext.h
View File

@@ -13,6 +13,7 @@
#include <openssl/err.h>
#include <openssl/tls1.h>
#include <functional>
#include <stdexcept>
#include <string>
#include <type_traits>
@@ -83,12 +84,13 @@ public:
*
* @return error_code indicating failures, if any
*/
template <class T>
template <
class T,
class = std::enable_if_t<
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)
requires(
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 ec;
if (!SSL_set_tlsext_host_name(strm.native_handle(), host.c_str()))
@@ -102,7 +104,11 @@ public:
return ec;
}
template <class T>
template <
class T,
class = std::enable_if_t<
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.
@@ -112,9 +118,6 @@ public:
*/
boost::system::error_code
postConnectVerify(T& strm, std::string const& host)
requires(
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 ec;
@@ -124,9 +127,8 @@ public:
if (!ec)
{
strm.set_verify_callback(
[host, j = j_](bool preverified, boost::asio::ssl::verify_context& ctx) {
return rfc6125Verify(host, preverified, ctx, j);
},
std::bind(
&rfc6125Verify, host, std::placeholders::_1, std::placeholders::_2, j_),
ec);
}
}

6
include/xrpl/nodestore/detail/DecodedBlob.h
View File

@@ -34,11 +34,11 @@ public:
createObject();
private:
bool success_{false};
bool success_;
void const* key_;
NodeObjectType objectType_{NodeObjectType::Unknown};
unsigned char const* objectData_{nullptr};
NodeObjectType objectType_;
unsigned char const* objectData_;
int dataBytes_;
};

8
include/xrpl/nodestore/detail/codec.h
View File

@@ -62,7 +62,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
std::array<std::uint8_t, varint_traits<std::size_t>::kMax> vi{};
auto const n = writeVarint(vi.data(), inSize);
auto const outMax = LZ4_compressBound(inSize);
auto* out = reinterpret_cast<std::uint8_t*>(bf(n + outMax));
std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(n + outMax));
result.first = out;
std::memcpy(out, vi.data(), n);
auto const outSize = LZ4_compress_default(
@@ -90,7 +90,7 @@ nodeobjectDecompress(void const* in, std::size_t inSize, BufferFactory&& bf)
{
using namespace nudb::detail;
auto const* p = reinterpret_cast<std::uint8_t const*>(in);
std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(in);
std::size_t type = 0;
auto const vn = readVarint(p, inSize, type);
if (vn == 0)
@@ -237,7 +237,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf)
auto const vs = sizeVarint(type);
result.second = vs + field<std::uint16_t>::size + // mask
(n * 32); // hashes
auto* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
result.first = out;
ostream os(out, result.second);
write<varint>(os, type);
@@ -249,7 +249,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf)
auto const type = 3U;
auto const vs = sizeVarint(type);
result.second = vs + (n * 32); // hashes
auto* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
result.first = out;
ostream os(out, result.second);
write<varint>(os, type);

13
include/xrpl/nodestore/detail/varint.h
View File

@@ -39,7 +39,7 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
if (buflen == 0)
return 0;
t = 0;
auto const* p = reinterpret_cast<std::uint8_t const*>(buf);
std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(buf);
std::size_t n = 0;
while (p[n] & 0x80)
{
@@ -68,10 +68,9 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
return used;
}
template <class T>
template <class T, std::enable_if_t<std::is_unsigned_v<T>>* = nullptr>
std::size_t
sizeVarint(T v)
requires(std::is_unsigned_v<T>)
{
std::size_t n = 0;
do
@@ -87,7 +86,7 @@ std::size_t
writeVarint(void* p0, std::size_t v)
{
// NOLINTNEXTLINE(misc-const-correctness)
auto* p = reinterpret_cast<std::uint8_t*>(p0);
std::uint8_t* p = reinterpret_cast<std::uint8_t*>(p0);
do
{
std::uint8_t d = v % 127;
@@ -101,10 +100,9 @@ writeVarint(void* p0, std::size_t v)
// input stream
template <class T>
template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
void
read(nudb::detail::istream& is, std::size_t& u)
requires(std::is_same_v<T, varint>)
{
auto p0 = is(1);
auto p1 = p0;
@@ -115,10 +113,9 @@ read(nudb::detail::istream& is, std::size_t& u)
// output stream
template <class T>
template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
void
write(nudb::detail::ostream& os, std::size_t t)
requires(std::is_same_v<T, varint>)
{
writeVarint(os.data(sizeVarint(t)), t);
}

2
include/xrpl/protocol/AmountConversions.h
View File

@@ -13,7 +13,7 @@
#include <xrpl/protocol/XRPAmount.h>
#include <cstdint>
#include <limits> // IWYU pragma: keep
#include <limits>
#include <stdexcept>
#include <type_traits>

2
include/xrpl/protocol/Quality.h
View File

@@ -282,7 +282,7 @@ public:
auto const maxVMantissa = mantissa(maxV);
auto const expDiff = exponent(maxV) - exponent(minV);
auto const minVD = static_cast<double>(minVMantissa);
double const minVD = static_cast<double>(minVMantissa);
double const maxVD =
(expDiff != 0) ? maxVMantissa * pow(10, expDiff) : static_cast<double>(maxVMantissa);

28
include/xrpl/protocol/STArray.h
View File

@@ -32,13 +32,17 @@ public:
STArray() = default;
STArray(STArray const&) = default;
template <class Iter>
explicit STArray(Iter first, Iter last)
requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>);
template <
class Iter,
class = std::enable_if_t<
std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>>>
explicit STArray(Iter first, Iter last);
template <class Iter>
STArray(SField const& f, Iter first, Iter last)
requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>);
template <
class Iter,
class = std::enable_if_t<
std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>>>
STArray(SField const& f, Iter first, Iter last);
STArray&
operator=(STArray const&) = default;
@@ -166,17 +170,13 @@ private:
friend class detail::STVar;
};
template <class Iter>
STArray::STArray(Iter first, Iter last)
requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>)
: v_(first, last)
template <class Iter, class>
STArray::STArray(Iter first, Iter last) : v_(first, last)
{
}
template <class Iter>
STArray::STArray(SField const& f, Iter first, Iter last)
requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>)
: STBase(f), v_(first, last)
template <class Iter, class>
STArray::STArray(SField const& f, Iter first, Iter last) : STBase(f), v_(first, last)
{
}

2
include/xrpl/protocol/STBitString.h
View File

@@ -148,7 +148,7 @@ template <int Bits>
bool
STBitString<Bits>::isEquivalent(STBase const& t) const
{
auto const* v = dynamic_cast<STBitString const*>(&t);
STBitString const* v = dynamic_cast<STBitString const*>(&t);
return v && (value_ == v->value_);
}

2
include/xrpl/protocol/STInteger.h
View File

@@ -115,7 +115,7 @@ template <typename Integer>
inline bool
STInteger<Integer>::isEquivalent(STBase const& t) const
{
auto const* v = dynamic_cast<STInteger const*>(&t);
STInteger const* v = dynamic_cast<STInteger const*>(&t);
return v && (value_ == v->value_);
}

23
include/xrpl/protocol/STObject.h
View File

@@ -555,14 +555,9 @@ public:
ValueProxy&
operator=(ValueProxy const&) = delete;
// Write-through proxy: assignment sets the referenced field to the given
// value, so it intentionally takes the assigned value rather than a
// ValueProxy.
template <class U>
// NOLINTNEXTLINE(misc-unconventional-assign-operator)
ValueProxy&
operator=(U&& u)
requires(std::is_assignable_v<T, U>);
std::enable_if_t<std::is_assignable_v<T, U>, ValueProxy&>
operator=(U&& u);
// Convenience operators for value types supporting
// arithmetic operations
@@ -696,9 +691,8 @@ public:
operator=(optional_type const& v);
template <class U>
OptionalProxy&
operator=(U&& u)
requires(std::is_assignable_v<T, U>);
std::enable_if_t<std::is_assignable_v<T, U>, OptionalProxy&>
operator=(U&& u);
private:
friend class STObject;
@@ -804,10 +798,8 @@ STObject::Proxy<T>::assign(U&& u)
template <class T>
template <class U>
// NOLINTNEXTLINE(misc-unconventional-assign-operator)
STObject::ValueProxy<T>&
std::enable_if_t<std::is_assignable_v<T, U>, STObject::ValueProxy<T>&>
STObject::ValueProxy<T>::operator=(U&& u)
requires(std::is_assignable_v<T, U>)
{
this->assign(std::forward<U>(u));
return *this;
@@ -910,9 +902,8 @@ STObject::OptionalProxy<T>::operator=(optional_type const& v) -> OptionalProxy&
template <class T>
template <class U>
STObject::OptionalProxy<T>&
std::enable_if_t<std::is_assignable_v<T, U>, STObject::OptionalProxy<T>&>
STObject::OptionalProxy<T>::operator=(U&& u)
requires(std::is_assignable_v<T, U>)
{
this->assign(std::forward<U>(u));
return *this;
@@ -1250,7 +1241,7 @@ template <typename T, typename V>
void
STObject::setFieldUsingSetValue(SField const& field, V value)
{
static_assert(!std::is_lvalue_reference_v<V>);
static_assert(!std::is_lvalue_reference_v<V>, "");
STBase* rf = getPField(field, true);

6
include/xrpl/protocol/STPathSet.h
View File

@@ -240,9 +240,6 @@ private:
inline STPathElement::STPathElement() : type_(TypeNone), isOffer_(true)
{
// hashValue_ is derived from the whole object, so it is computed in the body
// once every other member is initialized (as in the other constructors).
// NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
hashValue_ = getHash(*this);
}
@@ -318,9 +315,6 @@ inline STPathElement::STPathElement(
assetID_.visit(
[&](Currency const&) { type_ = type_ & (~Type::TypeMpt); },
[&](MPTID const&) { type_ = type_ & (~Type::TypeCurrency); });
// hashValue_ must be computed after type_ is adjusted above, so this cannot
// be a member initializer.
// NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
hashValue_ = getHash(*this);
}

2
include/xrpl/protocol/Serializer.h
View File

@@ -334,7 +334,7 @@ public:
template <int N>
explicit SerialIter(std::uint8_t const (&data)[N]) : SerialIter(&data[0], N)
{
static_assert(N > 0);
static_assert(N > 0, "");
}
[[nodiscard]] bool

59
include/xrpl/protocol/TER.h
View File

@@ -413,7 +413,7 @@ TERtoInt(TECcodes v)
//------------------------------------------------------------------------------
// Template class that is specific to selected ranges of error codes. The
// Trait tells the requires-clause which ranges are allowed.
// Trait tells std::enable_if which ranges are allowed.
template <template <typename> class Trait>
class TERSubset
{
@@ -439,11 +439,11 @@ public:
return TERSubset(from);
}
// Trait tells the requires-clause which types are allowed for construction.
template <typename T>
constexpr TERSubset(T rhs)
requires(Trait<std::remove_cv_t<std::remove_reference_t<T>>>::value)
: code_(TERtoInt(rhs))
// Trait tells enable_if which types are allowed for construction.
template <
typename T,
typename = std::enable_if_t<Trait<std::remove_cv_t<std::remove_reference_t<T>>>::value>>
constexpr TERSubset(T rhs) : code_(TERtoInt(rhs))
{
}
@@ -453,11 +453,10 @@ public:
constexpr TERSubset&
operator=(TERSubset&& rhs) = default;
// Trait tells the requires-clause which types are allowed for assignment.
// Trait tells enable_if which types are allowed for assignment.
template <typename T>
constexpr auto
operator=(T rhs) -> TERSubset&
requires(Trait<T>::value)
operator=(T rhs) -> std::enable_if_t<Trait<T>::value, TERSubset&>
{
code_ = TERtoInt(rhs);
return *this;
@@ -511,60 +510,54 @@ public:
// Only enabled if both arguments return int if TERtiInt is called with them.
template <typename L, typename R>
constexpr auto
operator==(L const& lhs, R const& rhs) -> bool
requires(
std::is_same_v<decltype(TERtoInt(lhs)), int> &&
std::is_same_v<decltype(TERtoInt(rhs)), int>)
operator==(L const& lhs, R const& rhs) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
{
return TERtoInt(lhs) == TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
operator!=(L const& lhs, R const& rhs) -> bool
requires(
std::is_same_v<decltype(TERtoInt(lhs)), int> &&
std::is_same_v<decltype(TERtoInt(rhs)), int>)
operator!=(L const& lhs, R const& rhs) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
{
return TERtoInt(lhs) != TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
operator<(L const& lhs, R const& rhs) -> bool
requires(
std::is_same_v<decltype(TERtoInt(lhs)), int> &&
std::is_same_v<decltype(TERtoInt(rhs)), int>)
operator<(L const& lhs, R const& rhs) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
{
return TERtoInt(lhs) < TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
operator<=(L const& lhs, R const& rhs) -> bool
requires(
std::is_same_v<decltype(TERtoInt(lhs)), int> &&
std::is_same_v<decltype(TERtoInt(rhs)), int>)
operator<=(L const& lhs, R const& rhs) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
{
return TERtoInt(lhs) <= TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
operator>(L const& lhs, R const& rhs) -> bool
requires(
std::is_same_v<decltype(TERtoInt(lhs)), int> &&
std::is_same_v<decltype(TERtoInt(rhs)), int>)
operator>(L const& lhs, R const& rhs) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
{
return TERtoInt(lhs) > TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
operator>=(L const& lhs, R const& rhs) -> bool
requires(
std::is_same_v<decltype(TERtoInt(lhs)), int> &&
std::is_same_v<decltype(TERtoInt(rhs)), int>)
operator>=(L const& lhs, R const& rhs) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
{
return TERtoInt(lhs) >= TERtoInt(rhs);
}

7
include/xrpl/protocol/detail/STVar.h
View File

@@ -50,13 +50,14 @@ public:
STVar&
operator=(STVar&& rhs);
// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
STVar(STBase&& t) : p_(t.move(kMaxSize, &d_))
STVar(STBase&& t) // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
{
p_ = t.move(kMaxSize, &d_);
}
STVar(STBase const& t) : p_(t.copy(kMaxSize, &d_))
STVar(STBase const& t)
{
p_ = t.copy(kMaxSize, &d_);
}
STVar(DefaultObjectT, SField const& name);

6
include/xrpl/protocol/detail/features.macro
View File

@@ -16,9 +16,9 @@
// Keep it sorted in reverse chronological order.
XRPL_FEATURE(Sponsor, Supported::No, VoteBehavior::DefaultNo)
XRPL_FEATURE(BatchV1_1, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(BatchV1_1, Supported::No, VoteBehavior::DefaultNo)
XRPL_FEATURE(LendingProtocolV1_1, Supported::No, VoteBehavior::DefaultNo)
XRPL_FEATURE(ConfidentialTransfer, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(ConfidentialTransfer, Supported::No, VoteBehavior::DefaultNo)
XRPL_FIX (Cleanup3_3_0, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FIX (Cleanup3_2_0, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(MPTokensV2, Supported::No, VoteBehavior::DefaultNo)
@@ -61,6 +61,7 @@ XRPL_FEATURE(PriceOracle, Supported::Yes, VoteBehavior::DefaultNo
XRPL_FIX (AMMOverflowOffer, Supported::Yes, VoteBehavior::DefaultYes)
XRPL_FIX (FillOrKill, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(DID, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FIX (DisallowIncomingV1, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(XChainBridge, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(AMM, Supported::Yes, VoteBehavior::DefaultNo)
XRPL_FEATURE(XRPFees, Supported::Yes, VoteBehavior::DefaultNo)
@@ -100,7 +101,6 @@ XRPL_RETIRE_FIX(1623)
XRPL_RETIRE_FIX(1781)
XRPL_RETIRE_FIX(AmendmentMajorityCalc)
XRPL_RETIRE_FIX(CheckThreading)
XRPL_RETIRE_FIX(DisallowIncomingV1)
XRPL_RETIRE_FIX(InnerObjTemplate)
XRPL_RETIRE_FIX(MasterKeyAsRegularKey)
XRPL_RETIRE_FIX(NonFungibleTokensV1_2)

5
include/xrpl/resource/detail/Logic.h
View File

@@ -351,9 +351,10 @@ public:
Import& import(iter->second);
if (iter->second.whenExpires <= elapsed)
{
for (auto& item : import.items)
for (auto itemIter(import.items.begin()); itemIter != import.items.end();
++itemIter)
{
item.consumer.entry().remoteBalance -= item.balance;
itemIter->consumer.entry().remoteBalance -= itemIter->balance;
}
iter = importTable_.erase(iter);

5
include/xrpl/server/Manifest.h
View File

@@ -161,12 +161,13 @@ deserializeManifest(
return deserializeManifest(makeSlice(s), journal);
}
template <class T>
template <
class T,
class = std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>>>
std::optional<Manifest>
deserializeManifest(
std::vector<T> const& v,
beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
{
return deserializeManifest(makeSlice(v), journal);
}

74
include/xrpl/server/detail/BaseHTTPPeer.h
View File

@@ -223,7 +223,10 @@ BaseHTTPPeer<Handler, Impl>::close()
{
if (!strand_.running_in_this_thread())
{
return post(strand_, [self = impl().shared_from_this()] { self->close(); });
return post(
strand_,
std::bind(
(void (BaseHTTPPeer::*)(void))&BaseHTTPPeer::close, impl().shared_from_this()));
}
boost::beast::get_lowest_layer(impl().stream_).close();
}
@@ -319,18 +322,22 @@ BaseHTTPPeer<Handler, Impl>::onWrite(error_code const& ec, std::size_t bytesTran
v,
bind_executor(
strand_,
[self = impl().shared_from_this()](
error_code const& ec, std::size_t bytesTransferred) {
self->onWrite(ec, bytesTransferred);
}));
std::bind(
&BaseHTTPPeer::onWrite,
impl().shared_from_this(),
std::placeholders::_1,
std::placeholders::_2)));
}
if (!complete_)
return;
if (graceful_)
return doClose();
util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
self->doRead(doYield);
});
util::spawn(
strand_,
std::bind(
&BaseHTTPPeer<Handler, Impl>::doRead,
impl().shared_from_this(),
std::placeholders::_1));
}
template <class Handler, class Impl>
@@ -344,9 +351,14 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
{
auto const p = impl().shared_from_this();
resume = std::function<void(void)>([this, p, writer, keepAlive]() {
util::spawn(strand_, [p, writer, keepAlive](yield_context doYield) {
p->doWriter(writer, keepAlive, doYield);
});
util::spawn(
strand_,
std::bind(
&BaseHTTPPeer<Handler, Impl>::doWriter,
p,
writer,
keepAlive,
std::placeholders::_1));
});
}
@@ -367,9 +379,12 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
if (!keepAlive)
return doClose();
util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
self->doRead(doYield);
});
util::spawn(
strand_,
std::bind(
&BaseHTTPPeer<Handler, Impl>::doRead,
impl().shared_from_this(),
std::placeholders::_1));
}
//------------------------------------------------------------------------------
@@ -390,7 +405,8 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
if (!strand_.running_in_this_thread())
{
return post(
strand_, [self = impl().shared_from_this()] { self->onWrite(error_code{}, 0); });
strand_,
std::bind(&BaseHTTPPeer::onWrite, impl().shared_from_this(), error_code{}, 0));
}
return onWrite(error_code{}, 0);
}
@@ -401,9 +417,13 @@ void
BaseHTTPPeer<Handler, Impl>::write(std::shared_ptr<Writer> const& writer, bool keepAlive)
{
util::spawn(
strand_, [self = impl().shared_from_this(), writer, keepAlive](yield_context doYield) {
self->doWriter(writer, keepAlive, doYield);
});
strand_,
std::bind(
&BaseHTTPPeer<Handler, Impl>::doWriter,
impl().shared_from_this(),
writer,
keepAlive,
std::placeholders::_1));
}
// DEPRECATED
@@ -423,7 +443,8 @@ BaseHTTPPeer<Handler, Impl>::complete()
{
if (!strand_.running_in_this_thread())
{
return post(strand_, [self = impl().shared_from_this()] { self->complete(); });
return post(
strand_, std::bind(&BaseHTTPPeer<Handler, Impl>::complete, impl().shared_from_this()));
}
message_ = {};
@@ -436,9 +457,12 @@ BaseHTTPPeer<Handler, Impl>::complete()
}
// keep-alive
util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
self->doRead(doYield);
});
util::spawn(
strand_,
std::bind(
&BaseHTTPPeer<Handler, Impl>::doRead,
impl().shared_from_this(),
std::placeholders::_1));
}
// DEPRECATED
@@ -450,7 +474,11 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
if (!strand_.running_in_this_thread())
{
return post(
strand_, [self = impl().shared_from_this(), graceful] { self->close(graceful); });
strand_,
std::bind(
(void (BaseHTTPPeer::*)(bool))&BaseHTTPPeer<Handler, Impl>::close,
impl().shared_from_this(),
graceful));
}
complete_ = true;

3
include/xrpl/server/detail/BasePeer.h
View File

@@ -10,6 +10,7 @@
#include <atomic>
#include <chrono>
#include <functional>
#include <string>
#include <utility>
@@ -83,7 +84,7 @@ void
BasePeer<Handler, Impl>::close()
{
if (!strand_.running_in_this_thread())
return post(strand_, [self = impl().shared_from_this()] { self->close(); });
return post(strand_, std::bind(&BasePeer::close, impl().shared_from_this()));
error_code ec;
xrpl::getLowestLayer(impl().ws_).socket().close(ec);
}

66
include/xrpl/server/detail/BaseWSPeer.h
View File

@@ -20,7 +20,6 @@
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <functional>
#include <iterator>
#include <list>
@@ -181,13 +180,12 @@ void
BaseWSPeer<Handler, Impl>::run()
{
if (!strand_.running_in_this_thread())
return post(strand_, [self = impl().shared_from_this()] { self->run(); });
return post(strand_, std::bind(&BaseWSPeer::run, impl().shared_from_this()));
impl().ws_.set_option(port().pmdOptions);
// Must manage the control callback memory outside of the `control_callback`
// function
controlCallback_ = [this](
boost::beast::websocket::frame_type kind,
boost::beast::string_view payload) { onPingPong(kind, payload); };
controlCallback_ =
std::bind(&BaseWSPeer::onPingPong, this, std::placeholders::_1, std::placeholders::_2);
impl().ws_.control_callback(controlCallback_);
startTimer();
closeOnTimer_ = true;
@@ -195,9 +193,11 @@ BaseWSPeer<Handler, Impl>::run()
res.set(boost::beast::http::field::server, BuildInfo::getFullVersionString());
}));
impl().ws_.async_accept(
request_, bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
self->onWsHandshake(ec);
}));
request_,
bind_executor(
strand_,
std::bind(
&BaseWSPeer::onWsHandshake, impl().shared_from_this(), std::placeholders::_1)));
}
template <class Handler, class Impl>
@@ -205,10 +205,7 @@ void
BaseWSPeer<Handler, Impl>::send(std::shared_ptr<WSMsg> w)
{
if (!strand_.running_in_this_thread())
{
return post(
strand_, [self = impl().shared_from_this(), w = std::move(w)] { self->send(w); });
}
return post(strand_, std::bind(&BaseWSPeer::send, impl().shared_from_this(), std::move(w)));
if (doClose_)
return;
if (wq_.size() > port().wsQueueLimit)
@@ -261,7 +258,7 @@ void
BaseWSPeer<Handler, Impl>::complete()
{
if (!strand_.running_in_this_thread())
return post(strand_, [self = impl().shared_from_this()] { self->complete(); });
return post(strand_, std::bind(&BaseWSPeer::complete, impl().shared_from_this()));
doRead();
}
@@ -280,7 +277,7 @@ void
BaseWSPeer<Handler, Impl>::doWrite()
{
if (!strand_.running_in_this_thread())
return post(strand_, [self = impl().shared_from_this()] { self->doWrite(); });
return post(strand_, std::bind(&BaseWSPeer::doWrite, impl().shared_from_this()));
onWrite({});
}
@@ -291,7 +288,8 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
if (ec)
return fail(ec, "write");
auto& w = *wq_.front();
auto const result = w.prepare(65536, [self = impl().shared_from_this()] { self->doWrite(); });
auto const result =
w.prepare(65536, std::bind(&BaseWSPeer::doWrite, impl().shared_from_this()));
if (boost::indeterminate(result.first))
return;
startTimer();
@@ -301,9 +299,8 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
static_cast<bool>(result.first),
result.second,
bind_executor(
strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
self->onWrite(ec);
}));
strand_,
std::bind(&BaseWSPeer::onWrite, impl().shared_from_this(), std::placeholders::_1)));
}
else
{
@@ -311,9 +308,9 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
static_cast<bool>(result.first),
result.second,
bind_executor(
strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
self->onWriteFin(ec);
}));
strand_,
std::bind(
&BaseWSPeer::onWriteFin, impl().shared_from_this(), std::placeholders::_1)));
}
}
@@ -327,9 +324,10 @@ BaseWSPeer<Handler, Impl>::onWriteFin(error_code const& ec)
if (doClose_)
{
impl().ws_.async_close(
cr_, bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
self->onClose(ec);
}));
cr_,
bind_executor(
strand_,
std::bind(&BaseWSPeer::onClose, impl().shared_from_this(), std::placeholders::_1)));
}
else if (!wq_.empty())
{
@@ -342,13 +340,12 @@ void
BaseWSPeer<Handler, Impl>::doRead()
{
if (!strand_.running_in_this_thread())
return post(strand_, [self = impl().shared_from_this()] { self->doRead(); });
return post(strand_, std::bind(&BaseWSPeer::doRead, impl().shared_from_this()));
impl().ws_.async_read(
rb_,
bind_executor(
strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
self->onRead(ec);
}));
strand_,
std::bind(&BaseWSPeer::onRead, impl().shared_from_this(), std::placeholders::_1)));
}
template <class Handler, class Impl>
@@ -392,7 +389,11 @@ BaseWSPeer<Handler, Impl>::startTimer()
}
timer_.async_wait(bind_executor(
strand_, [self = impl().shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
strand_,
std::bind(
&BaseWSPeer<Handler, Impl>::onTimer,
impl().shared_from_this(),
std::placeholders::_1)));
}
// Convenience for discarding the error code
@@ -460,9 +461,10 @@ BaseWSPeer<Handler, Impl>::onTimer(error_code ec)
beast::rngfill(payload_.begin(), payload_.size(), cryptoPrng());
impl().ws_.async_ping(
payload_,
bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
self->onPing(ec);
}));
bind_executor(
strand_,
std::bind(
&BaseWSPeer::onPing, impl().shared_from_this(), std::placeholders::_1)));
JLOG(this->j_.trace()) << "sent ping";
return;
}

9
include/xrpl/server/detail/Door.h
View File

@@ -33,6 +33,7 @@
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <sstream>
@@ -181,7 +182,7 @@ void
Door<Handler>::Detector::run()
{
util::spawn(
strand_, [self = this->shared_from_this()](yield_context yield) { self->doDetect(yield); });
strand_, std::bind(&Detector::doDetect, this->shared_from_this(), std::placeholders::_1));
}
template <class Handler>
@@ -296,7 +297,8 @@ void
Door<Handler>::run()
{
util::spawn(
strand_, [self = this->shared_from_this()](yield_context yield) { self->doAccept(yield); });
strand_,
std::bind(&Door<Handler>::doAccept, this->shared_from_this(), std::placeholders::_1));
}
template <class Handler>
@@ -305,7 +307,8 @@ Door<Handler>::close()
{
if (!strand_.running_in_this_thread())
{
return boost::asio::post(strand_, [self = this->shared_from_this()] { self->close(); });
return boost::asio::post(
strand_, std::bind(&Door<Handler>::close, this->shared_from_this()));
}
backoffTimer_.cancel();
error_code ec;

10
include/xrpl/server/detail/PlainHTTPPeer.h
View File

@@ -9,6 +9,7 @@
#include <boost/beast/core/tcp_stream.hpp>
#include <functional>
#include <memory>
#include <utility>
@@ -88,9 +89,7 @@ PlainHTTPPeer<Handler>::run()
{
if (!this->handler_.onAccept(this->session(), this->remoteAddress_))
{
util::spawn(this->strand_, [self = this->shared_from_this()](boost::asio::yield_context) {
self->doClose();
});
util::spawn(this->strand_, std::bind(&PlainHTTPPeer::doClose, this->shared_from_this()));
return;
}
@@ -98,9 +97,8 @@ PlainHTTPPeer<Handler>::run()
return;
util::spawn(
this->strand_, [self = this->shared_from_this()](boost::asio::yield_context doYield) {
self->doRead(doYield);
});
this->strand_,
std::bind(&PlainHTTPPeer::doRead, this->shared_from_this(), std::placeholders::_1));
}
template <class Handler>

18
include/xrpl/server/detail/SSLHTTPPeer.h
View File

@@ -13,6 +13,7 @@
#include <boost/beast/core/tcp_stream.hpp>
#include <boost/beast/ssl/ssl_stream.hpp>
#include <functional>
#include <memory>
#include <utility>
@@ -98,15 +99,14 @@ SSLHTTPPeer<Handler>::run()
{
if (!this->handler_.onAccept(this->session(), this->remoteAddress_))
{
util::spawn(
this->strand_, [self = this->shared_from_this()](yield_context) { self->doClose(); });
util::spawn(this->strand_, std::bind(&SSLHTTPPeer::doClose, this->shared_from_this()));
return;
}
if (!socket_.is_open())
return;
util::spawn(this->strand_, [self = this->shared_from_this()](yield_context doYield) {
self->doHandshake(doYield);
});
util::spawn(
this->strand_,
std::bind(&SSLHTTPPeer::doHandshake, this->shared_from_this(), std::placeholders::_1));
}
template <class Handler>
@@ -142,9 +142,9 @@ SSLHTTPPeer<Handler>::doHandshake(yield_context doYield)
this->port().protocol.count("https") > 0;
if (http)
{
util::spawn(this->strand_, [self = this->shared_from_this()](yield_context doYield) {
self->doRead(doYield);
});
util::spawn(
this->strand_,
std::bind(&SSLHTTPPeer::doRead, this->shared_from_this(), std::placeholders::_1));
return;
}
// `this` will be destroyed
@@ -172,7 +172,7 @@ SSLHTTPPeer<Handler>::doClose()
this->startTimer();
stream_.async_shutdown(bind_executor(
this->strand_,
[self = this->shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
std::bind(&SSLHTTPPeer::onShutdown, this->shared_from_this(), std::placeholders::_1)));
}
template <class Handler>

2
include/xrpl/shamap/FullBelowCache.h
View File

@@ -103,7 +103,7 @@ public:
/** generation determines whether cached entry is valid */
std::uint32_t
getGeneration() const
getGeneration(void) const
{
return gen_;
}

1
include/xrpl/shamap/SHAMapItem.h
View File

@@ -138,7 +138,6 @@ intrusive_ptr_release(SHAMapItem const* x)
// If the slabber doesn't claim this pointer, it was allocated
// manually, so we free it manually.
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
if (!detail::gSlabber.deallocate(const_cast<std::uint8_t*>(p)))
delete[] p;
}

1
include/xrpl/tx/paths/OfferStream.h
View File

@@ -92,7 +92,6 @@ public:
[[nodiscard]] TOffer<TIn, TOut>&
tip() const
{
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
return const_cast<TOfferStreamBase*>(this)->offer_;
}

2
include/xrpl/tx/paths/detail/EitherAmount.h
View File

@@ -6,7 +6,7 @@
#include <xrpl/protocol/MPTAmount.h> // IWYU pragma: keep
#include <xrpl/protocol/XRPAmount.h>
#include <ostream> // IWYU pragma: keep
#include <ostream>
#include <stdexcept>
#include <variant>