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

Merge remote-tracking branch 'XRPLF/develop' into ximinez/number-maxint-range

Browse Source 
* XRPLF/develop:
  test: Migrate basics Beast tests to GTest (7136)
  test: Migrate resource, shamap Beast tests to GTest (7133)
  chore: Enable most misc checks (7663)
  chore: Fix unity build (7730)
  chore: Enable most modernize checks (7664)
  chore: Delete dead code (7718)
  chore: Enable modernize-use-constraints (7715)
  chore: Enable modernize-avoid-bind (7711)
This commit is contained in:
Ed Hennis
2026-07-06 20:42:48 -04:00
parent 82ca28f329 f5e63f8a91
commit 642e09ac0a
155 changed files with 6014 additions and 6526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
include/xrpl/basics/Number.h
View File

@@ -643,19 +643,26 @@ public:
std::pair<T, int>
normalizeToRange() const;
class Access
{
/** May use ranges that don't fit the restrictions of the "real"
* normalizeToRange().
*
*/
template <Integral64 T>
[[nodiscard]]
static std::pair<T, int>
normalizeToRangeImpl(
Number const& n,
T minMantissa,
T maxMantissa,
MantissaRange::CuspRoundingFix fix);
friend class Number;
friend class NumberTest;
};
private:
/** May use ranges that don't fit the restrictions of the "real"
* normalizeToRange().
*
*/
template <Integral64 T>
[[nodiscard]]
std::pair<T, int>
normalizeToRangeImpl(T minMantissa, T maxMantissa, MantissaRange::CuspRoundingFix fix) const;
// Number_test needs to use normalizeToRangeImpl
friend class Number_test;
static thread_local RoundingMode mode;
// The available ranges for mantissa
@@ -956,7 +963,8 @@ Number::normalizeToRange() const
// Don't need to worry about the cuspRounding fix because rounding up will never take the
// mantissa over maxMantissa with a ones digit value other than 0. 0 can safely be truncated.
return normalizeToRangeImpl(kMIN, kMAX, MantissaRange::CuspRoundingFix::Disabled);
return Access::normalizeToRangeImpl(
*this, kMIN, kMAX, MantissaRange::CuspRoundingFix::Disabled);
}
/** Only intended to be used in tests
@@ -968,11 +976,15 @@ Number::normalizeToRange() const
template <Integral64 T>
[[nodiscard]]
std::pair<T, int>
Number::normalizeToRangeImpl(T minMantissa, T maxMantissa, MantissaRange::CuspRoundingFix fix) const
Number::Access::normalizeToRangeImpl(
Number const& n,
T minMantissa,
T maxMantissa,
MantissaRange::CuspRoundingFix fix)
{
bool negative = mantissa_ < 0;
internalrep mantissa = externalToInternal(mantissa_);
int exponent = exponent_;
bool negative = n.mantissa_ < 0;
internalrep mantissa = externalToInternal(n.mantissa_);
int exponent = n.exponent_;
if constexpr (std::is_unsigned_v<T>)
{

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

@@ -211,15 +211,17 @@ operator<<(Stream& s, Slice const& v)
}
template <class T, std::size_t N>
std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
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>
std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
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,11 +212,13 @@ public:
*/
template <class ReturnType = bool>
auto
insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>;
insert(key_type const& key, T const& value) -> ReturnType
requires(!IsKeyCache);
template <class ReturnType = bool>
auto
insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
insert(key_type const& key) -> ReturnType
requires IsKeyCache;
// 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,7 +57,10 @@ inline TaggedCache<
beast::insight::Collector::ptr const& collector)
: journal_(journal)
, clock_(clock)
, stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
, stats_(
name,
[this] { collectMetrics(); },
collector)
, name_(name)
, targetSize_(size)
, targetAge_(expiration)
@@ -500,7 +503,8 @@ template <
template <class ReturnType>
inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
insert(key_type const& key, T const& value) -> ReturnType
requires(!IsKeyCache)
{
static_assert(
std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -530,7 +534,8 @@ template <
template <class ReturnType>
inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
insert(key_type const& key) -> ReturnType
requires IsKeyCache
{
std::scoped_lock const lock(mutex_);
clock_type::time_point const now(clock_.now());

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

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

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

@@ -280,12 +280,11 @@ public:
{
}
template <
class Container,
class = std::enable_if_t<
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>>>
template <class Container>
explicit BaseUInt(Container const& c)
requires(
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>)
{
// Use AlwaysFalseT so the static_assert condition is dependent
// and only triggers when this constructor template is instantiated.
@@ -295,13 +294,12 @@ public:
"Use base_uint::fromRaw instead.");
}
template <
class Container,
class = std::enable_if_t<
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>>>
template <class Container>
static BaseUInt
fromRaw(Container const& c)
requires(
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>)
{
BaseUInt result;
XRPL_ASSERT(
@@ -312,11 +310,11 @@ public:
}
template <class Container>
std::enable_if_t<
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>,
BaseUInt&>
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
View File

@@ -1,54 +0,0 @@
#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

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

@@ -91,8 +91,9 @@ defaultPrng()
*/
/** @{ */
template <class Engine, class Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
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");
@@ -103,36 +104,41 @@ randInt(Engine& engine, Integral min, Integral max)
}
template <class Integral>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
Integral
randInt(Integral min, Integral max)
requires(std::is_integral_v<Integral>)
{
return randInt(defaultPrng(), min, max);
}
template <class Engine, class Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
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>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
Integral
randInt(Integral max)
requires(std::is_integral_v<Integral>)
{
return randInt(defaultPrng(), max);
}
template <class Integral, class Engine>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
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>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
Integral
randInt()
requires(std::is_integral_v<Integral>)
{
return randInt(defaultPrng(), std::numeric_limits<Integral>::max());
}
@@ -141,19 +147,20 @@ randInt()
/** Return a random byte */
/** @{ */
template <class Byte, class Engine>
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>
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>
std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
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,5 +1,7 @@
#pragma once
#include <xrpl/beast/utility/instrumentation.h> // IWYU pragma: keep
#include <type_traits>
namespace xrpl {
@@ -15,8 +17,9 @@ concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
: sizeof(Dest) >= sizeof(Src));
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr 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");
@@ -28,15 +31,17 @@ safeCast(Src s) noexcept
}
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr 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 std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
constexpr 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));
}
@@ -46,8 +51,9 @@ safeCast(Src s) noexcept
// underlying types become safe, it can be converted to a safe_cast.
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr Dest
unsafeCast(Src s) noexcept
requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
{
static_assert(
!SafeToCast<Src, Dest>,
@@ -57,15 +63,17 @@ unsafeCast(Src s) noexcept
}
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr 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 std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
constexpr 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,11 +46,9 @@ public:
operator=(ScopeExit&&) = delete;
template <class 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
explicit ScopeExit(EFP&& f) noexcept
requires(
!std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> && std::is_constructible_v<EF, EFP>)
: exitFunction_{std::forward<EFP>(f)}
{
static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -93,11 +91,9 @@ public:
operator=(ScopeFail&&) = delete;
template <class 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
explicit ScopeFail(EFP&& f) noexcept
requires(
!std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> && std::is_constructible_v<EF, EFP>)
: exitFunction_{std::forward<EFP>(f)}
{
static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -140,12 +136,11 @@ public:
operator=(ScopeSuccess&&) = delete;
template <class EFP>
explicit ScopeSuccess(
EFP&& f,
std::enable_if_t<
explicit ScopeSuccess(EFP&& f) noexcept(
std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
requires(
!std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
std::is_constructible_v<EF, EFP>>* =
0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
std::is_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,
class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
explicit constexpr TaggedInteger(OtherInt value) noexcept : value_(value)
template <class OtherInt>
explicit constexpr TaggedInteger(OtherInt value) noexcept
requires(std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int))
: 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::enable_if_t<IsAgedContainer<AgedContainer>::value, std::size_t>
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,20 +30,19 @@ 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,
class = std::enable_if_t<
(!OtherIsConst || IsConst) &&
!static_cast<bool>(std::is_same_v<Iterator, OtherIterator>)>>
template <bool OtherIsConst, class OtherIterator>
explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
requires(
(!OtherIsConst || IsConst) &&
!static_cast<bool>(std::is_same_v<Iterator, OtherIterator>))
: iter_(other.iter_)
{
}
// Disable constructing a const_iterator from a non-const_iterator.
template <bool OtherIsConst, class = std::enable_if_t<!OtherIsConst || IsConst>>
template <bool OtherIsConst>
AgedContainerIterator(AgedContainerIterator<OtherIsConst, Iterator> const& other)
requires(!OtherIsConst || IsConst)
: iter_(other.iter_)
{
}
@@ -52,7 +51,8 @@ public:
template <bool OtherIsConst, class OtherIterator>
auto
operator=(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-> std::enable_if_t<!OtherIsConst || IsConst, AgedContainerIterator&>
-> AgedContainerIterator&
requires(!OtherIsConst || IsConst)
{
iter_ = other.iter_;
return *this;

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

@@ -111,10 +111,9 @@ private:
{
}
template <
class... Args,
class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
template <class... Args>
Element(time_point const& when, Args&&... args)
requires(std::is_constructible_v<value_type, Args...>)
: value(std::forward<Args>(args)...), when(when)
{
}
@@ -608,35 +607,25 @@ public:
//
//--------------------------------------------------------------------------
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional_t<IsMap, T, void*>&
at(K const& k);
at(K const& k)
requires(MaybeMap && !MaybeMulti);
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional<IsMap, T, void*>::type const&
at(K const& k) const;
at(K const& k) const
requires(MaybeMap && !MaybeMulti);
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional_t<IsMap, T, void*>&
operator[](Key const& key);
operator[](Key const& key)
requires(MaybeMap && !MaybeMulti);
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional_t<IsMap, T, void*>&
operator[](Key&& key);
operator[](Key&& key)
requires(MaybeMap && !MaybeMulti);
//--------------------------------------------------------------------------
//
@@ -770,35 +759,40 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
insert(value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multimap, multiset
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
insert(value_type const& value) -> iterator
requires MaybeMulti;
// set
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value)
-> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
insert(value_type&& value) -> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap);
// multiset
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
insert(value_type&& value) -> iterator
requires(MaybeMulti && !MaybeMap);
//---
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(const_iterator hint, value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>;
insert(const_iterator hint, value_type const& value) -> iterator
requires(!MaybeMulti);
// multimap, multiset
template <bool MaybeMulti = IsMulti>
std::enable_if_t<MaybeMulti, iterator>
iterator
insert(const_iterator /*hint*/, value_type const& value)
requires MaybeMulti
{
// VFALCO TODO Figure out how to utilize 'hint'
return insert(value);
@@ -807,12 +801,14 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>;
insert(const_iterator hint, value_type&& value) -> iterator
requires(!MaybeMulti);
// multimap, multiset
template <bool MaybeMulti = IsMulti>
std::enable_if_t<MaybeMulti, iterator>
iterator
insert(const_iterator /*hint*/, value_type&& value)
requires MaybeMulti
{
// VFALCO TODO Figure out how to utilize 'hint'
return insert(std::move(value));
@@ -820,20 +816,18 @@ public:
// map, multimap
template <class P, bool MaybeMap = IsMap>
std::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
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::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
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));
}
@@ -855,46 +849,45 @@ public:
// map, set
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
emplace(Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
emplace(Args&&... args) -> iterator
requires MaybeMulti;
// map, set
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplaceHint(const_iterator hint, Args&&... args)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
emplaceHint(const_iterator hint, Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
std::enable_if_t<MaybeMulti, iterator>
iterator
emplaceHint(const_iterator /*hint*/, Args&&... args)
requires MaybeMulti
{
// VFALCO TODO Figure out how to utilize 'hint'
return emplace<MaybeMulti>(std::forward<Args>(args)...);
}
// enable_if prevents erase (reverse_iterator pos) from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
// The constraint prevents erase (reverse_iterator pos) from compiling
template <bool IsConst, class Iterator>
beast::detail::AgedContainerIterator<false, Iterator>
erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos);
erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
requires(!IsBoostReverseIterator<Iterator>::value);
// enable_if prevents erase (reverse_iterator first, reverse_iterator last)
// The constraint prevents erase (reverse_iterator first, reverse_iterator last)
// from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
template <bool IsConst, class Iterator>
beast::detail::AgedContainerIterator<false, Iterator>
erase(
beast::detail::AgedContainerIterator<IsConst, Iterator> first,
beast::detail::AgedContainerIterator<IsConst, Iterator> last);
beast::detail::AgedContainerIterator<IsConst, Iterator> last)
requires(!IsBoostReverseIterator<Iterator>::value);
template <class K>
auto
@@ -905,13 +898,11 @@ public:
//--------------------------------------------------------------------------
// enable_if prevents touch (reverse_iterator pos) from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
// The constraint prevents touch (reverse_iterator pos) from compiling
template <bool IsConst, class Iterator>
void
touch(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
requires(!IsBoostReverseIterator<Iterator>::value)
{
touch(pos, clock().now());
}
@@ -1142,25 +1133,25 @@ public:
}
private:
// enable_if prevents erase (reverse_iterator pos, now) from compiling
template <
bool IsConst,
class Iterator,
class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
// The constraint prevents erase (reverse_iterator pos, now) from compiling
template <bool IsConst, class Iterator>
void
touch(
beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
clock_type::time_point const& now);
clock_type::time_point const& now)
requires(!IsBoostReverseIterator<Iterator>::value);
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t<MaybePropagate>
swapData(AgedOrderedContainer& other) noexcept;
void
swapData(AgedOrderedContainer& other) noexcept
requires MaybePropagate;
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t<!MaybePropagate>
swapData(AgedOrderedContainer& other) noexcept;
void
swapData(AgedOrderedContainer& other) noexcept
requires(!MaybePropagate);
private:
ConfigT config_;
@@ -1369,9 +1360,10 @@ 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, class>
template <class K, bool MaybeMulti, bool MaybeMap>
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())
@@ -1380,9 +1372,10 @@ 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, class>
template <class K, bool MaybeMulti, bool MaybeMap>
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())
@@ -1391,9 +1384,10 @@ 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, class>
template <bool MaybeMulti, bool MaybeMap>
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));
@@ -1409,9 +1403,10 @@ 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, class>
template <bool MaybeMulti, bool MaybeMap>
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));
@@ -1445,7 +1440,8 @@ 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::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti)
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1464,7 +1460,8 @@ 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::enable_if_t<MaybeMulti, iterator>
value_type const& value) -> iterator
requires MaybeMulti
{
auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
Element* const p(newElement(value));
@@ -1478,7 +1475,8 @@ 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::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
-> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap)
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1497,7 +1495,8 @@ 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::enable_if_t<MaybeMulti && !MaybeMap, iterator>
-> iterator
requires(MaybeMulti && !MaybeMap)
{
auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
Element* const p(newElement(std::move(value)));
@@ -1514,7 +1513,8 @@ template <bool MaybeMulti>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
const_iterator hint,
value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>
value_type const& value) -> iterator
requires(!MaybeMulti)
{
typename cont_type::insert_commit_data d;
auto const result(
@@ -1535,7 +1535,8 @@ template <bool MaybeMulti>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
const_iterator hint,
value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>
value_type&& value) -> iterator
requires(!MaybeMulti)
{
typename cont_type::insert_commit_data d;
auto const result(
@@ -1555,7 +1556,8 @@ 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::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
-> std::pair<iterator, bool>
requires(!MaybeMulti)
{
// VFALCO NOTE Its unfortunate that we need to
// construct element here
@@ -1577,7 +1579,8 @@ 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::enable_if_t<MaybeMulti, iterator>
-> iterator
requires MaybeMulti
{
Element* const p(newElement(std::forward<Args>(args)...));
auto const before(cont_.upper_bound(extract(p->value), std::cref(config_.keyCompare())));
@@ -1592,7 +1595,8 @@ template <bool MaybeMulti, class... Args>
auto
AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplaceHint(
const_iterator hint,
Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti)
{
// VFALCO NOTE Its unfortunate that we need to
// construct element here
@@ -1611,21 +1615,23 @@ 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, class>
template <bool IsConst, class Iterator>
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, class>
template <bool IsConst, class Iterator>
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()));
@@ -1728,11 +1734,12 @@ 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, class>
template <bool IsConst, class Iterator>
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;
@@ -1742,9 +1749,10 @@ 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>
std::enable_if_t<MaybePropagate>
void
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());
@@ -1753,9 +1761,10 @@ 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>
std::enable_if_t<!MaybePropagate>
void
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);

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

@@ -117,10 +117,9 @@ private:
{
}
template <
class... Args,
class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
template <class... Args>
Element(time_point const& when, Args&&... args)
requires(std::is_constructible_v<value_type, Args...>)
: value(std::forward<Args>(args)...), when(when)
{
}
@@ -841,35 +840,25 @@ public:
//
//--------------------------------------------------------------------------
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional_t<IsMap, T, void*>&
at(K const& k);
at(K const& k)
requires(MaybeMap && !MaybeMulti);
template <
class K,
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional<IsMap, T, void*>::type const&
at(K const& k) const;
at(K const& k) const
requires(MaybeMap && !MaybeMulti);
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional_t<IsMap, T, void*>&
operator[](Key const& key);
operator[](Key const& key)
requires(MaybeMap && !MaybeMulti);
template <
bool MaybeMulti = IsMulti,
bool MaybeMap = IsMap,
class = std::enable_if_t<MaybeMap && !MaybeMulti>>
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
std::conditional_t<IsMap, T, void*>&
operator[](Key&& key);
operator[](Key&& key)
requires(MaybeMap && !MaybeMulti);
//--------------------------------------------------------------------------
//
@@ -967,28 +956,32 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
insert(value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multimap, multiset
template <bool MaybeMulti = IsMulti>
auto
insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
insert(value_type const& value) -> iterator
requires MaybeMulti;
// map, set
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value)
-> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
insert(value_type&& value) -> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap);
// multimap, multiset
template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
auto
insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
insert(value_type&& value) -> iterator
requires(MaybeMulti && !MaybeMap);
// map, set
template <bool MaybeMulti = IsMulti>
std::enable_if_t<!MaybeMulti, iterator>
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.
@@ -997,8 +990,9 @@ public:
// multimap, multiset
template <bool MaybeMulti = IsMulti>
std::enable_if_t<MaybeMulti, iterator>
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
@@ -1007,8 +1001,9 @@ public:
// map, set
template <bool MaybeMulti = IsMulti>
std::enable_if_t<!MaybeMulti, iterator>
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.
@@ -1017,8 +1012,9 @@ public:
// multimap, multiset
template <bool MaybeMulti = IsMulti>
std::enable_if_t<MaybeMulti, iterator>
iterator
insert(const_iterator /*hint*/, value_type&& value)
requires MaybeMulti
{
// VFALCO TODO The hint could be used to let
// the client order equal ranges
@@ -1027,20 +1023,18 @@ public:
// map, multimap
template <class P, bool MaybeMap = IsMap>
std::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
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::enable_if_t<
MaybeMap && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
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));
}
@@ -1061,23 +1055,26 @@ public:
// set, map
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
emplace(Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
emplace(Args&&... args) -> iterator
requires MaybeMulti;
// set, map
template <bool MaybeMulti = IsMulti, class... Args>
auto
emplaceHint(const_iterator /*hint*/, Args&&... args)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
emplaceHint(const_iterator /*hint*/, Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multiset, multimap
template <bool MaybeMulti = IsMulti, class... Args>
std::enable_if_t<MaybeMulti, iterator>
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
@@ -1308,7 +1305,7 @@ public:
class OtherHash,
class OtherAllocator,
bool MaybeMulti = IsMulti>
std::enable_if_t<!MaybeMulti, bool>
bool
operator==(AgedUnorderedContainer<
false,
OtherIsMap,
@@ -1317,7 +1314,8 @@ public:
OtherDuration,
OtherHash,
KeyEqual,
OtherAllocator> const& other) const;
OtherAllocator> const& other) const
requires(!MaybeMulti);
template <
bool OtherIsMap,
@@ -1327,7 +1325,7 @@ public:
class OtherHash,
class OtherAllocator,
bool MaybeMulti = IsMulti>
std::enable_if_t<MaybeMulti, bool>
bool
operator==(AgedUnorderedContainer<
true,
OtherIsMap,
@@ -1336,7 +1334,8 @@ public:
OtherDuration,
OtherHash,
KeyEqual,
OtherAllocator> const& other) const;
OtherAllocator> const& other) const
requires MaybeMulti;
template <
bool OtherIsMulti,
@@ -1381,13 +1380,14 @@ private:
// map, set
template <bool MaybeMulti = IsMulti>
auto
insertUnchecked(value_type const& value)
-> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
insertUnchecked(value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti);
// multimap, multiset
template <bool MaybeMulti = IsMulti>
auto
insertUnchecked(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
insertUnchecked(value_type const& value) -> iterator
requires MaybeMulti;
template <class InputIt>
void
@@ -1428,8 +1428,9 @@ private:
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t<MaybePropagate>
void
swapData(AgedUnorderedContainer& other) noexcept
requires MaybePropagate
{
std::swap(config_.hashFunction(), other.config_.hashFunction());
std::swap(config_.keyEq(), other.config_.keyEq());
@@ -1439,8 +1440,9 @@ private:
template <
bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
std::enable_if_t<!MaybePropagate>
void
swapData(AgedUnorderedContainer& other) noexcept
requires(!MaybePropagate)
{
std::swap(config_.hashFunction(), other.config_.hashFunction());
std::swap(config_.keyEq(), other.config_.keyEq());
@@ -2094,9 +2096,10 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <class K, bool MaybeMulti, bool MaybeMap, class>
template <class K, bool MaybeMulti, bool MaybeMap>
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())));
@@ -2114,10 +2117,11 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <class K, bool MaybeMulti, bool MaybeMap, class>
template <class K, bool MaybeMulti, bool MaybeMap>
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())));
@@ -2135,10 +2139,11 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <bool MaybeMulti, bool MaybeMap, class>
template <bool MaybeMulti, bool MaybeMap>
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;
@@ -2164,10 +2169,11 @@ template <
class Hash,
class KeyEqual,
class Allocator>
template <bool MaybeMulti, bool MaybeMap, class>
template <bool MaybeMulti, bool MaybeMap>
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;
@@ -2220,7 +2226,8 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti)
{
maybeRehash(1);
typename cont_type::insert_commit_data d;
@@ -2249,7 +2256,8 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
value_type const& value) -> iterator
requires MaybeMulti
{
maybeRehash(1);
Element* const p(newElement(value));
@@ -2271,7 +2279,8 @@ template <
template <bool MaybeMulti, bool MaybeMap>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type&& value) -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
value_type&& value) -> std::pair<iterator, bool>
requires(!MaybeMulti && !MaybeMap)
{
maybeRehash(1);
typename cont_type::insert_commit_data d;
@@ -2300,7 +2309,8 @@ template <
template <bool MaybeMulti, bool MaybeMap>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
value_type&& value) -> iterator
requires(MaybeMulti && !MaybeMap)
{
maybeRehash(1);
Element* const p(newElement(std::move(value)));
@@ -2309,7 +2319,6 @@ 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,
@@ -2323,7 +2332,8 @@ template <
template <bool MaybeMulti, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti)
{
maybeRehash(1);
// VFALCO NOTE Its unfortunate that we need to
@@ -2338,42 +2348,6 @@ 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 <
@@ -2388,7 +2362,8 @@ template <
template <bool MaybeMulti, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>
Args&&... args) -> iterator
requires MaybeMulti
{
maybeRehash(1);
Element* const p(newElement(std::forward<Args>(args)...));
@@ -2411,7 +2386,8 @@ template <bool MaybeMulti, class... Args>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplaceHint(
const_iterator /*hint*/,
Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
Args&&... args) -> std::pair<iterator, bool>
requires(!MaybeMulti)
{
maybeRehash(1);
// VFALCO NOTE Its unfortunate that we need to
@@ -2562,7 +2538,7 @@ template <
class OtherHash,
class OtherAllocator,
bool MaybeMulti>
std::enable_if_t<!MaybeMulti, bool>
bool
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
AgedUnorderedContainer<
false,
@@ -2573,6 +2549,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
OtherHash,
KeyEqual,
OtherAllocator> const& other) const
requires(!MaybeMulti)
{
if (size() != other.size())
return false;
@@ -2602,7 +2579,7 @@ template <
class OtherHash,
class OtherAllocator,
bool MaybeMulti>
std::enable_if_t<MaybeMulti, bool>
bool
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
AgedUnorderedContainer<
true,
@@ -2613,6 +2590,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
OtherHash,
KeyEqual,
OtherAllocator> const& other) const
requires MaybeMulti
{
if (size() != other.size())
return false;
@@ -2649,7 +2627,8 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
value_type const& value) -> std::pair<iterator, bool>
requires(!MaybeMulti)
{
typename cont_type::insert_commit_data d;
auto const result(cont_.insert_check(
@@ -2677,7 +2656,8 @@ template <
template <bool MaybeMulti>
auto
AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
value_type const& value) -> iterator
requires MaybeMulti
{
Element* const p(newElement(value));
chronological.list_.push_back(*p);

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

@@ -29,16 +29,18 @@ struct LexicalCast<std::string, In>
explicit LexicalCast() = default;
template <class Arithmetic = In>
std::enable_if_t<std::is_arithmetic_v<Arithmetic>, bool>
bool
operator()(std::string& out, Arithmetic in)
requires(std::is_arithmetic_v<Arithmetic>)
{
out = std::to_string(in);
return true;
}
template <class Enumeration = In>
std::enable_if_t<std::is_enum_v<Enumeration>, bool>
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;
@@ -56,8 +58,9 @@ struct LexicalCast<Out, std::string_view>
"beast::LexicalCast can only be used with integral types");
template <class Integral = Out>
std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, 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 static_cast<LockFreeStackIterator&>(*this);
return *this;
}
LockFreeStackIterator&

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

@@ -200,26 +200,29 @@ struct IsContiguouslyHashable<T[N], HashAlgorithm>
// scalars
template <class Hasher, class T>
inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
inline void
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 std::enable_if_t<
!IsContiguouslyHashable<T, Hasher>::value &&
(std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
inline void
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 std::enable_if_t<std::is_floating_point_v<T>>
inline void
hash_append(Hasher& h, T t) noexcept
requires(std::is_floating_point_v<T>)
{
if (t == 0)
t = 0;
@@ -239,36 +242,44 @@ hash_append(Hasher& h, std::nullptr_t) noexcept
// Forward declarations for ADL purposes
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, T (&a)[N]) noexcept;
void
hash_append(Hasher& h, T (&a)[N]) noexcept
requires(!IsContiguouslyHashable<T, Hasher>::value);
template <class Hasher, class CharT, class Traits, class Alloc>
std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
void
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
requires(!IsContiguouslyHashable<CharT, Hasher>::value);
template <class Hasher, class CharT, class Traits, class Alloc>
std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
void
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
requires(IsContiguouslyHashable<CharT, Hasher>::value);
template <class Hasher, class T, class U>
std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
hash_append(Hasher& h, std::pair<T, U> const& p) noexcept;
void
hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value);
template <class Hasher, class T, class Alloc>
std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
void
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
requires(!IsContiguouslyHashable<T, Hasher>::value);
template <class Hasher, class T, class Alloc>
std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
void
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
requires(IsContiguouslyHashable<T, Hasher>::value);
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
hash_append(Hasher& h, std::array<T, N> const& a) noexcept;
void
hash_append(Hasher& h, std::array<T, N> const& a) noexcept
requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value);
template <class Hasher, class... T>
std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
hash_append(Hasher& h, std::tuple<T...> const& t) noexcept;
void
hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value);
template <class Hasher, class Key, class T, class Hash, class Pred, class Alloc>
void
@@ -279,11 +290,13 @@ void
hash_append(Hasher& h, std::unordered_set<Key, Hash, Pred, Alloc> const& s);
template <class Hasher, class Key, class Compare, class Alloc>
std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
void
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
requires(!IsContiguouslyHashable<Key, Hasher>::value);
template <class Hasher, class Key, class Compare, class Alloc>
std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
void
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
requires(IsContiguouslyHashable<Key, Hasher>::value);
template <class Hasher, class T0, class T1, class... T>
void
hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
@@ -291,8 +304,9 @@ 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>
std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
void
hash_append(Hasher& h, T (&a)[N]) noexcept
requires(!IsContiguouslyHashable<T, Hasher>::value)
{
for (auto const& t : a)
hash_append(h, t);
@@ -301,8 +315,9 @@ hash_append(Hasher& h, T (&a)[N]) noexcept
// basic_string
template <class Hasher, class CharT, class Traits, class Alloc>
inline std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
inline void
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);
@@ -310,8 +325,9 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
}
template <class Hasher, class CharT, class Traits, class Alloc>
inline std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
inline void
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());
@@ -320,8 +336,9 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
// pair
template <class Hasher, class T, class U>
inline std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
inline void
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);
}
@@ -329,8 +346,9 @@ hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
// vector
template <class Hasher, class T, class Alloc>
inline std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
inline void
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);
@@ -338,8 +356,9 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
}
template <class Hasher, class T, class Alloc>
inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
inline void
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());
@@ -348,57 +367,37 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
// array
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
void
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>
std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
void
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>
std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
void
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
namespace detail {
inline void
forEachItem(...) noexcept
{
}
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>
inline void
hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value)
{
detail::tuple_hash(h, t, std::index_sequence_for<T...>{});
std::apply([&h](auto const&... item) { (hash_append(h, item), ...); }, t);
}
// shared_ptr

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

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

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

