ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-03 16:56:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' into pratik/test-tsan-and-gcc14-asan

Browse Source 
Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com>
This commit is contained in:
Pratik Mankawde
2026-04-24 12:52:31 +01:00
parent 1866a07add 7a449edebb
commit d67bec3bd6
1421 changed files with 67849 additions and 21883 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/xrpl/basics/BasicConfig.h
View File

@@ -33,7 +33,7 @@ private:
public:
/** Create an empty section. */
explicit Section(std::string const& name = "");
explicit Section(std::string name = "");
/** Returns the name of this section. */
std::string const&
@@ -67,9 +67,13 @@ public:
legacy(std::string value)
{
if (lines_.empty())
{
lines_.emplace_back(std::move(value));
}
else
{
lines_[0] = std::move(value);
}
}
/**
@@ -84,8 +88,10 @@ public:
if (lines_.empty())
return "";
if (lines_.size() > 1)
{
Throw<std::runtime_error>(
"A legacy value must have exactly one line. Section: " + name_);
}
return lines_[0];
}
@@ -269,8 +275,7 @@ public:
bool
had_trailing_comments() const
{
return std::any_of(
map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
return std::ranges::any_of(map_, [](auto s) { return s.second.had_trailing_comments(); });
}
protected:
@@ -296,7 +301,7 @@ set(T& target, std::string const& name, Section const& section)
if ((found_and_valid = val.has_value()))
target = *val;
}
catch (boost::bad_lexical_cast&)
catch (boost::bad_lexical_cast const&) // NOLINT(bugprone-empty-catch)
{
}
return found_and_valid;
@@ -311,7 +316,7 @@ template <class T>
bool
set(T& target, T const& defaultValue, std::string const& name, Section const& section)
{
bool found_and_valid = set<T>(target, name, section);
bool const found_and_valid = set<T>(target, name, section);
if (!found_and_valid)
target = defaultValue;
return found_and_valid;
@@ -330,7 +335,7 @@ get(Section const& section, std::string const& name, T const& defaultValue = T{}
{
return section.value_or<T>(name, defaultValue);
}
catch (boost::bad_lexical_cast&)
catch (boost::bad_lexical_cast const&) // NOLINT(bugprone-empty-catch)
{
}
return defaultValue;
@@ -345,7 +350,7 @@ get(Section const& section, std::string const& name, char const* defaultValue)
if (val.has_value())
return *val;
}
catch (boost::bad_lexical_cast&)
catch (boost::bad_lexical_cast const&) // NOLINT(bugprone-empty-catch)
{
}
return defaultValue;

13
include/xrpl/basics/Buffer.h
View File

@@ -24,7 +24,8 @@ public:
Buffer() = default;
/** Create an uninitialized buffer with the given size. */
explicit Buffer(std::size_t size) : p_(size ? new std::uint8_t[size] : nullptr), size_(size)
explicit Buffer(std::size_t size)
: p_((size != 0u) ? new std::uint8_t[size] : nullptr), size_(size)
{
}
@@ -36,7 +37,7 @@ public:
*/
Buffer(void const* data, std::size_t size) : Buffer(size)
{
if (size)
if (size != 0u)
std::memcpy(p_.get(), data, size);
}
@@ -91,7 +92,7 @@ public:
{
// Ensure the slice isn't a subset of the buffer.
XRPL_ASSERT(
s.size() == 0 || size_ == 0 || s.data() < p_.get() || s.data() >= p_.get() + size_,
s.empty() || size_ == 0 || s.data() < p_.get() || s.data() >= p_.get() + size_,
"xrpl::Buffer::operator=(Slice) : input not a subset");
if (auto p = alloc(s.size()))
@@ -114,7 +115,7 @@ public:
operator Slice() const noexcept
{
if (!size_)
if (size_ == 0u)
return Slice{};
return Slice{p_.get(), size_};
}
@@ -155,7 +156,7 @@ public:
{
if (n != size_)
{
p_.reset(n ? new std::uint8_t[n] : nullptr);
p_.reset((n != 0u) ? new std::uint8_t[n] : nullptr);
size_ = n;
}
return p_.get();
@@ -199,7 +200,7 @@ operator==(Buffer const& lhs, Buffer const& rhs) noexcept
if (lhs.size() != rhs.size())
return false;
if (lhs.size() == 0)
if (lhs.empty())
return true;
return std::memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;

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

@@ -9,9 +9,7 @@
#include <stdexcept>
#include <vector>
namespace xrpl {
namespace compression_algorithms {
namespace xrpl::compression_algorithms {
/** LZ4 block compression.
* @tparam BufferFactory Callable object or lambda.
@@ -68,12 +66,15 @@ lz4Decompress(
if (decompressedSize <= 0)
Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
// NOLINTNEXTLINE(readability-suspicious-call-argument)
if (LZ4_decompress_safe(
reinterpret_cast<char const*>(in),
reinterpret_cast<char*>(decompressed),
inSize,
decompressedSize) != decompressedSize)
{
Throw<std::runtime_error>("lz4Decompress: failed");
}
return decompressedSize;
}
@@ -138,6 +139,4 @@ lz4Decompress(
return lz4Decompress(chunk, inSize, decompressed, decompressedSize);
}
} // namespace compression_algorithms
} // namespace xrpl
} // namespace xrpl::compression_algorithms

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

@@ -34,7 +34,7 @@ public:
{
// Insert ourselves at the front of the lock-free linked list
CountedObjects& instance = CountedObjects::getInstance();
Counter* head;
Counter* head = nullptr;
do
{
@@ -99,7 +99,7 @@ private:
Derived classes have their instances counted automatically. This is used
for reporting purposes.
@ingroup ripple_basics
@ingroup basics
*/
template <class Object>
class CountedObject
@@ -112,7 +112,6 @@ private:
return c;
}
public:
CountedObject() noexcept
{
getCounter().increment();
@@ -126,10 +125,13 @@ public:
CountedObject&
operator=(CountedObject const&) noexcept = default;
public:
~CountedObject() noexcept
{
getCounter().decrement();
}
friend Object;
};
} // namespace xrpl

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

@@ -67,7 +67,7 @@ private:
}
else
{
while (elapsed--)
while ((elapsed--) != 0u)
m_value -= (m_value + Window - 1) / Window;
}
}
@@ -93,7 +93,7 @@ class DecayWindow
public:
using time_point = typename Clock::time_point;
explicit DecayWindow(time_point now) : value_(0), when_(now)
explicit DecayWindow(time_point now) : when_(now)
{
}
@@ -125,7 +125,7 @@ private:
when_ = now;
}
double value_;
double value_{0};
time_point when_;
};

2
include/xrpl/basics/Expected.h
View File

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

14
include/xrpl/basics/IntrusivePointer.h
View File

