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 remote-tracking branch 'XRPLF/develop' into ximinez/directory

Browse Source 
* XRPLF/develop:
  fix: Fix regressions in `server_definitions` (7008)
  chore: Do not duplicate sanitizer flags (7058)
  ci: Run pre-commit on diff in clang-tidy workflow (7078)
  ci: Use XRPLF/create-issue (7076)
  ci: Rewrite clang-tidy workflow(s) in a reusable manner (7062)
  chore: Ignore identifier-naming update in git blame (7066)
  refactor: Enable clang-tidy `readability-identifier-naming` check (6571)
This commit is contained in:
Ed Hennis
2026-05-05 16:44:42 -04:00
parent ac7db2e621 5e1c35f7f7
commit d21137c4c1
1508 changed files with 59256 additions and 59456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -27,7 +27,7 @@ private:
std::unordered_map<std::string, std::string> lookup_;
std::vector<std::string> lines_;
std::vector<std::string> values_;
bool had_trailing_comments_ = false;
bool hadTrailingComments_ = false;
using const_iterator = decltype(lookup_)::const_iterator;
@@ -133,7 +133,7 @@ public:
/// Returns a value if present, else another value.
template <class T>
[[nodiscard]] T
value_or(std::string const& name, T const& other) const
valueOr(std::string const& name, T const& other) const
{
auto const v = get<T>(name);
return v.has_value() ? *v : other;
@@ -142,9 +142,9 @@ public:
// indicates if trailing comments were seen
// during the appending of any lines/values
[[nodiscard]] bool
had_trailing_comments() const
hadTrailingComments() const
{
return had_trailing_comments_;
return hadTrailingComments_;
}
friend std::ostream&
@@ -273,9 +273,9 @@ public:
// indicates if trailing comments were seen
// in any loaded Sections
[[nodiscard]] bool
had_trailing_comments() const
hadTrailingComments() const
{
return std::ranges::any_of(map_, [](auto s) { return s.second.had_trailing_comments(); });
return std::ranges::any_of(map_, [](auto s) { return s.second.hadTrailingComments(); });
}
protected:
@@ -294,17 +294,17 @@ template <class T>
bool
set(T& target, std::string const& name, Section const& section)
{
bool found_and_valid = false;
bool foundAndValid = false;
try
{
auto const val = section.get<T>(name);
if ((found_and_valid = val.has_value()))
if ((foundAndValid = val.has_value()))
target = *val;
}
catch (boost::bad_lexical_cast const&) // NOLINT(bugprone-empty-catch)
{
}
return found_and_valid;
return foundAndValid;
}
/** Set a value from a configuration Section
@@ -316,10 +316,10 @@ template <class T>
bool
set(T& target, T const& defaultValue, std::string const& name, Section const& section)
{
bool const found_and_valid = set<T>(target, name, section);
if (!found_and_valid)
bool const foundAndValid = set<T>(target, name, section);
if (!foundAndValid)
target = defaultValue;
return found_and_valid;
return foundAndValid;
}
/** Retrieve a key/value pair from a section.
@@ -333,7 +333,7 @@ get(Section const& section, std::string const& name, T const& defaultValue = T{}
{
try
{
return section.value_or<T>(name, defaultValue);
return section.valueOr<T>(name, defaultValue);
}
catch (boost::bad_lexical_cast const&) // NOLINT(bugprone-empty-catch)
{
@@ -358,17 +358,17 @@ get(Section const& section, std::string const& name, char const* defaultValue)
template <class T>
bool
get_if_exists(Section const& section, std::string const& name, T& v)
getIfExists(Section const& section, std::string const& name, T& v)
{
return set<T>(v, name, section);
}
template <>
inline bool
get_if_exists<bool>(Section const& section, std::string const& name, bool& v)
getIfExists<bool>(Section const& section, std::string const& name, bool& v)
{
int intVal = 0;
auto stat = get_if_exists(section, name, intVal);
auto stat = getIfExists(section, name, intVal);
if (stat)
v = bool(intVal);
return stat;

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

@@ -38,11 +38,11 @@ public:
do
{
head = instance.m_head.load();
head = instance.head_.load();
next_ = head;
} while (instance.m_head.exchange(this) != head);
} while (instance.head_.exchange(this) != head);
++instance.m_count;
++instance.count_;
}
~Counter() noexcept = default;
@@ -88,8 +88,8 @@ private:
~CountedObjects() noexcept = default;
private:
std::atomic<int> m_count;
std::atomic<Counter*> m_head;
std::atomic<int> count_;
std::atomic<Counter*> head_;
};
//------------------------------------------------------------------------------
@@ -108,8 +108,8 @@ private:
static auto&
getCounter() noexcept
{
static CountedObjects::Counter c{beast::type_name<Object>()};
return c;
static CountedObjects::Counter kC{beast::typeName<Object>()};
return kC;
}
CountedObject() noexcept

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

@@ -20,7 +20,7 @@ public:
/**
@param now Start time of DecayingSample.
*/
explicit DecayingSample(time_point now) : m_value(value_type()), m_when(now)
explicit DecayingSample(time_point now) : value_(value_type()), when_(now)
{
}
@@ -31,8 +31,8 @@ public:
add(value_type value, time_point now)
{
decay(now);
m_value += value;
return m_value / Window;
value_ += value;
return value_ / Window;
}
/** Retrieve the current value in normalized units.
@@ -42,7 +42,7 @@ public:
value(time_point now)
{
decay(now);
return m_value / Window;
return value_ / Window;
}
private:
@@ -50,38 +50,38 @@ private:
void
decay(time_point now)
{
if (now == m_when)
if (now == when_)
return;
if (m_value != value_type())
if (value_ != value_type())
{
std::size_t elapsed =
std::chrono::duration_cast<std::chrono::seconds>(now - m_when).count();
std::chrono::duration_cast<std::chrono::seconds>(now - when_).count();
// A span larger than four times the window decays the
// value to an insignificant amount so just reset it.
//
if (elapsed > 4 * Window)
{
m_value = value_type();
value_ = value_type();
}
else
{
for (; elapsed > 0; --elapsed)
{
m_value -= (m_value + Window - 1) / Window;
value_ -= (value_ + Window - 1) / Window;
}
}
}
m_when = now;
when_ = now;
}
// Current value in exponential units
value_type m_value;
value_type value_;
// Last time the aging function was applied
time_point m_when;
time_point when_;
};
//------------------------------------------------------------------------------

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

@@ -16,9 +16,9 @@ namespace xrpl {
*/
// Exception thrown by an invalid access to Expected.
struct bad_expected_access : public std::runtime_error
struct BadExpectedAccess : public std::runtime_error
{
bad_expected_access() : runtime_error("bad expected access")
BadExpectedAccess() : runtime_error("bad expected access")
{
}
};
@@ -26,30 +26,33 @@ struct bad_expected_access : public std::runtime_error
namespace detail {
// Custom policy for Expected. Always throw on an invalid access.
struct throw_policy : public boost::outcome_v2::policy::base
struct ThrowPolicy : public boost::outcome_v2::policy::base
{
template <class Impl>
static constexpr void
// NOLINTNEXTLINE(readability-identifier-naming)
wide_value_check(Impl&& self)
{
if (!base::_has_value(std::forward<Impl>(self)))
Throw<bad_expected_access>();
Throw<BadExpectedAccess>();
}
template <class Impl>
static constexpr void
// NOLINTNEXTLINE(readability-identifier-naming)
wide_error_check(Impl&& self)
{
if (!base::_has_error(std::forward<Impl>(self)))
Throw<bad_expected_access>();
Throw<BadExpectedAccess>();
}
template <class Impl>
static constexpr void
// NOLINTNEXTLINE(readability-identifier-naming)
wide_exception_check(Impl&& self)
{
if (!base::_has_exception(std::forward<Impl>(self)))
Throw<bad_expected_access>();
Throw<BadExpectedAccess>();
}
};
@@ -107,9 +110,9 @@ Unexpected(E (&)[N]) -> Unexpected<E const*>;
// Definition of Expected. All of the machinery comes from boost::result.
template <class T, class E>
class [[nodiscard]] Expected : private boost::outcome_v2::result<T, E, detail::throw_policy>
class [[nodiscard]] Expected : private boost::outcome_v2::result<T, E, detail::ThrowPolicy>
{
using Base = boost::outcome_v2::result<T, E, detail::throw_policy>;
using Base = boost::outcome_v2::result<T, E, detail::ThrowPolicy>;
public:
template <typename U>
@@ -126,6 +129,7 @@ public:
}
[[nodiscard]] constexpr bool
// NOLINTNEXTLINE(readability-identifier-naming)
has_value() const
{
return Base::has_value();
@@ -193,9 +197,9 @@ public:
// (without a value) or the reason for the failure.
template <class E>
class [[nodiscard]]
Expected<void, E> : private boost::outcome_v2::result<void, E, detail::throw_policy>
Expected<void, E> : private boost::outcome_v2::result<void, E, detail::ThrowPolicy>
{
using Base = boost::outcome_v2::result<void, E, detail::throw_policy>;
using Base = boost::outcome_v2::result<void, E, detail::ThrowPolicy>;
public:
// The default constructor makes a successful Expected<void, E>.

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

@@ -164,11 +164,11 @@ public:
/** Return the strong count */
[[nodiscard]] std::size_t
use_count() const;
useCount() const;
template <class TT, class... Args>
friend SharedIntrusive<TT>
make_SharedIntrusive(Args&&... args);
makeSharedIntrusive(Args&&... args);
template <class TT>
friend class SharedIntrusive;
@@ -364,7 +364,7 @@ public:
* return 0
*/
[[nodiscard]] std::size_t
use_count() const;
useCount() const;
/** Return true if there is a non-zero strong count. */
[[nodiscard]] bool
@@ -406,8 +406,8 @@ private:
// pointer. The low bit must be masked to zero when converting back to a
// pointer. If the low bit is '1', this is a weak pointer.
std::uintptr_t tp_{0};
static constexpr std::uintptr_t tagMask = 1;
static constexpr std::uintptr_t ptrMask = ~tagMask;
static constexpr std::uintptr_t kTAG_MASK = 1;
static constexpr std::uintptr_t kPTR_MASK = ~kTAG_MASK;
private:
/** Return the raw pointer held by this object.
@@ -415,7 +415,7 @@ private:
[[nodiscard]] T*
unsafeGetRawPtr() const;
enum class RefStrength { strong, weak };
enum class RefStrength { Strong, Weak };
/** Set the raw pointer and tag bit directly.
*/
void
@@ -442,7 +442,7 @@ private:
*/
template <class TT, class... Args>
SharedIntrusive<TT>
make_SharedIntrusive(Args&&... args)
makeSharedIntrusive(Args&&... args)
{
auto p = new TT(std::forward<Args>(args)...);
@@ -469,21 +469,21 @@ using SharedWeakUnionPtr = SharedWeakUnion<T>;
template <class T, class... A>
SharedPtr<T>
make_shared(A&&... args)
makeShared(A&&... args)
{
return make_SharedIntrusive<T>(std::forward<A>(args)...);
return makeSharedIntrusive<T>(std::forward<A>(args)...);
}
template <class T, class TT>
SharedPtr<T>
static_pointer_cast(TT const& v)
staticPointerCast(TT const& v)
{
return SharedPtr<T>(StaticCastTagSharedIntrusive{}, v);
}
template <class T, class TT>
SharedPtr<T>
dynamic_pointer_cast(TT const& v)
dynamicPointerCast(TT const& v)
{
return SharedPtr<T>(DynamicCastTagSharedIntrusive{}, v);
}

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

@@ -43,14 +43,16 @@ SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT> const& rhs)
}
template <class T>
SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs) : ptr_{rhs.unsafeExchange(nullptr)}
SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs)
: ptr_{std::move(rhs).unsafeExchange(nullptr)}
{
}
template <class T>
template <class TT>
requires std::convertible_to<TT*, T*>
SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs) : ptr_{rhs.unsafeExchange(nullptr)}
SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs)
: ptr_{std::move(rhs).unsafeExchange(nullptr)}
{
}
template <class T>
@@ -93,7 +95,7 @@ SharedIntrusive<T>::operator=(SharedIntrusive&& rhs)
if (this == &rhs)
return *this;
unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
unsafeReleaseAndStore(std::move(rhs).unsafeExchange(nullptr));
return *this;
}
@@ -105,7 +107,7 @@ SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
{
static_assert(!std::is_same_v<T, TT>, "This overload should not be instantiated for T == TT");
unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
unsafeReleaseAndStore(std::move(rhs).unsafeExchange(nullptr));
return *this;
}
@@ -157,7 +159,7 @@ SharedIntrusive<T>::SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusiv
template <class T>
template <class TT>
SharedIntrusive<T>::SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs)
: ptr_{static_cast<T*>(rhs.unsafeExchange(nullptr))}
: ptr_{static_cast<T*>(std::move(rhs).unsafeExchange(nullptr))}
{
}
@@ -184,8 +186,10 @@ SharedIntrusive<T>::SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusi
{
ptr_ = dynamic_cast<T*>(toSet);
if (!ptr_)
{
// need to set the pointer back or will leak
rhs.unsafeExchange(toSet);
std::move(rhs).unsafeExchange(toSet);
}
}
}
@@ -226,10 +230,10 @@ SharedIntrusive<T>::get() const
template <class T>
std::size_t
SharedIntrusive<T>::use_count() const
SharedIntrusive<T>::useCount() const
{
if (auto p = unsafeGetRawPtr())
return p->use_count();
return p->useCount();
return 0;
}
@@ -266,12 +270,12 @@ SharedIntrusive<T>::unsafeReleaseAndStore(T* next)
auto action = prev->releaseStrongRef();
switch (action)
{
case noop:
case NoOp:
break;
case destroy:
case Destroy:
delete prev;
break;
case partialDestroy:
case PartialDestroy:
prev->partialDestructor();
partialDestructorFinished(&prev);
// prev is null and may no longer be used
@@ -345,7 +349,7 @@ template <class T>
bool
WeakIntrusive<T>::expired() const
{
return (!ptr_ || ptr_->expired());
return ((ptr_ == nullptr) || ptr_->expired());
}
template <class T>
@@ -360,16 +364,16 @@ template <class T>
void
WeakIntrusive<T>::unsafeReleaseNoStore()
{
if (!ptr_)
if (ptr_ == nullptr)
return;
using enum ReleaseWeakRefAction;
auto action = ptr_->releaseWeakRef();
switch (action)
{
case noop:
case NoOp:
break;
case destroy:
case Destroy:
delete ptr_;
break;
}
@@ -385,9 +389,13 @@ SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion const& rhs) : tp_{rhs.tp_}
return;
if (rhs.isStrong())
{
p->addStrongRef();
}
else
{
p->addWeakRef();
}
}
template <class T>
@@ -398,7 +406,7 @@ SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT> const& rhs)
auto p = rhs.unsafeGetRawPtr();
if (p)
p->addStrongRef();
unsafeSetRawPtr(p, RefStrength::strong);
unsafeSetRawPtr(p, RefStrength::Strong);
}
template <class T>
@@ -414,8 +422,8 @@ SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT>&& rhs)
{
auto p = rhs.unsafeGetRawPtr();
if (p)
unsafeSetRawPtr(p, RefStrength::strong);
rhs.unsafeSetRawPtr(nullptr);
unsafeSetRawPtr(p, RefStrength::Strong);
std::move(rhs).unsafeSetRawPtr(nullptr);
}
template <class T>
@@ -431,12 +439,12 @@ SharedWeakUnion<T>::operator=(SharedWeakUnion const& rhs)
if (rhs.isStrong())
{
p->addStrongRef();
unsafeSetRawPtr(p, RefStrength::strong);
unsafeSetRawPtr(p, RefStrength::Strong);
}
else
{
p->addWeakRef();
unsafeSetRawPtr(p, RefStrength::weak);
unsafeSetRawPtr(p, RefStrength::Weak);
}
}
else
@@ -456,7 +464,7 @@ SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
auto p = rhs.unsafeGetRawPtr();
if (p)
p->addStrongRef();
unsafeSetRawPtr(p, RefStrength::strong);
unsafeSetRawPtr(p, RefStrength::Strong);
return *this;
}
@@ -467,8 +475,8 @@ SharedWeakUnion<T>&
SharedWeakUnion<T>::operator=(SharedIntrusive<TT>&& rhs)
{
unsafeReleaseNoStore();
unsafeSetRawPtr(rhs.unsafeGetRawPtr(), RefStrength::strong);
rhs.unsafeSetRawPtr(nullptr);
unsafeSetRawPtr(rhs.unsafeGetRawPtr(), RefStrength::Strong);
std::move(rhs).unsafeSetRawPtr(nullptr);
return *this;
}
@@ -517,10 +525,10 @@ SharedWeakUnion<T>::get() const
template <class T>
std::size_t
SharedWeakUnion<T>::use_count() const
SharedWeakUnion<T>::useCount() const
{
if (auto p = get())
return p->use_count();
return p->useCount();
return 0;
}
@@ -559,14 +567,14 @@ template <class T>
bool
SharedWeakUnion<T>::isStrong() const
{
return !(tp_ & tagMask);
return (tp_ & kTAG_MASK) == 0u;
}
template <class T>
bool
SharedWeakUnion<T>::isWeak() const
{
return tp_ & tagMask;
return (tp_ & kTAG_MASK) != 0u;
}
template <class T>
@@ -581,10 +589,10 @@ SharedWeakUnion<T>::convertToStrong()
{
[[maybe_unused]] auto action = p->releaseWeakRef();
XRPL_ASSERT(
(action == ReleaseWeakRefAction::noop),
(action == ReleaseWeakRefAction::NoOp),
"xrpl::SharedWeakUnion::convertToStrong : "
"action is noop");
unsafeSetRawPtr(p, RefStrength::strong);
unsafeSetRawPtr(p, RefStrength::Strong);
return true;
}
return false;
@@ -605,9 +613,9 @@ SharedWeakUnion<T>::convertToWeak()
auto action = p->addWeakReleaseStrongRef();
switch (action)
{
case noop:
case NoOp:
break;
case destroy:
case Destroy:
// We just added a weak ref. How could we destroy?
// LCOV_EXCL_START
UNREACHABLE(
@@ -617,7 +625,7 @@ SharedWeakUnion<T>::convertToWeak()
unsafeSetRawPtr(nullptr);
return true; // Should never happen
// LCOV_EXCL_STOP
case partialDestroy:
case PartialDestroy:
// This is a weird case. We just converted the last strong
// pointer to a weak pointer.
p->partialDestructor();
@@ -625,7 +633,7 @@ SharedWeakUnion<T>::convertToWeak()
// p is null and may no longer be used
break;
}
unsafeSetRawPtr(p, RefStrength::weak);
unsafeSetRawPtr(p, RefStrength::Weak);
return true;
}
@@ -633,7 +641,7 @@ template <class T>
T*
SharedWeakUnion<T>::unsafeGetRawPtr() const
{
return reinterpret_cast<T*>(tp_ & ptrMask);
return reinterpret_cast<T*>(tp_ & kPTR_MASK);
}
template <class T>
@@ -641,8 +649,8 @@ void
SharedWeakUnion<T>::unsafeSetRawPtr(T* p, RefStrength rs)
{
tp_ = reinterpret_cast<std::uintptr_t>(p);
if (tp_ && rs == RefStrength::weak)
tp_ |= tagMask;
if (tp_ && rs == RefStrength::Weak)
tp_ |= kTAG_MASK;
}
template <class T>
@@ -666,12 +674,12 @@ SharedWeakUnion<T>::unsafeReleaseNoStore()
auto strongAction = p->releaseStrongRef();
switch (strongAction)
{
case noop:
case NoOp:
break;
case destroy:
case Destroy:
delete p;
break;
case partialDestroy:
case PartialDestroy:
p->partialDestructor();
partialDestructorFinished(&p);
// p is null and may no longer be used
@@ -684,9 +692,9 @@ SharedWeakUnion<T>::unsafeReleaseNoStore()
auto weakAction = p->releaseWeakRef();
switch (weakAction)
{
case noop:
case NoOp:
break;
case destroy:
case Destroy:
delete p;
break;
}

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

@@ -18,7 +18,7 @@ namespace xrpl {
destroy: Run the destructor. This action will occur when either the strong
count or weak count is decremented and the other count is also zero.
*/
enum class ReleaseStrongRefAction { noop, partialDestroy, destroy };
enum class ReleaseStrongRefAction { NoOp, PartialDestroy, Destroy };
/** Action to perform when releasing a weak pointer.
@@ -28,7 +28,7 @@ enum class ReleaseStrongRefAction { noop, partialDestroy, destroy };
destroy: Run the destructor. This action will occur when either the strong
count or weak count is decremented and the other count is also zero.
*/
enum class ReleaseWeakRefAction { noop, destroy };
enum class ReleaseWeakRefAction { NoOp, Destroy };
/** Implement the strong count, weak count, and bit flags for an intrusive
pointer.
@@ -71,7 +71,7 @@ struct IntrusiveRefCounts
expired() const noexcept;
std::size_t
use_count() const noexcept;
useCount() const noexcept;
// This function MUST be called after a partial destructor finishes running.
// Calling this function may cause other threads to delete the object
@@ -98,11 +98,11 @@ private:
// enough for strong pointers and 14 bit counts are enough for weak
// pointers. Use type aliases to make it easy to switch types.
using CountType = std::uint16_t;
static constexpr size_t StrongCountNumBits = sizeof(CountType) * 8;
static constexpr size_t WeakCountNumBits = StrongCountNumBits - 2;
static constexpr size_t kSTRONG_COUNT_NUM_BITS = sizeof(CountType) * 8;
static constexpr size_t kWEAK_COUNT_NUM_BITS = kSTRONG_COUNT_NUM_BITS - 2;
using FieldType = std::uint32_t;
static constexpr size_t FieldTypeBits = sizeof(FieldType) * 8;
static constexpr FieldType one = 1;
static constexpr size_t kFIELD_TYPE_BITS = sizeof(FieldType) * 8;
static constexpr FieldType kONE = 1;
/** `refCounts` consists of four fields that are treated atomically:
@@ -137,21 +137,21 @@ private:
*/
mutable std::atomic<FieldType> refCounts{strongDelta};
mutable std::atomic<FieldType> refCounts_{kSTRONG_DELTA};
/** Amount to change the strong count when adding or releasing a reference
Note: The strong count is stored in the low `StrongCountNumBits` bits
of refCounts
*/
static constexpr FieldType strongDelta = 1;
static constexpr FieldType kSTRONG_DELTA = 1;
/** Amount to change the weak count when adding or releasing a reference
Note: The weak count is stored in the high `WeakCountNumBits` bits of
refCounts
*/
static constexpr FieldType weakDelta = (one << StrongCountNumBits);
static constexpr FieldType kWEAK_DELTA = (kONE << kSTRONG_COUNT_NUM_BITS);
/** Flag that is set when the partialDestroy function has started running
(or is about to start running).
@@ -159,33 +159,34 @@ private:
See description of the `refCounts` field for a fuller description of
this field.
*/
static constexpr FieldType partialDestroyStartedMask = (one << (FieldTypeBits - 1));
static constexpr FieldType kPARTIAL_DESTROY_STARTED_MASK = (kONE << (kFIELD_TYPE_BITS - 1));
/** Flag that is set when the partialDestroy function has finished running
See description of the `refCounts` field for a fuller description of
this field.
*/
static constexpr FieldType partialDestroyFinishedMask = (one << (FieldTypeBits - 2));
static constexpr FieldType kPARTIAL_DESTROY_FINISHED_MASK = (kONE << (kFIELD_TYPE_BITS - 2));
/** Mask that will zero out all the `count` bits and leave the tag bits
unchanged.
*/
static constexpr FieldType tagMask = partialDestroyStartedMask | partialDestroyFinishedMask;
static constexpr FieldType kTAG_MASK =
kPARTIAL_DESTROY_STARTED_MASK | kPARTIAL_DESTROY_FINISHED_MASK;
/** Mask that will zero out the `tag` bits and leave the count bits
unchanged.
*/
static constexpr FieldType valueMask = ~tagMask;
static constexpr FieldType kVALUE_MASK = ~kTAG_MASK;
/** Mask that will zero out everything except the strong count.
*/
static constexpr FieldType strongMask = ((one << StrongCountNumBits) - 1) & valueMask;
static constexpr FieldType kSTRONG_MASK = ((kONE << kSTRONG_COUNT_NUM_BITS) - 1) & kVALUE_MASK;
/** Mask that will zero out everything except the weak count.
*/
static constexpr FieldType weakMask =
(((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
static constexpr FieldType kWEAK_MASK =
(((kONE << kWEAK_COUNT_NUM_BITS) - 1) << kSTRONG_COUNT_NUM_BITS) & kVALUE_MASK;
/** Unpack the count and tag fields from the packed atomic integer form. */
struct RefCountPair
@@ -210,29 +211,29 @@ private:
[[nodiscard]] FieldType
combinedValue() const noexcept;
static constexpr CountType maxStrongValue =
static_cast<CountType>((one << StrongCountNumBits) - 1);
static constexpr CountType maxWeakValue =
static_cast<CountType>((one << WeakCountNumBits) - 1);
static constexpr CountType kMAX_STRONG_VALUE =
static_cast<CountType>((kONE << kSTRONG_COUNT_NUM_BITS) - 1);
static constexpr CountType kMAX_WEAK_VALUE =
static_cast<CountType>((kONE << kWEAK_COUNT_NUM_BITS) - 1);
/** Put an extra margin to detect when running up against limits.
This is only used in debug code, and is useful if we reduce the
number of bits in the strong and weak counts (to 16 and 14 bits).
*/
static constexpr CountType checkStrongMaxValue = maxStrongValue - 32;
static constexpr CountType checkWeakMaxValue = maxWeakValue - 32;
static constexpr CountType kCHECK_STRONG_MAX_VALUE = kMAX_STRONG_VALUE - 32;
static constexpr CountType kCHECK_WEAK_MAX_VALUE = kMAX_WEAK_VALUE - 32;
};
};
inline void
IntrusiveRefCounts::addStrongRef() const noexcept
{
refCounts.fetch_add(strongDelta, std::memory_order_acq_rel);
refCounts_.fetch_add(kSTRONG_DELTA, std::memory_order_acq_rel);
}
inline void
IntrusiveRefCounts::addWeakRef() const noexcept
{
refCounts.fetch_add(weakDelta, std::memory_order_acq_rel);
refCounts_.fetch_add(kWEAK_DELTA, std::memory_order_acq_rel);
}
inline ReleaseStrongRefAction
@@ -246,36 +247,36 @@ IntrusiveRefCounts::releaseStrongRef() const
// conditional `fetch_or`. This loop will almost always run once.
using enum ReleaseStrongRefAction;
auto prevIntVal = refCounts.load(std::memory_order_acquire);
auto prevIntVal = refCounts_.load(std::memory_order_acquire);
while (true)
{
RefCountPair const prevVal{prevIntVal};
XRPL_ASSERT(
(prevVal.strong >= strongDelta),
(prevVal.strong >= kSTRONG_DELTA),
"xrpl::IntrusiveRefCounts::releaseStrongRef : previous ref "
"higher than new");
auto nextIntVal = prevIntVal - strongDelta;
ReleaseStrongRefAction action = noop;
auto nextIntVal = prevIntVal - kSTRONG_DELTA;
ReleaseStrongRefAction action = NoOp;
if (prevVal.strong == 1)
{
if (prevVal.weak == 0)
{
action = destroy;
action = Destroy;
}
else
{
nextIntVal |= partialDestroyStartedMask;
action = partialDestroy;
nextIntVal |= kPARTIAL_DESTROY_STARTED_MASK;
action = PartialDestroy;
}
}
if (refCounts.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
if (refCounts_.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
{
// Can't be in partial destroy because only decrementing the strong
// count to zero can start a partial destroy, and that can't happen
// twice.
XRPL_ASSERT(
(action == noop) || !(prevIntVal & partialDestroyStartedMask),
(action == NoOp) || !(prevIntVal & kPARTIAL_DESTROY_STARTED_MASK),
"xrpl::IntrusiveRefCounts::releaseStrongRef : not in partial "
"destroy");
return action;
@@ -288,9 +289,9 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
{
using enum ReleaseStrongRefAction;
static_assert(weakDelta > strongDelta);
auto constexpr delta = weakDelta - strongDelta;
auto prevIntVal = refCounts.load(std::memory_order_acquire);
static_assert(kWEAK_DELTA > kSTRONG_DELTA);
auto constexpr kDELTA = kWEAK_DELTA - kSTRONG_DELTA;
auto prevIntVal = refCounts_.load(std::memory_order_acquire);
// This loop will almost always run once. The loop is needed to atomically
// change the counts and flags (the count could be atomically changed, but
// the flags depend on the current value of the counts).
@@ -311,24 +312,24 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
"xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not in "
"partial destroy");
auto nextIntVal = prevIntVal + delta;
ReleaseStrongRefAction action = noop;
auto nextIntVal = prevIntVal + kDELTA;
ReleaseStrongRefAction action = NoOp;
if (prevVal.strong == 1)
{
if (prevVal.weak == 0)
{
action = noop;
action = NoOp;
}
else
{
nextIntVal |= partialDestroyStartedMask;
action = partialDestroy;
nextIntVal |= kPARTIAL_DESTROY_STARTED_MASK;
action = PartialDestroy;
}
}
if (refCounts.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
if (refCounts_.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
{
XRPL_ASSERT(
(!(prevIntVal & partialDestroyStartedMask)),
(!(prevIntVal & kPARTIAL_DESTROY_STARTED_MASK)),
"xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not "
"started partial destroy");
return action;
@@ -339,7 +340,7 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
inline ReleaseWeakRefAction
IntrusiveRefCounts::releaseWeakRef() const
{
auto prevIntVal = refCounts.fetch_sub(weakDelta, std::memory_order_acq_rel);
auto prevIntVal = refCounts_.fetch_sub(kWEAK_DELTA, std::memory_order_acq_rel);
RefCountPair prev = prevIntVal;
if (prev.weak == 1 && prev.strong == 0)
{
@@ -348,19 +349,19 @@ IntrusiveRefCounts::releaseWeakRef() const
// This case should only be hit if the partialDestroyStartedBit is
// set non-atomically (and even then very rarely). The code is kept
// in case we need to set the flag non-atomically for perf reasons.
refCounts.wait(prevIntVal, std::memory_order_acquire);
prevIntVal = refCounts.load(std::memory_order_acquire);
refCounts_.wait(prevIntVal, std::memory_order_acquire);
prevIntVal = refCounts_.load(std::memory_order_acquire);
prev = RefCountPair{prevIntVal};
}
if (prev.partialDestroyFinishedBit == 0u)
{
// partial destroy MUST finish before running a full destroy (when
// using weak pointers)
refCounts.wait(prevIntVal - weakDelta, std::memory_order_acquire);
refCounts_.wait(prevIntVal - kWEAK_DELTA, std::memory_order_acquire);
}
return ReleaseWeakRefAction::destroy;
return ReleaseWeakRefAction::Destroy;
}
return ReleaseWeakRefAction::noop;
return ReleaseWeakRefAction::NoOp;
}
inline bool
@@ -369,13 +370,13 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
auto curValue = RefCountPair{1, 1}.combinedValue();
auto desiredValue = RefCountPair{2, 1}.combinedValue();
while (!refCounts.compare_exchange_weak(curValue, desiredValue, std::memory_order_acq_rel))
while (!refCounts_.compare_exchange_weak(curValue, desiredValue, std::memory_order_acq_rel))
{
RefCountPair const prev{curValue};
if (prev.strong == 0u)
return false;
desiredValue = curValue + strongDelta;
desiredValue = curValue + kSTRONG_DELTA;
}
return true;
}
@@ -383,38 +384,39 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
inline bool
IntrusiveRefCounts::expired() const noexcept
{
RefCountPair const val = refCounts.load(std::memory_order_acquire);
RefCountPair const val = refCounts_.load(std::memory_order_acquire);
return val.strong == 0;
}
inline std::size_t
IntrusiveRefCounts::use_count() const noexcept
IntrusiveRefCounts::useCount() const noexcept
{
RefCountPair const val = refCounts.load(std::memory_order_acquire);
RefCountPair const val = refCounts_.load(std::memory_order_acquire);
return val.strong;
}
inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
{
#ifndef NDEBUG
auto v = refCounts.load(std::memory_order_acquire);
auto v = refCounts_.load(std::memory_order_acquire);
XRPL_ASSERT(
(!(v & valueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
auto t = v & tagMask;
XRPL_ASSERT((!t || t == tagMask), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
(!(v & kVALUE_MASK)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
auto t = v & kTAG_MASK;
XRPL_ASSERT(
(!t || t == kTAG_MASK), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
#endif
}
//------------------------------------------------------------------------------
inline IntrusiveRefCounts::RefCountPair::RefCountPair(IntrusiveRefCounts::FieldType v) noexcept
: strong{static_cast<CountType>(v & strongMask)}
, weak{static_cast<CountType>((v & weakMask) >> StrongCountNumBits)}
, partialDestroyStartedBit{v & partialDestroyStartedMask}
, partialDestroyFinishedBit{v & partialDestroyFinishedMask}
: strong{static_cast<CountType>(v & kSTRONG_MASK)}
, weak{static_cast<CountType>((v & kWEAK_MASK) >> kSTRONG_COUNT_NUM_BITS)}
, partialDestroyStartedBit{v & kPARTIAL_DESTROY_STARTED_MASK}
, partialDestroyFinishedBit{v & kPARTIAL_DESTROY_FINISHED_MASK}
{
XRPL_ASSERT(
(strong < checkStrongMaxValue && weak < checkWeakMaxValue),
(strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE),
"xrpl::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside "
"range");
}
@@ -425,7 +427,7 @@ inline IntrusiveRefCounts::RefCountPair::RefCountPair(
: strong{s}, weak{w}
{
XRPL_ASSERT(
(strong < checkStrongMaxValue && weak < checkWeakMaxValue),
(strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE),
"xrpl::IntrusiveRefCounts::RefCountPair(CountType, CountType) : "
"inputs inside range");
}
@@ -434,11 +436,11 @@ inline IntrusiveRefCounts::FieldType
IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
{
XRPL_ASSERT(
(strong < checkStrongMaxValue && weak < checkWeakMaxValue),
(strong < kCHECK_STRONG_MAX_VALUE && weak < kCHECK_WEAK_MAX_VALUE),
"xrpl::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
"inside range");
return (static_cast<IntrusiveRefCounts::FieldType>(weak)
<< IntrusiveRefCounts::StrongCountNumBits) |
<< IntrusiveRefCounts::kSTRONG_COUNT_NUM_BITS) |
static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit |
partialDestroyFinishedBit;
}
@@ -449,7 +451,7 @@ partialDestructorFinished(T** o)
{
T& self = **o;
IntrusiveRefCounts::RefCountPair const p =
self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
self.refCounts_.fetch_or(IntrusiveRefCounts::kPARTIAL_DESTROY_FINISHED_MASK);
XRPL_ASSERT(
(!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),
"xrpl::partialDestructorFinished : not a weak ref");
@@ -458,7 +460,7 @@ partialDestructorFinished(T** o)
// There was a weak count before the partial destructor ran (or we would
// have run the full destructor) and now there isn't a weak count. Some
// thread is waiting to run the destructor.
self.refCounts.notify_one();
self.refCounts_.notify_one();
}
// Set the pointer to null to emphasize that the object shouldn't be used
// after calling this function as it may be destroyed in another thread.

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

@@ -26,17 +26,17 @@ struct LocalValues
template <class T>
struct Value : BasicValue
{
T t_;
T t;
Value() = default;
explicit Value(T t) : t_(std::move(t))
explicit Value(T t) : t(std::move(t))
{
}
void*
get() override
{
return &t_;
return &t;
}
};
@@ -55,8 +55,8 @@ template <class = void>
boost::thread_specific_ptr<detail::LocalValues>&
getLocalValues()
{
static boost::thread_specific_ptr<detail::LocalValues> tsp(&detail::LocalValues::cleanup);
return tsp;
static boost::thread_specific_ptr<detail::LocalValues> kTSP(&detail::LocalValues::cleanup);
return kTSP;
}
} // namespace detail

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

@@ -17,15 +17,15 @@ namespace xrpl {
// DEPRECATED use beast::severities::Severity instead
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum LogSeverity {
lsINVALID = -1, // used to indicate an invalid severity
lsTRACE = 0, // Very low-level progress information, details inside
LSInvalid = -1, // used to indicate an invalid severity
LSTrace = 0, // Very low-level progress information, details inside
// an operation
lsDEBUG = 1, // Function-level progress information, operations
lsINFO = 2, // Server-level progress information, major operations
lsWARNING = 3, // Conditions that warrant human attention, may indicate
LSDebug = 1, // Function-level progress information, operations
LSInfo = 2, // Server-level progress information, major operations
LSWarning = 3, // Conditions that warrant human attention, may indicate
// a problem
lsERROR = 4, // A condition that indicates a problem
lsFATAL = 5 // A severe condition that indicates a server problem
LSError = 4, // A condition that indicates a problem
LSFatal = 5 // A severe condition that indicates a server problem
};
/** Manages partitions for logging. */
@@ -130,8 +130,8 @@ private:
/** @} */
private:
std::unique_ptr<std::ofstream> m_stream;
boost::filesystem::path m_path;
std::unique_ptr<std::ofstream> stream_;
boost::filesystem::path path_;
};
std::mutex mutable mutex_;
@@ -168,7 +168,7 @@ public:
threshold(beast::severities::Severity thresh);
std::vector<std::pair<std::string, std::string>>
partition_severities() const;
partitionSeverities() const;
void
write(
@@ -214,7 +214,7 @@ private:
// Maximum line length for log messages.
// If the message exceeds this length it will be truncated with
// ellipses.
maximumMessageCharacters = 12 * 1024
MaximumMessageCharacters = 12 * 1024
};
static void

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

@@ -70,27 +70,27 @@ isPowerOfTen(T value)
struct MantissaRange
{
using rep = std::uint64_t;
enum class mantissa_scale { small, large };
enum class MantissaScale { Small, Large };
explicit constexpr MantissaRange(mantissa_scale scale_)
: min(getMin(scale_)), log(logTen(min).value_or(-1)), scale(scale_)
explicit constexpr MantissaRange(MantissaScale scale)
: min(getMin(scale)), log(logTen(min).value_or(-1)), scale(scale)
{
}
rep min;
rep max{(min * 10) - 1};
int log;
mantissa_scale scale;
MantissaScale scale;
private:
static constexpr rep
getMin(mantissa_scale scale_)
getMin(MantissaScale scale)
{
switch (scale_)
switch (scale)
{
case mantissa_scale::small:
case MantissaScale::Small:
return 1'000'000'000'000'000ULL;
case mantissa_scale::large:
case MantissaScale::Large:
return 1'000'000'000'000'000'000ULL;
default:
// Since this can never be called outside a non-constexpr
@@ -214,26 +214,26 @@ class Number
public:
// The range for the exponent when normalized
constexpr static int minExponent = -32768;
constexpr static int maxExponent = 32768;
constexpr static int kMIN_EXPONENT = -32768;
constexpr static int kMAX_EXPONENT = 32768;
constexpr static internalrep maxRep = std::numeric_limits<rep>::max();
static_assert(maxRep == 9'223'372'036'854'775'807);
static_assert(-maxRep == std::numeric_limits<rep>::min() + 1);
constexpr static internalrep kMAX_REP = std::numeric_limits<rep>::max();
static_assert(kMAX_REP == 9'223'372'036'854'775'807);
static_assert(-kMAX_REP == std::numeric_limits<rep>::min() + 1);
// May need to make unchecked private
struct unchecked
struct Unchecked
{
explicit unchecked() = default;
explicit Unchecked() = default;
};
// Like unchecked, normalized is used with the ctors that take an
// internalrep mantissa. Unlike unchecked, those ctors will normalize the
// value.
// Only unit tests are expected to use this class
struct normalized
struct Normalized
{
explicit normalized() = default;
explicit Normalized() = default;
};
explicit constexpr Number() = default;
@@ -244,13 +244,13 @@ public:
bool negative,
internalrep mantissa,
int exponent,
unchecked) noexcept;
Unchecked) noexcept;
// Assume unsigned values are... unsigned. i.e. positive
explicit constexpr Number(internalrep mantissa, int exponent, unchecked) noexcept;
explicit constexpr Number(internalrep mantissa, int exponent, Unchecked) noexcept;
// Only unit tests are expected to use this ctor
explicit Number(bool negative, internalrep mantissa, int exponent, normalized);
explicit Number(bool negative, internalrep mantissa, int exponent, Normalized);
// Assume unsigned values are... unsigned. i.e. positive
explicit Number(internalrep mantissa, int exponent, normalized);
explicit Number(internalrep mantissa, int exponent, Normalized);
[[nodiscard]] constexpr rep
mantissa() const noexcept;
@@ -384,42 +384,44 @@ public:
root2(Number f);
// Thread local rounding control. Default is to_nearest
enum class rounding_mode { to_nearest, towards_zero, downward, upward };
static rounding_mode
enum class RoundingMode { ToNearest, TowardsZero, Downward, Upward };
static RoundingMode
getround();
// Returns previously set mode
static rounding_mode
setround(rounding_mode mode);
static RoundingMode
setround(RoundingMode inMode);
/** Returns which mantissa scale is currently in use for normalization.
*
* If you think you need to call this outside of unit tests, no you don't.
*/
static MantissaRange::mantissa_scale
static MantissaRange::MantissaScale
getMantissaScale();
/** Changes which mantissa scale is used for normalization.
*
* If you think you need to call this outside of unit tests, no you don't.
*/
static void
setMantissaScale(MantissaRange::mantissa_scale scale);
setMantissaScale(MantissaRange::MantissaScale scale);
static internalrep
minMantissa()
{
return range_.get().min;
return kRANGE.get().min;
}
static internalrep
maxMantissa()
{
return range_.get().max;
return kRANGE.get().max;
}
static int
mantissaLog()
{
return range_.get().log;
return kRANGE.get().log;
}
/// oneSmall is needed because the ranges are private
@@ -440,28 +442,28 @@ public:
normalizeToRange(T minMantissa, T maxMantissa) const;
private:
static thread_local rounding_mode mode_;
static thread_local RoundingMode mode;
// The available ranges for mantissa
constexpr static MantissaRange smallRange{MantissaRange::mantissa_scale::small};
static_assert(isPowerOfTen(smallRange.min));
static_assert(smallRange.min == 1'000'000'000'000'000LL);
static_assert(smallRange.max == 9'999'999'999'999'999LL);
static_assert(smallRange.log == 15);
static_assert(smallRange.min < maxRep);
static_assert(smallRange.max < maxRep);
constexpr static MantissaRange largeRange{MantissaRange::mantissa_scale::large};
static_assert(isPowerOfTen(largeRange.min));
static_assert(largeRange.min == 1'000'000'000'000'000'000ULL);
static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
static_assert(largeRange.log == 18);
static_assert(largeRange.min < maxRep);
static_assert(largeRange.max > maxRep);
constexpr static MantissaRange kSMALL_RANGE{MantissaRange::MantissaScale::Small};
static_assert(isPowerOfTen(kSMALL_RANGE.min));
static_assert(kSMALL_RANGE.min == 1'000'000'000'000'000LL);
static_assert(kSMALL_RANGE.max == 9'999'999'999'999'999LL);
static_assert(kSMALL_RANGE.log == 15);
static_assert(kSMALL_RANGE.min < kMAX_REP);
static_assert(kSMALL_RANGE.max < kMAX_REP);
constexpr static MantissaRange kLARGE_RANGE{MantissaRange::MantissaScale::Large};
static_assert(isPowerOfTen(kLARGE_RANGE.min));
static_assert(kLARGE_RANGE.min == 1'000'000'000'000'000'000ULL);
static_assert(kLARGE_RANGE.max == internalrep(9'999'999'999'999'999'999ULL));
static_assert(kLARGE_RANGE.log == 18);
static_assert(kLARGE_RANGE.min < kMAX_REP);
static_assert(kLARGE_RANGE.max > kMAX_REP);
// The range for the mantissa when normalized.
// Use reference_wrapper to avoid making copies, and prevent accidentally
// changing the values inside the range.
static thread_local std::reference_wrapper<MantissaRange const> range_;
static thread_local std::reference_wrapper<MantissaRange const> kRANGE;
void
normalize();
@@ -469,7 +471,7 @@ private:
/** Normalize Number components to an arbitrary range.
*
* min/maxMantissa are parameters because this function is used by both
* normalize(), which reads from range_, and by normalizeToRange,
* normalize(), which reads from kRANGE, and by normalizeToRange,
* which is public and can accept an arbitrary range from the caller.
*/
template <class T>
@@ -485,8 +487,8 @@ private:
friend void
doNormalize(
bool& negative,
T& mantissa_,
int& exponent_,
T& mantissa,
int& exponent,
MantissaRange::rep const& minMantissa,
MantissaRange::rep const& maxMantissa);
@@ -509,31 +511,31 @@ private:
class Guard;
};
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}
{
}
constexpr Number::Number(internalrep mantissa, int exponent, unchecked) noexcept
: Number(false, mantissa, exponent, unchecked{})
constexpr Number::Number(internalrep mantissa, int exponent, Unchecked) noexcept
: Number(false, mantissa, exponent, Unchecked{})
{
}
constexpr static Number numZero{};
constexpr static Number kNUM_ZERO{};
inline Number::Number(bool negative, internalrep mantissa, int exponent, normalized)
: Number(negative, mantissa, exponent, unchecked{})
inline Number::Number(bool negative, internalrep mantissa, int exponent, Normalized)
: Number(negative, mantissa, exponent, Unchecked{})
{
normalize();
}
inline Number::Number(internalrep mantissa, int exponent, normalized)
: Number(false, mantissa, exponent, normalized{})
inline Number::Number(internalrep mantissa, int exponent, Normalized)
: Number(false, mantissa, exponent, Normalized{})
{
}
inline Number::Number(rep mantissa, int exponent)
: Number(mantissa < 0, externalToInternal(mantissa), exponent, normalized{})
: Number(mantissa < 0, externalToInternal(mantissa), exponent, Normalized{})
{
}
@@ -550,10 +552,10 @@ constexpr Number::rep
Number::mantissa() const noexcept
{
auto m = mantissa_;
if (m > maxRep)
if (m > kMAX_REP)
{
XRPL_ASSERT_PARTS(
!isnormal() || (m % 10 == 0 && m / 10 <= maxRep),
!isnormal() || (m % 10 == 0 && m / 10 <= kMAX_REP),
"xrpl::Number::mantissa",
"large normalized mantissa has no remainder");
m /= 10;
@@ -571,10 +573,10 @@ constexpr int
Number::exponent() const noexcept
{
auto e = exponent_;
if (mantissa_ > maxRep)
if (mantissa_ > kMAX_REP)
{
XRPL_ASSERT_PARTS(
!isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= maxRep),
!isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= kMAX_REP),
"xrpl::Number::exponent",
"large normalized mantissa has no remainder");
++e;
@@ -669,29 +671,29 @@ operator/(Number const& x, Number const& y)
inline Number
Number::min() noexcept
{
return Number{false, range_.get().min, minExponent, unchecked{}};
return Number{false, kRANGE.get().min, kMIN_EXPONENT, Unchecked{}};
}
inline Number
Number::max() noexcept
{
return Number{false, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
return Number{false, std::min(kRANGE.get().max, kMAX_REP), kMAX_EXPONENT, Unchecked{}};
}
inline Number
Number::lowest() noexcept
{
return Number{true, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
return Number{true, std::min(kRANGE.get().max, kMAX_REP), kMAX_EXPONENT, Unchecked{}};
}
inline bool
Number::isnormal() const noexcept
{
MantissaRange const& range = range_;
auto const abs_m = mantissa_;
MantissaRange const& range = kRANGE;
auto const absM = mantissa_;
return *this == Number{} ||
(range.min <= abs_m && abs_m <= range.max && (abs_m <= maxRep || abs_m % 10 == 0) &&
minExponent <= exponent_ && exponent_ <= maxExponent);
(range.min <= absM && absM <= range.max && (absM <= kMAX_REP || absM % 10 == 0) &&
kMIN_EXPONENT <= exponent_ && exponent_ <= kMAX_EXPONENT);
}
template <Integral64 T>
@@ -755,34 +757,34 @@ squelch(Number const& x, Number const& limit) noexcept
}
inline std::string
to_string(MantissaRange::mantissa_scale const& scale)
to_string(MantissaRange::MantissaScale const& scale)
{
switch (scale)
{
case MantissaRange::mantissa_scale::small:
case MantissaRange::MantissaScale::Small:
return "small";
case MantissaRange::mantissa_scale::large:
case MantissaRange::MantissaScale::Large:
return "large";
default:
throw std::runtime_error("Bad scale");
}
}
class saveNumberRoundMode
class SaveNumberRoundMode
{
Number::rounding_mode mode_;
Number::RoundingMode mode_;
public:
~saveNumberRoundMode()
~SaveNumberRoundMode()
{
Number::setround(mode_);
}
explicit saveNumberRoundMode(Number::rounding_mode mode) noexcept : mode_{mode}
explicit SaveNumberRoundMode(Number::RoundingMode mode) noexcept : mode_{mode}
{
}
saveNumberRoundMode(saveNumberRoundMode const&) = delete;
saveNumberRoundMode&
operator=(saveNumberRoundMode const&) = delete;
SaveNumberRoundMode(SaveNumberRoundMode const&) = delete;
SaveNumberRoundMode&
operator=(SaveNumberRoundMode const&) = delete;
};
// saveNumberRoundMode doesn't do quite enough for us. What we want is a
@@ -791,10 +793,10 @@ public:
// build it here.
class NumberRoundModeGuard
{
saveNumberRoundMode saved_;
SaveNumberRoundMode saved_;
public:
explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept
explicit NumberRoundModeGuard(Number::RoundingMode mode) noexcept
: saved_{Number::setround(mode)}
{
}
@@ -812,10 +814,10 @@ public:
*/
class NumberMantissaScaleGuard
{
MantissaRange::mantissa_scale const saved_;
MantissaRange::MantissaScale const saved_;
public:
explicit NumberMantissaScaleGuard(MantissaRange::mantissa_scale scale) noexcept
explicit NumberMantissaScaleGuard(MantissaRange::MantissaScale scale) noexcept
: saved_{Number::getMantissaScale()}
{
Number::setMantissaScale(scale);

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

@@ -101,7 +101,7 @@ to_string(RangeSet<T> const& rs)
*/
template <class T>
[[nodiscard]] bool
from_string(RangeSet<T>& rs, std::string const& s)
fromString(RangeSet<T>& rs, std::string const& s)
{
std::vector<std::string> intervals;
std::vector<std::string> tokens;

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

@@ -16,7 +16,7 @@ public:
/** Issue an asynchronous stop request. */
virtual void
stop_async() = 0;
stopAsync() = 0;
/** Issue a synchronous stop request. */
virtual void

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

@@ -13,7 +13,7 @@ public:
explicit ResolverAsio() = default;
static std::unique_ptr<ResolverAsio>
New(boost::asio::io_context&, beast::Journal);
make(boost::asio::io_context&, beast::Journal);
};
} // namespace xrpl

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

@@ -21,12 +21,12 @@ public:
}
[[nodiscard]] uint256 const&
as_uint256() const
asUint256() const
{
return hash_;
}
uint256&
as_uint256()
asUint256()
{
return hash_;
}
@@ -93,7 +93,7 @@ template <>
inline std::size_t
extract(SHAMapHash const& key)
{
return *reinterpret_cast<std::size_t const*>(key.as_uint256().data());
return *reinterpret_cast<std::size_t const*>(key.asUint256().data());
}
} // namespace xrpl

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

@@ -73,7 +73,7 @@ public:
/** If this is a strong pointer, return the strong count. Otherwise return 0
*/
[[nodiscard]] std::size_t
use_count() const;
useCount() const;
/** Return true if there is a non-zero strong count. */
[[nodiscard]] bool

6
include/xrpl/basics/SharedWeakCachePointer.ipp
View File

@@ -57,10 +57,10 @@ template <class T>
std::shared_ptr<T> const&
SharedWeakCachePointer<T>::getStrong() const
{
static std::shared_ptr<T> const empty;
static std::shared_ptr<T> const kEMPTY;
if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
return *p;
return empty;
return kEMPTY;
}
template <class T>
@@ -86,7 +86,7 @@ SharedWeakCachePointer<T>::get() const
template <class T>
std::size_t
SharedWeakCachePointer<T>::use_count() const
SharedWeakCachePointer<T>::useCount() const
{
if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
return p->use_count();

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

@@ -36,32 +36,32 @@ class SlabAllocator
struct SlabBlock
{
// A mutex to protect the freelist for this block:
std::mutex m_;
std::mutex m;
// A linked list of appropriately sized free buffers:
std::uint8_t* l_ = nullptr;
std::uint8_t* l = nullptr;
// The next memory block
SlabBlock* next_;
SlabBlock* next;
// The underlying memory block:
std::uint8_t const* const p_ = nullptr;
std::uint8_t const* const p = nullptr;
// The extent of the underlying memory block:
std::size_t const size_;
std::size_t const size;
SlabBlock(SlabBlock* next, std::uint8_t* data, std::size_t size, std::size_t item)
: next_(next), p_(data), size_(size)
: next(next), p(data), size(size)
{
// We don't need to grab the mutex here, since we're the only
// ones with access at this moment.
while (data + item <= p_ + size_)
while (data + item <= p + size)
{
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(data, static_cast<void const*>(&l_), sizeof(std::uint8_t*));
l_ = data;
std::memcpy(data, static_cast<void const*>(&l), sizeof(std::uint8_t*));
l = data;
data += item;
}
}
@@ -81,9 +81,9 @@ class SlabAllocator
/** Determines whether the given pointer belongs to this allocator */
bool
own(std::uint8_t const* p) const noexcept
own(std::uint8_t const* pIn) const noexcept
{
return (p >= p_) && (p < p_ + size_);
return (pIn >= p) && (pIn < p + size);
}
std::uint8_t*
@@ -92,15 +92,14 @@ class SlabAllocator
std::uint8_t* ret = nullptr; // NOLINT(misc-const-correctness)
{
std::scoped_lock const l(m_);
ret = l_;
std::scoped_lock const lock(m);
ret = l;
if (ret != nullptr)
{
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(static_cast<void*>(&l_), ret, sizeof(std::uint8_t*));
std::memcpy(static_cast<void*>(&l), ret, sizeof(std::uint8_t*));
}
}
@@ -121,12 +120,12 @@ class SlabAllocator
{
XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
std::scoped_lock const l(m_);
std::scoped_lock const lock(m);
// Use memcpy to avoid unaligned UB
// (will optimize to equivalent code)
std::memcpy(ptr, static_cast<void const*>(&l_), sizeof(std::uint8_t*));
l_ = ptr;
std::memcpy(ptr, static_cast<void const*>(&l), sizeof(std::uint8_t*));
l = ptr;
}
};
@@ -201,7 +200,7 @@ public:
if (auto ret = slab->allocate())
return ret;
slab = slab->next_;
slab = slab->next;
}
// No slab can satisfy our request, so we attempt to allocate a new
@@ -242,7 +241,7 @@ public:
// Link the new slab
while (!slabs_.compare_exchange_weak(
slab->next_, slab, std::memory_order_release, std::memory_order_relaxed))
slab->next, slab, std::memory_order_release, std::memory_order_relaxed))
{
; // Nothing to do
}
@@ -265,7 +264,7 @@ public:
"xrpl::SlabAllocator::SlabAllocator::deallocate : non-null "
"input");
for (auto slab = slabs_.load(); slab != nullptr; slab = slab->next_)
for (auto slab = slabs_.load(); slab != nullptr; slab = slab->next)
{
if (slab->own(ptr))
{
@@ -294,16 +293,16 @@ public:
friend class SlabAllocatorSet;
private:
std::size_t extra;
std::size_t alloc;
std::size_t align;
std::size_t extra_;
std::size_t alloc_;
std::size_t align_;
public:
constexpr SlabConfig(
std::size_t extra_,
std::size_t alloc_ = 0,
std::size_t align_ = alignof(Type))
: extra(extra_), alloc(alloc_), align(align_)
std::size_t extra,
std::size_t alloc = 0,
std::size_t align = alignof(Type))
: extra_(extra), alloc_(alloc), align_(align)
{
}
};
@@ -313,22 +312,22 @@ public:
// Ensure that the specified allocators are sorted from smallest to
// largest by size:
std::sort(std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
return a.extra < b.extra;
return a.extra_ < b.extra_;
});
// We should never have two slabs of the same size
if (std::adjacent_find(
std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
return a.extra == b.extra;
return a.extra_ == b.extra_;
}) != cfg.end())
{
throw std::runtime_error(
"SlabAllocatorSet<" + beast::type_name<Type>() + ">: duplicate slab size");
"SlabAllocatorSet<" + beast::typeName<Type>() + ">: duplicate slab size");
}
for (auto const& c : cfg)
{
auto& a = allocators_.emplace_back(c.extra, c.alloc, c.align);
auto& a = allocators_.emplace_back(c.extra_, c.alloc_, c.align_);
if (a.size() > maxSize_)
maxSize_ = a.size();

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

@@ -110,7 +110,7 @@ public:
/** Shrinks the slice by moving its start forward by n characters. */
void
remove_prefix(std::size_t n)
removePrefix(std::size_t n)
{
data_ += n;
size_ -= n;
@@ -118,7 +118,7 @@ public:
/** Shrinks the slice by moving its end backward by n characters. */
void
remove_suffix(std::size_t n)
removeSuffix(std::size_t n)
{
size_ -= n;
}

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

@@ -30,7 +30,7 @@ template <class Iterator>
std::optional<Blob>
strUnHex(std::size_t strSize, Iterator begin, Iterator end)
{
static constexpr std::array<int, 256> const digitLookupTable = []() {
static constexpr std::array<int, 256> const kDIGIT_LOOKUP_TABLE = []() {
std::array<int, 256> t{};
for (auto& x : t)
@@ -56,7 +56,7 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
if (strSize & 1)
{
int c = digitLookupTable[*iter++];
int c = kDIGIT_LOOKUP_TABLE[*iter++];
if (c < 0)
return {};
@@ -66,12 +66,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
while (iter != end)
{
int const cHigh = digitLookupTable[*iter++];
int const cHigh = kDIGIT_LOOKUP_TABLE[*iter++];
if (cHigh < 0)
return {};
int const cLow = digitLookupTable[*iter++];
int const cLow = kDIGIT_LOOKUP_TABLE[*iter++];
if (cLow < 0)
return {};
@@ -94,9 +94,9 @@ strViewUnHex(std::string_view strSrc)
return strUnHex(strSrc.size(), strSrc.cbegin(), strSrc.cend());
}
struct parsedURL
struct ParsedUrl
{
explicit parsedURL() = default;
explicit ParsedUrl() = default;
std::string scheme;
std::string username;
@@ -106,7 +106,7 @@ struct parsedURL
std::string path;
bool
operator==(parsedURL const& other) const
operator==(ParsedUrl const& other) const
{
return scheme == other.scheme && domain == other.domain && port == other.port &&
path == other.path;
@@ -114,13 +114,13 @@ struct parsedURL
};
bool
parseUrl(parsedURL& pUrl, std::string const& strUrl);
parseUrl(ParsedUrl& pUrl, std::string const& strUrl);
std::string
trim_whitespace(std::string str);
trimWhitespace(std::string str);
std::optional<std::uint64_t>
to_uint64(std::string const& s);
toUint64(std::string const& s);
/** Determines if the given string looks like a TOML-file hosting domain.

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

@@ -35,7 +35,7 @@ template <
bool IsKeyCache = false,
class SharedWeakUnionPointerType = SharedWeakCachePointer<T>,
class SharedPointerType = std::shared_ptr<T>,
class Hash = hardened_hash<>,
class Hash = HardenedHash<>,
class KeyEqual = std::equal_to<Key>,
class Mutex = std::recursive_mutex>
class TaggedCache
@@ -44,7 +44,7 @@ public:
using mutex_type = Mutex;
using key_type = Key;
using mapped_type = T;
using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
using clock_type = beast::AbstractClock<std::chrono::steady_clock>;
using shared_weak_combo_pointer_type = SharedWeakUnionPointerType;
using shared_pointer_type = SharedPointerType;
@@ -55,7 +55,7 @@ public:
clock_type::duration expiration,
clock_type& clock,
beast::Journal journal,
beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::New());
beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::make());
public:
/** Return the clock associated with the cache. */
@@ -86,7 +86,7 @@ public:
*/
template <class KeyComparable>
bool
touch_if_exists(KeyComparable const& key);
touchIfExists(KeyComparable const& key);
using SweptPointersVector = std::vector<SharedWeakUnionPointerType>;
@@ -115,10 +115,10 @@ public:
canonicalize(key_type const& key, SharedPointerType& data, R&& replaceCallback);
bool
canonicalize_replace_cache(key_type const& key, SharedPointerType const& data);
canonicalizeReplaceCache(key_type const& key, SharedPointerType const& data);
bool
canonicalize_replace_client(key_type const& key, SharedPointerType& data);
canonicalizeReplaceClient(key_type const& key, SharedPointerType& data);
SharedPointerType
fetch(key_type const& key);
@@ -169,7 +169,7 @@ private:
initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l);
void
collect_metrics();
collectMetrics();
private:
struct Stats
@@ -179,9 +179,9 @@ private:
std::string const& prefix,
Handler const& handler,
beast::insight::Collector::ptr const& collector)
: hook(collector->make_hook(handler))
, size(collector->make_gauge(prefix, "size"))
, hit_rate(collector->make_gauge(prefix, "hit_rate"))
: hook(collector->makeHook(handler))
, size(collector->makeGauge(prefix, "size"))
, hit_rate(collector->makeGauge(prefix, "hit_rate"))
{
}
@@ -199,8 +199,7 @@ private:
public:
clock_type::time_point last_access;
explicit KeyOnlyEntry(clock_type::time_point const& last_access_)
: last_access(last_access_)
explicit KeyOnlyEntry(clock_type::time_point const& lastAccess) : last_access(lastAccess)
{
}
@@ -217,8 +216,8 @@ private:
shared_weak_combo_pointer_type ptr;
clock_type::time_point last_access;
ValueEntry(clock_type::time_point const& last_access_, shared_pointer_type const& ptr_)
: ptr(ptr_), last_access(last_access_)
ValueEntry(clock_type::time_point const& lastAccess, shared_pointer_type const& ptr)
: ptr(ptr), last_access(lastAccess)
{
}
@@ -261,7 +260,7 @@ private:
[[nodiscard]] std::thread
sweepHelper(
clock_type::time_point const& when_expire,
clock_type::time_point const& whenExpire,
[[maybe_unused]] clock_type::time_point const& now,
typename KeyValueCacheType::map_type& partition,
SweptPointersVector& stuffToSweep,
@@ -270,33 +269,33 @@ private:
[[nodiscard]] std::thread
sweepHelper(
clock_type::time_point const& when_expire,
clock_type::time_point const& whenExpire,
clock_type::time_point const& now,
typename KeyOnlyCacheType::map_type& partition,
SweptPointersVector&,
std::atomic<int>& allRemovals,
std::scoped_lock<std::recursive_mutex> const&);
beast::Journal m_journal;
clock_type& m_clock;
Stats m_stats;
beast::Journal journal_;
clock_type& clock_;
Stats stats_;
mutex_type mutable m_mutex;
mutex_type mutable mutex_;
// Used for logging
std::string m_name;
std::string name_;
// Desired number of cache entries (0 = ignore)
int const m_target_size;
int const target_size_;
// Desired maximum cache age
clock_type::duration const m_target_age;
clock_type::duration const target_age_;
// Number of items cached
int m_cache_count{0};
cache_type m_cache; // Hold strong reference to recent objects
std::uint64_t m_hits{0};
std::uint64_t m_misses{0};
int cache_count_{0};
cache_type cache_; // Hold strong reference to recent objects
std::uint64_t hits_{0};
std::uint64_t misses_{0};
};
} // namespace xrpl

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

@@ -30,13 +30,12 @@ inline TaggedCache<
clock_type& clock,
beast::Journal journal,
beast::insight::Collector::ptr const& collector)
: m_journal(journal)
, m_clock(clock)
, m_stats(name, std::bind(&TaggedCache::collect_metrics, this), collector)
, m_name(name)
, m_target_size(size)
, m_target_age(expiration)
: journal_(journal)
, clock_(clock)
, stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
, name_(name)
, target_size_(size)
, target_age_(expiration)
{
}
@@ -53,7 +52,7 @@ inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
clock() -> clock_type&
{
return m_clock;
return clock_;
}
template <
@@ -69,8 +68,8 @@ inline std::size_t
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
size() const
{
std::scoped_lock lock(m_mutex);
return m_cache.size();
std::scoped_lock const lock(mutex_);
return cache_.size();
}
template <
@@ -86,8 +85,8 @@ inline int
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
getCacheSize() const
{
std::scoped_lock lock(m_mutex);
return m_cache_count;
std::scoped_lock const lock(mutex_);
return cache_count_;
}
template <
@@ -103,8 +102,8 @@ inline int
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
getTrackSize() const
{
std::scoped_lock lock(m_mutex);
return m_cache.size();
std::scoped_lock const lock(mutex_);
return cache_.size();
}
template <
@@ -120,9 +119,9 @@ inline float
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
getHitRate()
{
std::scoped_lock lock(m_mutex);
auto const total = static_cast<float>(m_hits + m_misses);
return m_hits * (100.0f / std::max(1.0f, total));
std::scoped_lock const lock(mutex_);
auto const total = static_cast<float>(hits_ + misses_);
return hits_ * (100.0f / std::max(1.0f, total));
}
template <
@@ -138,9 +137,9 @@ inline void
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
clear()
{
std::scoped_lock lock(m_mutex);
m_cache.clear();
m_cache_count = 0;
std::scoped_lock const lock(mutex_);
cache_.clear();
cache_count_ = 0;
}
template <
@@ -156,11 +155,11 @@ inline void
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
reset()
{
std::scoped_lock lock(m_mutex);
m_cache.clear();
m_cache_count = 0;
m_hits = 0;
m_misses = 0;
std::scoped_lock const lock(mutex_);
cache_.clear();
cache_count_ = 0;
hits_ = 0;
misses_ = 0;
}
template <
@@ -175,17 +174,17 @@ template <
template <class KeyComparable>
inline bool
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
touch_if_exists(KeyComparable const& key)
touchIfExists(KeyComparable const& key)
{
std::scoped_lock lock(m_mutex);
auto const iter(m_cache.find(key));
if (iter == m_cache.end())
std::scoped_lock const lock(mutex_);
auto const iter(cache_.find(key));
if (iter == cache_.end())
{
++m_stats.misses;
++stats_.misses;
return false;
}
iter->second.touch(m_clock.now());
++m_stats.hits;
iter->second.touch(clock_.now());
++stats_.hits;
return true;
}
@@ -205,53 +204,53 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
// Keep references to all the stuff we sweep
// For performance, each worker thread should exit before the swept data
// is destroyed but still within the main cache lock.
std::vector<SweptPointersVector> allStuffToSweep(m_cache.partitions());
std::vector<SweptPointersVector> allStuffToSweep(cache_.partitions());
clock_type::time_point const now(m_clock.now());
clock_type::time_point when_expire;
clock_type::time_point const now(clock_.now());
clock_type::time_point whenExpire;
auto const start = std::chrono::steady_clock::now();
{
std::scoped_lock lock(m_mutex);
std::scoped_lock const lock(mutex_);
if (m_target_size == 0 || (static_cast<int>(m_cache.size()) <= m_target_size))
if (target_size_ == 0 || (static_cast<int>(cache_.size()) <= target_size_))
{
when_expire = now - m_target_age;
whenExpire = now - target_age_;
}
else
{
when_expire = now - m_target_age * m_target_size / m_cache.size();
whenExpire = now - (target_age_ * target_size_ / cache_.size());
clock_type::duration const minimumAge(std::chrono::seconds(1));
if (when_expire > (now - minimumAge))
when_expire = now - minimumAge;
if (whenExpire > (now - minimumAge))
whenExpire = now - minimumAge;
JLOG(m_journal.trace())
<< m_name << " is growing fast " << m_cache.size() << " of " << m_target_size
<< " aging at " << (now - when_expire).count() << " of " << m_target_age.count();
JLOG(journal_.trace())
<< name_ << " is growing fast " << cache_.size() << " of " << target_size_
<< " aging at " << (now - whenExpire).count() << " of " << target_age_.count();
}
std::vector<std::thread> workers;
workers.reserve(m_cache.partitions());
workers.reserve(cache_.partitions());
std::atomic<int> allRemovals = 0;
for (std::size_t p = 0; p < m_cache.partitions(); ++p)
for (std::size_t p = 0; p < cache_.partitions(); ++p)
{
workers.push_back(sweepHelper(
when_expire, now, m_cache.map()[p], allStuffToSweep[p], allRemovals, lock));
whenExpire, now, cache_.map()[p], allStuffToSweep[p], allRemovals, lock));
}
for (std::thread& worker : workers)
worker.join();
m_cache_count -= allRemovals;
cache_count_ -= allRemovals;
}
// At this point allStuffToSweep will go out of scope outside the lock
// and decrement the reference count on each strong pointer.
JLOG(m_journal.debug()) << m_name << " TaggedCache sweep lock duration "
<< std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - start)
.count()
<< "ms";
JLOG(journal_.debug()) << name_ << " TaggedCache sweep lock duration "
<< std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - start)
.count()
<< "ms";
}
template <
@@ -267,13 +266,12 @@ inline bool
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
del(key_type const& key, bool valid)
{
// Remove from cache, if !valid, remove from map too. Returns true if
// removed from cache
std::scoped_lock lock(m_mutex);
// Remove from cache, if !valid, remove from map too. Returns true if removed from cache
std::scoped_lock const lock(mutex_);
auto cit = m_cache.find(key);
auto cit = cache_.find(key);
if (cit == m_cache.end())
if (cit == cache_.end())
return false;
Entry& entry = cit->second;
@@ -282,13 +280,13 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
if (entry.isCached())
{
--m_cache_count;
--cache_count_;
entry.ptr.convertToWeak();
ret = true;
}
if (!valid || entry.isExpired())
m_cache.erase(cit);
cache_.erase(cit);
return ret;
}
@@ -309,22 +307,22 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
{
// Return canonical value, store if needed, refresh in cache
// Return values: true=we had the data already
std::scoped_lock lock(m_mutex);
std::scoped_lock const lock(mutex_);
auto cit = m_cache.find(key);
auto cit = cache_.find(key);
if (cit == m_cache.end())
if (cit == cache_.end())
{
m_cache.emplace(
cache_.emplace(
std::piecewise_construct,
std::forward_as_tuple(key),
std::forward_as_tuple(m_clock.now(), data));
++m_cache_count;
std::forward_as_tuple(clock_.now(), data));
++cache_count_;
return false;
}
Entry& entry = cit->second;
entry.touch(m_clock.now());
entry.touch(clock_.now());
auto shouldReplace = [&] {
if constexpr (std::is_invocable_r_v<bool, R>)
@@ -368,12 +366,12 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
data = cachedData;
}
++m_cache_count;
++cache_count_;
return true;
}
entry.ptr = data;
++m_cache_count;
++cache_count_;
return false;
}
@@ -389,7 +387,7 @@ template <
class Mutex>
inline bool
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
canonicalize_replace_cache(key_type const& key, SharedPointerType const& data)
canonicalizeReplaceCache(key_type const& key, SharedPointerType const& data)
{
return canonicalize(key, const_cast<SharedPointerType&>(data), []() { return true; });
}
@@ -405,7 +403,7 @@ template <
class Mutex>
inline bool
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
canonicalize_replace_client(key_type const& key, SharedPointerType& data)
canonicalizeReplaceClient(key_type const& key, SharedPointerType& data)
{
return canonicalize(key, data, []() { return false; });
}
@@ -423,10 +421,10 @@ inline SharedPointerType
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
fetch(key_type const& key)
{
std::scoped_lock<mutex_type> l(m_mutex);
std::scoped_lock<mutex_type> const l(mutex_);
auto ret = initialFetch(key, l);
if (!ret)
++m_misses;
++misses_;
return ret;
}
@@ -451,12 +449,12 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
if constexpr (std::is_same_v<std::shared_ptr<T>, SharedPointerType>)
{
auto p = std::make_shared<T>(std::cref(value));
return canonicalize_replace_client(key, p);
return canonicalizeReplaceClient(key, p);
}
if constexpr (std::is_same_v<intr_ptr::SharedPtr<T>, SharedPointerType>)
{
auto p = intr_ptr::make_shared<T>(std::cref(value));
return canonicalize_replace_client(key, p);
auto p = intr_ptr::makeShared<T>(std::cref(value));
return canonicalizeReplaceClient(key, p);
}
}
@@ -474,9 +472,9 @@ inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
{
std::scoped_lock lock(m_mutex);
clock_type::time_point const now(m_clock.now());
auto [it, inserted] = m_cache.emplace(
std::scoped_lock const lock(mutex_);
clock_type::time_point const now(clock_.now());
auto [it, inserted] = cache_.emplace(
std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
if (!inserted)
it->second.last_access = now;
@@ -519,7 +517,7 @@ inline auto
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
peekMutex() -> mutex_type&
{
return m_mutex;
return mutex_;
}
template <
@@ -538,9 +536,9 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
std::vector<key_type> v;
{
std::scoped_lock lock(m_mutex);
v.reserve(m_cache.size());
for (auto const& _ : m_cache)
std::scoped_lock const lock(mutex_);
v.reserve(cache_.size());
for (auto const& _ : cache_)
v.push_back(_.first);
}
@@ -560,11 +558,11 @@ inline double
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
rate() const
{
std::scoped_lock lock(m_mutex);
auto const tot = m_hits + m_misses;
std::scoped_lock const lock(mutex_);
auto const tot = hits_ + misses_;
if (tot == 0)
return 0;
return double(m_hits) / tot;
return double(hits_) / tot;
}
template <
@@ -582,7 +580,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
fetch(key_type const& digest, Handler const& h)
{
{
std::scoped_lock l(m_mutex);
std::scoped_lock const l(mutex_);
if (auto ret = initialFetch(digest, l))
return ret;
}
@@ -591,11 +589,11 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
if (!sle)
return {};
std::scoped_lock l(m_mutex);
++m_misses;
auto const [it, inserted] = m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
std::scoped_lock const l(mutex_);
++misses_;
auto const [it, inserted] = cache_.emplace(digest, Entry(clock_.now(), std::move(sle)));
if (!inserted)
it->second.touch(m_clock.now());
it->second.touch(clock_.now());
return it->second.ptr.getStrong();
}
// End CachedSLEs functions.
@@ -613,27 +611,27 @@ inline SharedPointerType
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l)
{
auto cit = m_cache.find(key);
if (cit == m_cache.end())
auto cit = cache_.find(key);
if (cit == cache_.end())
return {};
Entry& entry = cit->second;
if (entry.isCached())
{
++m_hits;
entry.touch(m_clock.now());
++hits_;
entry.touch(clock_.now());
return entry.ptr.getStrong();
}
entry.ptr = entry.lock();
if (entry.isCached())
{
// independent of cache size, so not counted as a hit
++m_cache_count;
entry.touch(m_clock.now());
++cache_count_;
entry.touch(clock_.now());
return entry.ptr.getStrong();
}
m_cache.erase(cit);
cache_.erase(cit);
return {};
}
@@ -648,19 +646,19 @@ template <
class Mutex>
inline void
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
collect_metrics()
collectMetrics()
{
m_stats.size.set(getCacheSize());
stats_.size.set(getCacheSize());
{
beast::insight::Gauge::value_type hit_rate(0);
beast::insight::Gauge::value_type hitRate(0);
{
std::scoped_lock lock(m_mutex);
auto const total(m_hits + m_misses);
std::scoped_lock const lock(mutex_);
auto const total(hits_ + misses_);
if (total != 0)
hit_rate = (m_hits * 100) / total;
hitRate = (hits_ * 100) / total;
}
m_stats.hit_rate.set(hit_rate);
stats_.hit_rate.set(hitRate);
}
}
@@ -676,7 +674,7 @@ template <
inline std::thread
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
sweepHelper(
clock_type::time_point const& when_expire,
clock_type::time_point const& whenExpire,
[[maybe_unused]] clock_type::time_point const& now,
typename KeyValueCacheType::map_type& partition,
SweptPointersVector& stuffToSweep,
@@ -708,11 +706,11 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
++cit;
}
}
else if (cit->second.last_access <= when_expire)
else if (cit->second.last_access <= whenExpire)
{
// strong, expired
++cacheRemovals;
if (cit->second.ptr.use_count() == 1)
if (cit->second.ptr.useCount() == 1)
{
stuffToSweep.emplace_back(std::move(cit->second.ptr));
++mapRemovals;
@@ -735,8 +733,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
if (mapRemovals || cacheRemovals)
{
JLOG(m_journal.debug())
<< "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
JLOG(journal_.debug())
<< "TaggedCache partition sweep " << name_ << ": cache = " << partition.size()
<< "-" << cacheRemovals << ", map-=" << mapRemovals;
}
@@ -756,7 +754,7 @@ template <
inline std::thread
TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
sweepHelper(
clock_type::time_point const& when_expire,
clock_type::time_point const& whenExpire,
clock_type::time_point const& now,
typename KeyOnlyCacheType::map_type& partition,
SweptPointersVector&,
@@ -764,8 +762,10 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
std::scoped_lock<std::recursive_mutex> const&)
{
return std::thread([&, this]() {
// NOLINTBEGIN https://github.com/XRPLF/rippled/issues/7056
int cacheRemovals = 0;
int mapRemovals = 0;
// NOLINTEND
// Keep references to all the stuff we sweep
// so that we can destroy them outside the lock.
@@ -778,7 +778,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
cit->second.last_access = now;
++cit;
}
else if (cit->second.last_access <= when_expire)
else if (cit->second.last_access <= whenExpire)
{
cit = partition.erase(cit);
}
@@ -789,10 +789,10 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
}
}
if (mapRemovals || cacheRemovals)
if (mapRemovals > 0 || cacheRemovals > 0)
{
JLOG(m_journal.debug())
<< "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
JLOG(journal_.debug())
<< "TaggedCache partition sweep " << name_ << ": cache = " << partition.size()
<< "-" << cacheRemovals << ", map-=" << mapRemovals;
}

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

@@ -13,31 +13,31 @@ namespace xrpl {
template <class T>
std::enable_if_t<std::is_arithmetic_v<T>, std::string>
to_string(T t)
to_string(T t) // NOLINT(readability-identifier-naming)
{
return std::to_string(t);
}
inline std::string
to_string(bool b)
to_string(bool b) // NOLINT(readability-identifier-naming)
{
return b ? "true" : "false";
}
inline std::string
to_string(char c)
to_string(char c) // NOLINT(readability-identifier-naming)
{
return std::string(1, c);
}
inline std::string
to_string(std::string s)
to_string(std::string s) // NOLINT(readability-identifier-naming)
{
return s;
}
inline std::string
to_string(char const* s)
to_string(char const* s) // NOLINT(readability-identifier-naming)
{
return s;
}

22
include/xrpl/basics/UnorderedContainers.h
View File

@@ -28,7 +28,7 @@ namespace xrpl {
template <
class Key,
class Value,
class Hash = beast::uhash<>,
class Hash = beast::Uhash<>,
class Pred = std::equal_to<Key>,
class Allocator = std::allocator<std::pair<Key const, Value>>>
using hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
@@ -36,33 +36,33 @@ using hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
template <
class Key,
class Value,
class Hash = beast::uhash<>,
class Hash = beast::Uhash<>,
class Pred = std::equal_to<Key>,
class Allocator = std::allocator<std::pair<Key const, Value>>>
using hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
template <
class Value,
class Hash = beast::uhash<>,
class Hash = beast::Uhash<>,
class Pred = std::equal_to<Value>,
class Allocator = std::allocator<Value>>
using hash_set = std::unordered_set<Value, Hash, Pred, Allocator>;
template <
class Value,
class Hash = beast::uhash<>,
class Hash = beast::Uhash<>,
class Pred = std::equal_to<Value>,
class Allocator = std::allocator<Value>>
using hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
// hardened_hash containers
using strong_hash = beast::xxhasher;
using strong_hash = beast::Xxhasher;
template <
class Key,
class Value,
class Hash = hardened_hash<strong_hash>,
class Hash = HardenedHash<strong_hash>,
class Pred = std::equal_to<Key>,
class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
@@ -70,29 +70,29 @@ using hardened_hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
template <
class Key,
class Value,
class Hash = hardened_hash<strong_hash>,
class Hash = HardenedHash<strong_hash>,
class Pred = std::equal_to<Key>,
class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_partitioned_hash_map = partitioned_unordered_map<Key, Value, Hash, Pred, Allocator>;
using hardened_partitioned_hash_map = PartitionedUnorderedMap<Key, Value, Hash, Pred, Allocator>;
template <
class Key,
class Value,
class Hash = hardened_hash<strong_hash>,
class Hash = HardenedHash<strong_hash>,
class Pred = std::equal_to<Key>,
class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
template <
class Value,
class Hash = hardened_hash<strong_hash>,
class Hash = HardenedHash<strong_hash>,
class Pred = std::equal_to<Value>,
class Allocator = std::allocator<Value>>
using hardened_hash_set = std::unordered_set<Value, Hash, Pred, Allocator>;
template <
class Value,
class Hash = hardened_hash<strong_hash>,
class Hash = HardenedHash<strong_hash>,
class Pred = std::equal_to<Value>,
class Allocator = std::allocator<Value>>
using hardened_hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;

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

@@ -21,7 +21,8 @@ public:
using period = std::ratio<1>;
using duration = std::chrono::duration<rep, period>;
using time_point = std::chrono::time_point<UptimeClock>;
static constexpr bool is_steady = std::chrono::system_clock::is_steady;
static constexpr bool is_steady = // NOLINT(readability-identifier-naming)
std::chrono::system_clock::is_steady;
explicit UptimeClock() = default;
@@ -29,19 +30,19 @@ public:
now(); // seconds since xrpld program start
private:
static std::atomic<rep> now_;
static std::atomic<bool> stop_;
static std::atomic<rep> kNOW;
static std::atomic<bool> kSTOP;
struct update_thread : private std::thread
struct UpdateThread : private std::thread
{
~update_thread();
update_thread(update_thread&&) = default;
~UpdateThread();
UpdateThread(UpdateThread&&) = default;
using std::thread::thread;
};
static update_thread
start_clock();
static UpdateThread
startClock();
};
} // namespace xrpl

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

@@ -13,7 +13,7 @@ namespace xrpl {
// Note: This algorithm is evolved from std::set_intersection.
template <class InputIter1, class InputIter2, class Action, class Comp>
void
generalized_set_intersection(
generalizedSetIntersection(
InputIter1 first1,
InputIter1 last1,
InputIter2 first2,
@@ -53,7 +53,7 @@ generalized_set_intersection(
// std::set_intersection.
template <class FwdIter1, class InputIter2, class Pred, class Comp>
FwdIter1
remove_if_intersect_or_match(
removeIfIntersectOrMatch(
FwdIter1 first1,
FwdIter1 last1,
InputIter2 first2,

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

@@ -40,15 +40,15 @@
namespace xrpl {
std::string
base64_encode(std::uint8_t const* data, std::size_t len);
base64Encode(std::uint8_t const* data, std::size_t len);
inline std::string
base64_encode(std::string const& s)
base64Encode(std::string const& s)
{
return base64_encode(reinterpret_cast<std::uint8_t const*>(s.data()), s.size());
return base64Encode(reinterpret_cast<std::uint8_t const*>(s.data()), s.size());
}
std::string
base64_decode(std::string_view data);
base64Decode(std::string_view data);
} // namespace xrpl

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

@@ -27,12 +27,12 @@ namespace xrpl {
namespace detail {
template <class Container, class = std::void_t<>>
struct is_contiguous_container : std::false_type
struct IsContiguousContainer : std::false_type
{
};
template <class Container>
struct is_contiguous_container<
struct IsContiguousContainer<
Container,
std::void_t<
decltype(std::declval<Container const>().size()),
@@ -42,7 +42,7 @@ struct is_contiguous_container<
};
template <>
struct is_contiguous_container<Slice> : std::true_type
struct IsContiguousContainer<Slice> : std::true_type
{
};
@@ -62,18 +62,18 @@ struct is_contiguous_container<Slice> : std::true_type
number of bits.
*/
template <std::size_t Bits, class Tag = void>
class base_uint
class BaseUint
{
static_assert((Bits % 32) == 0, "The length of a base_uint in bits must be a multiple of 32.");
static_assert(Bits >= 64, "The length of a base_uint in bits must be at least 64.");
static constexpr std::size_t WIDTH = Bits / 32;
static constexpr std::size_t kWIDTH = Bits / 32;
// This is really big-endian in byte order.
// We sometimes use std::uint32_t for speed.
std::array<std::uint32_t, WIDTH> data_;
std::array<std::uint32_t, kWIDTH> data_;
public:
//--------------------------------------------------------------------------
@@ -81,8 +81,8 @@ public:
// STL Container Interface
//
static std::size_t constexpr bytes = Bits / 8;
static_assert(sizeof(data_) == bytes, "");
static std::size_t constexpr kBYTES = Bits / 8;
static_assert(sizeof(data_) == kBYTES, "");
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
@@ -116,7 +116,7 @@ public:
iterator
end()
{
return data() + bytes;
return data() + kBYTES;
}
[[nodiscard]] const_iterator
begin() const
@@ -126,7 +126,7 @@ public:
[[nodiscard]] const_iterator
end() const
{
return data() + bytes;
return data() + kBYTES;
}
[[nodiscard]] const_iterator
cbegin() const
@@ -136,14 +136,14 @@ public:
[[nodiscard]] const_iterator
cend() const
{
return data() + bytes;
return data() + kBYTES;
}
/** Value hashing function.
The seed prevents crafted inputs from causing degenerate parent
containers.
*/
using hasher = hardened_hash<>;
using hasher = HardenedHash<>;
//--------------------------------------------------------------------------
@@ -160,16 +160,16 @@ private:
explicit VoidHelper() = default;
};
explicit base_uint(void const* data, VoidHelper)
explicit BaseUint(void const* data, VoidHelper)
{
memcpy(data_.data(), data, bytes);
memcpy(data_.data(), data, kBYTES);
}
// Helper function to initialize a base_uint from a std::string_view.
enum class ParseResult {
okay,
badLength,
badChar,
Okay,
BadLength,
BadChar,
};
constexpr Expected<decltype(data_), ParseResult>
@@ -180,7 +180,7 @@ private:
auto hexCharToUInt = [](char c, std::uint32_t shift, std::uint32_t& accum) -> ParseResult {
std::uint32_t nibble = 0xFFu;
if (c < '0' || c > 'f')
return ParseResult::badChar;
return ParseResult::BadChar;
if (c >= 'a')
{
@@ -196,11 +196,11 @@ private:
}
if (nibble > 0xFu)
return ParseResult::badChar;
return ParseResult::BadChar;
accum |= (nibble << shift);
return ParseResult::okay;
return ParseResult::Okay;
};
decltype(data_) ret{};
@@ -211,7 +211,7 @@ private:
}
if (sv.size() != size() * 2)
return Unexpected(ParseResult::badLength);
return Unexpected(ParseResult::BadLength);
std::size_t i = 0u;
auto in = sv.begin();
@@ -221,7 +221,7 @@ private:
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)
result != ParseResult::Okay)
return Unexpected(result);
}
ret[i++] = accum;
@@ -235,7 +235,7 @@ private:
auto const result = parseFromStringView(sv);
if (!result)
{
if (result.error() == ParseResult::badLength)
if (result.error() == ParseResult::BadLength)
Throw<std::invalid_argument>("invalid length for hex string");
Throw<std::range_error>("invalid hex character");
@@ -244,15 +244,15 @@ private:
}
public:
constexpr base_uint() : data_{}
constexpr BaseUint() : data_{}
{
}
constexpr base_uint(beast::Zero) : data_{}
constexpr BaseUint(beast::Zero) : data_{}
{
}
explicit base_uint(std::uint64_t b)
explicit BaseUint(std::uint64_t b)
{
*this = b;
}
@@ -260,7 +260,7 @@ public:
// This constructor is intended to be used at compile time since it might
// throw at runtime. Consider declaring this constructor consteval once
// we get to C++23.
explicit constexpr base_uint(std::string_view sv) noexcept(false)
explicit constexpr BaseUint(std::string_view sv) noexcept(false)
: data_(parseFromStringViewThrows(sv))
{
}
@@ -268,9 +268,9 @@ public:
template <
class Container,
class = std::enable_if_t<
detail::is_contiguous_container<Container>::value &&
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>>>
explicit base_uint(Container const& c)
explicit BaseUint(Container const& c)
{
XRPL_ASSERT(
c.size() * sizeof(typename Container::value_type) == size(),
@@ -280,9 +280,9 @@ public:
template <class Container>
std::enable_if_t<
detail::is_contiguous_container<Container>::value &&
detail::IsContiguousContainer<Container>::value &&
std::is_trivially_copyable_v<typename Container::value_type>,
base_uint&>
BaseUint&>
operator=(Container const& c)
{
XRPL_ASSERT(
@@ -295,14 +295,14 @@ public:
/* Construct from a raw pointer.
The buffer pointed to by `data` must be at least Bits/8 bytes.
*/
static base_uint
static BaseUint
fromVoid(void const* data)
{
return base_uint(data, VoidHelper());
return BaseUint(data, VoidHelper());
}
template <class T>
static std::optional<base_uint>
static std::optional<BaseUint>
fromVoidChecked(T const& from)
{
if (from.size() != size())
@@ -313,7 +313,7 @@ public:
[[nodiscard]] constexpr int
signum() const
{
for (int i = 0; i < WIDTH; i++)
for (int i = 0; i < kWIDTH; i++)
{
if (data_[i] != 0)
return 1;
@@ -325,24 +325,24 @@ public:
bool
operator!() const
{
return *this == beast::zero;
return *this == beast::kZERO;
}
constexpr base_uint
constexpr BaseUint
operator~() const
{
base_uint ret;
BaseUint ret;
for (int i = 0; i < WIDTH; i++)
for (int i = 0; i < kWIDTH; i++)
ret.data_[i] = ~data_[i];
return ret;
}
base_uint&
BaseUint&
operator=(std::uint64_t uHost)
{
*this = beast::zero;
*this = beast::kZERO;
// NOLINTBEGIN(cppcoreguidelines-pro-type-member-init)
union
{
@@ -352,43 +352,43 @@ public:
// NOLINTEND(cppcoreguidelines-pro-type-member-init)
// Put in least significant bits.
ul = boost::endian::native_to_big(uHost);
data_[WIDTH - 2] = u[0];
data_[WIDTH - 1] = u[1];
data_[kWIDTH - 2] = u[0];
data_[kWIDTH - 1] = u[1];
return *this;
}
base_uint&
operator^=(base_uint const& b)
BaseUint&
operator^=(BaseUint const& b)
{
for (int i = 0; i < WIDTH; i++)
for (int i = 0; i < kWIDTH; i++)
data_[i] ^= b.data_[i];
return *this;
}
base_uint&
operator&=(base_uint const& b)
BaseUint&
operator&=(BaseUint const& b)
{
for (int i = 0; i < WIDTH; i++)
for (int i = 0; i < kWIDTH; i++)
data_[i] &= b.data_[i];
return *this;
}
base_uint&
operator|=(base_uint const& b)
BaseUint&
operator|=(BaseUint const& b)
{
for (int i = 0; i < WIDTH; i++)
for (int i = 0; i < kWIDTH; i++)
data_[i] |= b.data_[i];
return *this;
}
base_uint&
BaseUint&
operator++()
{
// prefix operator
for (int i = WIDTH - 1; i >= 0; --i)
for (int i = kWIDTH - 1; i >= 0; --i)
{
data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) + 1);
if (data_[i] != 0)
@@ -398,20 +398,20 @@ public:
return *this;
}
base_uint
BaseUint
operator++(int)
{
// postfix operator
base_uint const ret = *this;
BaseUint const ret = *this;
++(*this);
return ret;
}
base_uint&
BaseUint&
operator--()
{
for (int i = WIDTH - 1; i >= 0; --i)
for (int i = kWIDTH - 1; i >= 0; --i)
{
auto prev = data_[i];
data_[i] = boost::endian::native_to_big(boost::endian::big_to_native(data_[i]) - 1);
@@ -423,36 +423,36 @@ public:
return *this;
}
base_uint
BaseUint
operator--(int)
{
// postfix operator
base_uint const ret = *this;
BaseUint const ret = *this;
--(*this);
return ret;
}
[[nodiscard]] base_uint
[[nodiscard]] BaseUint
next() const
{
auto ret = *this;
return ++ret;
}
[[nodiscard]] base_uint
[[nodiscard]] BaseUint
prev() const
{
auto ret = *this;
return --ret;
}
base_uint&
operator+=(base_uint const& b)
BaseUint&
operator+=(BaseUint const& b)
{
std::uint64_t carry = 0;
for (int i = WIDTH - 1; i >= 0; i--)
for (int i = kWIDTH - 1; i >= 0; i--)
{
std::uint64_t const n = carry + boost::endian::big_to_native(data_[i]) +
boost::endian::big_to_native(b.data_[i]);
@@ -466,7 +466,7 @@ public:
template <class Hasher>
friend void
hash_append(Hasher& h, base_uint const& a) noexcept
hash_append(Hasher& h, BaseUint const& a) noexcept
{
// Do not allow any endian transformations on this memory
h(a.data_.data(), sizeof(a.data_));
@@ -506,10 +506,10 @@ public:
constexpr static std::size_t
size()
{
return bytes;
return kBYTES;
}
base_uint<Bits, Tag>&
BaseUint<Bits, Tag>&
operator=(beast::Zero)
{
data_.fill(0);
@@ -520,28 +520,28 @@ public:
[[nodiscard]] bool
isZero() const
{
return *this == beast::zero;
return *this == beast::kZERO;
}
[[nodiscard]] bool
isNonZero() const
{
return *this != beast::zero;
return *this != beast::kZERO;
}
void
zero()
{
*this = beast::zero;
*this = beast::kZERO;
}
};
using uint128 = base_uint<128>;
using uint160 = base_uint<160>;
using uint256 = base_uint<256>;
using uint192 = base_uint<192>;
using uint128 = BaseUint<128>;
using uint160 = BaseUint<160>;
using uint256 = BaseUint<256>;
using uint192 = BaseUint<192>;
template <std::size_t Bits, class Tag>
[[nodiscard]] constexpr std::strong_ordering
operator<=>(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
operator<=>(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
{
// This comparison might seem wrong on a casual inspection because it
// compares data internally stored as std::uint32_t byte-by-byte. But
@@ -562,7 +562,7 @@ operator<=>(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
template <std::size_t Bits, typename Tag>
[[nodiscard]] constexpr bool
operator==(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
operator==(BaseUint<Bits, Tag> const& lhs, BaseUint<Bits, Tag> const& rhs)
{
return (lhs <=> rhs) == 0;
}
@@ -570,59 +570,59 @@ operator==(base_uint<Bits, Tag> const& lhs, base_uint<Bits, Tag> const& rhs)
//------------------------------------------------------------------------------
template <std::size_t Bits, class Tag>
constexpr bool
operator==(base_uint<Bits, Tag> const& a, std::uint64_t b)
operator==(BaseUint<Bits, Tag> const& a, std::uint64_t b)
{
return a == base_uint<Bits, Tag>(b);
return a == BaseUint<Bits, Tag>(b);
}
//------------------------------------------------------------------------------
template <std::size_t Bits, class Tag>
constexpr base_uint<Bits, Tag>
operator^(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
constexpr BaseUint<Bits, Tag>
operator^(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) ^= b;
return BaseUint<Bits, Tag>(a) ^= b;
}
template <std::size_t Bits, class Tag>
constexpr base_uint<Bits, Tag>
operator&(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
constexpr BaseUint<Bits, Tag>
operator&(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) &= b;
return BaseUint<Bits, Tag>(a) &= b;
}
template <std::size_t Bits, class Tag>
constexpr base_uint<Bits, Tag>
operator|(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
constexpr BaseUint<Bits, Tag>
operator|(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) |= b;
return BaseUint<Bits, Tag>(a) |= b;
}
template <std::size_t Bits, class Tag>
constexpr base_uint<Bits, Tag>
operator+(base_uint<Bits, Tag> const& a, base_uint<Bits, Tag> const& b)
constexpr BaseUint<Bits, Tag>
operator+(BaseUint<Bits, Tag> const& a, BaseUint<Bits, Tag> const& b)
{
return base_uint<Bits, Tag>(a) += b;
return BaseUint<Bits, Tag>(a) += b;
}
//------------------------------------------------------------------------------
template <std::size_t Bits, class Tag>
inline std::string
to_string(base_uint<Bits, Tag> const& a)
to_string(BaseUint<Bits, Tag> const& a)
{
return strHex(a.cbegin(), a.cend());
}
template <std::size_t Bits, class Tag>
inline std::string
to_short_string(base_uint<Bits, Tag> const& a)
toShortString(BaseUint<Bits, Tag> const& a)
{
static_assert(base_uint<Bits, Tag>::bytes > 4, "For 4 bytes or less, use a native type");
static_assert(BaseUint<Bits, Tag>::kBYTES > 4, "For 4 bytes or less, use a native type");
return strHex(a.cbegin(), a.cbegin() + 4) + "...";
}
template <std::size_t Bits, class Tag>
inline std::ostream&
operator<<(std::ostream& out, base_uint<Bits, Tag> const& u)
operator<<(std::ostream& out, BaseUint<Bits, Tag> const& u)
{
return out << to_string(u);
}
@@ -650,9 +650,9 @@ static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
namespace beast {
template <std::size_t Bits, class Tag>
struct is_uniquely_represented<xrpl::base_uint<Bits, Tag>> : public std::true_type
struct IsUniquelyRepresented<xrpl::BaseUint<Bits, Tag>> : public std::true_type
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
} // namespace beast

22
include/xrpl/basics/chrono.h
View File

@@ -30,10 +30,10 @@ using weeks = std::chrono::duration<int, std::ratio_multiply<days::period, std::
= seconds(946684800)
*/
constexpr static std::chrono::seconds epoch_offset =
constexpr static std::chrono::seconds kEPOCH_OFFSET =
date::sys_days{date::year{2000} / 1 / 1} - date::sys_days{date::year{1970} / 1 / 1};
static_assert(epoch_offset.count() == 946684800);
static_assert(kEPOCH_OFFSET.count() == 946684800);
class NetClock
{
@@ -45,7 +45,7 @@ public:
using duration = std::chrono::duration<rep, period>;
using time_point = std::chrono::time_point<NetClock>;
static bool const is_steady = false;
static bool const is_steady = false; // NOLINT(readability-identifier-naming)
};
template <class Duration>
@@ -60,42 +60,42 @@ to_string(NetClock::time_point tp)
{
// 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC
using namespace std::chrono;
return to_string(system_clock::time_point{tp.time_since_epoch() + epoch_offset});
return to_string(system_clock::time_point{tp.time_since_epoch() + kEPOCH_OFFSET});
}
template <class Duration>
std::string
to_string_iso(date::sys_time<Duration> tp)
toStringIso(date::sys_time<Duration> tp)
{
using namespace std::chrono;
return date::format("%FT%TZ", tp);
}
inline std::string
to_string_iso(NetClock::time_point tp)
toStringIso(NetClock::time_point tp)
{
// 2000-01-01 00:00:00 UTC is 946684800s from 1970-01-01 00:00:00 UTC
// Note, NetClock::duration is seconds, as checked by static_assert
static_assert(std::is_same_v<NetClock::duration::period, std::ratio<1>>);
return to_string_iso(date::sys_time<NetClock::duration>{tp.time_since_epoch() + epoch_offset});
return toStringIso(date::sys_time<NetClock::duration>{tp.time_since_epoch() + kEPOCH_OFFSET});
}
/** A clock for measuring elapsed time.
The epoch is unspecified.
*/
using Stopwatch = beast::abstract_clock<std::chrono::steady_clock>;
using Stopwatch = beast::AbstractClock<std::chrono::steady_clock>;
/** A manual Stopwatch for unit tests. */
using TestStopwatch = beast::manual_clock<std::chrono::steady_clock>;
using TestStopwatch = beast::ManualClock<std::chrono::steady_clock>;
/** Returns an instance of a wall clock. */
inline Stopwatch&
stopwatch()
{
using Clock = beast::basic_seconds_clock;
using Clock = beast::BasicSecondsClock;
using Facade = Clock::Clock;
return beast::get_abstract_clock<Facade, Clock>();
return beast::getAbstractClock<Facade, Clock>();
}
} // namespace xrpl

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

@@ -17,7 +17,7 @@ namespace xrpl {
/** Generates and logs a call stack */
void
LogThrow(std::string const& title);
logThrow(std::string const& title);
/** Rethrow the exception currently being handled.
@@ -30,9 +30,9 @@ LogThrow(std::string const& title);
triggering false positives, since it throws.
*/
[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
Rethrow()
rethrow()
{
LogThrow("Re-throwing exception");
logThrow("Re-throwing exception");
throw;
}
@@ -52,12 +52,12 @@ Throw(Args&&... args)
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());
logThrow(std::string("Throwing exception of type " + beast::typeName<E>() + ": ") + e.what());
throw std::move(e);
}
/** Called when faulty logic causes a broken invariant. */
[[noreturn]] void
LogicError(std::string const& how) noexcept;
logicError(std::string const& how) noexcept;
} // namespace xrpl

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

@@ -16,24 +16,24 @@ using seed_pair = std::pair<std::uint64_t, std::uint64_t>;
template <bool = true>
seed_pair
make_seed_pair() noexcept
makeSeedPair() noexcept
{
struct state_t
struct StateT
{
std::mutex mutex;
std::random_device rng;
std::mt19937_64 gen;
std::uniform_int_distribution<std::uint64_t> dist;
state_t() : gen(rng())
StateT() : gen(rng())
{
}
// state_t(state_t const&) = delete;
// state_t& operator=(state_t const&) = delete;
};
static state_t state;
std::scoped_lock const lock(state.mutex);
return {state.dist(state.gen), state.dist(state.gen)};
static StateT kSTATE;
std::scoped_lock const lock(kSTATE.mutex);
return {kSTATE.dist(kSTATE.gen), kSTATE.dist(kSTATE.gen)};
}
} // namespace detail
@@ -68,22 +68,22 @@ make_seed_pair() noexcept
see https://131002.net/siphash/#at
*/
template <class HashAlgorithm = beast::xxhasher>
class hardened_hash
template <class HashAlgorithm = beast::Xxhasher>
class HardenedHash
{
private:
detail::seed_pair m_seeds{detail::make_seed_pair<>()};
detail::seed_pair seeds_{detail::makeSeedPair<>()};
public:
using result_type = typename HashAlgorithm::result_type;
hardened_hash() = default;
HardenedHash() = default;
template <class T>
result_type
operator()(T const& t) const noexcept
{
HashAlgorithm h(m_seeds.first, m_seeds.second);
HashAlgorithm h(seeds_.first, seeds_.second);
hash_append(h, t);
return static_cast<result_type>(h);
}

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

@@ -8,11 +8,11 @@ namespace xrpl {
/** Create a self-signed SSL context that allows anonymous Diffie Hellman. */
std::shared_ptr<boost::asio::ssl::context>
make_SSLContext(std::string const& cipherList);
makeSslContext(std::string const& cipherList);
/** Create an authenticated SSL context using the specified files. */
std::shared_ptr<boost::asio::ssl::context>
make_SSLContextAuthed(
makeSslContextAuthed(
std::string const& keyFile,
std::string const& certFile,
std::string const& chainFile,

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

@@ -5,7 +5,7 @@
#include <optional>
namespace xrpl {
auto constexpr muldiv_max = std::numeric_limits<std::uint64_t>::max();
auto constexpr kMULDIV_MAX = std::numeric_limits<std::uint64_t>::max();
/** Return value*mul/div accurately.
Computes the result of the multiplication and division in

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

@@ -24,7 +24,7 @@ template <>
inline std::size_t
extract(std::string const& key)
{
return ::beast::uhash<>{}(key);
return ::beast::Uhash<>{}(key);
}
template <
@@ -33,7 +33,7 @@ template <
typename Hash,
typename Pred = std::equal_to<Key>,
typename Alloc = std::allocator<std::pair<Key const, Value>>>
class partitioned_unordered_map
class PartitionedUnorderedMap
{
std::size_t partitions_;
@@ -53,46 +53,46 @@ public:
using map_type = std::unordered_map<key_type, mapped_type, hasher, key_equal, allocator_type>;
using partition_map_type = std::vector<map_type>;
struct iterator
struct Iterator
{
using iterator_category = std::forward_iterator_tag;
partition_map_type* map_{nullptr};
typename partition_map_type::iterator ait_{};
typename map_type::iterator mit_;
partition_map_type* map{nullptr};
typename partition_map_type::iterator ait{};
typename map_type::iterator mit;
iterator() = default;
Iterator() = default;
iterator(partition_map_type* map) : map_(map)
Iterator(partition_map_type* m) : map(m)
{
}
reference
operator*() const
{
return *mit_;
return *mit;
}
pointer
operator->() const
{
return &(*mit_);
return &(*mit);
}
void
inc()
{
++mit_;
while (mit_ == ait_->end())
++mit;
while (mit == ait->end())
{
++ait_;
if (ait_ == map_->end())
++ait;
if (ait == map->end())
return;
mit_ = ait_->begin();
mit = ait->begin();
}
}
// ++it
iterator&
Iterator&
operator++()
{
inc();
@@ -100,75 +100,75 @@ public:
}
// it++
iterator
Iterator
operator++(int)
{
iterator tmp(*this);
Iterator tmp(*this);
inc();
return tmp;
}
friend bool
operator==(iterator const& lhs, iterator const& rhs)
operator==(Iterator const& lhs, Iterator const& rhs)
{
return lhs.map_ == rhs.map_ && lhs.ait_ == rhs.ait_ && lhs.mit_ == rhs.mit_;
return lhs.map == rhs.map && lhs.ait == rhs.ait && lhs.mit == rhs.mit;
}
friend bool
operator!=(iterator const& lhs, iterator const& rhs)
operator!=(Iterator const& lhs, Iterator const& rhs)
{
return !(lhs == rhs);
}
};
struct const_iterator
struct ConstIterator
{
using iterator_category = std::forward_iterator_tag;
partition_map_type* map_{nullptr};
typename partition_map_type::iterator ait_{};
typename map_type::iterator mit_;
partition_map_type* map{nullptr};
typename partition_map_type::iterator ait{};
typename map_type::iterator mit;
const_iterator() = default;
ConstIterator() = default;
const_iterator(partition_map_type* map) : map_(map)
ConstIterator(partition_map_type* m) : map(m)
{
}
const_iterator(iterator const& orig)
ConstIterator(Iterator const& orig)
{
map_ = orig.map_;
ait_ = orig.ait_;
mit_ = orig.mit_;
map = orig.map;
ait = orig.ait;
mit = orig.mit;
}
const_reference
operator*() const
{
return *mit_;
return *mit;
}
const_pointer
operator->() const
{
return &(*mit_);
return &(*mit);
}
void
inc()
{
++mit_;
while (mit_ == ait_->end())
++mit;
while (mit == ait->end())
{
++ait_;
if (ait_ == map_->end())
++ait;
if (ait == map->end())
return;
mit_ = ait_->begin();
mit = ait->begin();
}
}
// ++it
const_iterator&
ConstIterator&
operator++()
{
inc();
@@ -176,22 +176,22 @@ public:
}
// it++
const_iterator
ConstIterator
operator++(int)
{
const_iterator tmp(*this);
ConstIterator tmp(*this);
inc();
return tmp;
}
friend bool
operator==(const_iterator const& lhs, const_iterator const& rhs)
operator==(ConstIterator const& lhs, ConstIterator const& rhs)
{
return lhs.map_ == rhs.map_ && lhs.ait_ == rhs.ait_ && lhs.mit_ == rhs.mit_;
return lhs.map == rhs.map && lhs.ait == rhs.ait && lhs.mit == rhs.mit;
}
friend bool
operator!=(const_iterator const& lhs, const_iterator const& rhs)
operator!=(ConstIterator const& lhs, ConstIterator const& rhs)
{
return !(lhs == rhs);
}
@@ -208,26 +208,26 @@ private:
static void
end(T& it)
{
it.ait_ = it.map_->end();
it.mit_ = it.map_->back().end();
it.ait = it.map->end();
it.mit = it.map->back().end();
}
template <class T>
static void
begin(T& it)
{
for (it.ait_ = it.map_->begin(); it.ait_ != it.map_->end(); ++it.ait_)
for (it.ait = it.map->begin(); it.ait != it.map->end(); ++it.ait)
{
if (it.ait_->begin() == it.ait_->end())
if (it.ait->begin() == it.ait->end())
continue;
it.mit_ = it.ait_->begin();
it.mit = it.ait->begin();
return;
}
end(it);
}
public:
partitioned_unordered_map(std::optional<std::size_t> partitions = std::nullopt)
PartitionedUnorderedMap(std::optional<std::size_t> partitions = std::nullopt)
{
// Set partitions to the number of hardware threads if the parameter
// is either empty or set to 0.
@@ -252,45 +252,45 @@ public:
return map_;
}
iterator
Iterator
begin()
{
iterator it(&map_);
Iterator it(&map_);
begin(it);
return it;
}
const_iterator
ConstIterator
cbegin() const
{
const_iterator it(&map_);
ConstIterator it(&map_);
begin(it);
return it;
}
const_iterator
ConstIterator
begin() const
{
return cbegin();
}
iterator
Iterator
end()
{
iterator it(&map_);
Iterator it(&map_);
end(it);
return it;
}
const_iterator
ConstIterator
cend() const
{
const_iterator it(&map_);
ConstIterator it(&map_);
end(it);
return it;
}
const_iterator
ConstIterator
end() const
{
return cend();
@@ -301,50 +301,50 @@ private:
void
find(key_type const& key, T& it) const
{
it.ait_ = it.map_->begin() + partitioner(key);
it.mit_ = it.ait_->find(key);
if (it.mit_ == it.ait_->end())
it.ait = it.map->begin() + partitioner(key);
it.mit = it.ait->find(key);
if (it.mit == it.ait->end())
end(it);
}
public:
iterator
Iterator
find(key_type const& key)
{
iterator it(&map_);
Iterator it(&map_);
find(key, it);
return it;
}
const_iterator
ConstIterator
find(key_type const& key) const
{
const_iterator it(&map_);
ConstIterator it(&map_);
find(key, it);
return it;
}
template <class T, class U>
std::pair<iterator, bool>
std::pair<Iterator, bool>
emplace(std::piecewise_construct_t const&, T&& keyTuple, U&& valueTuple)
{
auto const& key = std::get<0>(keyTuple);
iterator it(&map_);
it.ait_ = it.map_->begin() + partitioner(key);
auto [eit, inserted] = it.ait_->emplace(
Iterator it(&map_);
it.ait = it.map->begin() + partitioner(key);
auto [eit, inserted] = it.ait->emplace(
std::piecewise_construct, std::forward<T>(keyTuple), std::forward<U>(valueTuple));
it.mit_ = eit;
it.mit = eit;
return {it, inserted};
}
template <class T, class U>
std::pair<iterator, bool>
std::pair<Iterator, bool>
emplace(T&& key, U&& val)
{
iterator it(&map_);
it.ait_ = it.map_->begin() + partitioner(key);
auto [eit, inserted] = it.ait_->emplace(std::forward<T>(key), std::forward<U>(val));
it.mit_ = eit;
Iterator it(&map_);
it.ait = it.map->begin() + partitioner(key);
auto [eit, inserted] = it.ait->emplace(std::forward<T>(key), std::forward<U>(val));
it.mit = eit;
return {it, inserted};
}
@@ -355,19 +355,19 @@ public:
p.clear();
}
iterator
erase(const_iterator position)
Iterator
erase(ConstIterator position)
{
iterator it(&map_);
it.ait_ = position.ait_;
it.mit_ = position.ait_->erase(position.mit_);
Iterator it(&map_);
it.ait = position.ait;
it.mit = position.ait->erase(position.mit);
while (it.mit_ == it.ait_->end())
while (it.mit == it.ait->end())
{
++it.ait_;
if (it.ait_ == it.map_->end())
++it.ait;
if (it.ait == it.map->end())
break;
it.mit_ = it.ait_->begin();
it.mit = it.ait->begin();
}
return it;

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

@@ -44,30 +44,30 @@ using is_engine = std::is_invocable_r<Result, Engine>;
will be randomly seeded.
*/
inline beast::xor_shift_engine&
default_prng()
defaultPrng()
{
// This is used to seed the thread-specific PRNGs on demand
static beast::xor_shift_engine seeder = [] {
static beast::xor_shift_engine kSEEDER = [] {
std::random_device rng;
std::uniform_int_distribution<std::uint64_t> distribution{1};
return beast::xor_shift_engine(distribution(rng));
}();
// This protects the seeder
static std::mutex m;
static std::mutex kM;
// The thread-specific PRNGs:
thread_local beast::xor_shift_engine engine = [] {
thread_local beast::xor_shift_engine kENGINE = [] {
std::uint64_t seed = 0;
{
std::scoped_lock const lk(m);
std::scoped_lock const lk(kM);
std::uniform_int_distribution<std::uint64_t> distribution{1};
seed = distribution(seeder);
seed = distribution(kSEEDER);
}
return beast::xor_shift_engine{seed};
}();
return engine;
return kENGINE;
}
/** Return a uniformly distributed random integer.
@@ -92,7 +92,7 @@ default_prng()
/** @{ */
template <class Engine, class Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine, Integral min, Integral max)
randInt(Engine& engine, Integral min, Integral max)
{
XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
@@ -104,37 +104,37 @@ rand_int(Engine& engine, Integral min, Integral max)
template <class Integral>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
rand_int(Integral min, Integral max)
randInt(Integral min, Integral max)
{
return rand_int(default_prng(), min, max);
return randInt(defaultPrng(), min, max);
}
template <class Engine, class Integral>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine, Integral max)
randInt(Engine& engine, Integral max)
{
return rand_int(engine, Integral(0), max);
return randInt(engine, Integral(0), max);
}
template <class Integral>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
rand_int(Integral max)
randInt(Integral max)
{
return rand_int(default_prng(), max);
return randInt(defaultPrng(), max);
}
template <class Integral, class Engine>
std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine)
randInt(Engine& engine)
{
return rand_int(engine, std::numeric_limits<Integral>::max());
return randInt(engine, std::numeric_limits<Integral>::max());
}
template <class Integral = int>
std::enable_if_t<std::is_integral_v<Integral>, Integral>
rand_int()
randInt()
{
return rand_int(default_prng(), std::numeric_limits<Integral>::max());
return randInt(defaultPrng(), std::numeric_limits<Integral>::max());
}
/** @} */
@@ -145,17 +145,17 @@ std::enable_if_t<
(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
detail::is_engine<Engine>::value,
Byte>
rand_byte(Engine& engine)
randByte(Engine& engine)
{
return static_cast<Byte>(rand_int<Engine, std::uint32_t>(
return static_cast<Byte>(randInt<Engine, std::uint32_t>(
engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
}
template <class Byte = std::uint8_t>
std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
rand_byte()
randByte()
{
return rand_byte<Byte>(default_prng());
return randByte<Byte>(defaultPrng());
}
/** @} */
@@ -163,15 +163,15 @@ rand_byte()
/** @{ */
template <class Engine>
inline bool
rand_bool(Engine& engine)
randBool(Engine& engine)
{
return rand_int(engine, 1) == 1;
return randInt(engine, 1) == 1;
}
inline bool
rand_bool()
randBool()
{
return rand_bool(default_prng());
return randBool(defaultPrng());
}
/** @} */

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

@@ -18,29 +18,29 @@ concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
safe_cast(Src s) noexcept
safeCast(Src s) noexcept
{
static_assert(
std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
constexpr unsigned not_same = std::is_signed_v<Dest> != std::is_signed_v<Src>;
constexpr unsigned kNOT_SAME = std::is_signed_v<Dest> != std::is_signed_v<Src>;
static_assert(
sizeof(Dest) >= sizeof(Src) + not_same,
sizeof(Dest) >= sizeof(Src) + kNOT_SAME,
"Destination is too small to hold all values of source");
return static_cast<Dest>(s);
}
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
safe_cast(Src s) noexcept
safeCast(Src s) noexcept
{
return static_cast<Dest>(safe_cast<std::underlying_type_t<Dest>>(s));
return static_cast<Dest>(safeCast<std::underlying_type_t<Dest>>(s));
}
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
safe_cast(Src s) noexcept
safeCast(Src s) noexcept
{
return safe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
return safeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
}
// unsafe_cast explicitly flags a static_cast as not necessarily able to hold
@@ -49,7 +49,7 @@ safe_cast(Src s) noexcept
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
unsafe_cast(Src s) noexcept
unsafeCast(Src s) noexcept
{
static_assert(
!SafeToCast<Src, Dest>,
@@ -60,22 +60,22 @@ unsafe_cast(Src s) noexcept
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
unsafe_cast(Src s) noexcept
unsafeCast(Src s) noexcept
{
return static_cast<Dest>(unsafe_cast<std::underlying_type_t<Dest>>(s));
return static_cast<Dest>(unsafeCast<std::underlying_type_t<Dest>>(s));
}
template <class Dest, class Src>
constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
unsafe_cast(Src s) noexcept
unsafeCast(Src s) noexcept
{
return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
return unsafeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
}
template <class Dest, class Src>
requires std::is_pointer_v<Dest>
inline Dest
safe_downcast(Src* s) noexcept
safeDowncast(Src* s) noexcept
{
#ifdef NDEBUG
return static_cast<Dest>(s); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
@@ -89,7 +89,7 @@ safe_downcast(Src* s) noexcept
template <class Dest, class Src>
requires std::is_lvalue_reference_v<Dest>
inline Dest
safe_downcast(Src& s) noexcept
safeDowncast(Src& s) noexcept
{
#ifndef NDEBUG
XRPL_ASSERT(

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

@@ -22,19 +22,19 @@ namespace xrpl {
// to enforce this restriction.
template <class EF>
class scope_exit
class ScopeExit
{
EF exit_function_;
bool execute_on_destruction_{true};
public:
~scope_exit()
~ScopeExit()
{
if (execute_on_destruction_)
exit_function_();
}
scope_exit(scope_exit&& rhs) noexcept(
ScopeExit(ScopeExit&& rhs) noexcept(
std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
: exit_function_{std::forward<EF>(rhs.exit_function_)}
, execute_on_destruction_{rhs.execute_on_destruction_}
@@ -42,14 +42,14 @@ public:
rhs.release();
}
scope_exit&
operator=(scope_exit&&) = delete;
ScopeExit&
operator=(ScopeExit&&) = delete;
template <class EFP>
explicit scope_exit(
explicit ScopeExit(
EFP&& f,
std::enable_if_t<
!std::is_same_v<std::remove_cv_t<EFP>, scope_exit> &&
!std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> &&
std::is_constructible_v<EF, EFP>>* = 0) noexcept
: exit_function_{std::forward<EFP>(f)}
{
@@ -64,23 +64,23 @@ public:
};
template <class EF>
scope_exit(EF) -> scope_exit<EF>;
ScopeExit(EF) -> ScopeExit<EF>;
template <class EF>
class scope_fail
class ScopeFail
{
EF exit_function_;
bool execute_on_destruction_{true};
int uncaught_on_creation_{std::uncaught_exceptions()};
public:
~scope_fail()
~ScopeFail()
{
if (execute_on_destruction_ && std::uncaught_exceptions() > uncaught_on_creation_)
exit_function_();
}
scope_fail(scope_fail&& rhs) noexcept(
ScopeFail(ScopeFail&& rhs) noexcept(
std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
: exit_function_{std::forward<EF>(rhs.exit_function_)}
, execute_on_destruction_{rhs.execute_on_destruction_}
@@ -89,14 +89,14 @@ public:
rhs.release();
}
scope_fail&
operator=(scope_fail&&) = delete;
ScopeFail&
operator=(ScopeFail&&) = delete;
template <class EFP>
explicit scope_fail(
explicit ScopeFail(
EFP&& f,
std::enable_if_t<
!std::is_same_v<std::remove_cv_t<EFP>, scope_fail> &&
!std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> &&
std::is_constructible_v<EF, EFP>>* = 0) noexcept
: exit_function_{std::forward<EFP>(f)}
{
@@ -111,23 +111,23 @@ public:
};
template <class EF>
scope_fail(EF) -> scope_fail<EF>;
ScopeFail(EF) -> ScopeFail<EF>;
template <class EF>
class scope_success
class ScopeSuccess
{
EF exit_function_;
bool execute_on_destruction_{true};
int uncaught_on_creation_{std::uncaught_exceptions()};
public:
~scope_success() noexcept(noexcept(exit_function_()))
~ScopeSuccess() noexcept(noexcept(exit_function_()))
{
if (execute_on_destruction_ && std::uncaught_exceptions() <= uncaught_on_creation_)
exit_function_();
}
scope_success(scope_success&& rhs) noexcept(
ScopeSuccess(ScopeSuccess&& rhs) noexcept(
std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
: exit_function_{std::forward<EF>(rhs.exit_function_)}
, execute_on_destruction_{rhs.execute_on_destruction_}
@@ -136,14 +136,14 @@ public:
rhs.release();
}
scope_success&
operator=(scope_success&&) = delete;
ScopeSuccess&
operator=(ScopeSuccess&&) = delete;
template <class EFP>
explicit scope_success(
explicit ScopeSuccess(
EFP&& f,
std::enable_if_t<
!std::is_same_v<std::remove_cv_t<EFP>, scope_success> &&
!std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
std::is_constructible_v<EF, EFP>>* =
0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
: exit_function_{std::forward<EFP>(f)}
@@ -158,7 +158,7 @@ public:
};
template <class EF>
scope_success(EF) -> scope_success<EF>;
ScopeSuccess(EF) -> ScopeSuccess<EF>;
/**
Automatically unlocks and re-locks a unique_lock object.
@@ -198,29 +198,29 @@ scope_success(EF) -> scope_success<EF>;
*/
template <class Mutex>
class scope_unlock
class ScopeUnlock
{
std::unique_lock<Mutex>* plock;
std::unique_lock<Mutex>* plock_;
public:
explicit scope_unlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock(&lock)
explicit ScopeUnlock(std::unique_lock<Mutex>& lock) noexcept(true) : plock_(&lock)
{
XRPL_ASSERT(plock->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked");
plock->unlock();
XRPL_ASSERT(plock_->owns_lock(), "xrpl::scope_unlock::scope_unlock : mutex must be locked");
plock_->unlock();
}
// Immovable type
scope_unlock(scope_unlock const&) = delete;
scope_unlock&
operator=(scope_unlock const&) = delete;
ScopeUnlock(ScopeUnlock const&) = delete;
ScopeUnlock&
operator=(ScopeUnlock const&) = delete;
~scope_unlock() noexcept(true)
~ScopeUnlock() noexcept(true)
{
plock->lock();
plock_->lock();
}
};
template <class Mutex>
scope_unlock(std::unique_lock<Mutex>&) -> scope_unlock<Mutex>;
ScopeUnlock(std::unique_lock<Mutex>&) -> ScopeUnlock<Mutex>;
} // namespace xrpl

31
include/xrpl/basics/spinlock.h
View File

@@ -26,7 +26,7 @@ namespace detail {
specific amount of time, to prevent this.
*/
inline void
spin_pause() noexcept
spinPause() noexcept
{
#ifdef __aarch64__
asm volatile("yield");
@@ -71,7 +71,7 @@ spin_pause() noexcept
https://en.cppreference.com/w/cpp/named_req/Lockable
*/
template <class T>
class packed_spinlock
class PackedSpinlock
{
// clang-format off
static_assert(std::is_unsigned_v<T>);
@@ -87,9 +87,9 @@ private:
T const mask_;
public:
packed_spinlock(packed_spinlock const&) = delete;
packed_spinlock&
operator=(packed_spinlock const&) = delete;
PackedSpinlock(PackedSpinlock const&) = delete;
PackedSpinlock&
operator=(PackedSpinlock const&) = delete;
/** A single spinlock packed inside the specified atomic
@@ -99,8 +99,7 @@ public:
@note For performance reasons, you should strive to have `lock` be
on a cacheline by itself.
*/
packed_spinlock(std::atomic<T>& lock, int index)
: bits_(lock), mask_(static_cast<T>(1) << index)
PackedSpinlock(std::atomic<T>& lock, int index) : bits_(lock), mask_(static_cast<T>(1) << index)
{
XRPL_ASSERT(
index >= 0 && (mask_ != 0),
@@ -108,7 +107,7 @@ public:
}
[[nodiscard]] bool
try_lock()
try_lock() // NOLINT(readability-identifier-naming)
{
return (bits_.fetch_or(mask_, std::memory_order_acquire) & mask_) == 0;
}
@@ -123,7 +122,7 @@ public:
// of contention by avoiding writes that would definitely not
// result in the lock being acquired.
while ((bits_.load(std::memory_order_relaxed) & mask_) != 0)
detail::spin_pause();
detail::spinPause();
}
}
@@ -147,7 +146,7 @@ public:
https://en.cppreference.com/w/cpp/named_req/Lockable
*/
template <class T>
class spinlock
class Spinlock
{
static_assert(std::is_unsigned_v<T>);
static_assert(std::atomic<T>::is_always_lock_free);
@@ -156,9 +155,9 @@ private:
std::atomic<T>& lock_;
public:
spinlock(spinlock const&) = delete;
spinlock&
operator=(spinlock const&) = delete;
Spinlock(Spinlock const&) = delete;
Spinlock&
operator=(Spinlock const&) = delete;
/** Grabs the
@@ -167,12 +166,12 @@ public:
@note For performance reasons, you should strive to have `lock` be
on a cacheline by itself.
*/
spinlock(std::atomic<T>& lock) : lock_(lock)
Spinlock(std::atomic<T>& lock) : lock_(lock)
{
}
[[nodiscard]] bool
try_lock()
try_lock() // NOLINT(readability-identifier-naming)
{
T expected = 0;
@@ -193,7 +192,7 @@ public:
// of contention by avoiding writes that would definitely not
// result in the lock being acquired.
while (lock_.load(std::memory_order_relaxed) != 0)
detail::spin_pause();
detail::spinPause();
}
}

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

@@ -23,171 +23,171 @@ namespace xrpl {
allowed arithmetic operations.
*/
template <class Int, class Tag>
class tagged_integer : boost::totally_ordered<
tagged_integer<Int, Tag>,
boost::integer_arithmetic<
tagged_integer<Int, Tag>,
boost::bitwise<
tagged_integer<Int, Tag>,
boost::unit_steppable<
tagged_integer<Int, Tag>,
boost::shiftable<tagged_integer<Int, Tag>>>>>>
class TaggedInteger : boost::totally_ordered<
TaggedInteger<Int, Tag>,
boost::integer_arithmetic<
TaggedInteger<Int, Tag>,
boost::bitwise<
TaggedInteger<Int, Tag>,
boost::unit_steppable<
TaggedInteger<Int, Tag>,
boost::shiftable<TaggedInteger<Int, Tag>>>>>>
{
private:
Int m_value;
Int value_;
public:
using value_type = Int;
using tag_type = Tag;
tagged_integer() = default;
TaggedInteger() = default;
template <
class OtherInt,
class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
explicit constexpr tagged_integer(OtherInt value) noexcept : m_value(value)
explicit constexpr TaggedInteger(OtherInt value) noexcept : value_(value)
{
static_assert(sizeof(tagged_integer) == sizeof(Int), "tagged_integer is adding padding");
static_assert(sizeof(TaggedInteger) == sizeof(Int), "tagged_integer is adding padding");
}
bool
operator<(tagged_integer const& rhs) const noexcept
operator<(TaggedInteger const& rhs) const noexcept
{
return m_value < rhs.m_value;
return value_ < rhs.value_;
}
bool
operator==(tagged_integer const& rhs) const noexcept
operator==(TaggedInteger const& rhs) const noexcept
{
return m_value == rhs.m_value;
return value_ == rhs.value_;
}
tagged_integer&
operator+=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator+=(TaggedInteger const& rhs) noexcept
{
m_value += rhs.m_value;
value_ += rhs.value_;
return *this;
}
tagged_integer&
operator-=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator-=(TaggedInteger const& rhs) noexcept
{
m_value -= rhs.m_value;
value_ -= rhs.value_;
return *this;
}
tagged_integer&
operator*=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator*=(TaggedInteger const& rhs) noexcept
{
m_value *= rhs.m_value;
value_ *= rhs.value_;
return *this;
}
tagged_integer&
operator/=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator/=(TaggedInteger const& rhs) noexcept
{
m_value /= rhs.m_value;
value_ /= rhs.value_;
return *this;
}
tagged_integer&
operator%=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator%=(TaggedInteger const& rhs) noexcept
{
m_value %= rhs.m_value;
value_ %= rhs.value_;
return *this;
}
tagged_integer&
operator|=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator|=(TaggedInteger const& rhs) noexcept
{
m_value |= rhs.m_value;
value_ |= rhs.value_;
return *this;
}
tagged_integer&
operator&=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator&=(TaggedInteger const& rhs) noexcept
{
m_value &= rhs.m_value;
value_ &= rhs.value_;
return *this;
}
tagged_integer&
operator^=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator^=(TaggedInteger const& rhs) noexcept
{
m_value ^= rhs.m_value;
value_ ^= rhs.value_;
return *this;
}
tagged_integer&
operator<<=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator<<=(TaggedInteger const& rhs) noexcept
{
m_value <<= rhs.m_value;
value_ <<= rhs.value_;
return *this;
}
tagged_integer&
operator>>=(tagged_integer const& rhs) noexcept
TaggedInteger&
operator>>=(TaggedInteger const& rhs) noexcept
{
m_value >>= rhs.m_value;
value_ >>= rhs.value_;
return *this;
}
tagged_integer
TaggedInteger
operator~() const noexcept
{
return tagged_integer{~m_value};
return TaggedInteger{~value_};
}
tagged_integer
TaggedInteger
operator+() const noexcept
{
return *this;
}
tagged_integer
TaggedInteger
operator-() const noexcept
{
return tagged_integer{-m_value};
return TaggedInteger{-value_};
}
tagged_integer&
TaggedInteger&
operator++() noexcept
{
++m_value;
++value_;
return *this;
}
tagged_integer&
TaggedInteger&
operator--() noexcept
{
--m_value;
--value_;
return *this;
}
explicit
operator Int() const noexcept
{
return m_value;
return value_;
}
friend std::ostream&
operator<<(std::ostream& s, tagged_integer const& t)
operator<<(std::ostream& s, TaggedInteger const& t)
{
s << t.m_value;
s << t.value_;
return s;
}
friend std::istream&
operator>>(std::istream& s, tagged_integer& t)
operator>>(std::istream& s, TaggedInteger& t)
{
s >> t.m_value;
s >> t.value_;
return s;
}
friend std::string
to_string(tagged_integer const& t)
to_string(TaggedInteger const& t)
{
return std::to_string(t.m_value);
return std::to_string(t.value_);
}
};
@@ -195,10 +195,10 @@ public:
namespace beast {
template <class Int, class Tag, class HashAlgorithm>
struct is_contiguously_hashable<xrpl::tagged_integer<Int, Tag>, HashAlgorithm>
: public is_contiguously_hashable<Int, HashAlgorithm>
struct IsContiguouslyHashable<xrpl::TaggedInteger<Int, Tag>, HashAlgorithm>
: public IsContiguouslyHashable<Int, HashAlgorithm>
{
explicit is_contiguously_hashable() = default;
explicit IsContiguouslyHashable() = default;
};
} // namespace beast

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

@@ -15,44 +15,44 @@ namespace beast {
/** Measures handler latency on an io_context queue. */
template <class Clock>
class io_latency_probe
class IoLatencyProbe
{
private:
using duration = typename Clock::duration;
using time_point = typename Clock::time_point;
std::recursive_mutex m_mutex;
std::condition_variable_any m_cond;
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{false};
std::recursive_mutex mutex_;
std::condition_variable_any cond_;
std::size_t count_{1};
duration const period_;
boost::asio::io_context& ios_;
boost::asio::basic_waitable_timer<std::chrono::steady_clock> timer_;
bool cancel_{false};
public:
io_latency_probe(duration const& period, boost::asio::io_context& ios)
: m_period(period), m_ios(ios), m_timer(m_ios)
IoLatencyProbe(duration const& period, boost::asio::io_context& ios)
: period_(period), ios_(ios), timer_(ios_)
{
}
~io_latency_probe()
~IoLatencyProbe()
{
std::unique_lock<decltype(m_mutex)> lock(m_mutex);
std::unique_lock<decltype(mutex_)> lock(mutex_);
cancel(lock, true);
}
/** Return the io_context associated with the latency probe. */
/** @{ */
boost::asio::io_context&
get_io_context()
getIoContext()
{
return m_ios;
return ios_;
}
[[nodiscard]] boost::asio::io_context const&
get_io_context() const
getIoContext() const
{
return m_ios;
return ios_;
}
/** @} */
@@ -63,14 +63,14 @@ public:
void
cancel()
{
std::unique_lock<decltype(m_mutex)> lock(m_mutex);
std::unique_lock<decltype(mutex_)> lock(mutex_);
cancel(lock, true);
}
void
cancel_async()
cancelAsync()
{
std::unique_lock<decltype(m_mutex)> lock(m_mutex);
std::unique_lock<decltype(mutex_)> lock(mutex_);
cancel(lock, false);
}
/** @} */
@@ -81,13 +81,13 @@ public:
*/
template <class Handler>
void
sample_one(Handler&& handler)
sampleOne(Handler&& handler)
{
std::scoped_lock const lock(m_mutex);
if (m_cancel)
std::scoped_lock const lock(mutex_);
if (cancel_)
throw std::logic_error("io_latency_probe is canceled");
boost::asio::post(
m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
}
/** Initiate continuous i/o latency sampling.
@@ -98,125 +98,123 @@ public:
void
sample(Handler&& handler)
{
std::scoped_lock const lock(m_mutex);
if (m_cancel)
std::scoped_lock const lock(mutex_);
if (cancel_)
throw std::logic_error("io_latency_probe is canceled");
boost::asio::post(
m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
ios_, SampleOp<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
}
private:
void
cancel(std::unique_lock<decltype(m_mutex)>& lock, bool wait)
cancel(std::unique_lock<decltype(mutex_)>& lock, bool wait)
{
if (!m_cancel)
if (!cancel_)
{
--m_count;
m_cancel = true;
--count_;
cancel_ = true;
}
if (wait)
m_cond.wait(lock, [this] { return this->m_count == 0; });
cond_.wait(lock, [this] { return this->count_ == 0; });
}
void
addref()
{
std::scoped_lock const lock(m_mutex);
++m_count;
std::scoped_lock const lock(mutex_);
++count_;
}
void
release()
{
std::scoped_lock const lock(m_mutex);
if (--m_count == 0)
m_cond.notify_all();
std::scoped_lock const lock(mutex_);
if (--count_ == 0)
cond_.notify_all();
}
template <class Handler>
struct sample_op
struct SampleOp
{
Handler m_handler;
time_point m_start;
bool m_repeat;
io_latency_probe* m_probe;
Handler handler;
time_point start;
bool repeat;
IoLatencyProbe* probe;
sample_op(
SampleOp(
Handler const& handler,
time_point const& start,
bool repeat,
io_latency_probe* probe)
: m_handler(handler), m_start(start), m_repeat(repeat), m_probe(probe)
IoLatencyProbe* probe)
: handler(handler), start(start), repeat(repeat), probe(probe)
{
XRPL_ASSERT(
m_probe,
probe,
"beast::io_latency_probe::sample_op::sample_op : non-null "
"probe input");
m_probe->addref();
probe->addref();
}
sample_op(sample_op&& from) noexcept
: m_handler(std::move(from.m_handler))
, m_start(from.m_start)
, m_repeat(from.m_repeat)
, m_probe(from.m_probe)
SampleOp(SampleOp&& from) noexcept
: handler(std::move(from.handler))
, start(from.start)
, repeat(from.repeat)
, probe(from.probe)
{
XRPL_ASSERT(
m_probe,
probe,
"beast::io_latency_probe::sample_op::sample_op(sample_op&&) : "
"non-null probe input");
from.m_probe = nullptr;
from.probe = nullptr;
}
sample_op(sample_op const&) = delete;
sample_op
operator=(sample_op const&) = delete;
sample_op&
operator=(sample_op&&) = delete;
SampleOp(SampleOp const&) = delete;
SampleOp
operator=(SampleOp const&) = delete;
SampleOp&
operator=(SampleOp&&) = delete;
~sample_op()
~SampleOp()
{
if (m_probe)
m_probe->release();
if (probe)
probe->release();
}
void
operator()() const
{
if (m_probe == nullptr)
if (probe == nullptr)
return;
typename Clock::time_point const now(Clock::now());
typename Clock::duration const elapsed(now - m_start);
typename Clock::duration const elapsed(now - start);
m_handler(elapsed);
handler(elapsed);
{
std::scoped_lock const lock(m_probe->m_mutex);
if (m_probe->m_cancel)
std::scoped_lock const lock(probe->mutex_);
if (probe->cancel_)
return;
}
if (m_repeat)
if (repeat)
{
// 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 + probe->period_ - (2 * elapsed));
if (when <= now)
{
// The latency is too high to maintain the desired
// period so don't bother with a timer.
//
boost::asio::post(
m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
boost::asio::post(probe->ios_, SampleOp<Handler>(handler, now, repeat, probe));
}
else
{
m_probe->m_timer.expires_after(when - now);
m_probe->m_timer.async_wait(
sample_op<Handler>(m_handler, now, m_repeat, m_probe));
probe->timer_.expires_after(when - now);
probe->timer_.async_wait(SampleOp<Handler>(handler, now, repeat, probe));
}
}
}
@@ -224,11 +222,10 @@ private:
void
operator()(boost::system::error_code const& ec)
{
if (m_probe == nullptr)
if (probe == nullptr)
return;
typename Clock::time_point const now(Clock::now());
boost::asio::post(
m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
boost::asio::post(probe->ios_, SampleOp<Handler>(handler, now, repeat, probe));
}
};
};

26
include/xrpl/beast/clock/abstract_clock.h
View File

@@ -31,7 +31,7 @@ namespace beast {
http://en.cppreference.com/w/cpp/concept/Clock
*/
template <class Clock>
class abstract_clock
class AbstractClock
{
public:
using rep = typename Clock::rep;
@@ -40,11 +40,11 @@ public:
using time_point = typename Clock::time_point;
using clock_type = Clock;
static bool const is_steady = Clock::is_steady;
static bool const is_steady = Clock::is_steady; // NOLINT(readability-identifier-naming)
virtual ~abstract_clock() = default;
abstract_clock() = default;
abstract_clock(abstract_clock const&) = default;
virtual ~AbstractClock() = default;
AbstractClock() = default;
AbstractClock(AbstractClock const&) = default;
/** Returns the current time. */
[[nodiscard]] virtual time_point
@@ -56,12 +56,12 @@ public:
namespace detail {
template <class Facade, class Clock>
struct abstract_clock_wrapper : public abstract_clock<Facade>
struct AbstractClockWrapper : public AbstractClock<Facade>
{
explicit abstract_clock_wrapper() = default;
explicit AbstractClockWrapper() = default;
using typename abstract_clock<Facade>::duration;
using typename abstract_clock<Facade>::time_point;
using typename AbstractClock<Facade>::duration;
using typename AbstractClock<Facade>::time_point;
[[nodiscard]] time_point
now() const override
@@ -80,11 +80,11 @@ struct abstract_clock_wrapper : public abstract_clock<Facade>
@tparam Clock The actual concrete clock to use.
*/
template <class Facade, class Clock = Facade>
abstract_clock<Facade>&
get_abstract_clock()
AbstractClock<Facade>&
getAbstractClock()
{
static detail::abstract_clock_wrapper<Facade, Clock> clock;
return clock;
static detail::AbstractClockWrapper<Facade, Clock> kCLOCK;
return kCLOCK;
}
} // namespace beast

7
include/xrpl/beast/clock/basic_seconds_clock.h
View File

@@ -13,19 +13,20 @@ namespace beast {
@tparam Clock A type meeting these requirements:
http://en.cppreference.com/w/cpp/concept/Clock
*/
class basic_seconds_clock
class BasicSecondsClock
{
public:
using Clock = std::chrono::steady_clock;
explicit basic_seconds_clock() = default;
explicit BasicSecondsClock() = default;
using rep = typename Clock::rep;
using period = typename Clock::period;
using duration = typename Clock::duration;
using time_point = typename Clock::time_point;
static bool const is_steady = Clock::is_steady;
static bool const is_steady = // NOLINT(readability-identifier-naming)
Clock::is_steady;
static time_point
now();

20
include/xrpl/beast/clock/manual_clock.h
View File

@@ -17,18 +17,18 @@ namespace beast {
http://en.cppreference.com/w/cpp/concept/Clock
*/
template <class Clock>
class manual_clock : public abstract_clock<Clock>
class ManualClock : public AbstractClock<Clock>
{
public:
using typename abstract_clock<Clock>::rep;
using typename abstract_clock<Clock>::duration;
using typename abstract_clock<Clock>::time_point;
using typename AbstractClock<Clock>::rep;
using typename AbstractClock<Clock>::duration;
using typename AbstractClock<Clock>::time_point;
private:
time_point now_;
public:
explicit manual_clock(time_point const& now = time_point(duration(0))) : now_(now)
explicit ManualClock(time_point const& now = time_point(duration(0))) : now_(now)
{
}
@@ -44,16 +44,16 @@ public:
{
XRPL_ASSERT(
!Clock::is_steady || when >= now_,
"beast::manual_clock::set(time_point) : forward input");
"beast::ManualClock::set(time_point) : forward input");
now_ = when;
}
/** Convenience for setting the time in seconds from epoch. */
template <class Integer>
void
set(Integer seconds_from_epoch)
set(Integer secondsFromEpoch)
{
set(time_point(duration(std::chrono::seconds(seconds_from_epoch))));
set(time_point(duration(std::chrono::seconds(secondsFromEpoch))));
}
/** Advance the clock by a duration. */
@@ -63,12 +63,12 @@ public:
{
XRPL_ASSERT(
!Clock::is_steady || (now_ + elapsed) >= now_,
"beast::manual_clock::advance(duration) : forward input");
"beast::ManualClock::advance(duration) : forward input");
now_ += elapsed;
}
/** Convenience for advancing the clock by one second. */
manual_clock&
ManualClock&
operator++()
{
advance(std::chrono::seconds(1));

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

@@ -5,9 +5,9 @@
namespace beast {
template <class T>
struct is_aged_container : std::false_type
struct IsAgedContainer : std::false_type
{
explicit is_aged_container() = default;
explicit IsAgedContainer() = default;
};
} // namespace beast

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>
std::enable_if_t<is_aged_container<AgedContainer>::value, std::size_t>
std::enable_if_t<IsAgedContainer<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

@@ -14,6 +14,6 @@ template <
class Clock = std::chrono::steady_clock,
class Compare = std::less<Key>,
class Allocator = std::allocator<std::pair<Key const, T>>>
using aged_map = detail::aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>;
using aged_map = detail::AgedOrderedContainer<false, true, Key, T, Clock, Compare, Allocator>;
} // namespace beast

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

@@ -14,6 +14,6 @@ template <
class Clock = std::chrono::steady_clock,
class Compare = std::less<Key>,
class Allocator = std::allocator<std::pair<Key const, T>>>
using aged_multimap = detail::aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>;
using aged_multimap = detail::AgedOrderedContainer<true, true, Key, T, Clock, Compare, Allocator>;
} // namespace beast

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

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

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

@@ -13,6 +13,6 @@ template <
class Clock = std::chrono::steady_clock,
class Compare = std::less<Key>,
class Allocator = std::allocator<Key>>
using aged_set = detail::aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>;
using aged_set = detail::AgedOrderedContainer<false, false, Key, void, Clock, Compare, Allocator>;
} // namespace beast

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

@@ -16,5 +16,6 @@ template <
class KeyEqual = std::equal_to<Key>,
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>;
detail::AgedUnorderedContainer<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
} // namespace beast

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

@@ -16,5 +16,6 @@ template <
class KeyEqual = std::equal_to<Key>,
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>;
detail::AgedUnorderedContainer<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
} // namespace beast

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

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

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

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

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

@@ -3,10 +3,10 @@
namespace beast::detail {
// Extracts the key portion of value
template <bool maybe_map>
struct aged_associative_container_extract_t
template <bool MaybeMap>
struct AgedAssociativeContainerExtractT
{
explicit aged_associative_container_extract_t() = default;
explicit AgedAssociativeContainerExtractT() = default;
template <class Value>
decltype(Value::first) const&
@@ -17,9 +17,9 @@ struct aged_associative_container_extract_t
};
template <>
struct aged_associative_container_extract_t<false>
struct AgedAssociativeContainerExtractT<false>
{
explicit aged_associative_container_extract_t() = default;
explicit AgedAssociativeContainerExtractT() = default;
template <class Value>
Value const&

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

@@ -12,137 +12,136 @@ class aged_ordered_container;
namespace detail {
// If Iterator is SCARY then this iterator will be as well.
template <bool is_const, class Iterator>
class aged_container_iterator
template <bool IsConst, class Iterator>
class AgedContainerIterator
{
public:
using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
using value_type = std::conditional_t<
is_const,
typename Iterator::value_type::stashed::value_type const,
typename Iterator::value_type::stashed::value_type>;
IsConst,
typename Iterator::value_type::Stashed::value_type const,
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&;
using time_point = typename Iterator::value_type::stashed::time_point;
using time_point = typename Iterator::value_type::Stashed::time_point;
aged_container_iterator() = default;
AgedContainerIterator() = default;
// Disable constructing a const_iterator from a non-const_iterator.
// Converting between reverse and non-reverse iterators should be explicit.
template <
bool other_is_const,
bool OtherIsConst,
class OtherIterator,
class = std::enable_if_t<
(!other_is_const || is_const) &&
(!OtherIsConst || IsConst) &&
!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)
explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
: iter_(other.iter_)
{
}
// Disable constructing a const_iterator from a non-const_iterator.
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)
template <bool OtherIsConst, class = std::enable_if_t<!OtherIsConst || IsConst>>
AgedContainerIterator(AgedContainerIterator<OtherIsConst, Iterator> const& other)
: iter_(other.iter_)
{
}
// Disable assigning a const_iterator to a non-const iterator
template <bool other_is_const, class OtherIterator>
template <bool OtherIsConst, class OtherIterator>
auto
operator=(aged_container_iterator<other_is_const, OtherIterator> const& other)
-> std::enable_if_t<!other_is_const || is_const, aged_container_iterator&>
operator=(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-> std::enable_if_t<!OtherIsConst || IsConst, AgedContainerIterator&>
{
m_iter = other.m_iter;
iter_ = other.iter_;
return *this;
}
template <bool other_is_const, class OtherIterator>
template <bool OtherIsConst, class OtherIterator>
bool
operator==(aged_container_iterator<other_is_const, OtherIterator> const& other) const
operator==(AgedContainerIterator<OtherIsConst, OtherIterator> const& other) const
{
return m_iter == other.m_iter;
return iter_ == other.iter_;
}
template <bool other_is_const, class OtherIterator>
template <bool OtherIsConst, class OtherIterator>
bool
operator!=(aged_container_iterator<other_is_const, OtherIterator> const& other) const
operator!=(AgedContainerIterator<OtherIsConst, OtherIterator> const& other) const
{
return m_iter != other.m_iter;
return iter_ != other.iter_;
}
aged_container_iterator&
AgedContainerIterator&
operator++()
{
++m_iter;
++iter_;
return *this;
}
aged_container_iterator
AgedContainerIterator
operator++(int)
{
aged_container_iterator const prev(*this);
++m_iter;
AgedContainerIterator const prev(*this);
++iter_;
return prev;
}
aged_container_iterator&
AgedContainerIterator&
operator--()
{
--m_iter;
--iter_;
return *this;
}
aged_container_iterator
AgedContainerIterator
operator--(int)
{
aged_container_iterator const prev(*this);
--m_iter;
AgedContainerIterator const prev(*this);
--iter_;
return prev;
}
reference
operator*() const
{
return m_iter->value;
return iter_->value;
}
pointer
operator->() const
{
return &m_iter->value;
return &iter_->value;
}
[[nodiscard]] time_point const&
when() const
{
return m_iter->when;
return iter_->when;
}
private:
template <bool, bool, class, class, class, class, class>
friend class aged_ordered_container;
friend class AgedOrderedContainer;
template <bool, bool, class, class, class, class, class, class>
friend class aged_unordered_container;
friend class AgedUnorderedContainer;
template <bool, class>
friend class aged_container_iterator;
friend class AgedContainerIterator;
template <class OtherIterator>
aged_container_iterator(OtherIterator iter) : m_iter(std::move(iter))
AgedContainerIterator(OtherIterator iter) : iter_(std::move(iter))
{
}
[[nodiscard]] Iterator const&
iterator() const
{
return m_iter;
return iter_;
}
Iterator m_iter;
Iterator iter_;
};
} // namespace detail

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@@ -14,25 +14,25 @@
namespace beast::detail {
template <class T>
struct is_empty_base_optimization_derived
struct IsEmptyBaseOptimizationDerived
: std::integral_constant<bool, std::is_empty_v<T> && !boost::is_final<T>::value>
{
};
template <class T, int UniqueID = 0, bool isDerived = is_empty_base_optimization_derived<T>::value>
class empty_base_optimization : private T
template <class T, int UniqueID = 0, bool IsDerived = IsEmptyBaseOptimizationDerived<T>::value>
class EmptyBaseOptimization : private T
{
public:
empty_base_optimization() = default;
empty_base_optimization(empty_base_optimization&&) = default;
empty_base_optimization(empty_base_optimization const&) = default;
empty_base_optimization&
operator=(empty_base_optimization&&) = default;
empty_base_optimization&
operator=(empty_base_optimization const&) = default;
EmptyBaseOptimization() = default;
EmptyBaseOptimization(EmptyBaseOptimization&&) = default;
EmptyBaseOptimization(EmptyBaseOptimization const&) = default;
EmptyBaseOptimization&
operator=(EmptyBaseOptimization&&) = default;
EmptyBaseOptimization&
operator=(EmptyBaseOptimization const&) = default;
template <class Arg1, class... ArgN>
explicit empty_base_optimization(Arg1&& arg1, ArgN&&... argn)
explicit EmptyBaseOptimization(Arg1&& arg1, ArgN&&... argn)
: T(std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...)
{
}
@@ -53,21 +53,21 @@ public:
//------------------------------------------------------------------------------
template <class T, int UniqueID>
class empty_base_optimization<T, UniqueID, false>
class EmptyBaseOptimization<T, UniqueID, false>
{
T t_;
public:
empty_base_optimization() = default;
empty_base_optimization(empty_base_optimization&&) = default;
empty_base_optimization(empty_base_optimization const&) = default;
empty_base_optimization&
operator=(empty_base_optimization&&) = default;
empty_base_optimization&
operator=(empty_base_optimization const&) = default;
EmptyBaseOptimization() = default;
EmptyBaseOptimization(EmptyBaseOptimization&&) = default;
EmptyBaseOptimization(EmptyBaseOptimization const&) = default;
EmptyBaseOptimization&
operator=(EmptyBaseOptimization&&) = default;
EmptyBaseOptimization&
operator=(EmptyBaseOptimization const&) = default;
template <class Arg1, class... ArgN>
explicit empty_base_optimization(Arg1&& arg1, ArgN&&... argn)
explicit EmptyBaseOptimization(Arg1&& arg1, ArgN&&... argn)
: t_(std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...)
{
}

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

@@ -21,7 +21,7 @@ setCurrentThreadName(std::string_view newThreadName);
// On Linux, thread names are limited to 16 bytes including the null terminator.
// Maximum number of characters is therefore 15.
constexpr std::size_t maxThreadNameLength = 15;
constexpr std::size_t kMAX_THREAD_NAME_LENGTH = 15;
/** Sets the name of the caller thread with compile-time size checking.
@tparam N The size of the string literal including null terminator
@@ -34,7 +34,7 @@ template <std::size_t N>
void
setCurrentThreadName(char const (&newThreadName)[N])
{
static_assert(N <= maxThreadNameLength + 1, "Thread name cannot exceed 15 characters");
static_assert(N <= kMAX_THREAD_NAME_LENGTH + 1, "Thread name cannot exceed 15 characters");
setCurrentThreadName(std::string_view(newThreadName, N - 1));
}

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

@@ -45,8 +45,8 @@ class ListNode
template <typename>
friend class ListIterator;
ListNode* m_next = nullptr;
ListNode* m_prev = nullptr;
ListNode* next_ = nullptr;
ListNode* prev_ = nullptr;
};
//------------------------------------------------------------------------------
@@ -62,12 +62,12 @@ public:
using reference = value_type&;
using size_type = std::size_t;
ListIterator(N* node = nullptr) noexcept : m_node(node)
ListIterator(N* node = nullptr) noexcept : node_(node)
{
}
template <typename M>
ListIterator(ListIterator<M> const& other) noexcept : m_node(other.m_node)
ListIterator(ListIterator<M> const& other) noexcept : node_(other.node_)
{
}
@@ -75,7 +75,7 @@ public:
bool
operator==(ListIterator<M> const& other) const noexcept
{
return m_node == other.m_node;
return node_ == other.node_;
}
template <typename M>
@@ -131,22 +131,22 @@ private:
[[nodiscard]] reference
dereference() const noexcept
{
return static_cast<reference>(*m_node);
return static_cast<reference>(*node_);
}
void
increment() noexcept
{
m_node = m_node->m_next;
node_ = node_->next_;
}
void
decrement() noexcept
{
m_node = m_node->m_prev;
node_ = node_->prev_;
}
N* m_node;
N* node_;
};
} // namespace detail
@@ -161,11 +161,11 @@ private:
struct Object : List <Object>::Node
{
explicit Object (int value) : m_value (value)
explicit Object (int value) : value_ (value)
{
}
int m_value;
int value_;
};
@endcode
@@ -190,7 +190,7 @@ private:
@code
for (List <Object>::iterator iter = list.begin(); iter != list.end; ++iter)
std::cout << iter->m_value;
std::cout << iter->value_;
@endcode
@@ -199,10 +199,10 @@ private:
@code
BOOST_FOREACH (Object& object, list) // boost only
std::cout << object.m_value;
std::cout << object.value_;
for (Object& object : list) // C++11 only
std::cout << object.m_value;
std::cout << object.value_;
@endcode
@@ -275,8 +275,8 @@ public:
/** Create an empty list. */
List()
{
m_head.m_prev = nullptr; // identifies the head
m_tail.m_next = nullptr; // identifies the tail
head_.prev_ = nullptr; // identifies the head
tail_.next_ = nullptr; // identifies the tail
clear();
}
@@ -297,7 +297,7 @@ public:
[[nodiscard]] size_type
size() const noexcept
{
return m_size;
return size_;
}
/** Obtain a reference to the first element.
@@ -307,7 +307,7 @@ public:
reference
front() noexcept
{
return element_from(m_head.m_next);
return element_from(head_.next_);
}
/** Obtain a const reference to the first element.
@@ -317,7 +317,7 @@ public:
[[nodiscard]] const_reference
front() const noexcept
{
return element_from(m_head.m_next);
return element_from(head_.next_);
}
/** Obtain a reference to the last element.
@@ -327,7 +327,7 @@ public:
reference
back() noexcept
{
return element_from(m_tail.m_prev);
return element_from(tail_.prev_);
}
/** Obtain a const reference to the last element.
@@ -337,7 +337,7 @@ public:
[[nodiscard]] const_reference
back() const noexcept
{
return element_from(m_tail.m_prev);
return element_from(tail_.prev_);
}
/** Obtain an iterator to the beginning of the list.
@@ -346,7 +346,7 @@ public:
iterator
begin() noexcept
{
return iterator(m_head.m_next);
return iterator(head_.next_);
}
/** Obtain a const iterator to the beginning of the list.
@@ -355,7 +355,7 @@ public:
[[nodiscard]] const_iterator
begin() const noexcept
{
return const_iterator(m_head.m_next);
return const_iterator(head_.next_);
}
/** Obtain a const iterator to the beginning of the list.
@@ -364,7 +364,7 @@ public:
[[nodiscard]] const_iterator
cbegin() const noexcept
{
return const_iterator(m_head.m_next);
return const_iterator(head_.next_);
}
/** Obtain a iterator to the end of the list.
@@ -373,7 +373,7 @@ public:
iterator
end() noexcept
{
return iterator(&m_tail);
return iterator(&tail_);
}
/** Obtain a const iterator to the end of the list.
@@ -382,7 +382,7 @@ public:
[[nodiscard]] const_iterator
end() const noexcept
{
return const_iterator(&m_tail);
return const_iterator(&tail_);
}
/** Obtain a const iterator to the end of the list
@@ -391,7 +391,7 @@ public:
[[nodiscard]] const_iterator
cend() const noexcept
{
return const_iterator(&m_tail);
return const_iterator(&tail_);
}
/** Clear the list.
@@ -400,9 +400,9 @@ public:
void
clear() noexcept
{
m_head.m_next = &m_tail;
m_tail.m_prev = &m_head;
m_size = 0;
head_.next_ = &tail_;
tail_.prev_ = &head_;
size_ = 0;
}
/** Insert an element.
@@ -415,11 +415,11 @@ public:
insert(iterator pos, T& element) noexcept
{
Node* node = static_cast<Node*>(&element);
node->m_next = &*pos;
node->m_prev = node->m_next->m_prev;
node->m_next->m_prev = node;
node->m_prev->m_next = node;
++m_size;
node->next_ = &*pos;
node->prev_ = node->next_->prev_;
node->next_->prev_ = node;
node->prev_->next_ = node;
++size_;
return iterator(node);
}
@@ -434,11 +434,11 @@ public:
if (!other.empty())
{
Node* before = &*pos;
other.m_head.m_next->m_prev = before->m_prev;
before->m_prev->m_next = other.m_head.m_next;
other.m_tail.m_prev->m_next = before;
before->m_prev = other.m_tail.m_prev;
m_size += other.m_size;
other.head_.next_->prev_ = before->prev_;
before->prev_->next_ = other.head_.next_;
other.tail_.prev_->next_ = before;
before->prev_ = other.tail_.prev_;
size_ += other.size_;
other.clear();
}
}
@@ -453,9 +453,9 @@ public:
{
Node const* node = &*pos;
++pos;
node->m_next->m_prev = node->m_prev;
node->m_prev->m_next = node->m_next;
--m_size;
node->next_->prev_ = node->prev_;
node->prev_->next_ = node->next_;
--size_;
return pos;
}
@@ -464,7 +464,7 @@ public:
@param element The element to insert.
*/
iterator
push_front(T& element) noexcept
pushFront(T& element) noexcept
{
return insert(begin(), element);
}
@@ -474,7 +474,7 @@ public:
@return A reference to the popped element.
*/
T&
pop_front() noexcept
popFront() noexcept
{
T& element(front());
erase(begin());
@@ -486,7 +486,7 @@ public:
@param element The element to append.
*/
iterator
push_back(T& element) noexcept
pushBack(T& element) noexcept
{
return insert(end(), element);
}
@@ -496,7 +496,7 @@ public:
@return A reference to the popped element.
*/
T&
pop_back() noexcept
popBack() noexcept
{
T& element(back());
erase(--end());
@@ -539,7 +539,7 @@ public:
@return An iterator to the element.
*/
iterator
iterator_to(T& element) const noexcept
iteratorTo(T& element) const noexcept
{
return iterator(static_cast<Node*>(&element));
}
@@ -550,28 +550,28 @@ public:
@return A const iterator to the element.
*/
[[nodiscard]] const_iterator
const_iterator_to(T const& element) const noexcept
constIteratorTo(T const& element) const noexcept
{
return const_iterator(static_cast<Node const*>(&element));
}
private:
reference
element_from(Node* node) noexcept
elementFrom(Node* node) noexcept
{
return *(static_cast<pointer>(node));
}
const_reference
element_from(Node const* node) const noexcept
elementFrom(Node const* node) const noexcept
{
return *(static_cast<const_pointer>(node));
}
private:
size_type m_size = 0u;
Node m_head;
Node m_tail;
size_type size_ = 0u;
Node head_;
Node tail_;
};
} // namespace beast

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

@@ -26,27 +26,27 @@ public:
LockFreeStackIterator() = default;
LockFreeStackIterator(NodePtr node) : m_node(node)
LockFreeStackIterator(NodePtr node) : node_(node)
{
}
template <bool OtherIsConst>
explicit LockFreeStackIterator(LockFreeStackIterator<Container, OtherIsConst> const& other)
: m_node(other.m_node)
: node_(other.node_)
{
}
LockFreeStackIterator&
operator=(NodePtr node)
{
m_node = node;
node_ = node;
return static_cast<LockFreeStackIterator&>(*this);
}
LockFreeStackIterator&
operator++()
{
m_node = m_node->m_next.load();
node_ = node_->next_.load();
return static_cast<LockFreeStackIterator&>(*this);
}
@@ -54,14 +54,14 @@ public:
operator++(int)
{
LockFreeStackIterator result(*this);
m_node = m_node->m_next;
node_ = node_->next_;
return result;
}
NodePtr
node() const
{
return m_node;
return node_;
}
reference
@@ -73,11 +73,11 @@ public:
pointer
operator->() const
{
return static_cast<pointer>(m_node);
return static_cast<pointer>(node_);
}
private:
NodePtr m_node{};
NodePtr node_{};
};
//------------------------------------------------------------------------------
@@ -121,11 +121,11 @@ public:
class Node
{
public:
Node() : m_next(nullptr)
Node() : next_(nullptr)
{
}
explicit Node(Node* next) : m_next(next)
explicit Node(Node* next) : next_(next)
{
}
@@ -139,7 +139,7 @@ public:
template <class Container, bool IsConst>
friend class LockFreeStackIterator;
std::atomic<Node*> m_next;
std::atomic<Node*> next_;
};
public:
@@ -153,7 +153,7 @@ public:
using iterator = LockFreeStackIterator<LockFreeStack<Element, Tag>, false>;
using const_iterator = LockFreeStackIterator<LockFreeStack<Element, Tag>, true>;
LockFreeStack() : m_end(nullptr), m_head(&m_end)
LockFreeStack() : end_(nullptr), head_(&end_)
{
}
@@ -165,7 +165,7 @@ public:
[[nodiscard]] bool
empty() const
{
return m_head.load() == &m_end;
return head_.load() == &end_;
}
/** Push a node onto the stack.
@@ -181,16 +181,16 @@ public:
*/
// VFALCO NOTE Fix this, shouldn't it be a reference like intrusive list?
bool
push_front(Node* node)
pushFront(Node* node)
{
bool first = false;
Node* old_head = m_head.load(std::memory_order_relaxed);
Node* oldHead = head_.load(std::memory_order_relaxed);
do
{
first = (old_head == &m_end);
node->m_next = old_head;
} while (!m_head.compare_exchange_strong(
old_head, node, std::memory_order_release, std::memory_order_relaxed));
first = (oldHead == &end_);
node->next_ = oldHead;
} while (!head_.compare_exchange_strong(
oldHead, node, std::memory_order_release, std::memory_order_relaxed));
return first;
}
@@ -204,17 +204,17 @@ public:
was empty.
*/
Element*
pop_front()
popFront()
{
Node* node = m_head.load();
Node* new_head = nullptr;
Node* node = head_.load();
Node* newHead = nullptr;
do
{
if (node == &m_end)
if (node == &end_)
return nullptr;
new_head = node->m_next.load();
} while (!m_head.compare_exchange_strong(
node, new_head, std::memory_order_release, std::memory_order_relaxed));
newHead = node->next_.load();
} while (!head_.compare_exchange_strong(
node, newHead, std::memory_order_release, std::memory_order_relaxed));
return static_cast<Element*>(node);
}
@@ -228,43 +228,43 @@ public:
iterator
begin()
{
return iterator(m_head.load());
return iterator(head_.load());
}
iterator
end()
{
return iterator(&m_end);
return iterator(&end_);
}
[[nodiscard]] const_iterator
begin() const
{
return const_iterator(m_head.load());
return const_iterator(head_.load());
}
[[nodiscard]] const_iterator
end() const
{
return const_iterator(&m_end);
return const_iterator(&end_);
}
[[nodiscard]] const_iterator
cbegin() const
{
return const_iterator(m_head.load());
return const_iterator(head_.load());
}
[[nodiscard]] const_iterator
cend() const
{
return const_iterator(&m_end);
return const_iterator(&end_);
}
/** @} */
private:
Node m_end;
std::atomic<Node*> m_head;
Node end_;
std::atomic<Node*> head_;
};
} // namespace beast

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

@@ -24,7 +24,7 @@ namespace detail {
template <class T>
/*constexpr*/
inline void
reverse_bytes(T& t)
reverseBytes(T& t)
{
unsigned char* bytes =
static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
@@ -35,14 +35,14 @@ reverse_bytes(T& t)
template <class T>
/*constexpr*/
inline void
maybe_reverse_bytes(T& t, std::false_type)
maybeReverseBytes(T& t, std::false_type)
{
}
template <class T>
/*constexpr*/
inline void
maybe_reverse_bytes(T& t, std::true_type)
maybeReverseBytes(T& t, std::true_type)
{
reverse_bytes(t);
}
@@ -50,15 +50,15 @@ maybe_reverse_bytes(T& t, std::true_type)
template <class T, class Hasher>
/*constexpr*/
inline void
maybe_reverse_bytes(T& t, Hasher&)
maybeReverseBytes(T& t, Hasher&)
{
maybe_reverse_bytes(
t, std::integral_constant<bool, Hasher::endian != boost::endian::order::native>{});
maybeReverseBytes(
t, std::integral_constant<bool, Hasher::kENDIAN != boost::endian::order::native>{});
}
} // namespace detail
// is_uniquely_represented<T>
// IsUniquelyRepresented<T>
// A type T is contiguously hashable if for all combinations of two values of
// a type, say x and y, if x == y, then it must also be true that
@@ -66,78 +66,78 @@ maybe_reverse_bytes(T& t, Hasher&)
// then x and y have the same bit pattern representation.
template <class T>
struct is_uniquely_represented
struct IsUniquelyRepresented
: public std::integral_constant<
bool,
std::is_integral_v<T> || std::is_enum_v<T> || std::is_pointer_v<T>>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
template <class T>
struct is_uniquely_represented<T const> : public is_uniquely_represented<T>
struct IsUniquelyRepresented<T const> : public IsUniquelyRepresented<T>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
template <class T>
struct is_uniquely_represented<T volatile> : public is_uniquely_represented<T>
struct IsUniquelyRepresented<T volatile> : public IsUniquelyRepresented<T>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
template <class T>
struct is_uniquely_represented<T const volatile> : public is_uniquely_represented<T>
struct IsUniquelyRepresented<T const volatile> : public IsUniquelyRepresented<T>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
// is_uniquely_represented<std::pair<T, U>>
// IsUniquelyRepresented<std::pair<T, U>>
template <class T, class U>
struct is_uniquely_represented<std::pair<T, U>>
struct IsUniquelyRepresented<std::pair<T, U>>
: public std::integral_constant<
bool,
is_uniquely_represented<T>::value && is_uniquely_represented<U>::value &&
IsUniquelyRepresented<T>::value && IsUniquelyRepresented<U>::value &&
sizeof(T) + sizeof(U) == sizeof(std::pair<T, U>)>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
// is_uniquely_represented<std::tuple<T...>>
// IsUniquelyRepresented<std::tuple<T...>>
template <class... T>
struct is_uniquely_represented<std::tuple<T...>>
struct IsUniquelyRepresented<std::tuple<T...>>
: public std::integral_constant<
bool,
std::conjunction_v<is_uniquely_represented<T>...> &&
std::conjunction_v<IsUniquelyRepresented<T>...> &&
sizeof(std::tuple<T...>) == (sizeof(T) + ...)>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
// is_uniquely_represented<T[N]>
// IsUniquelyRepresented<T[N]>
template <class T, std::size_t N>
struct is_uniquely_represented<T[N]> : public is_uniquely_represented<T>
struct IsUniquelyRepresented<T[N]> : public IsUniquelyRepresented<T>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
// is_uniquely_represented<std::array<T, N>>
// IsUniquelyRepresented<std::array<T, N>>
template <class T, std::size_t N>
struct is_uniquely_represented<std::array<T, N>>
struct IsUniquelyRepresented<std::array<T, N>>
: public std::integral_constant<
bool,
is_uniquely_represented<T>::value && sizeof(T) * N == sizeof(std::array<T, N>)>
IsUniquelyRepresented<T>::value && sizeof(T) * N == sizeof(std::array<T, N>)>
{
explicit is_uniquely_represented() = default;
explicit IsUniquelyRepresented() = default;
};
/** Metafunction returning `true` if the type can be hashed in one call.
For `is_contiguously_hashable<T>::value` to be true, then for every
For `IsContiguouslyHashable<T>::value` to be true, then for every
combination of possible values of `T` held in `x` and `y`,
if `x == y`, then it must be true that `memcmp(&x, &y, sizeof(T))`
return 0; i.e. that `x` and `y` are represented by the same bit pattern.
@@ -150,23 +150,23 @@ struct is_uniquely_represented<std::array<T, N>>
*/
/** @{ */
template <class T, class HashAlgorithm>
struct is_contiguously_hashable
struct IsContiguouslyHashable
: public std::integral_constant<
bool,
is_uniquely_represented<T>::value &&
(sizeof(T) == 1 || HashAlgorithm::endian == boost::endian::order::native)>
IsUniquelyRepresented<T>::value &&
(sizeof(T) == 1 || HashAlgorithm::kENDIAN == boost::endian::order::native)>
{
explicit is_contiguously_hashable() = default;
explicit IsContiguouslyHashable() = default;
};
template <class T, std::size_t N, class HashAlgorithm>
struct is_contiguously_hashable<T[N], HashAlgorithm>
struct IsContiguouslyHashable<T[N], HashAlgorithm>
: public std::integral_constant<
bool,
is_uniquely_represented<T[N]>::value &&
IsUniquelyRepresented<T[N]>::value &&
(sizeof(T) == 1 || HashAlgorithm::endian == boost::endian::order::native)>
{
explicit is_contiguously_hashable() = default;
explicit IsContiguouslyHashable() = default;
};
/** @} */
@@ -200,7 +200,7 @@ struct is_contiguously_hashable<T[N], HashAlgorithm>
// scalars
template <class Hasher, class T>
inline std::enable_if_t<is_contiguously_hashable<T, Hasher>::value>
inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, T const& t) noexcept
{
// NOLINTNEXTLINE(bugprone-sizeof-expression)
@@ -209,11 +209,11 @@ hash_append(Hasher& h, T const& t) noexcept
template <class Hasher, class T>
inline std::enable_if_t<
!is_contiguously_hashable<T, Hasher>::value &&
!IsContiguouslyHashable<T, Hasher>::value &&
(std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
hash_append(Hasher& h, T t) noexcept
{
detail::reverse_bytes(t);
detail::reverseBytes(t);
h(std::addressof(t), sizeof(t));
}
@@ -223,7 +223,7 @@ hash_append(Hasher& h, T t) noexcept
{
if (t == 0)
t = 0;
detail::maybe_reverse_bytes(t, h);
detail::maybeReverseBytes(t, h);
h(&t, sizeof(t));
}
@@ -232,42 +232,42 @@ inline void
hash_append(Hasher& h, std::nullptr_t) noexcept
{
void const* p = nullptr;
detail::maybe_reverse_bytes(p, h);
detail::maybeReverseBytes(p, h);
h(&p, sizeof(p));
}
// Forward declarations for ADL purposes
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!is_contiguously_hashable<T, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, T (&a)[N]) noexcept;
template <class Hasher, class CharT, class Traits, class Alloc>
std::enable_if_t<!is_contiguously_hashable<CharT, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
template <class Hasher, class CharT, class Traits, class Alloc>
std::enable_if_t<is_contiguously_hashable<CharT, Hasher>::value>
std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
template <class Hasher, class T, class U>
std::enable_if_t<!is_contiguously_hashable<std::pair<T, U>, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
hash_append(Hasher& h, std::pair<T, U> const& p) noexcept;
template <class Hasher, class T, class Alloc>
std::enable_if_t<!is_contiguously_hashable<T, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
template <class Hasher, class T, class Alloc>
std::enable_if_t<is_contiguously_hashable<T, Hasher>::value>
std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!is_contiguously_hashable<std::array<T, N>, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
hash_append(Hasher& h, std::array<T, N> const& a) noexcept;
template <class Hasher, class... T>
std::enable_if_t<!is_contiguously_hashable<std::tuple<T...>, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
hash_append(Hasher& h, std::tuple<T...> const& t) noexcept;
template <class Hasher, class Key, class T, class Hash, class Pred, class Alloc>
@@ -279,10 +279,10 @@ void
hash_append(Hasher& h, std::unordered_set<Key, Hash, Pred, Alloc> const& s);
template <class Hasher, class Key, class Compare, class Alloc>
std::enable_if_t<!is_contiguously_hashable<Key, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
template <class Hasher, class Key, class Compare, class Alloc>
std::enable_if_t<is_contiguously_hashable<Key, Hasher>::value>
std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
template <class Hasher, class T0, class T1, class... T>
void
@@ -291,7 +291,7 @@ hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
// c-array
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!is_contiguously_hashable<T, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, T (&a)[N]) noexcept
{
for (auto const& t : a)
@@ -301,7 +301,7 @@ hash_append(Hasher& h, T (&a)[N]) noexcept
// basic_string
template <class Hasher, class CharT, class Traits, class Alloc>
inline std::enable_if_t<!is_contiguously_hashable<CharT, Hasher>::value>
inline std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
{
for (auto c : s)
@@ -310,7 +310,7 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
}
template <class Hasher, class CharT, class Traits, class Alloc>
inline std::enable_if_t<is_contiguously_hashable<CharT, Hasher>::value>
inline std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
{
h(s.data(), s.size() * sizeof(CharT));
@@ -320,7 +320,7 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
// pair
template <class Hasher, class T, class U>
inline std::enable_if_t<!is_contiguously_hashable<std::pair<T, U>, Hasher>::value>
inline std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
{
hash_append(h, p.first, p.second);
@@ -329,7 +329,7 @@ hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
// vector
template <class Hasher, class T, class Alloc>
inline std::enable_if_t<!is_contiguously_hashable<T, Hasher>::value>
inline std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
{
for (auto const& t : v)
@@ -338,7 +338,7 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
}
template <class Hasher, class T, class Alloc>
inline std::enable_if_t<is_contiguously_hashable<T, Hasher>::value>
inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
{
h(v.data(), v.size() * sizeof(T));
@@ -348,7 +348,7 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
// array
template <class Hasher, class T, std::size_t N>
std::enable_if_t<!is_contiguously_hashable<std::array<T, N>, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
hash_append(Hasher& h, std::array<T, N> const& a) noexcept
{
for (auto const& t : a)
@@ -356,14 +356,14 @@ hash_append(Hasher& h, std::array<T, N> const& a) noexcept
}
template <class Hasher, class Key, class Compare, class Alloc>
std::enable_if_t<!is_contiguously_hashable<Key, Hasher>::value>
std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
{
for (auto const& t : v)
hash_append(h, t);
}
template <class Hasher, class Key, class Compare, class Alloc>
std::enable_if_t<is_contiguously_hashable<Key, Hasher>::value>
std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
{
h(&(v.begin()), v.size() * sizeof(Key));
@@ -373,13 +373,13 @@ hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v)
namespace detail {
inline void
for_each_item(...) noexcept
forEachItem(...) noexcept
{
}
template <class Hasher, class T>
inline int
hash_one(Hasher& h, T const& t) noexcept
hashOne(Hasher& h, T const& t) noexcept
{
hash_append(h, t);
return 0;
@@ -395,7 +395,7 @@ tuple_hash(Hasher& h, std::tuple<T...> const& t, std::index_sequence<I...>) noex
} // namespace detail
template <class Hasher, class... T>
inline std::enable_if_t<!is_contiguously_hashable<std::tuple<T...>, Hasher>::value>
inline std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
{
detail::tuple_hash(h, t, std::index_sequence_for<T...>{});

6
include/xrpl/beast/hash/uhash.h
View File

@@ -6,10 +6,10 @@
namespace beast {
// Universal hash function
template <class Hasher = xxhasher>
struct uhash
template <class Hasher = Xxhasher>
struct Uhash
{
uhash() = default;
Uhash() = default;
using result_type = typename Hasher::result_type;

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

@@ -12,7 +12,7 @@
namespace beast {
class xxhasher
class Xxhasher
{
public:
using result_type = std::size_t;
@@ -21,9 +21,9 @@ private:
static_assert(sizeof(std::size_t) == 8, "requires 64-bit std::size_t");
// Have an internal buffer to avoid the streaming API
// A 64-byte buffer should to be big enough for us
static constexpr std::size_t INTERNAL_BUFFER_SIZE = 64;
static constexpr std::size_t kINTERNAL_BUFFER_SIZE = 64;
alignas(64) std::array<std::uint8_t, INTERNAL_BUFFER_SIZE> buffer_{};
alignas(64) std::array<std::uint8_t, kINTERNAL_BUFFER_SIZE> buffer_{};
std::span<std::uint8_t> readBuffer_;
std::span<std::uint8_t> writeBuffer_;
@@ -102,18 +102,18 @@ private:
}
public:
static constexpr auto const endian = boost::endian::order::native;
static constexpr auto const kENDIAN = boost::endian::order::native;
xxhasher(xxhasher const&) = delete;
xxhasher&
operator=(xxhasher const&) = delete;
Xxhasher(Xxhasher const&) = delete;
Xxhasher&
operator=(Xxhasher const&) = delete;
xxhasher()
Xxhasher()
{
resetBuffers();
}
~xxhasher() noexcept
~Xxhasher() noexcept
{
if (state_ != nullptr)
{
@@ -122,13 +122,13 @@ public:
}
template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
explicit xxhasher(Seed seed) : seed_(seed)
explicit Xxhasher(Seed seed) : seed_(seed)
{
resetBuffers();
}
template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
xxhasher(Seed seed, Seed) : seed_(seed)
Xxhasher(Seed seed, Seed) : seed_(seed)
{
resetBuffers();
}

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

@@ -42,13 +42,13 @@ public:
/** @{ */
template <class Handler>
Hook
make_hook(Handler handler)
makeHook(Handler handler)
{
return make_hook(HookImpl::HandlerType(handler));
return makeHook(HookImpl::HandlerType(handler));
}
virtual Hook
make_hook(HookImpl::HandlerType const& handler) = 0;
makeHook(HookImpl::HandlerType const& handler) = 0;
/** @} */
/** Create a counter with the specified name.
@@ -56,14 +56,14 @@ public:
*/
/** @{ */
virtual Counter
make_counter(std::string const& name) = 0;
makeCounter(std::string const& name) = 0;
Counter
make_counter(std::string const& prefix, std::string const& name)
makeCounter(std::string const& prefix, std::string const& name)
{
if (prefix.empty())
return make_counter(name);
return make_counter(prefix + "." + name);
return makeCounter(name);
return makeCounter(prefix + "." + name);
}
/** @} */
@@ -72,14 +72,14 @@ public:
*/
/** @{ */
virtual Event
make_event(std::string const& name) = 0;
makeEvent(std::string const& name) = 0;
Event
make_event(std::string const& prefix, std::string const& name)
makeEvent(std::string const& prefix, std::string const& name)
{
if (prefix.empty())
return make_event(name);
return make_event(prefix + "." + name);
return makeEvent(name);
return makeEvent(prefix + "." + name);
}
/** @} */
@@ -88,14 +88,14 @@ public:
*/
/** @{ */
virtual Gauge
make_gauge(std::string const& name) = 0;
makeGauge(std::string const& name) = 0;
Gauge
make_gauge(std::string const& prefix, std::string const& name)
makeGauge(std::string const& prefix, std::string const& name)
{
if (prefix.empty())
return make_gauge(name);
return make_gauge(prefix + "." + name);
return makeGauge(name);
return makeGauge(prefix + "." + name);
}
/** @} */
@@ -104,14 +104,14 @@ public:
*/
/** @{ */
virtual Meter
make_meter(std::string const& name) = 0;
makeMeter(std::string const& name) = 0;
Meter
make_meter(std::string const& prefix, std::string const& name)
makeMeter(std::string const& prefix, std::string const& name)
{
if (prefix.empty())
return make_meter(name);
return make_meter(prefix + "." + name);
return makeMeter(name);
return makeMeter(prefix + "." + name);
}
/** @} */
};

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

@@ -29,7 +29,7 @@ public:
factory function in the Collector interface.
@see Collector.
*/
explicit Counter(std::shared_ptr<CounterImpl> const& impl) : m_impl(impl)
explicit Counter(std::shared_ptr<CounterImpl> const& impl) : impl_(impl)
{
}
@@ -38,8 +38,8 @@ public:
void
increment(value_type amount) const
{
if (m_impl)
m_impl->increment(amount);
if (impl_)
impl_->increment(amount);
}
Counter const&
@@ -85,7 +85,7 @@ public:
}
private:
std::shared_ptr<CounterImpl> m_impl;
std::shared_ptr<CounterImpl> impl_;
};
} // namespace beast::insight

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

@@ -31,7 +31,7 @@ public:
factory function in the Collector interface.
@see Collector.
*/
explicit Event(std::shared_ptr<EventImpl> const& impl) : m_impl(impl)
explicit Event(std::shared_ptr<EventImpl> const& impl) : impl_(impl)
{
}
@@ -41,18 +41,18 @@ public:
notify(std::chrono::duration<Rep, Period> const& value) const
{
using namespace std::chrono;
if (m_impl)
m_impl->notify(ceil<value_type>(value));
if (impl_)
impl_->notify(ceil<value_type>(value));
}
[[nodiscard]] std::shared_ptr<EventImpl> const&
impl() const
{
return m_impl;
return impl_;
}
private:
std::shared_ptr<EventImpl> m_impl;
std::shared_ptr<EventImpl> impl_;
};
} // namespace beast::insight

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

@@ -31,7 +31,7 @@ public:
factory function in the Collector interface.
@see Collector.
*/
explicit Gauge(std::shared_ptr<GaugeImpl> const& impl) : m_impl(impl)
explicit Gauge(std::shared_ptr<GaugeImpl> const& impl) : impl_(impl)
{
}
@@ -44,8 +44,8 @@ public:
void
set(value_type value) const
{
if (m_impl)
m_impl->set(value);
if (impl_)
impl_->set(value);
}
Gauge const&
@@ -61,8 +61,8 @@ public:
void
increment(difference_type amount) const
{
if (m_impl)
m_impl->increment(amount);
if (impl_)
impl_->increment(amount);
}
Gauge const&
@@ -111,11 +111,11 @@ public:
[[nodiscard]] std::shared_ptr<GaugeImpl> const&
impl() const
{
return m_impl;
return impl_;
}
private:
std::shared_ptr<GaugeImpl> m_impl;
std::shared_ptr<GaugeImpl> impl_;
};
} // namespace beast::insight

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

@@ -29,6 +29,6 @@ public:
/** Create a group container that uses the specified collector. */
std::unique_ptr<Groups>
make_Groups(Collector::ptr const& collector);
makeGroups(Collector::ptr const& collector);
} // namespace beast::insight

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

@@ -20,18 +20,18 @@ public:
factory function in the Collector interface.
@see Collector.
*/
explicit Hook(std::shared_ptr<HookImpl> const& impl) : m_impl(impl)
explicit Hook(std::shared_ptr<HookImpl> const& impl) : impl_(impl)
{
}
[[nodiscard]] std::shared_ptr<HookImpl> const&
impl() const
{
return m_impl;
return impl_;
}
private:
std::shared_ptr<HookImpl> m_impl;
std::shared_ptr<HookImpl> impl_;
};
} // namespace beast::insight

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

@@ -28,7 +28,7 @@ public:
factory function in the Collector interface.
@see Collector.
*/
explicit Meter(std::shared_ptr<MeterImpl> const& impl) : m_impl(impl)
explicit Meter(std::shared_ptr<MeterImpl> const& impl) : impl_(impl)
{
}
@@ -37,8 +37,8 @@ public:
void
increment(value_type amount) const
{
if (m_impl)
m_impl->increment(amount);
if (impl_)
impl_->increment(amount);
}
Meter const&
@@ -66,11 +66,11 @@ public:
[[nodiscard]] std::shared_ptr<MeterImpl> const&
impl() const
{
return m_impl;
return impl_;
}
private:
std::shared_ptr<MeterImpl> m_impl;
std::shared_ptr<MeterImpl> impl_;
};
} // namespace beast::insight

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

@@ -11,7 +11,7 @@ public:
explicit NullCollector() = default;
static std::shared_ptr<Collector>
New();
make();
};
} // namespace beast::insight

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

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

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

@@ -27,37 +27,37 @@ to_string(Address const& addr)
/** Returns `true` if this is a loopback address. */
inline bool
is_loopback(Address const& addr)
isLoopback(Address const& addr)
{
return addr.is_loopback();
}
/** Returns `true` if the address is unspecified. */
inline bool
is_unspecified(Address const& addr)
isUnspecified(Address const& addr)
{
return addr.is_unspecified();
}
/** Returns `true` if the address is a multicast address. */
inline bool
is_multicast(Address const& addr)
isMulticast(Address const& addr)
{
return addr.is_multicast();
}
/** Returns `true` if the address is a private unroutable address. */
inline bool
is_private(Address const& addr)
isPrivate(Address const& addr)
{
return (addr.is_v4()) ? is_private(addr.to_v4()) : is_private(addr.to_v6());
return (addr.is_v4()) ? isPrivate(addr.to_v4()) : isPrivate(addr.to_v6());
}
/** Returns `true` if the address is a public routable address. */
inline bool
is_public(Address const& addr)
isPublic(Address const& addr)
{
return (addr.is_v4()) ? is_public(addr.to_v4()) : is_public(addr.to_v6());
return (addr.is_v4()) ? isPublic(addr.to_v4()) : isPublic(addr.to_v6());
}
} // namespace IP
@@ -95,7 +95,7 @@ struct hash<::beast::IP::Address>
std::size_t
operator()(::beast::IP::Address const& addr) const
{
return ::beast::uhash<>{}(addr);
return ::beast::Uhash<>{}(addr);
}
};
} // namespace boost

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

@@ -10,21 +10,21 @@ namespace beast::IP {
The port is set to zero.
*/
Endpoint
from_asio(boost::asio::ip::address const& address);
fromAsio(boost::asio::ip::address const& address);
/** Convert to Endpoint. */
Endpoint
from_asio(boost::asio::ip::tcp::endpoint const& endpoint);
fromAsio(boost::asio::ip::tcp::endpoint const& endpoint);
/** Convert to asio::ip::address.
The port is ignored.
*/
boost::asio::ip::address
to_asio_address(Endpoint const& endpoint);
toAsioAddress(Endpoint const& endpoint);
/** Convert to asio::ip::tcp::endpoint. */
boost::asio::ip::tcp::endpoint
to_asio_endpoint(Endpoint const& endpoint);
toAsioEndpoint(Endpoint const& endpoint);
} // namespace beast::IP
@@ -36,24 +36,24 @@ struct IPAddressConversion
explicit IPAddressConversion() = default;
static IP::Endpoint
from_asio(boost::asio::ip::address const& address)
fromAsio(boost::asio::ip::address const& address)
{
return IP::from_asio(address);
return IP::fromAsio(address);
}
static IP::Endpoint
from_asio(boost::asio::ip::tcp::endpoint const& endpoint)
fromAsio(boost::asio::ip::tcp::endpoint const& endpoint)
{
return IP::from_asio(endpoint);
return IP::fromAsio(endpoint);
}
static boost::asio::ip::address
to_asio_address(IP::Endpoint const& address)
toAsioAddress(IP::Endpoint const& address)
{
return IP::to_asio_address(address);
return IP::toAsioAddress(address);
}
static boost::asio::ip::tcp::endpoint
to_asio_endpoint(IP::Endpoint const& address)
toAsioEndpoint(IP::Endpoint const& address)
{
return IP::to_asio_endpoint(address);
return IP::toAsioEndpoint(address);
}
};

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

@@ -10,16 +10,16 @@ using AddressV4 = boost::asio::ip::address_v4;
/** Returns `true` if the address is a private unroutable address. */
bool
is_private(AddressV4 const& addr);
isPrivate(AddressV4 const& addr);
/** Returns `true` if the address is a public routable address. */
bool
is_public(AddressV4 const& addr);
isPublic(AddressV4 const& addr);
/** Returns the address class for the given address.
@note Class 'D' represents multicast addresses (224.*.*.*).
*/
char
get_class(AddressV4 const& address);
getClass(AddressV4 const& address);
} // namespace beast::IP

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

@@ -10,10 +10,10 @@ using AddressV6 = boost::asio::ip::address_v6;
/** Returns `true` if the address is a private unroutable address. */
bool
is_private(AddressV6 const& addr);
isPrivate(AddressV6 const& addr);
/** Returns `true` if the address is a public routable address. */
bool
is_public(AddressV6 const& addr);
isPublic(AddressV6 const& addr);
} // namespace beast::IP

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

@@ -27,56 +27,56 @@ public:
@return An optional endpoint; will be `std::nullopt` on failure
*/
static std::optional<Endpoint>
from_string_checked(std::string const& s);
fromStringChecked(std::string const& s);
static Endpoint
from_string(std::string const& s);
fromString(std::string const& s);
/** Returns a string representing the endpoint. */
[[nodiscard]] std::string
to_string() const;
toString() const;
/** Returns the port number on the endpoint. */
[[nodiscard]] Port
port() const
{
return m_port;
return port_;
}
/** Returns a new Endpoint with a different port. */
[[nodiscard]] Endpoint
at_port(Port port) const
atPort(Port port) const
{
return Endpoint(m_addr, port);
return Endpoint(addr_, port);
}
/** Returns the address portion of this endpoint. */
[[nodiscard]] Address const&
address() const
{
return m_addr;
return addr_;
}
/** Convenience accessors for the address part. */
/** @{ */
[[nodiscard]] bool
is_v4() const
isV4() const
{
return m_addr.is_v4();
return addr_.is_v4();
}
[[nodiscard]] bool
is_v6() const
isV6() const
{
return m_addr.is_v6();
return addr_.is_v6();
}
[[nodiscard]] AddressV4
to_v4() const
toV4() const
{
return m_addr.to_v4();
return addr_.to_v4();
}
[[nodiscard]] AddressV6
to_v6() const
toV6() const
{
return m_addr.to_v6();
return addr_.to_v6();
}
/** @} */
@@ -114,12 +114,12 @@ public:
hash_append(Hasher& h, Endpoint const& endpoint)
{
using ::beast::hash_append;
hash_append(h, endpoint.m_addr, endpoint.m_port);
hash_append(h, endpoint.addr_, endpoint.port_);
}
private:
Address m_addr;
Port m_port;
Address addr_;
Port port_;
};
//------------------------------------------------------------------------------
@@ -128,37 +128,37 @@ private:
/** Returns `true` if the endpoint is a loopback address. */
inline bool
is_loopback(Endpoint const& endpoint)
isLoopback(Endpoint const& endpoint)
{
return is_loopback(endpoint.address());
return isLoopback(endpoint.address());
}
/** Returns `true` if the endpoint is unspecified. */
inline bool
is_unspecified(Endpoint const& endpoint)
isUnspecified(Endpoint const& endpoint)
{
return is_unspecified(endpoint.address());
return isUnspecified(endpoint.address());
}
/** Returns `true` if the endpoint is a multicast address. */
inline bool
is_multicast(Endpoint const& endpoint)
isMulticast(Endpoint const& endpoint)
{
return is_multicast(endpoint.address());
return isMulticast(endpoint.address());
}
/** Returns `true` if the endpoint is a private unroutable address. */
inline bool
is_private(Endpoint const& endpoint)
isPrivate(Endpoint const& endpoint)
{
return is_private(endpoint.address());
return isPrivate(endpoint.address());
}
/** Returns `true` if the endpoint is a public routable address. */
inline bool
is_public(Endpoint const& endpoint)
isPublic(Endpoint const& endpoint)
{
return is_public(endpoint.address());
return isPublic(endpoint.address());
}
//------------------------------------------------------------------------------
@@ -167,7 +167,7 @@ is_public(Endpoint const& endpoint)
inline std::string
to_string(Endpoint const& endpoint)
{
return endpoint.to_string();
return endpoint.toString();
}
/** Output stream conversion. */
@@ -197,7 +197,7 @@ struct hash<::beast::IP::Endpoint>
std::size_t
operator()(::beast::IP::Endpoint const& endpoint) const
{
return ::beast::uhash<>{}(endpoint);
return ::beast::Uhash<>{}(endpoint);
}
};
} // namespace std
@@ -212,7 +212,7 @@ struct hash<::beast::IP::Endpoint>
std::size_t
operator()(::beast::IP::Endpoint const& endpoint) const
{
return ::beast::uhash<>{}(endpoint);
return ::beast::Uhash<>{}(endpoint);
}
};
} // namespace boost

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

@@ -16,9 +16,9 @@ namespace beast::rfc2616 {
namespace detail {
struct ci_equal_pred
struct CiEqualPred
{
explicit ci_equal_pred() = default;
explicit CiEqualPred() = default;
bool
operator()(char c1, char c2)
@@ -34,14 +34,14 @@ struct ci_equal_pred
This excludes the CRLF sequence allowed for line continuations.
*/
inline bool
is_lws(char c)
isLws(char c)
{
return c == ' ' || c == '\t';
}
/** Returns `true` if `c` is any whitespace character. */
inline bool
is_white(char c)
isWhite(char c)
{
switch (c)
{
@@ -59,14 +59,14 @@ is_white(char c)
template <class FwdIter>
FwdIter
trim_right(FwdIter first, FwdIter last)
trimRight(FwdIter first, FwdIter last)
{
if (first == last)
return last;
do
{
--last;
if (!is_white(*last))
if (!isWhite(*last))
return ++last;
} while (last != first);
return first;
@@ -74,13 +74,13 @@ trim_right(FwdIter first, FwdIter last)
template <class String>
String
trim_right(String const& s)
trimRight(String const& s)
{
using std::begin;
using std::end;
auto first(begin(s));
auto last(end(s));
last = trim_right(first, last);
last = trimRight(first, last);
return {first, last};
}
@@ -143,7 +143,7 @@ split(FwdIt first, FwdIt last, Char delim)
}
else if (*iter == delim)
{
e = trim_right(e);
e = trimRight(e);
if (!e.empty())
{
result.emplace_back(std::move(e));
@@ -151,7 +151,7 @@ split(FwdIt first, FwdIt last, Char delim)
}
++iter;
}
else if (is_lws(*iter))
else if (isLws(*iter))
{
++iter;
}
@@ -163,7 +163,7 @@ split(FwdIt first, FwdIt last, Char delim)
if (!e.empty())
{
e = trim_right(e);
e = trimRight(e);
if (!e.empty())
result.emplace_back(std::move(e));
}
@@ -174,16 +174,16 @@ template <
class FwdIt,
class Result = std::vector<std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>>
Result
split_commas(FwdIt first, FwdIt last)
splitCommas(FwdIt first, FwdIt last)
{
return split(first, last, ',');
}
template <class Result = std::vector<std::string>>
Result
split_commas(boost::beast::string_view const& s)
splitCommas(boost::beast::string_view const& s)
{
return split_commas(s.begin(), s.end());
return splitCommas(s.begin(), s.end());
}
//------------------------------------------------------------------------------
@@ -196,7 +196,7 @@ split_commas(boost::beast::string_view const& s)
@note Values returned may contain backslash escapes.
*/
class list_iterator
class ListIterator
{
using iter_type = boost::string_ref::const_iterator;
@@ -211,20 +211,20 @@ public:
using difference_type = std::ptrdiff_t;
using iterator_category = std::forward_iterator_tag;
list_iterator(iter_type begin, iter_type end) : it_(begin), end_(end)
ListIterator(iter_type begin, iter_type end) : it_(begin), end_(end)
{
if (it_ != end_)
increment();
}
bool
operator==(list_iterator const& other) const
operator==(ListIterator const& other) const
{
return other.it_ == it_ && other.end_ == end_ && other.value_.size() == value_.size();
}
bool
operator!=(list_iterator const& other) const
operator!=(ListIterator const& other) const
{
return !(*this == other);
}
@@ -241,14 +241,14 @@ public:
return &*(*this);
}
list_iterator&
ListIterator&
operator++()
{
increment();
return *this;
}
list_iterator
ListIterator
operator++(int)
{
auto temp = *this;
@@ -264,7 +264,7 @@ private:
template <class>
void
list_iterator::increment()
ListIterator::increment()
{
using namespace detail;
value_.clear();
@@ -302,7 +302,7 @@ list_iterator::increment()
it_++;
continue;
}
else if (is_lws(*it_))
else if (isLws(*it_))
{
++it_;
continue;
@@ -313,7 +313,7 @@ list_iterator::increment()
for (;;)
{
++it_;
if (it_ == end_ || *it_ == ',' || is_lws(*it_))
if (it_ == end_ || *it_ == ',' || isLws(*it_))
{
value_ = boost::string_ref(&*start, std::distance(start, it_));
return;
@@ -327,17 +327,17 @@ list_iterator::increment()
A case-insensitive comparison is used.
*/
inline bool
ci_equal(boost::string_ref s1, boost::string_ref s2)
ciEqual(boost::string_ref s1, boost::string_ref s2)
{
return boost::range::equal(s1, s2, detail::ci_equal_pred{});
return boost::range::equal(s1, s2, detail::CiEqualPred{});
}
/** Returns a range representing the list. */
inline boost::iterator_range<list_iterator>
make_list(boost::string_ref const& field)
inline boost::iterator_range<ListIterator>
makeList(boost::string_ref const& field)
{
return boost::iterator_range<list_iterator>{
list_iterator{field.begin(), field.end()}, list_iterator{field.end(), field.end()}};
return boost::iterator_range<ListIterator>{
ListIterator{field.begin(), field.end()}, ListIterator{field.end(), field.end()}};
}
/** Returns true if the specified token exists in the list.
@@ -346,19 +346,19 @@ make_list(boost::string_ref const& field)
*/
template <class = void>
bool
token_in_list(boost::string_ref const& value, boost::string_ref const& token)
tokenInList(boost::string_ref const& value, boost::string_ref const& token)
{
for (auto const& item : make_list(value))
for (auto const& item : makeList(value))
{
if (ci_equal(item, token))
if (ciEqual(item, token))
return true;
}
return false;
}
template <bool isRequest, class Body, class Fields>
template <bool IsRequest, class Body, class Fields>
bool
is_keep_alive(boost::beast::http::message<isRequest, Body, Fields> const& m)
isKeepAlive(boost::beast::http::message<IsRequest, Body, Fields> const& m)
{
if (m.version() <= 10)
{

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

@@ -23,7 +23,7 @@ namespace beast::test {
functions inside coroutines. This is handy for testing
asynchronous asio code.
*/
class enable_yield_to
class EnableYieldTo
{
protected:
boost::asio::io_context ios_;
@@ -39,8 +39,7 @@ public:
/// The type of yield context passed to functions.
using yield_context = boost::asio::yield_context;
explicit enable_yield_to(std::size_t concurrency = 1)
: work_(boost::asio::make_work_guard(ios_))
explicit EnableYieldTo(std::size_t concurrency = 1) : work_(boost::asio::make_work_guard(ios_))
{
threads_.reserve(concurrency);
for (std::size_t i = 0; i < concurrency; ++i)
@@ -49,7 +48,7 @@ public:
}
}
~enable_yield_to()
~EnableYieldTo()
{
work_ = boost::none;
for (auto& t : threads_)
@@ -58,7 +57,7 @@ public:
/// Return the `io_context` associated with the object
boost::asio::io_context&
get_io_context()
getIoContext()
{
return ios_;
}
@@ -81,7 +80,7 @@ public:
#else
template <class F0, class... FN>
void
yield_to(F0&& f0, FN&&... fn);
yieldTo(F0&& f0, FN&&... fn);
#endif
private:
@@ -97,7 +96,7 @@ private:
template <class F0, class... FN>
void
enable_yield_to::yield_to(F0&& f0, FN&&... fn)
EnableYieldTo::yieldTo(F0&& f0, FN&&... fn)
{
running_ = 1 + sizeof...(FN);
spawn(f0, fn...);
@@ -107,7 +106,7 @@ enable_yield_to::yield_to(F0&& f0, FN&&... fn)
template <class F0, class... FN>
inline void
enable_yield_to::spawn(F0&& f, FN&&... fn)
EnableYieldTo::spawn(F0&& f, FN&&... fn)
{
boost::asio::spawn(
ios_,

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

@@ -13,7 +13,7 @@ namespace beast {
template <typename T>
std::string
type_name()
typeName()
{
using TR = std::remove_reference_t<T>;

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

@@ -11,31 +11,31 @@
namespace beast::unit_test {
/** Utility for producing nicely composed output of amounts with units. */
class amount
class Amount
{
private:
std::size_t n_;
std::string const& what_;
public:
amount(amount const&) = default;
amount&
operator=(amount const&) = delete;
Amount(Amount const&) = default;
Amount&
operator=(Amount const&) = delete;
template <class = void>
amount(std::size_t n, std::string const& what);
Amount(std::size_t n, std::string const& what);
friend std::ostream&
operator<<(std::ostream& s, amount const& t);
operator<<(std::ostream& s, Amount const& t);
};
template <class>
amount::amount(std::size_t n, std::string const& what) : n_(n), what_(what)
Amount::Amount(std::size_t n, std::string const& what) : n_(n), what_(what)
{
}
inline std::ostream&
operator<<(std::ostream& s, amount const& t)
operator<<(std::ostream& s, Amount const& t)
{
s << t.n_ << " " << t.what_ << ((t.n_ != 1) ? "s" : "");
return s;

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

@@ -11,24 +11,24 @@ namespace beast::unit_test::detail {
provide additional behavior.
*/
template <class Container>
class const_container
class ConstContainer
{
private:
using cont_type = Container;
cont_type m_cont;
cont_type cont_;
protected:
cont_type&
cont()
{
return m_cont;
return cont_;
}
[[nodiscard]] cont_type const&
cont() const
{
return m_cont;
return cont_;
}
public:
@@ -42,14 +42,14 @@ public:
[[nodiscard]] bool
empty() const
{
return m_cont.empty();
return cont_.empty();
}
/** Returns the number of items in the container. */
[[nodiscard]] size_type
size() const
{
return m_cont.size();
return cont_.size();
}
/** Returns forward iterators for traversal. */
@@ -57,25 +57,25 @@ public:
[[nodiscard]] const_iterator
begin() const
{
return m_cont.cbegin();
return cont_.cbegin();
}
[[nodiscard]] const_iterator
cbegin() const
{
return m_cont.cbegin();
return cont_.cbegin();
}
[[nodiscard]] const_iterator
end() const
{
return m_cont.cend();
return cont_.cend();
}
[[nodiscard]] const_iterator
cend() const
{
return m_cont.cend();
return cont_.cend();
}
/** @} */
};

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

@@ -11,34 +11,34 @@ namespace beast::unit_test {
namespace detail {
/// Holds test suites registered during static initialization.
inline suite_list&
global_suites()
inline SuiteList&
globalSuites()
{
static suite_list s;
return s;
static SuiteList kS;
return kS;
}
template <class Suite>
struct insert_suite
struct InsertSuite
{
insert_suite(
InsertSuite(
char const* name,
char const* module,
char const* library,
bool manual,
int priority)
{
global_suites().insert<Suite>(name, module, library, manual, priority);
globalSuites().insert<Suite>(name, module, library, manual, priority);
}
};
} // namespace detail
/// Holds test suites registered during static initialization.
inline suite_list const&
global_suites()
inline SuiteList const&
globalSuites()
{
return detail::global_suites();
return detail::globalSuites();
}
} // namespace beast::unit_test

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

@@ -11,70 +11,70 @@
namespace beast::unit_test {
// Predicate for implementing matches
class selector
class Selector
{
public:
enum class mode_t {
enum class ModeT {
// Run all tests except manual ones
all,
All,
// Run tests that match in any field
automatch,
Automatch,
// Match on suite
suite,
Suite,
// Match on library
library,
Library,
// Match on module (used internally)
module,
Module,
// Match nothing (used internally)
none
None
};
private:
mode_t mode_;
ModeT mode_;
std::string pat_;
std::string library_;
public:
template <class = void>
explicit selector(mode_t mode, std::string const& pattern = "");
explicit Selector(ModeT mode, std::string const& pattern = "");
template <class = void>
bool
operator()(suite_info const& s);
operator()(SuiteInfo const& s);
};
//------------------------------------------------------------------------------
template <class>
selector::selector(mode_t mode, std::string const& pattern) : mode_(mode), pat_(pattern)
Selector::Selector(ModeT mode, std::string const& pattern) : mode_(mode), pat_(pattern)
{
if (mode_ == mode_t::automatch && pattern.empty())
mode_ = mode_t::all;
if (mode_ == ModeT::Automatch && pattern.empty())
mode_ = ModeT::All;
}
template <class>
bool
selector::operator()(suite_info const& s)
Selector::operator()(SuiteInfo const& s)
{
switch (mode_)
{
case mode_t::automatch:
case ModeT::Automatch:
// suite or full name
if (s.name() == pat_ || s.full_name() == pat_)
if (s.name() == pat_ || s.fullName() == pat_)
{
mode_ = mode_t::none;
mode_ = ModeT::None;
return true;
}
// check module
if (pat_ == s.module())
{
mode_ = mode_t::module;
mode_ = ModeT::Module;
library_ = s.library();
return !s.manual();
}
@@ -82,12 +82,12 @@ selector::operator()(suite_info const& s)
// check library
if (pat_ == s.library())
{
mode_ = mode_t::library;
mode_ = ModeT::Library;
return !s.manual();
}
// check start of name
if (s.name().starts_with(pat_) || s.full_name().starts_with(pat_))
if (s.name().starts_with(pat_) || s.fullName().starts_with(pat_))
{
// Don't change the mode so that the partial pattern can match
// more than once
@@ -96,19 +96,19 @@ selector::operator()(suite_info const& s)
return false;
case mode_t::suite:
case ModeT::Suite:
return pat_ == s.name();
case mode_t::module:
case ModeT::Module:
return pat_ == s.module() && !s.manual();
case mode_t::library:
case ModeT::Library:
return pat_ == s.library() && !s.manual();
case mode_t::none:
case ModeT::None:
return false;
case mode_t::all:
case ModeT::All:
default:
break;
};
@@ -122,7 +122,7 @@ selector::operator()(suite_info const& s)
/** Returns a predicate that implements a smart matching rule.
The predicate checks the suite, module, and library fields of the
suite_info in that order. When it finds a match, it changes modes
SuiteInfo in that order. When it finds a match, it changes modes
depending on what was found:
If a suite is matched first, then only the suite is selected. The
@@ -135,31 +135,31 @@ selector::operator()(suite_info const& s)
not marked manual are selected from then on.
*/
inline selector
match_auto(std::string const& name)
inline Selector
matchAuto(std::string const& name)
{
return selector(selector::mode_t::automatch, name);
return Selector(Selector::ModeT::Automatch, name);
}
/** Return a predicate that matches all suites not marked manual. */
inline selector
match_all()
inline Selector
matchAll()
{
return selector(selector::mode_t::all);
return Selector(Selector::ModeT::All);
}
/** Returns a predicate that matches a specific suite. */
inline selector
match_suite(std::string const& name)
inline Selector
matchSuite(std::string const& name)
{
return selector(selector::mode_t::suite, name);
return Selector(Selector::ModeT::Suite, name);
}
/** Returns a predicate that matches all suites in a library. */
inline selector
match_library(std::string const& name)
inline Selector
matchLibrary(std::string const& name)
{
return selector(selector::mode_t::library, name);
return Selector(Selector::ModeT::Library, name);
}
} // namespace beast::unit_test

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

@@ -10,65 +10,65 @@
namespace beast::unit_test {
/** A test runner that stores the results. */
class recorder : public runner
class Recorder : public Runner
{
private:
results m_results;
suite_results m_suite;
case_results m_case;
Results results_;
SuiteResults suite_;
CaseResults case_;
public:
recorder() = default;
Recorder() = default;
/** Returns a report with the results of all completed suites. */
[[nodiscard]] results const&
[[nodiscard]] Results const&
report() const
{
return m_results;
return results_;
}
private:
void
on_suite_begin(suite_info const& info) override
onSuiteBegin(SuiteInfo const& info) override
{
m_suite = suite_results(info.full_name());
suite_ = SuiteResults(info.fullName());
}
void
on_suite_end() override
onSuiteEnd() override
{
m_results.insert(std::move(m_suite));
results_.insert(std::move(suite_));
}
void
on_case_begin(std::string const& name) override
onCaseBegin(std::string const& name) override
{
m_case = case_results(name);
case_ = CaseResults(name);
}
void
on_case_end() override
onCaseEnd() override
{
if (!m_case.tests.empty())
m_suite.insert(std::move(m_case));
if (!case_.tests.empty())
suite_.insert(std::move(case_));
}
void
on_pass() override
onPass() override
{
m_case.tests.pass();
case_.tests.pass();
}
void
on_fail(std::string const& reason) override
onFail(std::string const& reason) override
{
m_case.tests.fail(reason);
case_.tests.fail(reason);
}
void
on_log(std::string const& s) override
onLog(std::string const& s) override
{
m_case.log.insert(s);
case_.log.insert(s);
}
};

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

@@ -26,23 +26,23 @@ namespace detail {
The totals are output when the object is destroyed.
*/
template <class = void>
class reporter : public runner
class Reporter : public Runner
{
private:
using clock_type = std::chrono::steady_clock;
struct case_results
struct CaseResults
{
std::string name;
std::size_t total = 0;
std::size_t failed = 0;
explicit case_results(std::string name_ = "") : name(std::move(name_))
explicit CaseResults(std::string name = "") : name(std::move(name))
{
}
};
struct suite_results
struct SuiteResults
{
std::string name;
std::size_t cases = 0;
@@ -50,21 +50,21 @@ private:
std::size_t failed = 0;
typename clock_type::time_point start = clock_type::now();
explicit suite_results(std::string name_ = "") : name(std::move(name_))
explicit SuiteResults(std::string name = "") : name(std::move(name))
{
}
void
add(case_results const& r);
add(CaseResults const& r);
};
struct results
struct Results
{
using run_time = std::pair<std::string, typename clock_type::duration>;
// Need to be named before converting
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum { max_top = 10 };
enum { MaxTop = 10 };
std::size_t suites = 0;
std::size_t cases = 0;
@@ -74,54 +74,54 @@ private:
typename clock_type::time_point start = clock_type::now();
void
add(suite_results const& r);
add(SuiteResults const& r);
};
std::ostream& os_;
results results_;
suite_results suite_results_;
case_results case_results_;
Results results_;
SuiteResults suite_results_;
CaseResults case_results_;
public:
reporter(reporter const&) = delete;
reporter&
operator=(reporter const&) = delete;
Reporter(Reporter const&) = delete;
Reporter&
operator=(Reporter const&) = delete;
~reporter() override;
~Reporter() override;
explicit reporter(std::ostream& os = std::cout);
explicit Reporter(std::ostream& os = std::cout);
private:
static std::string
fmtdur(typename clock_type::duration const& d);
void
on_suite_begin(suite_info const& info) override;
onSuiteBegin(SuiteInfo const& info) override;
void
on_suite_end() override;
onSuiteEnd() override;
void
on_case_begin(std::string const& name) override;
onCaseBegin(std::string const& name) override;
void
on_case_end() override;
onCaseEnd() override;
void
on_pass() override;
onPass() override;
void
on_fail(std::string const& reason) override;
onFail(std::string const& reason) override;
void
on_log(std::string const& s) override;
onLog(std::string const& s) override;
};
//------------------------------------------------------------------------------
template <class Unused>
void
reporter<Unused>::suite_results::add(case_results const& r)
Reporter<Unused>::SuiteResults::add(CaseResults const& r)
{
++cases;
total += r.total;
@@ -130,7 +130,7 @@ reporter<Unused>::suite_results::add(case_results const& r)
template <class Unused>
void
reporter<Unused>::results::add(suite_results const& r)
Reporter<Unused>::Results::add(SuiteResults const& r)
{
++suites;
total += r.total;
@@ -148,11 +148,11 @@ reporter<Unused>::results::add(suite_results const& r)
});
if (iter != top.end())
{
if (top.size() == max_top)
if (top.size() == MaxTop)
top.resize(top.size() - 1);
top.emplace(iter, r.name, elapsed);
}
else if (top.size() < max_top)
else if (top.size() < MaxTop)
{
top.emplace_back(r.name, elapsed);
}
@@ -162,12 +162,12 @@ reporter<Unused>::results::add(suite_results const& r)
//------------------------------------------------------------------------------
template <class Unused>
reporter<Unused>::reporter(std::ostream& os) : os_(os)
Reporter<Unused>::Reporter(std::ostream& os) : os_(os)
{
}
template <class Unused>
reporter<Unused>::~reporter()
Reporter<Unused>::~Reporter()
{
if (results_.top.size() > 0)
{
@@ -176,14 +176,14 @@ reporter<Unused>::~reporter()
os_ << std::setw(8) << fmtdur(i.second) << " " << i.first << '\n';
}
auto const elapsed = clock_type::now() - results_.start;
os_ << fmtdur(elapsed) << ", " << amount{results_.suites, "suite"} << ", "
<< amount{results_.cases, "case"} << ", " << amount{results_.total, "test"} << " total, "
<< amount{results_.failed, "failure"} << std::endl;
os_ << fmtdur(elapsed) << ", " << Amount{results_.suites, "suite"} << ", "
<< Amount{results_.cases, "case"} << ", " << Amount{results_.total, "test"} << " total, "
<< Amount{results_.failed, "failure"} << std::endl;
}
template <class Unused>
std::string
reporter<Unused>::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);
@@ -196,44 +196,44 @@ reporter<Unused>::fmtdur(typename clock_type::duration const& d)
template <class Unused>
void
reporter<Unused>::on_suite_begin(suite_info const& info)
Reporter<Unused>::onSuiteBegin(SuiteInfo const& info)
{
suite_results_ = suite_results{info.full_name()};
suite_results_ = SuiteResults{info.fullName()};
}
template <class Unused>
void
reporter<Unused>::on_suite_end()
Reporter<Unused>::onSuiteEnd()
{
results_.add(suite_results_);
}
template <class Unused>
void
reporter<Unused>::on_case_begin(std::string const& name)
Reporter<Unused>::onCaseBegin(std::string const& name)
{
case_results_ = case_results(name);
case_results_ = CaseResults(name);
os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name))
<< std::endl;
}
template <class Unused>
void
reporter<Unused>::on_case_end()
Reporter<Unused>::onCaseEnd()
{
suite_results_.add(case_results_);
}
template <class Unused>
void
reporter<Unused>::on_pass()
Reporter<Unused>::onPass()
{
++case_results_.total;
}
template <class Unused>
void
reporter<Unused>::on_fail(std::string const& reason)
Reporter<Unused>::onFail(std::string const& reason)
{
++case_results_.failed;
++case_results_.total;
@@ -243,13 +243,13 @@ reporter<Unused>::on_fail(std::string const& reason)
template <class Unused>
void
reporter<Unused>::on_log(std::string const& s)
Reporter<Unused>::onLog(std::string const& s)
{
os_ << s;
}
} // namespace detail
using reporter = detail::reporter<>;
using reporter = detail::Reporter<>;
} // namespace beast::unit_test

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

@@ -13,17 +13,17 @@
namespace beast::unit_test {
/** Holds a set of test condition outcomes in a testcase. */
class case_results
class CaseResults
{
public:
/** Holds the result of evaluating one test condition. */
struct test
struct Test
{
explicit test(bool pass_) : pass(pass_)
explicit Test(bool pass) : pass(pass)
{
}
test(bool pass_, std::string reason_) : pass(pass_), reason(std::move(reason_))
Test(bool pass, std::string reason) : pass(pass), reason(std::move(reason))
{
}
@@ -32,13 +32,13 @@ public:
};
private:
class tests_t : public detail::const_container<std::vector<test>>
class TestsT : public detail::ConstContainer<std::vector<Test>>
{
private:
std::size_t failed_{0};
public:
tests_t() = default;
TestsT() = default;
/** Returns the total number of test conditions. */
[[nodiscard]] std::size_t
@@ -70,7 +70,7 @@ private:
}
};
class log_t : public detail::const_container<std::vector<std::string>>
class LogT : public detail::ConstContainer<std::vector<std::string>>
{
public:
/** Insert a string into the log. */
@@ -84,7 +84,7 @@ private:
std::string name_;
public:
explicit case_results(std::string name = "") : name_(std::move(name))
explicit CaseResults(std::string name = "") : name_(std::move(name))
{
}
@@ -96,16 +96,16 @@ public:
}
/** Memberspace for a container of test condition outcomes. */
tests_t tests;
TestsT tests;
/** Memberspace for a container of testcase log messages. */
log_t log;
LogT log;
};
//--------------------------------------------------------------------------
/** Holds the set of testcase results in a suite. */
class suite_results : public detail::const_container<std::vector<case_results>>
class SuiteResults : public detail::ConstContainer<std::vector<CaseResults>>
{
private:
std::string name_;
@@ -113,7 +113,7 @@ private:
std::size_t failed_ = 0;
public:
explicit suite_results(std::string name = "") : name_(std::move(name))
explicit SuiteResults(std::string name = "") : name_(std::move(name))
{
}
@@ -141,7 +141,7 @@ public:
/** Insert a set of testcase results. */
/** @{ */
void
insert(case_results&& r)
insert(CaseResults&& r)
{
total_ += r.tests.total();
failed_ += r.tests.failed();
@@ -149,7 +149,7 @@ public:
}
void
insert(case_results const& r)
insert(CaseResults const& r)
{
cont().push_back(r);
total_ += r.tests.total();
@@ -162,21 +162,21 @@ public:
// VFALCO TODO Make this a template class using scoped allocators
/** Holds the results of running a set of testsuites. */
class results : public detail::const_container<std::vector<suite_results>>
class Results : public detail::ConstContainer<std::vector<SuiteResults>>
{
private:
std::size_t m_cases{0};
std::size_t cases_{0};
std::size_t total_{0};
std::size_t failed_{0};
public:
results() = default;
Results() = default;
/** Returns the total number of test cases. */
[[nodiscard]] std::size_t
cases() const
{
return m_cases;
return cases_;
}
/** Returns the total number of test conditions. */
@@ -196,18 +196,18 @@ public:
/** Insert a set of suite results. */
/** @{ */
void
insert(suite_results&& r)
insert(SuiteResults&& r)
{
m_cases += r.size();
cases_ += r.size();
total_ += r.total();
failed_ += r.failed();
cont().emplace_back(std::move(r));
}
void
insert(suite_results const& r)
insert(SuiteResults const& r)
{
m_cases += r.size();
cases_ += r.size();
total_ += r.total();
failed_ += r.failed();
cont().push_back(r);

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

@@ -18,7 +18,7 @@ namespace beast::unit_test {
Derived classes can customize the reporting behavior. This interface is
injected into the unit_test class to receive the results of the tests.
*/
class runner
class Runner
{
std::string arg_;
bool default_ = false;
@@ -27,11 +27,11 @@ class runner
std::recursive_mutex mutex_;
public:
runner() = default;
virtual ~runner() = default;
runner(runner const&) = delete;
runner&
operator=(runner const&) = delete;
Runner() = default;
virtual ~Runner() = default;
Runner(Runner const&) = delete;
Runner&
operator=(Runner const&) = delete;
/** Set the argument string.
@@ -58,12 +58,12 @@ public:
*/
template <class = void>
bool
run(suite_info const& s);
run(SuiteInfo const& s);
/** Run a sequence of suites.
The expression
`FwdIter::value_type`
must be convertible to `suite_info`.
must be convertible to `SuiteInfo`.
@return `true` if any conditions failed.
*/
template <class FwdIter>
@@ -73,77 +73,77 @@ public:
/** Conditionally run a sequence of suites.
pred will be called as:
@code
bool pred(suite_info const&);
bool pred(SuiteInfo const&);
@endcode
@return `true` if any conditions failed.
*/
template <class FwdIter, class Pred>
bool
run_if(FwdIter first, FwdIter last, Pred pred = Pred{});
runIf(FwdIter first, FwdIter last, Pred pred = Pred{});
/** Run all suites in a container.
@return `true` if any conditions failed.
*/
template <class SequenceContainer>
bool
run_each(SequenceContainer const& c);
runEach(SequenceContainer const& c);
/** Conditionally run suites in a container.
pred will be called as:
@code
bool pred(suite_info const&);
bool pred(SuiteInfo const&);
@endcode
@return `true` if any conditions failed.
*/
template <class SequenceContainer, class Pred>
bool
run_each_if(SequenceContainer const& c, Pred pred = Pred{});
runEachIf(SequenceContainer const& c, Pred pred = Pred{});
protected:
/// Called when a new suite starts.
virtual void
on_suite_begin(suite_info const&)
onSuiteBegin(SuiteInfo const&)
{
}
/// Called when a suite ends.
virtual void
on_suite_end()
onSuiteEnd()
{
}
/// Called when a new case starts.
virtual void
on_case_begin(std::string const&)
onCaseBegin(std::string const&)
{
}
/// Called when a new case ends.
virtual void
on_case_end()
onCaseEnd()
{
}
/// Called for each passing condition.
virtual void
on_pass()
onPass()
{
}
/// Called for each failing condition.
virtual void
on_fail(std::string const&)
onFail(std::string const&)
{
}
/// Called when a test logs output.
virtual void
on_log(std::string const&)
onLog(std::string const&)
{
}
private:
friend class suite;
friend class Suite;
// Start a new testcase.
template <class = void>
@@ -167,23 +167,23 @@ private:
template <class>
bool
runner::run(suite_info const& s)
Runner::run(SuiteInfo const& s)
{
// Enable 'default' testcase
default_ = true;
failed_ = false;
on_suite_begin(s);
onSuiteBegin(s);
s.run(*this);
// Forgot to call pass or fail.
BOOST_ASSERT(cond_);
on_case_end();
on_suite_end();
onCaseEnd();
onSuiteEnd();
return failed_;
}
template <class FwdIter>
bool
runner::run(FwdIter first, FwdIter last)
Runner::run(FwdIter first, FwdIter last)
{
bool failed(false);
for (; first != last; ++first)
@@ -193,7 +193,7 @@ runner::run(FwdIter first, FwdIter last)
template <class FwdIter, class Pred>
bool
runner::run_if(FwdIter first, FwdIter last, Pred pred)
Runner::runIf(FwdIter first, FwdIter last, Pred pred)
{
bool failed(false);
for (; first != last; ++first)
@@ -206,7 +206,7 @@ runner::run_if(FwdIter first, FwdIter last, Pred pred)
template <class SequenceContainer>
bool
runner::run_each(SequenceContainer const& c)
Runner::runEach(SequenceContainer const& c)
{
bool failed(false);
for (auto const& s : c)
@@ -216,7 +216,7 @@ runner::run_each(SequenceContainer const& c)
template <class SequenceContainer, class Pred>
bool
runner::run_each_if(SequenceContainer const& c, Pred pred)
Runner::runEachIf(SequenceContainer const& c, Pred pred)
{
bool failed(false);
for (auto const& s : c)
@@ -229,7 +229,7 @@ runner::run_each_if(SequenceContainer const& c, Pred pred)
template <class>
void
runner::testcase(std::string const& name)
Runner::testcase(std::string const& name)
{
std::scoped_lock const lock(mutex_);
// Name may not be empty
@@ -237,43 +237,43 @@ runner::testcase(std::string const& name)
// Forgot to call pass or fail
BOOST_ASSERT(default_ || cond_);
if (!default_)
on_case_end();
onCaseEnd();
default_ = false;
cond_ = false;
on_case_begin(name);
onCaseBegin(name);
}
template <class>
void
runner::pass()
Runner::pass()
{
std::scoped_lock const lock(mutex_);
if (default_)
testcase("");
on_pass();
onPass();
cond_ = true;
}
template <class>
void
runner::fail(std::string const& reason)
Runner::fail(std::string const& reason)
{
std::scoped_lock const lock(mutex_);
if (default_)
testcase("");
on_fail(reason);
onFail(reason);
failed_ = true;
cond_ = true;
}
template <class>
void
runner::log(std::string const& s)
Runner::log(std::string const& s)
{
std::scoped_lock const lock(mutex_);
if (default_)
testcase("");
on_log(s);
onLog(s);
}
} // namespace beast::unit_test

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

@@ -20,7 +20,7 @@ namespace detail {
template <class String>
static std::string
make_reason(String const& reason, char const* file, int line)
makeReason(String const& reason, char const* file, int line)
{
std::string s(reason);
if (!s.empty())
@@ -37,7 +37,7 @@ make_reason(String const& reason, char const* file, int line)
class Thread;
enum class abort_t { no_abort_on_fail, abort_on_fail };
enum class AbortT { NoAbortOnFail, AbortOnFail };
/** A testsuite class.
@@ -46,16 +46,16 @@ enum class abort_t { no_abort_on_fail, abort_on_fail };
derive from it and use the BEAST_DEFINE_UNIT_TEST macro in a
translation unit.
*/
class suite
class Suite
{
private:
bool abort_ = false;
bool aborted_ = false;
runner* runner_ = nullptr;
Runner* runner_ = nullptr;
// This exception is thrown internally to stop the current suite
// in the event of a failure, if the option to stop is set.
struct abort_exception : public std::exception
struct AbortException : public std::exception
{
[[nodiscard]] char const*
what() const noexcept override
@@ -65,16 +65,16 @@ private:
};
template <class CharT, class Traits, class Allocator>
class log_buf : public std::basic_stringbuf<CharT, Traits, Allocator>
class LogBuf : public std::basic_stringbuf<CharT, Traits, Allocator>
{
suite& suite_;
Suite& suite_;
public:
explicit log_buf(suite& self) : suite_(self)
explicit LogBuf(Suite& self) : suite_(self)
{
}
~log_buf() override
~LogBuf() override
{
sync();
}
@@ -94,25 +94,25 @@ private:
class CharT,
class Traits = std::char_traits<CharT>,
class Allocator = std::allocator<CharT>>
class log_os : public std::basic_ostream<CharT, Traits>
class LogOs : public std::basic_ostream<CharT, Traits>
{
log_buf<CharT, Traits, Allocator> buf_;
LogBuf<CharT, Traits, Allocator> buf_;
public:
explicit log_os(suite& self) : std::basic_ostream<CharT, Traits>(&buf_), buf_(self)
explicit LogOs(Suite& self) : std::basic_ostream<CharT, Traits>(&buf_), buf_(self)
{
}
};
class scoped_testcase;
class ScopedTestcase;
class testcase_t
class TestcaseT
{
suite& suite_;
Suite& suite_;
std::stringstream ss_;
public:
explicit testcase_t(suite& self) : suite_(self)
explicit TestcaseT(Suite& self) : suite_(self)
{
}
@@ -127,13 +127,13 @@ private:
@param abort Determines if suite continues running after a failure.
*/
void
operator()(std::string const& name, abort_t abort = abort_t::no_abort_on_fail);
operator()(std::string const& name, AbortT abort = AbortT::NoAbortOnFail);
scoped_testcase
operator()(abort_t abort);
ScopedTestcase
operator()(AbortT abort);
template <class T>
scoped_testcase
ScopedTestcase
operator<<(T const& t);
};
@@ -143,28 +143,28 @@ public:
Text sent to the log output stream will be forwarded to
the output stream associated with the runner.
*/
log_os<char> log;
LogOs<char> log;
/** Memberspace for declaring test cases. */
testcase_t testcase;
TestcaseT testcase;
/** Returns the "current" running suite.
If no suite is running, nullptr is returned.
*/
static suite*
this_suite()
static Suite*
thisSuite()
{
return *p_this_suite();
return *pThisSuite();
}
suite() : log(*this), testcase(*this)
Suite() : log(*this), testcase(*this)
{
}
virtual ~suite() = default;
suite(suite const&) = delete;
suite&
operator=(suite const&) = delete;
virtual ~Suite() = default;
Suite(Suite const&) = delete;
Suite&
operator=(Suite const&) = delete;
/** Invokes the test using the specified runner.
@@ -175,7 +175,7 @@ public:
*/
template <class = void>
void
operator()(runner& r);
operator()(Runner& r);
/** Record a successful test condition. */
template <class = void>
@@ -296,11 +296,11 @@ public:
private:
friend class Thread;
static suite**
p_this_suite()
static Suite**
pThisSuite()
{
static suite* pts = nullptr; // NOLINT(misc-const-correctness)
return &pts;
static Suite* kP_TS = nullptr; // NOLINT TODO
return &kP_TS;
}
/** Runs the suite. */
@@ -308,41 +308,41 @@ private:
run() = 0;
void
propagate_abort() const;
propagateAbort() const;
template <class = void>
void
run(runner& r);
run(Runner& r);
};
//------------------------------------------------------------------------------
// Helper for streaming testcase names
class suite::scoped_testcase
class Suite::ScopedTestcase
{
private:
suite& suite_;
Suite& suite_;
std::stringstream& ss_;
public:
scoped_testcase&
operator=(scoped_testcase const&) = delete;
ScopedTestcase&
operator=(ScopedTestcase const&) = delete;
~scoped_testcase()
~ScopedTestcase()
{
auto const& name = ss_.str();
if (!name.empty())
suite_.runner_->testcase(name);
}
scoped_testcase(suite& self, std::stringstream& ss) : suite_(self), ss_(ss)
ScopedTestcase(Suite& self, std::stringstream& ss) : suite_(self), ss_(ss)
{
ss_.clear();
ss_.str({});
}
template <class T>
scoped_testcase(suite& self, std::stringstream& ss, T const& t) : suite_(self), ss_(ss)
ScopedTestcase(Suite& self, std::stringstream& ss, T const& t) : suite_(self), ss_(ss)
{
ss_.clear();
ss_.str({});
@@ -350,7 +350,7 @@ public:
}
template <class T>
scoped_testcase&
ScopedTestcase&
operator<<(T const& t)
{
ss_ << t;
@@ -361,22 +361,22 @@ public:
//------------------------------------------------------------------------------
inline void
suite::testcase_t::operator()(std::string const& name, abort_t abort)
Suite::TestcaseT::operator()(std::string const& name, AbortT abort)
{
suite_.abort_ = abort == abort_t::abort_on_fail;
suite_.abort_ = abort == AbortT::AbortOnFail;
suite_.runner_->testcase(name);
}
inline suite::scoped_testcase
suite::testcase_t::operator()(abort_t abort)
inline Suite::ScopedTestcase
Suite::TestcaseT::operator()(AbortT abort)
{
suite_.abort_ = abort == abort_t::abort_on_fail;
suite_.abort_ = abort == AbortT::AbortOnFail;
return {suite_, ss_};
}
template <class T>
inline suite::scoped_testcase
suite::testcase_t::operator<<(T const& t)
inline Suite::ScopedTestcase
Suite::TestcaseT::operator<<(T const& t)
{
return {suite_, ss_, t};
}
@@ -385,24 +385,24 @@ suite::testcase_t::operator<<(T const& t)
template <class>
void
suite::operator()(runner& r)
Suite::operator()(Runner& r)
{
*p_this_suite() = this;
*pThisSuite() = this;
try
{
run(r);
*p_this_suite() = nullptr;
*pThisSuite() = nullptr;
}
catch (...)
{
*p_this_suite() = nullptr;
*pThisSuite() = nullptr;
throw;
}
}
template <class Condition, class String>
bool
suite::expect(Condition const& shouldBeTrue, String const& reason)
Suite::expect(Condition const& shouldBeTrue, String const& reason)
{
if (shouldBeTrue)
{
@@ -415,14 +415,14 @@ suite::expect(Condition const& shouldBeTrue, String const& reason)
template <class Condition, class String>
bool
suite::expect(Condition const& shouldBeTrue, String const& reason, char const* file, int line)
Suite::expect(Condition const& shouldBeTrue, String const& reason, char const* file, int line)
{
if (shouldBeTrue)
{
pass();
return true;
}
fail(detail::make_reason(reason, file, line));
fail(detail::makeReason(reason, file, line));
return false;
}
@@ -430,7 +430,7 @@ suite::expect(Condition const& shouldBeTrue, String const& reason, char const* f
template <class F, class String>
bool
suite::except(F&& f, String const& reason)
Suite::except(F&& f, String const& reason)
{
try
{
@@ -447,7 +447,7 @@ suite::except(F&& f, String const& reason)
template <class E, class F, class String>
bool
suite::except(F&& f, String const& reason)
Suite::except(F&& f, String const& reason)
{
try
{
@@ -464,7 +464,7 @@ suite::except(F&& f, String const& reason)
template <class F, class String>
bool
suite::unexcept(F&& f, String const& reason)
Suite::unexcept(F&& f, String const& reason)
{
try
{
@@ -481,7 +481,7 @@ suite::unexcept(F&& f, String const& reason)
template <class Condition, class String>
bool
suite::unexpected(Condition shouldBeFalse, String const& reason)
Suite::unexpected(Condition shouldBeFalse, String const& reason)
{
bool const b = static_cast<bool>(shouldBeFalse);
if (!b)
@@ -497,43 +497,43 @@ suite::unexpected(Condition shouldBeFalse, String const& reason)
template <class>
void
suite::pass()
Suite::pass()
{
propagate_abort();
propagateAbort();
runner_->pass();
}
// ::fail
template <class>
void
suite::fail(std::string const& reason)
Suite::fail(std::string const& reason)
{
propagate_abort();
propagateAbort();
runner_->fail(reason);
if (abort_)
{
aborted_ = true;
BOOST_THROW_EXCEPTION(abort_exception());
BOOST_THROW_EXCEPTION(AbortException());
}
}
template <class String>
void
suite::fail(String const& reason, char const* file, int line)
Suite::fail(String const& reason, char const* file, int line)
{
fail(detail::make_reason(reason, file, line));
fail(detail::makeReason(reason, file, line));
}
inline void
suite::propagate_abort() const
Suite::propagateAbort() const
{
if (abort_ && aborted_)
BOOST_THROW_EXCEPTION(abort_exception());
BOOST_THROW_EXCEPTION(AbortException());
}
template <class>
void
suite::run(runner& r)
Suite::run(Runner& r)
{
runner_ = &r;
@@ -541,7 +541,7 @@ suite::run(runner& r)
{
run();
}
catch (abort_exception const&) // NOLINT(bugprone-empty-catch)
catch (AbortException const&) // NOLINT(bugprone-empty-catch)
{
// ends the suite
}
@@ -579,7 +579,7 @@ suite::run(runner& r)
// detail:
// This inserts the suite with the given manual flag
#define BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, manual, priority) \
static beast::unit_test::detail::insert_suite<Class##_test> \
static beast::unit_test::detail::InsertSuite<Class##_test> \
Library##Module##Class##_test_instance(#Class, #Module, #Library, manual, priority)
//------------------------------------------------------------------------------

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

@@ -11,12 +11,12 @@
namespace beast::unit_test {
class runner;
class Runner;
/** Associates a unit test type with metadata. */
class suite_info
class SuiteInfo
{
using run_type = std::function<void(runner&)>;
using run_type = std::function<void(Runner&)>;
std::string name_;
std::string module_;
@@ -26,7 +26,7 @@ class suite_info
run_type run_;
public:
suite_info(
SuiteInfo(
std::string name,
std::string module,
std::string library,
@@ -69,20 +69,20 @@ public:
/// Return the canonical suite name as a string.
[[nodiscard]] std::string
full_name() const
fullName() const
{
return library_ + "." + module_ + "." + name_;
}
/// Run a new instance of the associated test suite.
void
run(runner& r) const
run(Runner& r) const
{
run_(r);
}
friend bool
operator<(suite_info const& lhs, suite_info const& rhs)
operator<(SuiteInfo const& lhs, SuiteInfo const& rhs)
{
// we want higher priority suites sorted first, thus the negation
// of priority value here
@@ -93,18 +93,13 @@ public:
//------------------------------------------------------------------------------
/// Convenience for producing suite_info for a given test type.
/// Convenience for producing SuiteInfo for a given test type.
template <class Suite>
suite_info
make_suite_info(
std::string name,
std::string module,
std::string library,
bool manual,
int priority)
SuiteInfo
makeSuiteInfo(std::string name, std::string module, std::string library, bool manual, int priority)
{
return suite_info(
std::move(name), std::move(module), std::move(library), manual, priority, [](runner& r) {
return SuiteInfo(
std::move(name), std::move(module), std::move(library), manual, priority, [](Runner& r) {
Suite{}(r);
});
}

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

@@ -16,7 +16,7 @@
namespace beast::unit_test {
/// A container of test suites.
class suite_list : public detail::const_container<std::set<suite_info>>
class SuiteList : public detail::ConstContainer<std::set<SuiteInfo>>
{
private:
#ifndef NDEBUG
@@ -38,7 +38,7 @@ public:
template <class Suite>
void
suite_list::insert(
SuiteList::insert(
char const* name,
char const* module,
char const* library,
@@ -58,7 +58,7 @@ suite_list::insert(
BOOST_ASSERT(result.second); // Duplicate type
}
#endif
cont().emplace(make_suite_info<Suite>(name, module, library, manual, priority));
cont().emplace(makeSuiteInfo<Suite>(name, module, library, manual, priority));
}
} // namespace beast::unit_test

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

@@ -16,7 +16,7 @@ namespace beast::unit_test {
class Thread
{
private:
suite* s_ = nullptr;
Suite* s_ = nullptr;
std::thread t_;
public:
@@ -41,7 +41,7 @@ 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));
@@ -54,13 +54,13 @@ public:
}
[[nodiscard]] std::thread::id
get_id() const
getId() const
{
return t_.get_id();
}
static unsigned
hardware_concurrency() noexcept
hardwareConcurrency() noexcept
{
return std::thread::hardware_concurrency();
}
@@ -69,7 +69,7 @@ public:
join()
{
t_.join();
s_->propagate_abort();
s_->propagateAbort();
}
void
@@ -93,7 +93,7 @@ private:
{
f();
}
catch (suite::abort_exception const&) // NOLINT(bugprone-empty-catch)
catch (Suite::AbortException const&) // NOLINT(bugprone-empty-catch)
{
}
catch (std::exception const& e)

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

@@ -12,17 +12,17 @@ namespace severities {
// Hundreds of usages via logging macros
// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum Severity {
kAll = 0,
KAll = 0,
kTrace = kAll,
kDebug = 1,
kInfo = 2,
kWarning = 3,
kError = 4,
kFatal = 5,
KTrace = KAll,
KDebug = 1,
KInfo = 2,
KWarning = 3,
KError = 4,
KFatal = 5,
kDisabled = 6,
kNone = kDisabled
KDisabled = 6,
KNone = KDisabled
};
} // namespace severities
@@ -47,8 +47,8 @@ private:
// Severity level / threshold of a Journal message.
using Severity = severities::Severity;
// Invariant: m_sink always points to a valid Sink
Sink* m_sink;
// Invariant: sink_ always points to a valid Sink
Sink* sink_;
public:
//--------------------------------------------------------------------------
@@ -108,7 +108,7 @@ public:
private:
Severity thresh_;
bool m_console;
bool console_;
};
#ifndef __INTELLISENSE__
@@ -132,7 +132,7 @@ public:
class ScopedStream
{
public:
ScopedStream(ScopedStream const& other) : ScopedStream(other.m_sink, other.m_level)
ScopedStream(ScopedStream const& other) : ScopedStream(other.sink_, other.level_)
{
}
@@ -151,7 +151,7 @@ public:
std::ostringstream&
ostream() const
{
return m_ostream;
return ostream_;
}
std::ostream&
@@ -162,9 +162,9 @@ public:
operator<<(T const& t) const;
private:
Sink& m_sink;
Severity const m_level;
std::ostringstream mutable m_ostream;
Sink& sink_;
Severity const level_;
std::ostringstream mutable ostream_;
};
#ifndef __INTELLISENSE__
@@ -183,7 +183,7 @@ public:
{
public:
/** Create a stream which produces no output. */
explicit Stream() : m_sink(getNullSink()), m_level(severities::kDisabled)
explicit Stream() : sink_(getNullSink()), level_(severities::KDisabled)
{
}
@@ -191,14 +191,14 @@ public:
Constructor is inlined so checking active() very inexpensive.
*/
Stream(Sink& sink, Severity level) : m_sink(sink), m_level(level)
Stream(Sink& sink, Severity level) : sink_(sink), level_(level)
{
XRPL_ASSERT(
m_level < severities::kDisabled, "beast::Journal::Stream::Stream : maximum level");
level_ < severities::KDisabled, "beast::Journal::Stream::Stream : maximum level");
}
/** Construct or copy another Stream. */
Stream(Stream const& other) : Stream(other.m_sink, other.m_level)
Stream(Stream const& other) : Stream(other.sink_, other.level_)
{
}
@@ -209,14 +209,14 @@ public:
[[nodiscard]] Sink&
sink() const
{
return m_sink;
return sink_;
}
/** Returns the Severity level of messages this Stream reports. */
[[nodiscard]] Severity
level() const
{
return m_level;
return level_;
}
/** Returns `true` if sink logs anything at this stream's level. */
@@ -224,7 +224,7 @@ public:
[[nodiscard]] bool
active() const
{
return m_sink.active(m_level);
return sink_.active(level_);
}
explicit
@@ -245,8 +245,8 @@ public:
/** @} */
private:
Sink& m_sink;
Severity m_level;
Sink& sink_;
Severity level_;
};
#ifndef __INTELLISENSE__
@@ -264,7 +264,7 @@ public:
Journal() = delete;
/** Create a journal that writes to the specified sink. */
explicit Journal(Sink& sink) : m_sink(&sink)
explicit Journal(Sink& sink) : sink_(&sink)
{
}
@@ -272,14 +272,14 @@ public:
[[nodiscard]] Sink&
sink() const
{
return *m_sink;
return *sink_;
}
/** Returns a stream for this sink, with the specified severity level. */
[[nodiscard]] Stream
stream(Severity level) const
{
return Stream(*m_sink, level);
return Stream(*sink_, level);
}
/** Returns `true` if any message would be logged at this severity level.
@@ -289,7 +289,7 @@ public:
[[nodiscard]] bool
active(Severity level) const
{
return m_sink->active(level);
return sink_->active(level);
}
/** Severity stream access functions. */
@@ -297,37 +297,37 @@ public:
[[nodiscard]] Stream
trace() const
{
return {*m_sink, severities::kTrace};
return {*sink_, severities::KTrace};
}
[[nodiscard]] Stream
debug() const
{
return {*m_sink, severities::kDebug};
return {*sink_, severities::KDebug};
}
[[nodiscard]] Stream
info() const
{
return {*m_sink, severities::kInfo};
return {*sink_, severities::KInfo};
}
[[nodiscard]] Stream
warn() const
{
return {*m_sink, severities::kWarning};
return {*sink_, severities::KWarning};
}
[[nodiscard]] Stream
error() const
{
return {*m_sink, severities::kError};
return {*sink_, severities::KError};
}
[[nodiscard]] Stream
fatal() const
{
return {*m_sink, severities::kFatal};
return {*sink_, severities::KFatal};
}
/** @} */
};
@@ -347,15 +347,15 @@ template <typename T>
Journal::ScopedStream::ScopedStream(Journal::Stream const& stream, T const& t)
: ScopedStream(stream.sink(), stream.level())
{
m_ostream << t;
ostream_ << t;
}
template <typename T>
std::ostream&
Journal::ScopedStream::operator<<(T const& t) const
{
m_ostream << t;
return m_ostream;
ostream_ << t;
return ostream_;
}
//------------------------------------------------------------------------------
@@ -370,7 +370,7 @@ Journal::Stream::operator<<(T const& t) const
namespace detail {
template <class CharT, class Traits = std::char_traits<CharT>>
class logstream_buf : public std::basic_stringbuf<CharT, Traits>
class LogStreamBuf : public std::basic_stringbuf<CharT, Traits>
{
beast::Journal::Stream strm_;
@@ -389,11 +389,11 @@ class logstream_buf : public std::basic_stringbuf<CharT, Traits>
}
public:
explicit logstream_buf(beast::Journal::Stream const& strm) : strm_(strm)
explicit LogStreamBuf(beast::Journal::Stream const& strm) : strm_(strm)
{
}
~logstream_buf() override
~LogStreamBuf() override
{
sync();
}
@@ -414,7 +414,7 @@ public:
} // namespace detail
template <class CharT, class Traits = std::char_traits<CharT>>
class basic_logstream : public std::basic_ostream<CharT, Traits>
class BasicLogstream : public std::basic_ostream<CharT, Traits>
{
using char_type = CharT;
using traits_type = Traits;
@@ -422,16 +422,16 @@ class basic_logstream : public std::basic_ostream<CharT, Traits>
using pos_type = typename traits_type::pos_type;
using off_type = typename traits_type::off_type;
detail::logstream_buf<CharT, Traits> buf_;
detail::LogStreamBuf<CharT, Traits> buf_;
public:
explicit basic_logstream(beast::Journal::Stream const& strm)
explicit BasicLogstream(beast::Journal::Stream const& strm)
: std::basic_ostream<CharT, Traits>(&buf_), buf_(strm)
{
}
};
using logstream = basic_logstream<char>;
using logwstream = basic_logstream<wchar_t>;
using logstream = BasicLogstream<char>;
using logwstream = BasicLogstream<wchar_t>;
} // namespace beast

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

@@ -23,11 +23,11 @@ public:
protected:
virtual void
map_begin() = 0;
mapBegin() = 0;
virtual void
map_begin(std::string const& key) = 0;
mapBegin(std::string const& key) = 0;
virtual void
map_end() = 0;
mapEnd() = 0;
virtual void
add(std::string const& key, std::string const& value) = 0;
@@ -40,7 +40,7 @@ protected:
template <typename Value>
void
lexical_add(std::string const& key, Value value)
lexicalAdd(std::string const& key, Value value)
{
std::stringstream ss;
ss << value;
@@ -79,11 +79,11 @@ protected:
add(std::string const& key, long double value);
virtual void
array_begin() = 0;
arrayBegin() = 0;
virtual void
array_begin(std::string const& key) = 0;
arrayBegin(std::string const& key) = 0;
virtual void
array_end() = 0;
arrayEnd() = 0;
virtual void
add(std::string const& value) = 0;
@@ -96,7 +96,7 @@ protected:
template <typename Value>
void
lexical_add(Value value)
lexicalAdd(Value value)
{
std::stringstream ss;
ss << value;
@@ -157,7 +157,7 @@ public:
operator*() const;
private:
Source* m_source;
Source* source_;
};
//------------------------------------------------------------------------------
@@ -169,9 +169,9 @@ private:
class PropertyStream::Proxy
{
private:
Map const* m_map;
std::string m_key;
std::ostringstream mutable m_ostream;
Map const* map_;
std::string key_;
std::ostringstream mutable ostream_;
public:
Proxy(Map const& map, std::string key);
@@ -189,7 +189,7 @@ public:
std::ostream&
operator<<(T const& t) const
{
return m_ostream << t;
return ostream_ << t;
}
};
@@ -202,7 +202,7 @@ public:
class PropertyStream::Map
{
private:
PropertyStream& m_stream;
PropertyStream& stream_;
public:
explicit Map(PropertyStream& stream);
@@ -224,7 +224,7 @@ public:
void
add(std::string const& key, Value value) const
{
m_stream.add(key, value);
stream_.add(key, value);
}
template <typename Key, typename Value>
@@ -261,7 +261,7 @@ template <typename Value>
PropertyStream::Proxy&
PropertyStream::Proxy::operator=(Value value)
{
m_map->add(m_key, value);
map_->add(key_, value);
return *this;
}
@@ -274,7 +274,7 @@ PropertyStream::Proxy::operator=(Value value)
class PropertyStream::Set
{
private:
PropertyStream& m_stream;
PropertyStream& stream_;
public:
Set(std::string const& key, Map& map);
@@ -294,7 +294,7 @@ public:
void
add(Value value) const
{
m_stream.add(value);
stream_.add(value);
}
};
@@ -308,7 +308,7 @@ public:
class PropertyStream::Source
{
private:
std::string const m_name;
std::string const name_;
std::recursive_mutex lock_;
Item item_;
Source* parent_{nullptr};
@@ -351,7 +351,7 @@ public:
/** Write only this Source to the stream. */
void
write_one(PropertyStream& stream);
writeOne(PropertyStream& stream);
/** write this source and all its children recursively to the stream. */
void
@@ -384,18 +384,18 @@ public:
find(std::string path);
Source*
find_one_deep(std::string const& name);
findOneDeep(std::string const& name);
PropertyStream::Source*
find_path(std::string path);
findPath(std::string path);
PropertyStream::Source*
find_one(std::string const& name);
findOne(std::string const& name);
static bool
peel_leading_slash(std::string* path);
peelLeadingSlash(std::string* path);
static bool
peel_trailing_slashstar(std::string* path);
peelTrailingSlashstar(std::string* path);
static std::string
peel_name(std::string* path);
peelName(std::string* path);
//--------------------------------------------------------------------------

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

@@ -27,7 +27,7 @@ struct Zero
};
namespace {
constexpr Zero zero{};
constexpr Zero kZERO{};
} // namespace
/** Default implementation of signum calls the method on the class. */
@@ -44,7 +44,7 @@ namespace detail::zero_helper {
// be made from a namespace that does not include overloads of the function..
template <class T>
auto
call_signum(T const& t)
callSignum(T const& t)
{
return signum(t);
}
@@ -57,42 +57,42 @@ template <typename T>
bool
operator==(T const& t, Zero)
{
return detail::zero_helper::call_signum(t) == 0;
return detail::zero_helper::callSignum(t) == 0;
}
template <typename T>
bool
operator!=(T const& t, Zero)
{
return detail::zero_helper::call_signum(t) != 0;
return detail::zero_helper::callSignum(t) != 0;
}
template <typename T>
bool
operator<(T const& t, Zero)
{
return detail::zero_helper::call_signum(t) < 0;
return detail::zero_helper::callSignum(t) < 0;
}
template <typename T>
bool
operator>(T const& t, Zero)
{
return detail::zero_helper::call_signum(t) > 0;
return detail::zero_helper::callSignum(t) > 0;
}
template <typename T>
bool
operator>=(T const& t, Zero)
{
return detail::zero_helper::call_signum(t) >= 0;
return detail::zero_helper::callSignum(t) >= 0;
}
template <typename T>
bool
operator<=(T const& t, Zero)
{
return detail::zero_helper::call_signum(t) <= 0;
return detail::zero_helper::callSignum(t) <= 0;
}
// Handle operators where T is on the right side by
@@ -102,42 +102,42 @@ template <typename T>
bool
operator==(Zero, T const& t)
{
return t == zero;
return t == kZERO;
}
template <typename T>
bool
operator!=(Zero, T const& t)
{
return t != zero;
return t != kZERO;
}
template <typename T>
bool
operator<(Zero, T const& t)
{
return t > zero;
return t > kZERO;
}
template <typename T>
bool
operator>(Zero, T const& t)
{
return t < zero;
return t < kZERO;
}
template <typename T>
bool
operator>=(Zero, T const& t)
{
return t <= zero;
return t <= kZERO;
}
template <typename T>
bool
operator<=(Zero, T const& t)
{
return t >= zero;
return t >= kZERO;
}
} // namespace beast

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

@@ -6,15 +6,15 @@ namespace beast {
/** Makes T const or non const depending on a bool. */
template <bool IsConst, class T>
struct maybe_const
struct MaybeConst
{
explicit maybe_const() = default;
explicit MaybeConst() = default;
using type = std::
conditional_t<IsConst, typename std::remove_const<T>::type const, std::remove_const_t<T>>;
};
/** Alias for omitting `typename`. */
template <bool IsConst, class T>
using maybe_const_t = typename maybe_const<IsConst, T>::type;
using maybe_const_t = typename MaybeConst<IsConst, T>::type;
} // namespace beast

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

@@ -14,24 +14,24 @@ void
rngfill(void* const buffer, std::size_t const bytes, Generator& g)
{
using result_type = typename Generator::result_type;
constexpr std::size_t result_size = sizeof(result_type);
constexpr std::size_t kRESULT_SIZE = sizeof(result_type);
std::uint8_t* const buffer_start = static_cast<std::uint8_t*>(buffer);
std::size_t const complete_iterations = bytes / result_size;
std::size_t const bytes_remaining = bytes % result_size;
std::uint8_t* const bufferStart = static_cast<std::uint8_t*>(buffer);
std::size_t const completeIterations = bytes / kRESULT_SIZE;
std::size_t const bytesRemaining = bytes % kRESULT_SIZE;
for (std::size_t count = 0; count < complete_iterations; ++count)
for (std::size_t count = 0; count < completeIterations; ++count)
{
result_type const v = g();
std::size_t const offset = count * result_size;
std::memcpy(buffer_start + offset, &v, result_size);
std::size_t const offset = count * kRESULT_SIZE;
std::memcpy(bufferStart + offset, &v, kRESULT_SIZE);
}
if (bytes_remaining > 0)
if (bytesRemaining > 0)
{
result_type const v = g();
std::size_t const offset = complete_iterations * result_size;
std::memcpy(buffer_start + offset, &v, bytes_remaining);
std::size_t const offset = completeIterations * kRESULT_SIZE;
std::memcpy(bufferStart + offset, &v, bytesRemaining);
}
}

12
include/xrpl/beast/utility/temp_dir.h
View File

@@ -11,19 +11,19 @@ namespace beast {
The directory and all its contents are deleted when
the instance of `temp_dir` is destroyed.
*/
class temp_dir
class TempDir
{
boost::filesystem::path path_;
public:
#if !GENERATING_DOCS
temp_dir(temp_dir const&) = delete;
temp_dir&
operator=(temp_dir const&) = delete;
TempDir(TempDir const&) = delete;
TempDir&
operator=(TempDir const&) = delete;
#endif
/// Construct a temporary directory.
temp_dir()
TempDir()
{
auto const dir = boost::filesystem::temp_directory_path();
do
@@ -34,7 +34,7 @@ public:
}
/// Destroy a temporary directory.
~temp_dir()
~TempDir()
{
// use non-throwing calls in the destructor
boost::system::error_code ec;

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

@@ -9,16 +9,16 @@ namespace beast {
namespace detail {
template <class = void>
class xor_shift_engine
class XorShiftEngine
{
public:
using result_type = std::uint64_t;
xor_shift_engine(xor_shift_engine const&) = default;
xor_shift_engine&
operator=(xor_shift_engine const&) = default;
XorShiftEngine(XorShiftEngine const&) = default;
XorShiftEngine&
operator=(XorShiftEngine const&) = default;
explicit xor_shift_engine(result_type val = 1977u);
explicit XorShiftEngine(result_type val = 1977u);
void
seed(result_type seed);
@@ -44,14 +44,14 @@ private:
};
template <class Unused>
xor_shift_engine<Unused>::xor_shift_engine(result_type val)
XorShiftEngine<Unused>::XorShiftEngine(result_type val)
{
seed(val);
}
template <class Unused>
void
xor_shift_engine<Unused>::seed(result_type seed)
XorShiftEngine<Unused>::seed(result_type seed)
{
if (seed == 0)
throw std::domain_error("invalid seed");
@@ -61,7 +61,7 @@ xor_shift_engine<Unused>::seed(result_type seed)
template <class Unused>
auto
xor_shift_engine<Unused>::operator()() -> result_type
XorShiftEngine<Unused>::operator()() -> result_type
{
result_type s1 = s_[0];
result_type const s0 = s_[1];
@@ -72,7 +72,7 @@ xor_shift_engine<Unused>::operator()() -> result_type
template <class Unused>
auto
xor_shift_engine<Unused>::murmurhash3(result_type x) -> result_type
XorShiftEngine<Unused>::murmurhash3(result_type x) -> result_type
{
x ^= x >> 33;
x *= 0xff51afd7ed558ccdULL;
@@ -91,6 +91,6 @@ xor_shift_engine<Unused>::murmurhash3(result_type x) -> result_type
http://xorshift.di.unimi.it/xorshift128plus.c
does not accept seed==0
*/
using xor_shift_engine = detail::xor_shift_engine<>;
using xor_shift_engine = detail::XorShiftEngine<>;
} // namespace beast

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

@@ -10,11 +10,11 @@
namespace xrpl::cryptoconditions {
enum class Type : std::uint8_t {
preimageSha256 = 0,
prefixSha256 = 1,
thresholdSha256 = 2,
rsaSha256 = 3,
ed25519Sha256 = 4
PreimageSha256 = 0,
PrefixSha256 = 1,
ThresholdSha256 = 2,
RsaSha256 = 3,
Ed25519Sha256 = 4
};
class Condition
@@ -27,7 +27,7 @@ public:
that were previously considered valid to no longer
be allowed.
*/
static constexpr std::size_t maxSerializedCondition = 128;
static constexpr std::size_t kMAX_SERIALIZED_CONDITION = 128;
/** Load a condition from its binary form

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