@@ -49,6 +49,11 @@ 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
{

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

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

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

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

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

@@ -3,7 +3,6 @@
#include <array>
#include <cstdint>
#include <cstring>
#include <type_traits>
namespace beast {
@@ -33,12 +32,10 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
}
}
template <
class Generator,
std::size_t N,
class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
template <class Generator, std::size_t N>
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);

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

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

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

@@ -154,16 +154,14 @@ public:
@param type The type of job.
@param name Name of the job.
@param jobHandler Lambda with signature void (Job&). Called when the
job is executed.
@param jobHandler Callable with signature void(). Called when the job is executed.
@return true if jobHandler added to queue.
*/
template <
typename JobHandler,
typename = std::enable_if_t<std::is_same_v<decltype(std::declval<JobHandler&&>()()), void>>>
template <typename JobHandler>
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/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 = 0);
addError(std::string const& message, Token& token, Location extra = nullptr);
bool
recoverFromError(TokenType skipUntilToken);
bool

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

@@ -82,7 +82,7 @@ private:
using txs_map = std::map<
key_type,
TxData,
std::less<key_type>,
std::less<>,
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/detail/RawStateTable.h
View File

@@ -105,7 +105,7 @@ private:
using items_t = std::map<
key_type,
SleAction,
std::less<key_type>,
std::less<>,
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.

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