@@ -59,7 +59,7 @@ concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
still retaining the reference counts. For example, for SHAMapInnerNodes the
children may be reset in that function. Note that std::shared_pointer WILL
run the destructor when the strong count reaches zero, but may not free the
memory used by the object until the weak count reaches zero. In rippled, we
memory used by the object until the weak count reaches zero. In xrpld, we
typically allocate shared pointers with the `make_shared` function. When
that is used, the memory is not reclaimed until the weak count reaches zero.
*/
@@ -84,7 +84,8 @@ public:
template <class TT>
requires std::convertible_to<TT*, T*>
SharedIntrusive(SharedIntrusive<TT>&& rhs);
SharedIntrusive(
SharedIntrusive<TT>&& rhs); // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
SharedIntrusive&
operator=(SharedIntrusive const& rhs);
@@ -106,7 +107,8 @@ public:
template <class TT>
requires std::convertible_to<TT*, T*>
SharedIntrusive&
operator=(SharedIntrusive<TT>&& rhs);
operator=(
SharedIntrusive<TT>&& rhs); // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
/** Adopt the raw pointer. The strong reference may or may not be
incremented, depending on the TAdoptTag
@@ -314,7 +316,8 @@ public:
template <class TT>
requires std::convertible_to<TT*, T*>
SharedWeakUnion(SharedIntrusive<TT>&& rhs);
SharedWeakUnion(
SharedIntrusive<TT>&& rhs); // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
SharedWeakUnion&
operator=(SharedWeakUnion const& rhs);
@@ -327,7 +330,8 @@ public:
template <class TT>
requires std::convertible_to<TT*, T*>
SharedWeakUnion&
operator=(SharedIntrusive<TT>&& rhs);
operator=(
SharedIntrusive<TT>&& rhs); // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
~SharedWeakUnion();

20
include/xrpl/basics/IntrusivePointer.ipp
View File

@@ -68,9 +68,7 @@ SharedIntrusive<T>::operator=(SharedIntrusive const& rhs)
template <class T>
template <class TT>
// clang-format off
requires std::convertible_to<TT*, T*>
// clang-format on
requires std::convertible_to<TT*, T*>
SharedIntrusive<T>&
SharedIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
{
@@ -101,9 +99,7 @@ SharedIntrusive<T>::operator=(SharedIntrusive&& rhs)
template <class T>
template <class TT>
// clang-format off
requires std::convertible_to<TT*, T*>
// clang-format on
requires std::convertible_to<TT*, T*>
SharedIntrusive<T>&
SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
{
@@ -307,9 +303,7 @@ WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs) : ptr_{rhs.unsafe
template <class T>
template <class TT>
// clang-format off
requires std::convertible_to<TT*, T*>
// clang-format on
requires std::convertible_to<TT*, T*>
WeakIntrusive<T>&
WeakIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
{
@@ -454,9 +448,7 @@ SharedWeakUnion<T>::operator=(SharedWeakUnion const& rhs)
template <class T>
template <class TT>
// clang-format off
requires std::convertible_to<TT*, T*>
// clang-format on
requires std::convertible_to<TT*, T*>
SharedWeakUnion<T>&
SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
{
@@ -470,9 +462,7 @@ SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
template <class T>
template <class TT>
// clang-format off
requires std::convertible_to<TT*, T*>
// clang-format on
requires std::convertible_to<TT*, T*>
SharedWeakUnion<T>&
SharedWeakUnion<T>::operator=(SharedIntrusive<TT>&& rhs)
{

14
include/xrpl/basics/IntrusiveRefCounts.h
View File

@@ -33,7 +33,7 @@ enum class ReleaseWeakRefAction { noop, destroy };
/** Implement the strong count, weak count, and bit flags for an intrusive
pointer.
A class can satisfy the requirements of a xrpl::IntrusivePointer by
A class can satisfy the requirements of an xrpl::IntrusivePointer by
inheriting from this class.
*/
struct IntrusiveRefCounts
@@ -247,7 +247,7 @@ IntrusiveRefCounts::releaseStrongRef() const
using enum ReleaseStrongRefAction;
auto prevIntVal = refCounts.load(std::memory_order_acquire);
while (1)
while (true)
{
RefCountPair const prevVal{prevIntVal};
XRPL_ASSERT(
@@ -298,7 +298,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
// Note: If this becomes a perf bottleneck, the `partialDestroyStartedMask`
// may be able to be set non-atomically. But it is easier to reason about
// the code if the flag is set atomically.
while (1)
while (true)
{
RefCountPair const prevVal{prevIntVal};
// Converted the last strong pointer to a weak pointer.
@@ -343,7 +343,7 @@ IntrusiveRefCounts::releaseWeakRef() const
RefCountPair prev = prevIntVal;
if (prev.weak == 1 && prev.strong == 0)
{
if (!prev.partialDestroyStartedBit)
if (prev.partialDestroyStartedBit == 0u)
{
// This case should only be hit if the partialDestroyStartedBit is
// set non-atomically (and even then very rarely). The code is kept
@@ -352,7 +352,7 @@ IntrusiveRefCounts::releaseWeakRef() const
prevIntVal = refCounts.load(std::memory_order_acquire);
prev = RefCountPair{prevIntVal};
}
if (!prev.partialDestroyFinishedBit)
if (prev.partialDestroyFinishedBit == 0u)
{
// partial destroy MUST finish before running a full destroy (when
// using weak pointers)
@@ -372,7 +372,7 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
while (!refCounts.compare_exchange_weak(curValue, desiredValue, std::memory_order_acq_rel))
{
RefCountPair const prev{curValue};
if (!prev.strong)
if (prev.strong == 0u)
return false;
desiredValue = curValue + strongDelta;
@@ -448,7 +448,7 @@ inline void
partialDestructorFinished(T** o)
{
T& self = **o;
IntrusiveRefCounts::RefCountPair p =
IntrusiveRefCounts::RefCountPair const p =
self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
XRPL_ASSERT(
(!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),

9
include/xrpl/basics/LocalValue.h
View File

@@ -4,6 +4,7 @@
#include <memory>
#include <unordered_map>
#include <utility>
namespace xrpl {
@@ -28,7 +29,7 @@ struct LocalValues
T t_;
Value() = default;
explicit Value(T const& t) : t_(t)
explicit Value(T t) : t_(std::move(t))
{
}
@@ -42,10 +43,10 @@ struct LocalValues
// Keys are the address of a LocalValue.
std::unordered_map<void const*, std::unique_ptr<BasicValue>> values;
static inline void
static void
cleanup(LocalValues* lvs)
{
if (lvs && !lvs->onCoro)
if ((lvs != nullptr) && !lvs->onCoro)
delete lvs;
}
};
@@ -89,7 +90,7 @@ T&
LocalValue<T>::operator*()
{
auto lvs = detail::getLocalValues().get();
if (!lvs)
if (lvs == nullptr)
{
lvs = new detail::LocalValues();
lvs->onCoro = false;

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

@@ -38,7 +38,7 @@ private:
std::string partition_;
public:
Sink(std::string const& partition, beast::severities::Severity thresh, Logs& logs);
Sink(std::string partition, beast::severities::Severity thresh, Logs& logs);
Sink(Sink const&) = delete;
Sink&
@@ -226,7 +226,7 @@ private:
// expensive argument lists if the stream is not active.
#ifndef JLOG
#define JLOG(x) \
if (!x) \
if (!(x)) \
{ \
} \
else \
@@ -235,7 +235,7 @@ private:
#ifndef CLOG
#define CLOG(ss) \
if (!ss) \
if (!(ss)) \
; \
else \
*ss

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

@@ -73,12 +73,12 @@ struct MantissaRange
enum mantissa_scale { small, large };
explicit constexpr MantissaRange(mantissa_scale scale_)
: min(getMin(scale_)), max(min * 10 - 1), log(logTen(min).value_or(-1)), scale(scale_)
: min(getMin(scale_)), log(logTen(min).value_or(-1)), scale(scale_)
{
}
rep min;
rep max;
rep max{(min * 10) - 1};
int log;
mantissa_scale scale;
@@ -342,7 +342,9 @@ public:
constexpr int
signum() const noexcept
{
return negative_ ? -1 : (mantissa_ ? 1 : 0);
if (negative_)
return -1;
return (mantissa_ != 0u) ? 1 : 0;
}
Number
@@ -402,19 +404,19 @@ public:
static void
setMantissaScale(MantissaRange::mantissa_scale scale);
inline static internalrep
static internalrep
minMantissa()
{
return range_.get().min;
}
inline static internalrep
static internalrep
maxMantissa()
{
return range_.get().max;
}
inline static int
static int
mantissaLog()
{
return range_.get().log;
@@ -507,16 +509,12 @@ private:
class Guard;
};
inline constexpr Number::Number(
bool negative,
internalrep mantissa,
int exponent,
unchecked) noexcept
constexpr Number::Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept
: negative_(negative), mantissa_{mantissa}, exponent_{exponent}
{
}
inline constexpr Number::Number(internalrep mantissa, int exponent, unchecked) noexcept
constexpr Number::Number(internalrep mantissa, int exponent, unchecked) noexcept
: Number(false, mantissa, exponent, unchecked{})
{
}
@@ -548,7 +546,7 @@ inline Number::Number(rep mantissa) : Number{mantissa, 0}
* Please see the "---- External Interface ----" section of the class
* documentation for an explanation of why the internal value may be modified.
*/
inline constexpr Number::rep
constexpr Number::rep
Number::mantissa() const noexcept
{
auto m = mantissa_;
@@ -569,7 +567,7 @@ Number::mantissa() const noexcept
* Please see the "---- External Interface ----" section of the class
* documentation for an explanation of why the internal value may be modified.
*/
inline constexpr int
constexpr int
Number::exponent() const noexcept
{
auto e = exponent_;
@@ -584,13 +582,13 @@ Number::exponent() const noexcept
return e;
}
inline constexpr Number
constexpr Number
Number::operator+() const noexcept
{
return *this;
}
inline constexpr Number
constexpr Number
Number::operator-() const noexcept
{
if (mantissa_ == 0)
@@ -705,17 +703,19 @@ Number::normalizeToRange(T minMantissa, T maxMantissa) const
int exponent = exponent_;
if constexpr (std::is_unsigned_v<T>)
{
XRPL_ASSERT_PARTS(
!negative,
"xrpl::Number::normalizeToRange",
"Number is non-negative for unsigned range.");
}
Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);
auto const sign = negative ? -1 : 1;
return std::make_pair(static_cast<T>(sign * mantissa), exponent);
}
inline constexpr Number
constexpr Number
abs(Number x) noexcept
{
if (x < Number{})
@@ -746,7 +746,7 @@ power(Number const& f, unsigned n, unsigned d);
// Return 0 if abs(x) < limit, else returns x
inline constexpr Number
constexpr Number
squelch(Number const& x, Number const& limit) noexcept
{
if (abs(x) < limit)

4
include/xrpl/basics/README.md
View File

@@ -2,9 +2,9 @@
Utility functions and classes.
ripple/basic should contain no dependencies on other modules.
The module xrpl/basics should contain no dependencies on other modules.
# Choosing a rippled container.
# Choosing an xrpld container.
- `std::vector`
- For ordered containers with most insertions or erases at the end.

10
include/xrpl/basics/RangeSet.h
View File

@@ -117,22 +117,32 @@ from_string(RangeSet<T>& rs, std::string const& s)
case 1: {
T front;
if (!beast::lexicalCastChecked(front, intervals.front()))
{
result = false;
}
else
{
rs.insert(front);
}
break;
}
case 2: {
T front;
if (!beast::lexicalCastChecked(front, intervals.front()))
{
result = false;
}
else
{
T back;
if (!beast::lexicalCastChecked(back, intervals.back()))
{
result = false;
}
else
{
rs.insert(range(front, back));
}
}
break;
}

51
include/xrpl/basics/SlabAllocator.h
View File

@@ -60,18 +60,16 @@ class SlabAllocator
{
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(data, &l_, sizeof(std::uint8_t*));
std::memcpy(data, static_cast<void const*>(&l_), sizeof(std::uint8_t*));
l_ = data;
data += item;
}
}
~SlabBlock()
{
// Calling this destructor will release the allocated memory but
// will not properly destroy any objects that are constructed in
// the block itself.
}
// Calling this destructor will release the allocated memory but
// will not properly destroy any objects that are constructed in
// the block itself.
~SlabBlock() = default;
SlabBlock(SlabBlock const& other) = delete;
SlabBlock&
@@ -91,18 +89,18 @@ class SlabAllocator
std::uint8_t*
allocate() noexcept
{
std::uint8_t* ret;
std::uint8_t* ret = nullptr; // NOLINT(misc-const-correctness)
{
std::lock_guard l(m_);
std::lock_guard const l(m_);
ret = l_;
if (ret)
if (ret != nullptr)
{
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(&l_, ret, sizeof(std::uint8_t*));
std::memcpy(static_cast<void*>(&l_), ret, sizeof(std::uint8_t*));
}
}
@@ -123,11 +121,11 @@ class SlabAllocator
{
XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
std::lock_guard l(m_);
std::lock_guard const l(m_);
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(ptr, &l_, sizeof(std::uint8_t*));
std::memcpy(ptr, static_cast<void const*>(&l_), sizeof(std::uint8_t*));
l_ = ptr;
}
};
@@ -159,7 +157,7 @@ public:
std::size_t extra,
std::size_t alloc = 0,
std::size_t align = 0)
: itemAlignment_(align ? align : alignof(Type))
: itemAlignment_((align != 0u) ? align : alignof(Type))
, itemSize_(boost::alignment::align_up(sizeof(Type) + extra, itemAlignment_))
, slabSize_(alloc)
{
@@ -176,12 +174,10 @@ public:
SlabAllocator&
operator=(SlabAllocator&& other) = delete;
~SlabAllocator()
{
// FIXME: We can't destroy the memory blocks we've allocated, because
// we can't be sure that they are not being used. Cleaning the
// shutdown process up could make this possible.
}
// FIXME: We can't destroy the memory blocks we've allocated, because
// we can't be sure that they are not being used. Cleaning the
// shutdown process up could make this possible.
~SlabAllocator() = default;
/** Returns the size of the memory block this allocator returns. */
constexpr std::size_t
@@ -210,16 +206,13 @@ public:
// No slab can satisfy our request, so we attempt to allocate a new
// one here:
std::size_t size = slabSize_;
std::size_t const size = slabSize_;
// We want to allocate the memory at a 2 MiB boundary, to make it
// possible to use hugepage mappings on Linux:
auto buf = boost::alignment::aligned_alloc(megabytes(std::size_t(2)), size);
// clang-format off
if (!buf) [[unlikely]]
if (buf == nullptr) [[unlikely]]
return nullptr;
// clang-format on
#if BOOST_OS_LINUX
// When allocating large blocks, attempt to leverage Linux's
@@ -238,7 +231,7 @@ public:
// This operation is essentially guaranteed not to fail but
// let's be careful anyways.
if (!boost::alignment::align(itemAlignment_, itemSize_, slabData, slabSize))
if (boost::alignment::align(itemAlignment_, itemSize_, slabData, slabSize) == nullptr)
{
boost::alignment::aligned_free(buf);
return nullptr;
@@ -291,7 +284,7 @@ class SlabAllocatorSet
{
private:
// The list of allocators that belong to this set
boost::container::static_vector<SlabAllocator<Type>, 64> allocators_;
boost::container::static_vector<SlabAllocator<Type>, 64> allocators_{};
std::size_t maxSize_ = 0;
@@ -350,9 +343,7 @@ public:
SlabAllocatorSet&
operator=(SlabAllocatorSet&& other) = delete;
~SlabAllocatorSet()
{
}
~SlabAllocatorSet() = default;
/** Returns a suitably aligned pointer, if one is available.

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

@@ -183,7 +183,7 @@ operator==(Slice const& lhs, Slice const& rhs) noexcept
if (lhs.size() != rhs.size())
return false;
if (lhs.size() == 0)
if (lhs.empty())
return true;
return std::memcmp(lhs.data(), rhs.data(), lhs.size()) == 0;
@@ -211,14 +211,14 @@ operator<<(Stream& s, Slice const& v)
}
template <class T, std::size_t N>
std::enable_if_t<std::is_same<T, char>::value || std::is_same<T, unsigned char>::value, Slice>
std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
makeSlice(std::array<T, N> const& a)
{
return Slice(a.data(), a.size());
}
template <class T, class Alloc>
std::enable_if_t<std::is_same<T, char>::value || std::is_same<T, unsigned char>::value, Slice>
std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
makeSlice(std::vector<T, Alloc> const& v)
{
return Slice(v.data(), v.size());

4
include/xrpl/basics/StringUtilities.h
View File

@@ -66,12 +66,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
while (iter != end)
{
int cHigh = digitLookupTable[*iter++];
int const cHigh = digitLookupTable[*iter++];
if (cHigh < 0)
return {};
int cLow = digitLookupTable[*iter++];
int const cLow = digitLookupTable[*iter++];
if (cLow < 0)
return {};

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

@@ -182,8 +182,7 @@ private:
: hook(collector->make_hook(handler))
, size(collector->make_gauge(prefix, "size"))
, hit_rate(collector->make_gauge(prefix, "hit_rate"))
, hits(0)
, misses(0)
{
}
@@ -191,8 +190,8 @@ private:
beast::insight::Gauge size;
beast::insight::Gauge hit_rate;
std::size_t hits;
std::size_t misses;
std::size_t hits{0};
std::size_t misses{0};
};
class KeyOnlyEntry
@@ -252,7 +251,7 @@ private:
}
};
typedef typename std::conditional<IsKeyCache, KeyOnlyEntry, ValueEntry>::type Entry;
using Entry = std::conditional_t<IsKeyCache, KeyOnlyEntry, ValueEntry>;
using KeyOnlyCacheType = hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>;
@@ -294,10 +293,10 @@ private:
clock_type::duration const m_target_age;
// Number of items cached
int m_cache_count;
int m_cache_count{0};
cache_type m_cache; // Hold strong reference to recent objects
std::uint64_t m_hits;
std::uint64_t m_misses;
std::uint64_t m_hits{0};
std::uint64_t m_misses{0};
};
} // namespace xrpl

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

@@ -36,9 +36,7 @@ inline TaggedCache<
, m_name(name)
, m_target_size(size)
, m_target_age(expiration)
, m_cache_count(0)
, m_hits(0)
, m_misses(0)
{
}

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

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

2
include/xrpl/basics/UptimeClock.h
View File

@@ -26,7 +26,7 @@ public:
explicit UptimeClock() = default;
static time_point
now(); // seconds since rippled program start
now(); // seconds since xrpld program start
private:
static std::atomic<rep> now_;

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

@@ -23,8 +23,10 @@ generalized_set_intersection(
{
while (first1 != last1 && first2 != last2)
{
if (comp(*first1, *first2)) // if *first1 < *first2
++first1; // then reduce first range
if (comp(*first1, *first2))
{ // if *first1 < *first2
++first1; // then reduce first range
}
else
{
if (!comp(*first2, *first1)) // if *first1 == *first2

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

@@ -183,11 +183,17 @@ private:
return ParseResult::badChar;
if (c >= 'a')
{
nibble = static_cast<std::uint32_t>(c - 'a' + 0xA);
}
else if (c >= 'A')
{
nibble = static_cast<std::uint32_t>(c - 'A' + 0xA);
}
else if (c <= '9')
{
nibble = static_cast<std::uint32_t>(c - '0');
}
if (nibble > 0xFu)
return ParseResult::badChar;
@@ -212,7 +218,7 @@ private:
while (in != sv.end())
{
std::uint32_t accum = {};
for (std::uint32_t shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
for (std::uint32_t const shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
{
if (auto const result = hexCharToUInt(*in++, shift, accum);
result != ParseResult::okay)
@@ -263,7 +269,7 @@ public:
class Container,
class = std::enable_if_t<
detail::is_contiguous_container<Container>::value &&
std::is_trivially_copyable<typename Container::value_type>::value>>
std::is_trivially_copyable_v<typename Container::value_type>>>
explicit base_uint(Container const& c)
{
XRPL_ASSERT(
@@ -275,7 +281,7 @@ public:
template <class Container>
std::enable_if_t<
detail::is_contiguous_container<Container>::value &&
std::is_trivially_copyable<typename Container::value_type>::value,
std::is_trivially_copyable_v<typename Container::value_type>,
base_uint&>
operator=(Container const& c)
{
@@ -308,8 +314,10 @@ public:
signum() const
{
for (int i = 0; i < WIDTH; i++)
{
if (data_[i] != 0)
return 1;
}
return 0;
}
@@ -335,11 +343,13 @@ public:
operator=(std::uint64_t uHost)
{
*this = beast::zero;
// NOLINTBEGIN(cppcoreguidelines-pro-type-member-init)
union
{
unsigned u[2];
std::uint64_t ul;
};
// NOLINTEND(cppcoreguidelines-pro-type-member-init)
// Put in least significant bits.
ul = boost::endian::native_to_big(uHost);
data_[WIDTH - 2] = u[0];
@@ -388,7 +398,7 @@ public:
return *this;
}
base_uint const
base_uint
operator++(int)
{
// postfix operator
@@ -413,7 +423,7 @@ public:
return *this;
}
base_uint const
base_uint
operator--(int)
{
// postfix operator
@@ -442,9 +452,9 @@ public:
{
std::uint64_t carry = 0;
for (int i = WIDTH; i--;)
for (int i = WIDTH - 1; i >= 0; i--)
{
std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) +
std::uint64_t const n = carry + boost::endian::big_to_native(data_[i]) +
boost::endian::big_to_native(b.data_[i]);
data_[i] = boost::endian::native_to_big(static_cast<std::uint32_t>(n));
@@ -530,7 +540,7 @@ using uint256 = base_uint<256>;
using uint192 = base_uint<192>;
template <std::size_t Bits, class Tag>
[[nodiscard]] inline constexpr std::strong_ordering
[[nodiscard]] constexpr std::strong_ordering
operator<=>(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
{
// This comparison might seem wrong on a casual inspection because it
@@ -551,7 +561,7 @@ operator<=>(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
}
template <std::size_t Bits, typename Tag>
[[nodiscard]] inline constexpr bool
[[nodiscard]] constexpr bool
operator==(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
{
return (lhs <=> rhs) == 0;
@@ -559,7 +569,7 @@ operator==(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
//------------------------------------------------------------------------------
template <std::size_t Bits, class Tag>
inline constexpr bool
constexpr bool
operator==(base_uint<Bits, Tag> const& a, std::uint64_t b)
{
return a == base_uint<Bits, Tag>(b);
@@ -567,28 +577,28 @@ operator==(base_uint<Bits, Tag> const& a, std::uint64_t b)
//------------------------------------------------------------------------------
template <std::size_t Bits, class Tag>
inline constexpr base_uint<Bits, Tag>
constexpr base_uint<Bits, Tag>
operator^(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) ^= b;
}
template <std::size_t Bits, class Tag>
inline constexpr base_uint<Bits, Tag>
constexpr base_uint<Bits, Tag>
operator&(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) &= b;
}
template <std::size_t Bits, class Tag>
inline constexpr base_uint<Bits, Tag>
constexpr base_uint<Bits, Tag>
operator|(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) |= b;
}
template <std::size_t Bits, class Tag>
inline constexpr base_uint<Bits, Tag>
constexpr base_uint<Bits, Tag>
operator+(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) += b;
@@ -621,7 +631,7 @@ template <>
inline std::size_t
extract(uint256 const& key)
{
std::size_t result;
std::size_t result = 0;
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(&result, key.data(), sizeof(std::size_t));

5
include/xrpl/basics/contract.h
View File

@@ -49,12 +49,11 @@ template <class E, class... Args>
Throw(Args&&... args)
{
static_assert(
std::is_convertible<E*, std::exception*>::value,
"Exception must derive from std::exception.");
std::is_convertible_v<E*, std::exception*>, "Exception must derive from std::exception.");
E e(std::forward<Args>(args)...);
LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());
throw e;
throw std::move(e);
}
/** Called when faulty logic causes a broken invariant. */

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

@@ -32,7 +32,7 @@ make_seed_pair() noexcept
// state_t& operator=(state_t const&) = delete;
};
static state_t state;
std::lock_guard lock(state.mutex);
std::lock_guard const lock(state.mutex);
return {state.dist(state.gen), state.dist(state.gen)};
}
@@ -72,14 +72,12 @@ template <class HashAlgorithm = beast::xxhasher>
class hardened_hash
{
private:
detail::seed_pair m_seeds;
detail::seed_pair m_seeds{detail::make_seed_pair<>()};
public:
using result_type = typename HashAlgorithm::result_type;
hardened_hash() : m_seeds(detail::make_seed_pair<>())
{
}
hardened_hash() = default;
template <class T>
result_type

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

@@ -57,7 +57,7 @@ public:
{
using iterator_category = std::forward_iterator_tag;
partition_map_type* map_{nullptr};
typename partition_map_type::iterator ait_;
typename partition_map_type::iterator ait_{};
typename map_type::iterator mit_;
iterator() = default;
@@ -126,7 +126,7 @@ public:
using iterator_category = std::forward_iterator_tag;
partition_map_type* map_{nullptr};
typename partition_map_type::iterator ait_;
typename partition_map_type::iterator ait_{};
typename map_type::iterator mit_;
const_iterator() = default;
@@ -231,7 +231,8 @@ public:
{
// Set partitions to the number of hardware threads if the parameter
// is either empty or set to 0.
partitions_ = partitions && *partitions ? *partitions : std::thread::hardware_concurrency();
partitions_ =
partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency();
map_.resize(partitions_);
XRPL_ASSERT(
partitions_,

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

@@ -14,14 +14,16 @@ namespace xrpl {
#ifndef __INTELLISENSE__
static_assert(
std::is_integral<beast::xor_shift_engine::result_type>::value &&
std::is_unsigned<beast::xor_shift_engine::result_type>::value,
"The Ripple default PRNG engine must return an unsigned integral type.");
// NOLINTNEXTLINE(misc-redundant-expression)
std::is_integral_v<beast::xor_shift_engine::result_type> &&
std::is_unsigned_v<beast::xor_shift_engine::result_type>,
"The XRPL default PRNG engine must return an unsigned integral type.");
static_assert(
// NOLINTNEXTLINE(misc-redundant-expression)
std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
std::numeric_limits<std::uint64_t>::max(),
"The Ripple default PRNG engine return must be at least 64 bits wide.");
"The XRPL default PRNG engine return must be at least 64 bits wide.");
#endif
namespace detail {
@@ -56,9 +58,9 @@ default_prng()
// The thread-specific PRNGs:
thread_local beast::xor_shift_engine engine = [] {
std::uint64_t seed;
std::uint64_t seed = 0;
{
std::lock_guard lk(m);
std::lock_guard const lk(m);
std::uniform_int_distribution<std::uint64_t> distribution{1};
seed = distribution(seeder);
}
@@ -89,7 +91,7 @@ default_prng()
*/
/** @{ */
template <class Engine, class Integral>
std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine, Integral min, Integral max)
{
XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
@@ -101,35 +103,35 @@ rand_int(Engine& engine, Integral min, Integral max)
}
template <class Integral>
std::enable_if_t<std::is_integral<Integral>::value, Integral>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
rand_int(Integral min, Integral max)
{
return rand_int(default_prng(), min, max);
}
template <class Engine, class Integral>
std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine, Integral max)
{
return rand_int(engine, Integral(0), max);
}
template <class Integral>
std::enable_if_t<std::is_integral<Integral>::value, Integral>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
rand_int(Integral max)
{
return rand_int(default_prng(), max);
}
template <class Integral, class Engine>
std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine)
{
return rand_int(engine, std::numeric_limits<Integral>::max());
}
template <class Integral = int>
std::enable_if_t<std::is_integral<Integral>::value, Integral>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
rand_int()
{
return rand_int(default_prng(), std::numeric_limits<Integral>::max());
@@ -140,7 +142,7 @@ rand_int()
/** @{ */
template <class Byte, class Engine>
std::enable_if_t<
(std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value) &&
(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
detail::is_engine<Engine>::value,
Byte>
rand_byte(Engine& engine)
@@ -150,9 +152,7 @@ rand_byte(Engine& engine)
}
template <class Byte = std::uint8_t>
std::enable_if_t<
(std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value),
Byte>
std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
rand_byte()
{
return rand_byte<Byte>(default_prng());

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

@@ -12,12 +12,12 @@ namespace xrpl {
template <class Src, class Dest>
concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
(std::is_signed<Src>::value || std::is_unsigned<Dest>::value) &&
(std::is_signed<Src>::value != std::is_signed<Dest>::value ? sizeof(Dest) > sizeof(Src)
: sizeof(Dest) >= sizeof(Src));
(std::is_signed_v<Src> || std::is_unsigned_v<Dest>) &&
(std::is_signed_v<Src> != std::is_signed_v<Dest> ? sizeof(Dest) > sizeof(Src)
: sizeof(Dest) >= sizeof(Src));
template <class Dest, class Src>
inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
safe_cast(Src s) noexcept
{
static_assert(
@@ -30,14 +30,14 @@ safe_cast(Src s) noexcept
}
template <class Dest, class Src>
inline constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
safe_cast(Src s) noexcept
{
return static_cast<Dest>(safe_cast<std::underlying_type_t<Dest>>(s));
}
template <class Dest, class Src>
inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
safe_cast(Src s) noexcept
{
return safe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
@@ -48,7 +48,7 @@ safe_cast(Src s) noexcept
// underlying types become safe, it can be converted to a safe_cast.
template <class Dest, class Src>
inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
unsafe_cast(Src s) noexcept
{
static_assert(
@@ -59,14 +59,14 @@ unsafe_cast(Src s) noexcept
}
template <class Dest, class Src>
inline constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
unsafe_cast(Src s) noexcept
{
return static_cast<Dest>(unsafe_cast<std::underlying_type_t<Dest>>(s));
}
template <class Dest, class Src>
inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
unsafe_cast(Src s) noexcept
{
return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));

4
include/xrpl/basics/strHex.h
View File

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

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

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

22
include/xrpl/beast/asio/io_latency_probe.h
View File

@@ -23,15 +23,15 @@ private:
std::recursive_mutex m_mutex;
std::condition_variable_any m_cond;
std::size_t m_count;
std::size_t m_count{1};
duration const m_period;
boost::asio::io_context& m_ios;
boost::asio::basic_waitable_timer<std::chrono::steady_clock> m_timer;
bool m_cancel;
bool m_cancel{false};
public:
io_latency_probe(duration const& period, boost::asio::io_context& ios)
: m_count(1), m_period(period), m_ios(ios), m_timer(m_ios), m_cancel(false)
: m_period(period), m_ios(ios), m_timer(m_ios)
{
}
@@ -83,7 +83,7 @@ public:
void
sample_one(Handler&& handler)
{
std::lock_guard lock(m_mutex);
std::lock_guard const lock(m_mutex);
if (m_cancel)
throw std::logic_error("io_latency_probe is canceled");
boost::asio::post(
@@ -98,7 +98,7 @@ public:
void
sample(Handler&& handler)
{
std::lock_guard lock(m_mutex);
std::lock_guard const lock(m_mutex);
if (m_cancel)
throw std::logic_error("io_latency_probe is canceled");
boost::asio::post(
@@ -122,14 +122,14 @@ private:
void
addref()
{
std::lock_guard lock(m_mutex);
std::lock_guard const lock(m_mutex);
++m_count;
}
void
release()
{
std::lock_guard lock(m_mutex);
std::lock_guard const lock(m_mutex);
if (--m_count == 0)
m_cond.notify_all();
}
@@ -184,7 +184,7 @@ private:
void
operator()() const
{
if (!m_probe)
if (m_probe == nullptr)
return;
typename Clock::time_point const now(Clock::now());
typename Clock::duration const elapsed(now - m_start);
@@ -192,7 +192,7 @@ private:
m_handler(elapsed);
{
std::lock_guard lock(m_probe->m_mutex);
std::lock_guard const lock(m_probe->m_mutex);
if (m_probe->m_cancel)
return;
}
@@ -202,7 +202,7 @@ private:
// Calculate when we want to sample again, and
// adjust for the expected latency.
//
typename Clock::time_point const when(now + m_probe->m_period - 2 * elapsed);
typename Clock::time_point const when(now + m_probe->m_period - (2 * elapsed));
if (when <= now)
{
@@ -224,7 +224,7 @@ private:
void
operator()(boost::system::error_code const& ec)
{
if (!m_probe)
if (m_probe == nullptr)
return;
typename Clock::time_point const now(Clock::now());
boost::asio::post(

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

@@ -9,7 +9,7 @@ namespace beast {
/** Expire aged container items past the specified age. */
template <class AgedContainer, class Rep, class Period>
typename std::enable_if<is_aged_container<AgedContainer>::value, std::size_t>::type
std::enable_if_t<is_aged_container<AgedContainer>::value, std::size_t>
expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
{
std::size_t n(0);

2
include/xrpl/beast/container/aged_map.h
View File

@@ -16,4 +16,4 @@ template <
class Allocator = std::allocator<std::pair<Key const, T>>>
using aged_map = detail::aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_multimap.h
View File

@@ -16,4 +16,4 @@ template <
class Allocator = std::allocator<std::pair<Key const, T>>>
using aged_multimap = detail::aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_multiset.h
View File

@@ -15,4 +15,4 @@ template <
class Allocator = std::allocator<Key>>
using aged_multiset =
detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_set.h
View File

@@ -15,4 +15,4 @@ template <
class Allocator = std::allocator<Key>>
using aged_set = detail::aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_unordered_map.h
View File

@@ -17,4 +17,4 @@ template <
class Allocator = std::allocator<std::pair<Key const, T>>>
using aged_unordered_map =
detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_unordered_multimap.h
View File

@@ -17,4 +17,4 @@ template <
class Allocator = std::allocator<std::pair<Key const, T>>>
using aged_unordered_multimap =
detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_unordered_multiset.h
View File

@@ -17,4 +17,4 @@ template <
using aged_unordered_multiset =
detail::aged_unordered_container<true, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
}
} // namespace beast

2
include/xrpl/beast/container/aged_unordered_set.h
View File

@@ -16,4 +16,4 @@ template <
class Allocator = std::allocator<Key>>
using aged_unordered_set =
detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
}
} // namespace beast

8
include/xrpl/beast/container/detail/aged_associative_container.h
View File

@@ -1,7 +1,6 @@
#pragma once
namespace beast {
namespace detail {
namespace beast::detail {
// Extracts the key portion of value
template <bool maybe_map>
@@ -26,9 +25,8 @@ struct aged_associative_container_extract_t<false>
Value const&
operator()(Value const& value) const
{
return value;
return value; // NOLINT(bugprone-return-const-ref-from-parameter)
}
};
} // namespace detail
} // namespace beast
} // namespace beast::detail

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

@@ -2,6 +2,7 @@
#include <iterator>
#include <type_traits>
#include <utility>
namespace beast {
@@ -16,10 +17,10 @@ class aged_container_iterator
{
public:
using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
using value_type = typename std::conditional<
using value_type = std::conditional_t<
is_const,
typename Iterator::value_type::stashed::value_type const,
typename Iterator::value_type::stashed::value_type>::type;
typename Iterator::value_type::stashed::value_type>;
using difference_type = typename std::iterator_traits<Iterator>::difference_type;
using pointer = value_type*;
using reference = value_type&;
@@ -32,9 +33,9 @@ public:
template <
bool other_is_const,
class OtherIterator,
class = typename std::enable_if<
(other_is_const == false || is_const == true) &&
std::is_same<Iterator, OtherIterator>::value == false>::type>
class = std::enable_if_t<
(!other_is_const || is_const) &&
!static_cast<bool>(std::is_same_v<Iterator, OtherIterator>)>>
explicit aged_container_iterator(
aged_container_iterator<other_is_const, OtherIterator> const& other)
: m_iter(other.m_iter)
@@ -42,9 +43,7 @@ public:
}
// Disable constructing a const_iterator from a non-const_iterator.
template <
bool other_is_const,
class = typename std::enable_if<other_is_const == false || is_const == true>::type>
template <bool other_is_const, class = std::enable_if_t<!other_is_const || is_const>>
aged_container_iterator(aged_container_iterator<other_is_const, Iterator> const& other)
: m_iter(other.m_iter)
{
@@ -53,8 +52,8 @@ public:
// Disable assigning a const_iterator to a non-const iterator
template <bool other_is_const, class OtherIterator>
auto
operator=(aged_container_iterator<other_is_const, OtherIterator> const& other) -> typename std::
enable_if<other_is_const == false || is_const == true, aged_container_iterator&>::type
operator=(aged_container_iterator<other_is_const, OtherIterator> const& other)
-> std::enable_if_t<!other_is_const || is_const, aged_container_iterator&>
{
m_iter = other.m_iter;
return *this;
@@ -133,7 +132,7 @@ private:
friend class aged_container_iterator;
template <class OtherIterator>
aged_container_iterator(OtherIterator const& iter) : m_iter(iter)
aged_container_iterator(OtherIterator iter) : m_iter(std::move(iter))
{
}

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

@@ -57,8 +57,7 @@ template <
class T,
class Clock = std::chrono::steady_clock,
class Compare = std::less<Key>,
class Allocator =
std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
class Allocator = std::allocator<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>
class aged_ordered_container
{
public:
@@ -67,7 +66,7 @@ public:
using duration = typename clock_type::duration;
using key_type = Key;
using mapped_type = T;
using value_type = typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type;
using value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
@@ -110,8 +109,7 @@ private:
template <
class... Args,
class =
typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
element(time_point const& when_, Args&&... args)
: value(std::forward<Args>(args)...), when(when_)
{
@@ -135,9 +133,7 @@ private:
return Compare::operator()(lhs.first, rhs.first);
}
pair_value_compare()
{
}
pair_value_compare() = default;
pair_value_compare(pair_value_compare const& other) : Compare(other)
{
@@ -200,7 +196,7 @@ private:
using list_type = typename boost::intrusive::
make_list<element, boost::intrusive::constant_time_size<false>>::type;
using cont_type = typename std::conditional<
using cont_type = std::conditional_t<
IsMulti,
typename boost::intrusive::make_multiset<
element,
@@ -209,7 +205,7 @@ private:
typename boost::intrusive::make_set<
element,
boost::intrusive::constant_time_size<true>,
boost::intrusive::compare<KeyValueCompare>>::type>::type;
boost::intrusive::compare<KeyValueCompare>>::type>;
using ElementAllocator =
typename std::allocator_traits<Allocator>::template rebind_alloc<element>;
@@ -257,12 +253,15 @@ private:
config_t(config_t&& other)
: KeyValueCompare(std::move(other.key_compare()))
, beast::detail::empty_base_optimization<ElementAllocator>(std::move(other))
, beast::detail::empty_base_optimization<ElementAllocator>(std::move(
static_cast<beast::detail::empty_base_optimization<ElementAllocator>&>(other)))
, clock(other.clock)
{
}
config_t(config_t&& other, Allocator const& alloc)
config_t(
config_t&& other, // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
Allocator const& alloc)
: KeyValueCompare(std::move(other.key_compare()))
, beast::detail::empty_base_optimization<ElementAllocator>(alloc)
, clock(other.clock)
@@ -371,7 +370,7 @@ private:
public:
using key_compare = Compare;
using value_compare = typename std::conditional<IsMap, pair_value_compare, Compare>::type;
using value_compare = std::conditional_t<IsMap, pair_value_compare, Compare>;
using allocator_type = Allocator;
using reference = value_type&;
using const_reference = value_type const&;
@@ -399,6 +398,8 @@ public:
class chronological_t
{
chronological_t() = default;
public:
// A set iterator (IsMap==false) is always const
// because the elements of a set are immutable.
@@ -486,7 +487,7 @@ public:
iterator
iterator_to(value_type& value)
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return list.iterator_to(*reinterpret_cast<element*>(
reinterpret_cast<uint8_t*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
@@ -495,20 +496,16 @@ public:
const_iterator
iterator_to(value_type const& value) const
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return list.iterator_to(*reinterpret_cast<element const*>(
reinterpret_cast<uint8_t const*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
}
private:
chronological_t()
{
}
chronological_t(chronological_t const&) = delete;
chronological_t(chronological_t&&) = delete;
private:
friend class aged_ordered_container;
list_type mutable list;
} chronological;
@@ -552,7 +549,10 @@ public:
aged_ordered_container(aged_ordered_container&& other);
aged_ordered_container(aged_ordered_container&& other, Allocator const& alloc);
aged_ordered_container(
// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
aged_ordered_container&& other,
Allocator const& alloc);
aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock);
@@ -611,30 +611,30 @@ public:
class K,
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
typename std::conditional<IsMap, T, void*>::type&
class = std::enable_if_t<maybe_map && !maybe_multi>>
std::conditional_t<IsMap, T, void*>&
at(K const& k);
template <
class K,
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
class = std::enable_if_t<maybe_map && !maybe_multi>>
typename std::conditional<IsMap, T, void*>::type const&
at(K const& k) const;
template <
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
typename std::conditional<IsMap, T, void*>::type&
class = std::enable_if_t<maybe_map && !maybe_multi>>
std::conditional_t<IsMap, T, void*>&
operator[](Key const& key);
template <
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
typename std::conditional<IsMap, T, void*>::type&
class = std::enable_if_t<maybe_map && !maybe_multi>>
std::conditional_t<IsMap, T, void*>&
operator[](Key&& key);
//--------------------------------------------------------------------------
@@ -718,7 +718,7 @@ public:
iterator
iterator_to(value_type& value)
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return m_cont.iterator_to(*reinterpret_cast<element*>(
reinterpret_cast<uint8_t*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
@@ -727,7 +727,7 @@ public:
const_iterator
iterator_to(value_type const& value) const
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return m_cont.iterator_to(*reinterpret_cast<element const*>(
reinterpret_cast<uint8_t const*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
@@ -769,37 +769,35 @@ public:
// map, set
template <bool maybe_multi = IsMulti>
auto
insert(value_type const& value) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
insert(value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multimap, multiset
template <bool maybe_multi = IsMulti>
auto
insert(value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type;
insert(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>;
// set
template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
auto
insert(value_type&& value) ->
typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
insert(value_type&& value)
-> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>;
// multiset
template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
auto
insert(value_type&& value) ->
typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
insert(value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>;
//---
// map, set
template <bool maybe_multi = IsMulti>
auto
insert(const_iterator hint, value_type const& value) ->
typename std::enable_if<!maybe_multi, iterator>::type;
insert(const_iterator hint, value_type const& value)
-> std::enable_if_t<!maybe_multi, iterator>;
// multimap, multiset
template <bool maybe_multi = IsMulti>
typename std::enable_if<maybe_multi, iterator>::type
std::enable_if_t<maybe_multi, iterator>
insert(const_iterator /*hint*/, value_type const& value)
{
// VFALCO TODO Figure out how to utilize 'hint'
@@ -809,12 +807,11 @@ public:
// map, set
template <bool maybe_multi = IsMulti>
auto
insert(const_iterator hint, value_type&& value) ->
typename std::enable_if<!maybe_multi, iterator>::type;
insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!maybe_multi, iterator>;
// multimap, multiset
template <bool maybe_multi = IsMulti>
typename std::enable_if<maybe_multi, iterator>::type
std::enable_if_t<maybe_multi, iterator>
insert(const_iterator /*hint*/, value_type&& value)
{
// VFALCO TODO Figure out how to utilize 'hint'
@@ -823,9 +820,9 @@ public:
// map, multimap
template <class P, bool maybe_map = IsMap>
typename std::enable_if<
maybe_map && std::is_constructible<value_type, P&&>::value,
typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
std::enable_if_t<
maybe_map && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(P&& value)
{
return emplace(std::forward<P>(value));
@@ -833,9 +830,9 @@ public:
// map, multimap
template <class P, bool maybe_map = IsMap>
typename std::enable_if<
maybe_map && std::is_constructible<value_type, P&&>::value,
typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
std::enable_if_t<
maybe_map && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(const_iterator hint, P&& value)
{
return emplace_hint(hint, std::forward<P>(value));
@@ -858,23 +855,22 @@ public:
// map, set
template <bool maybe_multi = IsMulti, class... Args>
auto
emplace(Args&&... args) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
emplace(Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multiset, multimap
template <bool maybe_multi = IsMulti, class... Args>
auto
emplace(Args&&... args) -> typename std::enable_if<maybe_multi, iterator>::type;
emplace(Args&&... args) -> std::enable_if_t<maybe_multi, iterator>;
// map, set
template <bool maybe_multi = IsMulti, class... Args>
auto
emplace_hint(const_iterator hint, Args&&... args) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
emplace_hint(const_iterator hint, Args&&... args)
-> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multiset, multimap
template <bool maybe_multi = IsMulti, class... Args>
typename std::enable_if<maybe_multi, iterator>::type
std::enable_if_t<maybe_multi, iterator>
emplace_hint(const_iterator /*hint*/, Args&&... args)
{
// VFALCO TODO Figure out how to utilize 'hint'
@@ -1158,12 +1154,12 @@ private:
template <
bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
typename std::enable_if<maybe_propagate>::type
std::enable_if_t<maybe_propagate>
swap_data(aged_ordered_container& other) noexcept;
template <
bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
typename std::enable_if<!maybe_propagate>::type
std::enable_if_t<!maybe_propagate>
swap_data(aged_ordered_container& other) noexcept;
private:
@@ -1290,7 +1286,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_ordered_container(
aged_ordered_container&& other,
aged_ordered_container&& other, // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
Allocator const& alloc)
: m_config(std::move(other.m_config), alloc)
#if BOOST_VERSION >= 108000
@@ -1390,7 +1386,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <class K, bool maybe_multi, bool maybe_map, class>
typename std::conditional<IsMap, T, void*>::type&
std::conditional_t<IsMap, T, void*>&
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k)
{
auto const iter(m_cont.find(k, std::cref(m_config.key_compare())));
@@ -1412,7 +1408,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool maybe_multi, bool maybe_map, class>
typename std::conditional<IsMap, T, void*>::type&
std::conditional_t<IsMap, T, void*>&
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](
Key const& key)
{
@@ -1431,7 +1427,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool maybe_multi, bool maybe_map, class>
typename std::conditional<IsMap, T, void*>::type&
std::conditional_t<IsMap, T, void*>&
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
{
typename cont_type::insert_commit_data d;
@@ -1466,8 +1462,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool maybe_multi>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
value_type const& value) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
typename cont_type::insert_commit_data d;
auto const result(m_cont.insert_check(extract(value), std::cref(m_config.key_compare()), d));
@@ -1486,7 +1481,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool maybe_multi>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type
value_type const& value) -> std::enable_if_t<maybe_multi, iterator>
{
auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
element* const p(new_element(value));
@@ -1500,8 +1495,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool maybe_multi, bool maybe_map>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
value_type&& value) ->
typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type
value_type&& value) -> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>
{
typename cont_type::insert_commit_data d;
auto const result(m_cont.insert_check(extract(value), std::cref(m_config.key_compare()), d));
@@ -1520,7 +1514,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool maybe_multi, bool maybe_map>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>
{
auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
element* const p(new_element(std::move(value)));
@@ -1537,7 +1531,7 @@ template <bool maybe_multi>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
const_iterator hint,
value_type const& value) -> typename std::enable_if<!maybe_multi, iterator>::type
value_type const& value) -> std::enable_if_t<!maybe_multi, iterator>
{
typename cont_type::insert_commit_data d;
auto const result(
@@ -1558,7 +1552,7 @@ template <bool maybe_multi>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
const_iterator hint,
value_type&& value) -> typename std::enable_if<!maybe_multi, iterator>::type
value_type&& value) -> std::enable_if_t<!maybe_multi, iterator>
{
typename cont_type::insert_commit_data d;
auto const result(
@@ -1578,7 +1572,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool maybe_multi, class... Args>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
-> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
// VFALCO NOTE Its unfortunate that we need to
// construct element here
@@ -1600,7 +1594,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
template <bool maybe_multi, class... Args>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-> typename std::enable_if<maybe_multi, iterator>::type
-> std::enable_if_t<maybe_multi, iterator>
{
element* const p(new_element(std::forward<Args>(args)...));
auto const before(m_cont.upper_bound(extract(p->value), std::cref(m_config.key_compare())));
@@ -1615,7 +1609,7 @@ template <bool maybe_multi, class... Args>
auto
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace_hint(
const_iterator hint,
Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
// VFALCO NOTE Its unfortunate that we need to
// construct element here
@@ -1765,7 +1759,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool maybe_propagate>
typename std::enable_if<maybe_propagate>::type
std::enable_if_t<maybe_propagate>
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_data(
aged_ordered_container& other) noexcept
{
@@ -1776,7 +1770,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_
template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
template <bool maybe_propagate>
typename std::enable_if<!maybe_propagate>::type
std::enable_if_t<!maybe_propagate>
aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_data(
aged_ordered_container& other) noexcept
{

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

@@ -62,8 +62,7 @@ template <
class Clock = std::chrono::steady_clock,
class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>,
class Allocator =
std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
class Allocator = std::allocator<std::conditional_t<IsMap, std::pair<Key const, T>, Key>>>
class aged_unordered_container
{
public:
@@ -72,7 +71,7 @@ public:
using duration = typename clock_type::duration;
using key_type = Key;
using mapped_type = T;
using value_type = typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type;
using value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
@@ -115,8 +114,7 @@ private:
template <
class... Args,
class =
typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
element(time_point const& when_, Args&&... args)
: value(std::forward<Args>(args)...), when(when_)
{
@@ -133,9 +131,7 @@ private:
using argument_type = element;
using result_type = size_t;
ValueHash()
{
}
ValueHash() = default;
ValueHash(Hash const& h) : Hash(h)
{
@@ -169,9 +165,7 @@ private:
using second_argument_type = element;
using result_type = bool;
KeyValueEqual()
{
}
KeyValueEqual() = default;
KeyValueEqual(KeyEqual const& keyEqual) : KeyEqual(keyEqual)
{
@@ -211,7 +205,7 @@ private:
using list_type = typename boost::intrusive::
make_list<element, boost::intrusive::constant_time_size<false>>::type;
using cont_type = typename std::conditional<
using cont_type = std::conditional_t<
IsMulti,
typename boost::intrusive::make_unordered_multiset<
element,
@@ -224,7 +218,7 @@ private:
boost::intrusive::constant_time_size<true>,
boost::intrusive::hash<ValueHash>,
boost::intrusive::equal<KeyValueEqual>,
boost::intrusive::cache_begin<true>>::type>::type;
boost::intrusive::cache_begin<true>>::type>;
using bucket_type = typename cont_type::bucket_type;
using bucket_traits = typename cont_type::bucket_traits;
@@ -318,7 +312,9 @@ private:
{
}
config_t(config_t&& other, Allocator const& alloc)
config_t(
config_t&& other, // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
Allocator const& alloc)
: ValueHash(std::move(other.hash_function()))
, KeyValueEqual(std::move(other.key_eq()))
, beast::detail::empty_base_optimization<ElementAllocator>(alloc)
@@ -660,7 +656,7 @@ public:
iterator
iterator_to(value_type& value)
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return list.iterator_to(*reinterpret_cast<element*>(
reinterpret_cast<uint8_t*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
@@ -669,20 +665,17 @@ public:
const_iterator
iterator_to(value_type const& value) const
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return list.iterator_to(*reinterpret_cast<element const*>(
reinterpret_cast<uint8_t const*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
}
private:
chronological_t()
{
}
chronological_t(chronological_t const&) = delete;
chronological_t(chronological_t&&) = delete;
chronological_t() = default;
private:
friend class aged_unordered_container;
list_type mutable list;
} chronological;
@@ -774,7 +767,10 @@ public:
aged_unordered_container(aged_unordered_container&& other);
aged_unordered_container(aged_unordered_container&& other, Allocator const& alloc);
aged_unordered_container(
// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
aged_unordered_container&& other,
Allocator const& alloc);
aged_unordered_container(std::initializer_list<value_type> init, clock_type& clock);
@@ -857,30 +853,30 @@ public:
class K,
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
typename std::conditional<IsMap, T, void*>::type&
class = std::enable_if_t<maybe_map && !maybe_multi>>
std::conditional_t<IsMap, T, void*>&
at(K const& k);
template <
class K,
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
class = std::enable_if_t<maybe_map && !maybe_multi>>
typename std::conditional<IsMap, T, void*>::type const&
at(K const& k) const;
template <
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
typename std::conditional<IsMap, T, void*>::type&
class = std::enable_if_t<maybe_map && !maybe_multi>>
std::conditional_t<IsMap, T, void*>&
operator[](Key const& key);
template <
bool maybe_multi = IsMulti,
bool maybe_map = IsMap,
class = typename std::enable_if<maybe_map && !maybe_multi>::type>
typename std::conditional<IsMap, T, void*>::type&
class = std::enable_if_t<maybe_map && !maybe_multi>>
std::conditional_t<IsMap, T, void*>&
operator[](Key&& key);
//--------------------------------------------------------------------------
@@ -928,7 +924,7 @@ public:
iterator
iterator_to(value_type& value)
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return m_cont.iterator_to(*reinterpret_cast<element*>(
reinterpret_cast<uint8_t*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
@@ -937,7 +933,7 @@ public:
const_iterator
iterator_to(value_type const& value) const
{
static_assert(std::is_standard_layout<element>::value, "must be standard layout");
static_assert(std::is_standard_layout_v<element>, "must be standard layout");
return m_cont.iterator_to(*reinterpret_cast<element const*>(
reinterpret_cast<uint8_t const*>(&value) -
((std::size_t)std::addressof(((element*)0)->member))));
@@ -979,29 +975,27 @@ public:
// map, set
template <bool maybe_multi = IsMulti>
auto
insert(value_type const& value) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
insert(value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multimap, multiset
template <bool maybe_multi = IsMulti>
auto
insert(value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type;
insert(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>;
// map, set
template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
auto
insert(value_type&& value) ->
typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
insert(value_type&& value)
-> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>;
// multimap, multiset
template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
auto
insert(value_type&& value) ->
typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
insert(value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>;
// map, set
template <bool maybe_multi = IsMulti>
typename std::enable_if<!maybe_multi, iterator>::type
std::enable_if_t<!maybe_multi, iterator>
insert(const_iterator /*hint*/, value_type const& value)
{
// Hint is ignored but we provide the interface so
@@ -1011,7 +1005,7 @@ public:
// multimap, multiset
template <bool maybe_multi = IsMulti>
typename std::enable_if<maybe_multi, iterator>::type
std::enable_if_t<maybe_multi, iterator>
insert(const_iterator /*hint*/, value_type const& value)
{
// VFALCO TODO The hint could be used to let
@@ -1021,7 +1015,7 @@ public:
// map, set
template <bool maybe_multi = IsMulti>
typename std::enable_if<!maybe_multi, iterator>::type
std::enable_if_t<!maybe_multi, iterator>
insert(const_iterator /*hint*/, value_type&& value)
{
// Hint is ignored but we provide the interface so
@@ -1031,7 +1025,7 @@ public:
// multimap, multiset
template <bool maybe_multi = IsMulti>
typename std::enable_if<maybe_multi, iterator>::type
std::enable_if_t<maybe_multi, iterator>
insert(const_iterator /*hint*/, value_type&& value)
{
// VFALCO TODO The hint could be used to let
@@ -1041,9 +1035,9 @@ public:
// map, multimap
template <class P, bool maybe_map = IsMap>
typename std::enable_if<
maybe_map && std::is_constructible<value_type, P&&>::value,
typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
std::enable_if_t<
maybe_map && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(P&& value)
{
return emplace(std::forward<P>(value));
@@ -1051,9 +1045,9 @@ public:
// map, multimap
template <class P, bool maybe_map = IsMap>
typename std::enable_if<
maybe_map && std::is_constructible<value_type, P&&>::value,
typename std::conditional<IsMulti, iterator, std::pair<iterator, bool>>::type>::type
std::enable_if_t<
maybe_map && std::is_constructible_v<value_type, P&&>,
std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
insert(const_iterator hint, P&& value)
{
return emplace_hint(hint, std::forward<P>(value));
@@ -1075,23 +1069,22 @@ public:
// set, map
template <bool maybe_multi = IsMulti, class... Args>
auto
emplace(Args&&... args) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
emplace(Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multiset, multimap
template <bool maybe_multi = IsMulti, class... Args>
auto
emplace(Args&&... args) -> typename std::enable_if<maybe_multi, iterator>::type;
emplace(Args&&... args) -> std::enable_if_t<maybe_multi, iterator>;
// set, map
template <bool maybe_multi = IsMulti, class... Args>
auto
emplace_hint(const_iterator /*hint*/, Args&&... args) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
emplace_hint(const_iterator /*hint*/, Args&&... args)
-> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multiset, multimap
template <bool maybe_multi = IsMulti, class... Args>
typename std::enable_if<maybe_multi, iterator>::type
std::enable_if_t<maybe_multi, iterator>
emplace_hint(const_iterator /*hint*/, Args&&... args)
{
// VFALCO TODO The hint could be used for multi, to let
@@ -1323,7 +1316,7 @@ public:
class OtherHash,
class OtherAllocator,
bool maybe_multi = IsMulti>
typename std::enable_if<!maybe_multi, bool>::type
std::enable_if_t<!maybe_multi, bool>
operator==(aged_unordered_container<
false,
OtherIsMap,
@@ -1342,7 +1335,7 @@ public:
class OtherHash,
class OtherAllocator,
bool maybe_multi = IsMulti>
typename std::enable_if<maybe_multi, bool>::type
std::enable_if_t<maybe_multi, bool>
operator==(aged_unordered_container<
true,
OtherIsMap,
@@ -1396,14 +1389,13 @@ private:
// map, set
template <bool maybe_multi = IsMulti>
auto
insert_unchecked(value_type const& value) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
insert_unchecked(value_type const& value)
-> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>;
// multimap, multiset
template <bool maybe_multi = IsMulti>
auto
insert_unchecked(value_type const& value) ->
typename std::enable_if<maybe_multi, iterator>::type;
insert_unchecked(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>;
template <class InputIt>
void
@@ -1444,7 +1436,7 @@ private:
template <
bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
typename std::enable_if<maybe_propagate>::type
std::enable_if_t<maybe_propagate>
swap_data(aged_unordered_container& other) noexcept
{
std::swap(m_config.key_compare(), other.m_config.key_compare());
@@ -1454,7 +1446,7 @@ private:
template <
bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
typename std::enable_if<!maybe_propagate>::type
std::enable_if_t<!maybe_propagate>
swap_data(aged_unordered_container& other) noexcept
{
std::swap(m_config.key_compare(), other.m_config.key_compare());
@@ -1838,7 +1830,10 @@ template <
class KeyEqual,
class Allocator>
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
aged_unordered_container(aged_unordered_container&& other, Allocator const& alloc)
aged_unordered_container(
// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
aged_unordered_container&& other,
Allocator const& alloc)
: m_config(std::move(other.m_config), alloc)
, m_buck(alloc)
, m_cont(m_buck, std::cref(m_config.value_hash()), std::cref(m_config.key_value_equal()))
@@ -2106,7 +2101,7 @@ template <
class KeyEqual,
class Allocator>
template <class K, bool maybe_multi, bool maybe_map, class>
typename std::conditional<IsMap, T, void*>::type&
std::conditional_t<IsMap, T, void*>&
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(K const& k)
{
auto const iter(
@@ -2147,7 +2142,7 @@ template <
class KeyEqual,
class Allocator>
template <bool maybe_multi, bool maybe_map, class>
typename std::conditional<IsMap, T, void*>::type&
std::conditional_t<IsMap, T, void*>&
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
Key const& key)
{
@@ -2176,7 +2171,7 @@ template <
class KeyEqual,
class Allocator>
template <bool maybe_multi, bool maybe_map, class>
typename std::conditional<IsMap, T, void*>::type&
std::conditional_t<IsMap, T, void*>&
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
Key&& key)
{
@@ -2231,8 +2226,7 @@ template <
template <bool maybe_multi>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type const& value) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
value_type const& value) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
maybe_rehash(1);
typename cont_type::insert_commit_data d;
@@ -2264,7 +2258,7 @@ template <
template <bool maybe_multi>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type
value_type const& value) -> std::enable_if_t<maybe_multi, iterator>
{
maybe_rehash(1);
element* const p(new_element(value));
@@ -2286,8 +2280,7 @@ template <
template <bool maybe_multi, bool maybe_map>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type&& value) ->
typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type
value_type&& value) -> std::enable_if_t<!maybe_multi && !maybe_map, std::pair<iterator, bool>>
{
maybe_rehash(1);
typename cont_type::insert_commit_data d;
@@ -2319,7 +2312,7 @@ template <
template <bool maybe_multi, bool maybe_map>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
value_type&& value) -> std::enable_if_t<maybe_multi && !maybe_map, iterator>
{
maybe_rehash(1);
element* const p(new_element(std::move(value)));
@@ -2342,7 +2335,7 @@ template <
template <bool maybe_multi, class... Args>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
maybe_rehash(1);
// VFALCO NOTE Its unfortunate that we need to
@@ -2407,7 +2400,7 @@ template <
template <bool maybe_multi, class... Args>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
Args&&... args) -> typename std::enable_if<maybe_multi, iterator>::type
Args&&... args) -> std::enable_if_t<maybe_multi, iterator>
{
maybe_rehash(1);
element* const p(new_element(std::forward<Args>(args)...));
@@ -2430,7 +2423,7 @@ template <bool maybe_multi, class... Args>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace_hint(
const_iterator /*hint*/,
Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
Args&&... args) -> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
maybe_rehash(1);
// VFALCO NOTE Its unfortunate that we need to
@@ -2582,7 +2575,7 @@ template <
class OtherHash,
class OtherAllocator,
bool maybe_multi>
typename std::enable_if<!maybe_multi, bool>::type
std::enable_if_t<!maybe_multi, bool>
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
aged_unordered_container<
false,
@@ -2622,7 +2615,7 @@ template <
class OtherHash,
class OtherAllocator,
bool maybe_multi>
typename std::enable_if<maybe_multi, bool>::type
std::enable_if_t<maybe_multi, bool>
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
aged_unordered_container<
true,
@@ -2669,8 +2662,8 @@ template <
template <bool maybe_multi>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
insert_unchecked(value_type const& value) ->
typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
insert_unchecked(value_type const& value)
-> std::enable_if_t<!maybe_multi, std::pair<iterator, bool>>
{
typename cont_type::insert_commit_data d;
auto const result(m_cont.insert_check(
@@ -2701,8 +2694,7 @@ template <
template <bool maybe_multi>
auto
aged_unordered_container<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
insert_unchecked(value_type const& value) ->
typename std::enable_if<maybe_multi, iterator>::type
insert_unchecked(value_type const& value) -> std::enable_if_t<maybe_multi, iterator>
{
element* const p(new_element(value));
chronological.list.push_back(*p);

8
include/xrpl/beast/container/detail/empty_base_optimization.h
View File

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

8
include/xrpl/beast/core/List.h
View File

@@ -16,7 +16,7 @@ struct CopyConst
{
explicit CopyConst() = default;
using type = typename std::remove_const<U>::type;
using type = std::remove_const_t<U>;
};
template <typename T, typename U>
@@ -35,9 +35,11 @@ struct CopyConst<T const, U>
template <typename T, typename Tag>
class ListNode
{
private:
ListNode() = default;
using value_type = T;
friend T;
friend class List<T, Tag>;
template <typename>
@@ -449,7 +451,7 @@ public:
iterator
erase(iterator pos) noexcept
{
Node* node = &*pos;
Node const* node = &*pos;
++pos;
node->m_next->m_prev = node->m_prev;
node->m_prev->m_next = node->m_next;

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

@@ -13,22 +13,18 @@ class LockFreeStackIterator
{
protected:
using Node = typename Container::Node;
using NodePtr = typename std::conditional<IsConst, Node const*, Node*>::type;
using NodePtr = std::conditional_t<IsConst, Node const*, Node*>;
public:
using iterator_category = std::forward_iterator_tag;
using value_type = typename Container::value_type;
using difference_type = typename Container::difference_type;
using pointer = typename std::
conditional<IsConst, typename Container::const_pointer, typename Container::pointer>::type;
using reference = typename std::conditional<
IsConst,
typename Container::const_reference,
typename Container::reference>::type;
using pointer =
std::conditional_t<IsConst, typename Container::const_pointer, typename Container::pointer>;
using reference = std::
conditional_t<IsConst, typename Container::const_reference, typename Container::reference>;
LockFreeStackIterator() : m_node()
{
}
LockFreeStackIterator() = default;
LockFreeStackIterator(NodePtr node) : m_node(node)
{
@@ -81,7 +77,7 @@ public:
}
private:
NodePtr m_node;
NodePtr m_node{};
};
//------------------------------------------------------------------------------
@@ -187,7 +183,7 @@ public:
bool
push_front(Node* node)
{
bool first;
bool first = false;
Node* old_head = m_head.load(std::memory_order_relaxed);
do
{
@@ -211,7 +207,7 @@ public:
pop_front()
{
Node* node = m_head.load();
Node* new_head;
Node* new_head = nullptr;
do
{
if (node == &m_end)

4
include/xrpl/beast/core/SemanticVersion.h
View File

@@ -40,12 +40,12 @@ public:
std::string
print() const;
inline bool
bool
isRelease() const noexcept
{
return preReleaseIdentifiers.empty();
}
inline bool
bool
isPreRelease() const noexcept
{
return !isRelease();

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

@@ -69,7 +69,7 @@ template <class T>
struct is_uniquely_represented
: public std::integral_constant<
bool,
std::is_integral<T>::value || std::is_enum<T>::value || std::is_pointer<T>::value>
std::is_integral_v<T> || std::is_enum_v<T> || std::is_pointer_v<T>>
{
explicit is_uniquely_represented() = default;
};
@@ -203,13 +203,14 @@ template <class Hasher, class T>
inline std::enable_if_t<is_contiguously_hashable<T, Hasher>::value>
hash_append(Hasher& h, T const& t) noexcept
{
h(std::addressof(t), sizeof(t));
// NOLINTNEXTLINE(bugprone-sizeof-expression)
h(static_cast<void const*>(std::addressof(t)), sizeof(t));
}
template <class Hasher, class T>
inline std::enable_if_t<
!is_contiguously_hashable<T, Hasher>::value &&
(std::is_integral<T>::value || std::is_pointer<T>::value || std::is_enum<T>::value)>
(std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
hash_append(Hasher& h, T t) noexcept
{
detail::reverse_bytes(t);
@@ -217,7 +218,7 @@ hash_append(Hasher& h, T t) noexcept
}
template <class Hasher, class T>
inline std::enable_if_t<std::is_floating_point<T>::value>
inline std::enable_if_t<std::is_floating_point_v<T>>
hash_append(Hasher& h, T t) noexcept
{
if (t == 0)

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

@@ -23,7 +23,7 @@ private:
// A 64-byte buffer should to be big enough for us
static constexpr std::size_t INTERNAL_BUFFER_SIZE = 64;
alignas(64) std::array<std::uint8_t, INTERNAL_BUFFER_SIZE> buffer_;
alignas(64) std::array<std::uint8_t, INTERNAL_BUFFER_SIZE> buffer_{};
std::span<std::uint8_t> readBuffer_;
std::span<std::uint8_t> writeBuffer_;
@@ -64,7 +64,7 @@ private:
void
flushToState(void const* data, std::size_t len)
{
if (!state_)
if (state_ == nullptr)
{
state_ = allocState();
if (seed_.has_value())
@@ -78,7 +78,7 @@ private:
}
XXH3_64bits_update(state_, readBuffer_.data(), readBuffer_.size());
resetBuffers();
if (data && len)
if ((data != nullptr) && (len != 0u))
{
XXH3_64bits_update(state_, data, len);
}
@@ -87,22 +87,18 @@ private:
result_type
retrieveHash()
{
if (state_)
if (state_ != nullptr)
{
flushToState(nullptr, 0);
return XXH3_64bits_digest(state_);
}
else
if (seed_.has_value())
{
if (seed_.has_value())
{
return XXH3_64bits_withSeed(readBuffer_.data(), readBuffer_.size(), *seed_);
}
else
{
return XXH3_64bits(readBuffer_.data(), readBuffer_.size());
}
return XXH3_64bits_withSeed(readBuffer_.data(), readBuffer_.size(), *seed_);
}
return XXH3_64bits(readBuffer_.data(), readBuffer_.size());
}
public:
@@ -119,19 +115,19 @@ public:
~xxhasher() noexcept
{
if (state_)
if (state_ != nullptr)
{
XXH3_freeState(state_);
}
}
template <class Seed, std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
explicit xxhasher(Seed seed) : seed_(seed)
{
resetBuffers();
}
template <class Seed, std::enable_if_t<std::is_unsigned<Seed>::value>* = nullptr>
template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
xxhasher(Seed seed, Seed) : seed_(seed)
{
resetBuffers();

6
include/xrpl/beast/insight/Collector.h
View File

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

10
include/xrpl/beast/insight/Counter.h
View File

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

6
include/xrpl/beast/insight/CounterImpl.h
View File

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

10
include/xrpl/beast/insight/Event.h
View File

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

6
include/xrpl/beast/insight/EventImpl.h
View File

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

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

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

6
include/xrpl/beast/insight/GaugeImpl.h
View File

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

6
include/xrpl/beast/insight/Group.h
View File

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

6
include/xrpl/beast/insight/Groups.h
View File

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

10
include/xrpl/beast/insight/Hook.h
View File

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

6
include/xrpl/beast/insight/HookImpl.h
View File

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

10
include/xrpl/beast/insight/Meter.h
View File

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

6
include/xrpl/beast/insight/MeterImpl.h
View File

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

6
include/xrpl/beast/insight/NullCollector.h
View File

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

6
include/xrpl/beast/insight/StatsDCollector.h
View File

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

4
include/xrpl/beast/net/IPAddress.h
View File

@@ -70,9 +70,13 @@ hash_append(Hasher& h, beast::IP::Address const& addr) noexcept
{
using beast::hash_append;
if (addr.is_v4())
{
hash_append(h, addr.to_v4().to_bytes());
}
else if (addr.is_v6())
{
hash_append(h, addr.to_v6().to_bytes());
}
else
{
// LCOV_EXCL_START

6
include/xrpl/beast/net/IPAddressConversion.h
View File

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

6
include/xrpl/beast/net/IPAddressV4.h
View File

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

6
include/xrpl/beast/net/IPAddressV6.h
View File

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

12
include/xrpl/beast/net/IPEndpoint.h
View File

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

13
include/xrpl/beast/rfc2616.h
View File

@@ -12,8 +12,7 @@
#include <string>
#include <vector>
namespace beast {
namespace rfc2616 {
namespace beast::rfc2616 {
namespace detail {
@@ -53,8 +52,9 @@ is_white(char c)
case '\t':
case '\v':
return true;
default:
return false;
};
return false;
}
template <class FwdIter>
@@ -349,8 +349,10 @@ bool
token_in_list(boost::string_ref const& value, boost::string_ref const& token)
{
for (auto const& item : make_list(value))
{
if (ci_equal(item, token))
return true;
}
return false;
}
@@ -359,11 +361,12 @@ bool
is_keep_alive(boost::beast::http::message<isRequest, Body, Fields> const& m)
{
if (m.version() <= 10)
{
return boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists(
"keep-alive");
}
return !boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists(
"close");
}
} // namespace rfc2616
} // namespace beast
} // namespace beast::rfc2616

10
include/xrpl/beast/test/yield_to.h
View File

@@ -16,8 +16,7 @@
#include <thread>
#include <vector>
namespace beast {
namespace test {
namespace beast::test {
/** Stack size for yield_to coroutines.
*
@@ -66,7 +65,7 @@ public:
: work_(boost::asio::make_work_guard(ios_))
{
threads_.reserve(concurrency);
while (concurrency--)
while ((concurrency--) != 0u)
threads_.emplace_back([&] { ios_.run(); });
}
@@ -136,7 +135,7 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
boost::context::fixedsize_stack(yieldStackSize),
[&](yield_context yield) {
f(yield);
std::lock_guard lock{m_};
std::lock_guard const lock{m_};
if (--running_ == 0)
cv_.notify_all();
},
@@ -147,5 +146,4 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
spawn(fn...);
}
} // namespace test
} // namespace beast
} // namespace beast::test

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

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

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

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

8
include/xrpl/beast/unit_test/detail/const_container.h
View File

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

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

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

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

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

22
include/xrpl/beast/unit_test/recorder.h
View File

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

70
include/xrpl/beast/unit_test/reporter.h
View File

@@ -18,8 +18,7 @@
#include <string>
#include <utility>
namespace beast {
namespace unit_test {
namespace beast::unit_test {
namespace detail {
@@ -86,7 +85,7 @@ public:
reporter&
operator=(reporter const&) = delete;
~reporter();
~reporter() override;
explicit reporter(std::ostream& os = std::cout);
@@ -94,42 +93,42 @@ private:
static std::string
fmtdur(typename clock_type::duration const& d);
virtual void
void
on_suite_begin(suite_info const& info) override;
virtual void
void
on_suite_end() override;
virtual void
void
on_case_begin(std::string const& name) override;
virtual void
void
on_case_end() override;
virtual void
void
on_pass() override;
virtual void
void
on_fail(std::string const& reason) override;
virtual void
void
on_log(std::string const& s) override;
};
//------------------------------------------------------------------------------
template <class _>
template <class Unused>
void
reporter<_>::suite_results::add(case_results const& r)
reporter<Unused>::suite_results::add(case_results const& r)
{
++cases;
total += r.total;
failed += r.failed;
}
template <class _>
template <class Unused>
void
reporter<_>::results::add(suite_results const& r)
reporter<Unused>::results::add(suite_results const& r)
{
++suites;
total += r.total;
@@ -160,13 +159,13 @@ reporter<_>::results::add(suite_results const& r)
//------------------------------------------------------------------------------
template <class _>
reporter<_>::reporter(std::ostream& os) : os_(os)
template <class Unused>
reporter<Unused>::reporter(std::ostream& os) : os_(os)
{
}
template <class _>
reporter<_>::~reporter()
template <class Unused>
reporter<Unused>::~reporter()
{
if (results_.top.size() > 0)
{
@@ -180,9 +179,9 @@ reporter<_>::~reporter()
<< amount{results_.failed, "failure"} << std::endl;
}
template <class _>
template <class Unused>
std::string
reporter<_>::fmtdur(typename clock_type::duration const& d)
reporter<Unused>::fmtdur(typename clock_type::duration const& d)
{
using namespace std::chrono;
auto const ms = duration_cast<milliseconds>(d);
@@ -193,46 +192,46 @@ reporter<_>::fmtdur(typename clock_type::duration const& d)
return ss.str();
}
template <class _>
template <class Unused>
void
reporter<_>::on_suite_begin(suite_info const& info)
reporter<Unused>::on_suite_begin(suite_info const& info)
{
suite_results_ = suite_results{info.full_name()};
}
template <class _>
template <class Unused>
void
reporter<_>::on_suite_end()
reporter<Unused>::on_suite_end()
{
results_.add(suite_results_);
}
template <class _>
template <class Unused>
void
reporter<_>::on_case_begin(std::string const& name)
reporter<Unused>::on_case_begin(std::string const& name)
{
case_results_ = case_results(name);
os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name))
<< std::endl;
}
template <class _>
template <class Unused>
void
reporter<_>::on_case_end()
reporter<Unused>::on_case_end()
{
suite_results_.add(case_results_);
}
template <class _>
template <class Unused>
void
reporter<_>::on_pass()
reporter<Unused>::on_pass()
{
++case_results_.total;
}
template <class _>
template <class Unused>
void
reporter<_>::on_fail(std::string const& reason)
reporter<Unused>::on_fail(std::string const& reason)
{
++case_results_.failed;
++case_results_.total;
@@ -240,9 +239,9 @@ reporter<_>::on_fail(std::string const& reason)
<< std::endl;
}
template <class _>
template <class Unused>
void
reporter<_>::on_log(std::string const& s)
reporter<Unused>::on_log(std::string const& s)
{
os_ << s;
}
@@ -251,5 +250,4 @@ reporter<_>::on_log(std::string const& s)
using reporter = detail::reporter<>;
} // namespace unit_test
} // namespace beast
} // namespace beast::unit_test

31
include/xrpl/beast/unit_test/results.h
View File

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

18
include/xrpl/beast/unit_test/runner.h
View File

@@ -11,8 +11,7 @@
#include <mutex>
#include <string>
namespace beast {
namespace unit_test {
namespace beast::unit_test {
/** Unit test runner interface.
@@ -198,8 +197,10 @@ runner::run_if(FwdIter first, FwdIter last, Pred pred)
{
bool failed(false);
for (; first != last; ++first)
{
if (pred(*first))
failed = run(*first) || failed;
}
return failed;
}
@@ -219,8 +220,10 @@ runner::run_each_if(SequenceContainer const& c, Pred pred)
{
bool failed(false);
for (auto const& s : c)
{
if (pred(s))
failed = run(s) || failed;
}
return failed;
}
@@ -228,7 +231,7 @@ template <class>
void
runner::testcase(std::string const& name)
{
std::lock_guard lock(mutex_);
std::lock_guard const lock(mutex_);
// Name may not be empty
BOOST_ASSERT(default_ || !name.empty());
// Forgot to call pass or fail
@@ -244,7 +247,7 @@ template <class>
void
runner::pass()
{
std::lock_guard lock(mutex_);
std::lock_guard const lock(mutex_);
if (default_)
testcase("");
on_pass();
@@ -255,7 +258,7 @@ template <class>
void
runner::fail(std::string const& reason)
{
std::lock_guard lock(mutex_);
std::lock_guard const lock(mutex_);
if (default_)
testcase("");
on_fail(reason);
@@ -267,11 +270,10 @@ template <class>
void
runner::log(std::string const& s)
{
std::lock_guard lock(mutex_);
std::lock_guard const lock(mutex_);
if (default_)
testcase("");
on_log(s);
}
} // namespace unit_test
} // namespace beast
} // namespace beast::unit_test

24
include/xrpl/beast/unit_test/suite.h
View File

@@ -14,8 +14,7 @@
#include <sstream>
#include <string>
namespace beast {
namespace unit_test {
namespace beast::unit_test {
namespace detail {
@@ -36,7 +35,7 @@ make_reason(String const& reason, char const* file, int line)
} // namespace detail
class thread;
class Thread;
enum abort_t { no_abort_on_fail, abort_on_fail };
@@ -75,7 +74,7 @@ private:
{
}
~log_buf()
~log_buf() override
{
sync();
}
@@ -295,12 +294,12 @@ public:
}
private:
friend class thread;
friend class Thread;
static suite**
p_this_suite()
{
static suite* pts = nullptr;
static suite* pts = nullptr; // NOLINT(misc-const-correctness)
return &pts;
}
@@ -309,7 +308,7 @@ private:
run() = 0;
void
propagate_abort();
propagate_abort() const;
template <class = void>
void
@@ -486,9 +485,13 @@ suite::unexpected(Condition shouldBeFalse, String const& reason)
{
bool const b = static_cast<bool>(shouldBeFalse);
if (!b)
{
pass();
}
else
{
fail(reason);
}
return !b;
}
@@ -522,7 +525,7 @@ suite::fail(String const& reason, char const* file, int line)
}
inline void
suite::propagate_abort()
suite::propagate_abort() const
{
if (abort_ && aborted_)
BOOST_THROW_EXCEPTION(abort_exception());
@@ -538,7 +541,7 @@ suite::run(runner& r)
{
run();
}
catch (abort_exception const&)
catch (abort_exception const&) // NOLINT(bugprone-empty-catch)
{
// ends the suite
}
@@ -569,8 +572,7 @@ suite::run(runner& r)
((cond) ? (pass(), true) : (fail((reason), __FILE__, __LINE__), false))
#endif
} // namespace unit_test
} // namespace beast
} // namespace beast::unit_test
//------------------------------------------------------------------------------

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

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

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

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

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

@@ -10,11 +10,10 @@
#include <thread>
#include <utility>
namespace beast {
namespace unit_test {
namespace beast::unit_test {
/** Replacement for std::thread that handles exceptions in unit tests. */
class thread
class Thread
{
private:
suite* s_ = nullptr;
@@ -24,17 +23,17 @@ public:
using id = std::thread::id;
using native_handle_type = std::thread::native_handle_type;
thread() = default;
thread(thread const&) = delete;
thread&
operator=(thread const&) = delete;
Thread() = default;
Thread(Thread const&) = delete;
Thread&
operator=(Thread const&) = delete;
thread(thread&& other) : s_(other.s_), t_(std::move(other.t_))
Thread(Thread&& other) : s_(other.s_), t_(std::move(other.t_))
{
}
thread&
operator=(thread&& other)
Thread&
operator=(Thread&& other)
{
s_ = other.s_;
t_ = std::move(other.t_);
@@ -42,10 +41,10 @@ public:
}
template <class F, class... Args>
explicit thread(suite& s, F&& f, Args&&... args) : s_(&s)
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)...);
t_ = std::thread(&thread::run, this, std::move(b));
t_ = std::thread(&Thread::run, this, std::move(b));
}
bool
@@ -80,7 +79,7 @@ public:
}
void
swap(thread& other)
swap(Thread& other)
{
std::swap(s_, other.s_);
std::swap(t_, other.t_);
@@ -94,7 +93,7 @@ private:
{
f();
}
catch (suite::abort_exception const&)
catch (suite::abort_exception const&) // NOLINT(bugprone-empty-catch)
{
}
catch (std::exception const& e)
@@ -108,5 +107,4 @@ private:
}
};
} // namespace unit_test
} // namespace beast
} // namespace beast::unit_test

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

@@ -14,13 +14,13 @@ enum Severity {
kAll = 0,
kTrace = kAll,
kDebug,
kInfo,
kWarning,
kError,
kFatal,
kDebug = 1,
kInfo = 2,
kWarning = 3,
kError = 4,
kFatal = 5,
kDisabled,
kDisabled = 6,
kNone = kDisabled
};
} // namespace severities
@@ -56,15 +56,16 @@ public:
class Sink
{
protected:
Sink() = delete;
explicit Sink(Sink const& sink);
Sink(Severity thresh, bool console);
Sink&
operator=(Sink const& lhs) = delete;
public:
virtual ~Sink() = 0;
Sink() = delete;
Sink&
operator=(Sink const& lhs) = delete;
/** Returns `true` if text at the passed severity produces output. */
virtual bool
active(Severity level) const;
@@ -112,12 +113,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(std::is_default_constructible<Sink>::value == false, "");
static_assert(std::is_copy_constructible<Sink>::value == false, "");
static_assert(std::is_move_constructible<Sink>::value == false, "");
static_assert(std::is_copy_assignable<Sink>::value == false, "");
static_assert(std::is_move_assignable<Sink>::value == false, "");
static_assert(std::is_nothrow_destructible<Sink>::value == true, "");
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. */
@@ -168,12 +169,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(std::is_default_constructible<ScopedStream>::value == false, "");
static_assert(std::is_copy_constructible<ScopedStream>::value == true, "");
static_assert(std::is_move_constructible<ScopedStream>::value == true, "");
static_assert(std::is_copy_assignable<ScopedStream>::value == false, "");
static_assert(std::is_move_assignable<ScopedStream>::value == false, "");
static_assert(std::is_nothrow_destructible<ScopedStream>::value == true, "");
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
//--------------------------------------------------------------------------
@@ -250,12 +251,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(std::is_default_constructible<Stream>::value == true, "");
static_assert(std::is_copy_constructible<Stream>::value == true, "");
static_assert(std::is_move_constructible<Stream>::value == true, "");
static_assert(std::is_copy_assignable<Stream>::value == false, "");
static_assert(std::is_move_assignable<Stream>::value == false, "");
static_assert(std::is_nothrow_destructible<Stream>::value == true, "");
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
//--------------------------------------------------------------------------
@@ -333,12 +334,12 @@ public:
};
#ifndef __INTELLISENSE__
static_assert(std::is_default_constructible<Journal>::value == false, "");
static_assert(std::is_copy_constructible<Journal>::value == true, "");
static_assert(std::is_move_constructible<Journal>::value == true, "");
static_assert(std::is_copy_assignable<Journal>::value == true, "");
static_assert(std::is_move_assignable<Journal>::value == true, "");
static_assert(std::is_nothrow_destructible<Journal>::value == true, "");
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
//------------------------------------------------------------------------------
@@ -374,10 +375,6 @@ class logstream_buf : public std::basic_stringbuf<CharT, Traits>
{
beast::Journal::Stream strm_;
template <class T>
void
write(T const*) = delete;
void
write(char const* s)
{
@@ -397,7 +394,7 @@ public:
{
}
~logstream_buf()
~logstream_buf() override
{
sync();
}
@@ -409,6 +406,10 @@ public:
this->str("");
return 0;
}
template <class T>
void
write(T const*) = delete;
};
} // namespace detail
@@ -416,11 +417,11 @@ public:
template <class CharT, class Traits = std::char_traits<CharT>>
class basic_logstream : public std::basic_ostream<CharT, Traits>
{
typedef CharT char_type;
typedef Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
using char_type = CharT;
using traits_type = Traits;
using int_type = typename traits_type::int_type;
using pos_type = typename traits_type::pos_type;
using off_type = typename traits_type::off_type;
detail::logstream_buf<CharT, Traits> buf_;

6
include/xrpl/beast/utility/PropertyStream.h
View File

@@ -174,7 +174,7 @@ private:
std::ostringstream mutable m_ostream;
public:
Proxy(Map const& map, std::string const& key);
Proxy(Map const& map, std::string key);
Proxy(Proxy const& other);
~Proxy();
@@ -311,11 +311,11 @@ private:
std::string const m_name;
std::recursive_mutex lock_;
Item item_;
Source* parent_;
Source* parent_{nullptr};
List<Item> children_;
public:
explicit Source(std::string const& name);
explicit Source(std::string name);
virtual ~Source();
Source(Source const&) = delete;

6
include/xrpl/beast/utility/WrappedSink.h
View File

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

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

@@ -27,8 +27,8 @@ struct Zero
};
namespace {
static constexpr Zero zero{};
}
constexpr Zero zero{};
} // namespace
/** Default implementation of signum calls the method on the class. */
template <typename T>
@@ -38,8 +38,7 @@ signum(T const& t)
return t.signum();
}
namespace detail {
namespace zero_helper {
namespace detail::zero_helper {
// For argument dependent lookup to function properly, calls to signum must
// be made from a namespace that does not include overloads of the function..
@@ -50,8 +49,7 @@ call_signum(T const& t)
return signum(t);
}
} // namespace zero_helper
} // namespace detail
} // namespace detail::zero_helper
// Handle operators where T is on the left side using signum.

2
include/xrpl/beast/utility/instrumentation.h
View File

@@ -15,7 +15,7 @@
#define ALWAYS_OR_UNREACHABLE(cond, message) assert((message) && (cond))
#define SOMETIMES(cond, message, ...)
#define REACHABLE(message, ...)
#define UNREACHABLE(message, ...) assert((message) && false)
#define UNREACHABLE(message, ...) assert((message) && false) // NOLINT(misc-static-assert)
#endif
#define XRPL_ASSERT ALWAYS_OR_UNREACHABLE

6
include/xrpl/beast/utility/maybe_const.h
View File

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

18
include/xrpl/beast/xor_shift_engine.h
View File

@@ -37,21 +37,21 @@ public:
}
private:
result_type s_[2];
result_type s_[2]{};
static result_type
murmurhash3(result_type x);
};
template <class _>
xor_shift_engine<_>::xor_shift_engine(result_type val)
template <class Unused>
xor_shift_engine<Unused>::xor_shift_engine(result_type val)
{
seed(val);
}
template <class _>
template <class Unused>
void
xor_shift_engine<_>::seed(result_type seed)
xor_shift_engine<Unused>::seed(result_type seed)
{
if (seed == 0)
throw std::domain_error("invalid seed");
@@ -59,9 +59,9 @@ xor_shift_engine<_>::seed(result_type seed)
s_[1] = murmurhash3(s_[0]);
}
template <class _>
template <class Unused>
auto
xor_shift_engine<_>::operator()() -> result_type
xor_shift_engine<Unused>::operator()() -> result_type
{
result_type s1 = s_[0];
result_type const s0 = s_[1];
@@ -70,9 +70,9 @@ xor_shift_engine<_>::operator()() -> result_type
return (s_[1] = (s1 ^ s0 ^ (s1 >> 17) ^ (s0 >> 26))) + s0;
}
template <class _>
template <class Unused>
auto
xor_shift_engine<_>::murmurhash3(result_type x) -> result_type
xor_shift_engine<Unused>::murmurhash3(result_type x) -> result_type
{
x ^= x >> 33;
x *= 0xff51afd7ed558ccdULL;

7
include/xrpl/conditions/Condition.h
View File

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

6
include/xrpl/conditions/Fulfillment.h
View File

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

6
include/xrpl/conditions/detail/PreimageSha256.h
View File

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

6
include/xrpl/conditions/detail/error.h
View File

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

11
include/xrpl/conditions/detail/utils.h
View File

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

22
include/xrpl/core/ClosureCounter.h
View File

@@ -34,9 +34,9 @@ template <typename Ret_t, typename... Args_t>
class ClosureCounter
{
private:
std::mutex mutable mutex_{};
std::condition_variable allClosuresDoneCond_{}; // guard with mutex_
bool waitForClosures_{false}; // guard with mutex_
std::mutex mutable mutex_;
std::condition_variable allClosuresDoneCond_; // guard with mutex_
bool waitForClosures_{false}; // guard with mutex_
std::atomic<int> closureCount_{0};
// Increment the count.
@@ -56,7 +56,7 @@ private:
// a lock. This removes a small timing window that occurs if the
// waiting thread is handling a spurious wakeup when closureCount_
// drops to zero.
std::lock_guard lock{mutex_};
std::lock_guard const lock{mutex_};
// Update closureCount_. Notify if stopping and closureCount_ == 0.
if ((--closureCount_ == 0) && waitForClosures_)
@@ -72,10 +72,10 @@ private:
{
private:
ClosureCounter& counter_;
std::remove_reference_t<Closure> closure_;
std::remove_reference_t<Closure> closure_{};
static_assert(
std::is_same<decltype(closure_(std::declval<Args_t>()...)), Ret_t>::value,
std::is_same_v<decltype(closure_(std::declval<Args_t>()...)), Ret_t>,
"Closure arguments don't match ClosureCounter Ret_t or Args_t");
public:
@@ -86,13 +86,15 @@ private:
++counter_;
}
Substitute(Substitute&& rhs) noexcept(std::is_nothrow_move_constructible<Closure>::value)
Substitute(Substitute&& rhs) noexcept(std::is_nothrow_move_constructible_v<Closure>)
: counter_(rhs.counter_), closure_(std::move(rhs.closure_))
{
++counter_;
}
Substitute(ClosureCounter& counter, Closure&& closure)
Substitute(
ClosureCounter& counter,
Closure&& closure) // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
: counter_(counter), closure_(std::forward<Closure>(closure))
{
++counter_;
@@ -168,7 +170,7 @@ public:
{
std::optional<Substitute<Closure>> ret;
std::lock_guard lock{mutex_};
std::lock_guard const lock{mutex_};
if (!waitForClosures_)
ret.emplace(*this, std::forward<Closure>(closure));
@@ -191,7 +193,7 @@ public:
bool
joined() const
{
std::lock_guard lock{mutex_};
std::lock_guard const lock{mutex_};
return waitForClosures_;
}
};

17
include/xrpl/core/Coro.ipp
View File

@@ -19,7 +19,6 @@ JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string cons
: jq_(jq)
, type_(type)
, name_(name)
, running_(false)
, coro_(
boost::context::protected_fixedsize_stack(coroStackSize),
[this, fn = std::forward<F>(f)](
@@ -80,14 +79,24 @@ JobQueue::Coro::resume()
running_ = true;
}
{
std::lock_guard lock(jq_.m_mutex);
std::lock_guard lk(jq_.m_mutex);
--jq_.nSuspend_;
}
auto saved = detail::getLocalValues().release();
detail::getLocalValues().reset(&lvs_);
std::lock_guard lock(mutex_);
XRPL_ASSERT(static_cast<bool>(coro_), "xrpl::JobQueue::Coro::resume : is runnable");
coro_();
// A late resume() can arrive after the coroutine has already completed.
// This is an expected (if rare) outcome of the race condition documented
// in JobQueue.h:354-377 where post() schedules a resume job before the
// coroutine yields — the mutex serializes access, but by the time this
// resume() acquires the lock the coroutine may have already run to
// completion. Calling operator() on a completed boost::coroutine2 is
// undefined behavior, so we must check and skip invoking the coroutine
// body if it has already completed.
if (coro_)
{
coro_();
}
detail::getLocalValues().release();
detail::getLocalValues().reset(saved);
std::lock_guard lk(mutex_run_);

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

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

Some files were not shown because too many files have changed in this diff Show More