@@ -19,11 +19,7 @@ namespace xrpl {
namespace detail {
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>>>
template <class V, class N>
bool
internalDirNext(
V& view,
@@ -31,6 +27,7 @@ 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");
@@ -68,11 +65,7 @@ internalDirNext(
return true;
}
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>>>
template <class V, class N>
bool
internalDirFirst(
V& view,
@@ -80,6 +73,7 @@ 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>)
{

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

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

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

@@ -13,7 +13,6 @@
#include <openssl/err.h>
#include <openssl/tls1.h>
#include <functional>
#include <stdexcept>
#include <string>
#include <type_traits>
@@ -84,13 +83,12 @@ public:
*
* @return error_code indicating failures, if any
*/
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&>>>>
template <class T>
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()))
@@ -104,11 +102,7 @@ public:
return ec;
}
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&>>>>
template <class T>
/**
* @brief invoked after connect/async_connect but before sending data
* on an ssl stream - to setup name verification.
@@ -118,6 +112,9 @@ 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;
@@ -127,8 +124,9 @@ public:
if (!ec)
{
strm.set_verify_callback(
std::bind(
&rfc6125Verify, host, std::placeholders::_1, std::placeholders::_2, j_),
[host, j = j_](bool preverified, boost::asio::ssl::verify_context& ctx) {
return rfc6125Verify(host, preverified, ctx, j);
},
ec);
}
}

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

@@ -68,9 +68,10 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
return used;
}
template <class T, std::enable_if_t<std::is_unsigned_v<T>>* = nullptr>
template <class T>
std::size_t
sizeVarint(T v)
requires(std::is_unsigned_v<T>)
{
std::size_t n = 0;
do
@@ -100,9 +101,10 @@ writeVarint(void* p0, std::size_t v)
// input stream
template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
template <class T>
void
read(nudb::detail::istream& is, std::size_t& u)
requires(std::is_same_v<T, varint>)
{
auto p0 = is(1);
auto p1 = p0;
@@ -113,9 +115,10 @@ read(nudb::detail::istream& is, std::size_t& u)
// output stream
template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
template <class T>
void
write(nudb::detail::ostream& os, std::size_t t)
requires(std::is_same_v<T, varint>)
{
writeVarint(os.data(sizeVarint(t)), t);
}

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

@@ -32,17 +32,13 @@ public:
STArray() = default;
STArray(STArray const&) = default;
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>
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>>>
STArray(SField const& f, 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>);
STArray&
operator=(STArray const&) = default;
@@ -170,13 +166,17 @@ private:
friend class detail::STVar;
};
template <class Iter, class>
STArray::STArray(Iter first, Iter last) : v_(first, last)
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(SField const& f, Iter first, Iter last) : STBase(f), 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)
{
}

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

@@ -555,9 +555,14 @@ 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>
std::enable_if_t<std::is_assignable_v<T, U>, ValueProxy&>
operator=(U&& u);
// NOLINTNEXTLINE(misc-unconventional-assign-operator)
ValueProxy&
operator=(U&& u)
requires(std::is_assignable_v<T, U>);
// Convenience operators for value types supporting
// arithmetic operations
@@ -691,8 +696,9 @@ public:
operator=(optional_type const& v);
template <class U>
std::enable_if_t<std::is_assignable_v<T, U>, OptionalProxy&>
operator=(U&& u);
OptionalProxy&
operator=(U&& u)
requires(std::is_assignable_v<T, U>);
private:
friend class STObject;
@@ -798,8 +804,10 @@ STObject::Proxy<T>::assign(U&& u)
template <class T>
template <class U>
std::enable_if_t<std::is_assignable_v<T, U>, STObject::ValueProxy<T>&>
// NOLINTNEXTLINE(misc-unconventional-assign-operator)
STObject::ValueProxy<T>&
STObject::ValueProxy<T>::operator=(U&& u)
requires(std::is_assignable_v<T, U>)
{
this->assign(std::forward<U>(u));
return *this;
@@ -902,8 +910,9 @@ STObject::OptionalProxy<T>::operator=(optional_type const& v) -> OptionalProxy&
template <class T>
template <class U>
std::enable_if_t<std::is_assignable_v<T, U>, STObject::OptionalProxy<T>&>
STObject::OptionalProxy<T>&
STObject::OptionalProxy<T>::operator=(U&& u)
requires(std::is_assignable_v<T, U>)
{
this->assign(std::forward<U>(u));
return *this;

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

@@ -411,7 +411,7 @@ TERtoInt(TECcodes v)
//------------------------------------------------------------------------------
// Template class that is specific to selected ranges of error codes. The
// Trait tells std::enable_if which ranges are allowed.
// Trait tells the requires-clause which ranges are allowed.
template <template <typename> class Trait>
class TERSubset
{
@@ -437,11 +437,11 @@ public:
return TERSubset(from);
}
// 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))
// 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))
{
}
@@ -451,10 +451,11 @@ public:
constexpr TERSubset&
operator=(TERSubset&& rhs) = default;
// Trait tells enable_if which types are allowed for assignment.
// Trait tells the requires-clause which types are allowed for assignment.
template <typename T>
constexpr auto
operator=(T rhs) -> std::enable_if_t<Trait<T>::value, TERSubset&>
operator=(T rhs) -> TERSubset&
requires(Trait<T>::value)
{
code_ = TERtoInt(rhs);
return *this;
@@ -508,54 +509,60 @@ 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) -> std::enable_if_t<
std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
bool>
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>)
{
return TERtoInt(lhs) == TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
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>
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>)
{
return TERtoInt(lhs) != TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
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>
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>)
{
return TERtoInt(lhs) < TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
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>
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>)
{
return TERtoInt(lhs) <= TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
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>
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>)
{
return TERtoInt(lhs) > TERtoInt(rhs);
}
template <typename L, typename R>
constexpr auto
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>
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>)
{
return TERtoInt(lhs) >= TERtoInt(rhs);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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