Namespaces
namespace	detail
namespace	insight
namespace	ip
namespace	rfc2616
namespace	test
namespace	unit_test
namespace	inner_adl_test

Classes
struct	IsUniquelyRepresented< xrpl::BaseUInt< Bits, Tag > >
struct	IsContiguouslyHashable< xrpl::TaggedInteger< Int, Tag >, HashAlgorithm >
class	IOLatencyProbe
	Measures handler latency on an io_context queue. More...
class	AbstractClock
	Abstract interface to a clock. More...
class	BasicSecondsClock
	A clock whose minimum resolution is one second. More...
class	ManualClock
	Manual clock implementation. More...
struct	IsAgedContainer
class	aged_ordered_container
struct	IsAgedContainer< beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > >
struct	IsAgedContainer< beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > >
struct	BadLexicalCast
	Thrown when a conversion is not possible with LexicalCast. More...
class	List
	Intrusive doubly linked list. More...
class	LockFreeStackIterator
class	LockFreeStack
	Multiple Producer, Multiple Consumer (MPMC) intrusive stack. More...
class	SemanticVersion
	A Semantic Version number. More...
struct	IsUniquelyRepresented
struct	IsUniquelyRepresented< T const >
struct	IsUniquelyRepresented< T volatile >
struct	IsUniquelyRepresented< T const volatile >
struct	IsUniquelyRepresented< std::pair< T, U > >
struct	IsUniquelyRepresented< std::tuple< T... > >
struct	IsUniquelyRepresented< T[N]>
struct	IsUniquelyRepresented< std::array< T, N > >
struct	IsContiguouslyHashable
	Metafunction returning true if the type can be hashed in one call. More...
struct	IsContiguouslyHashable< T[N], HashAlgorithm >
struct	Uhash
class	Xxhasher
struct	IPAddressConversion
class	Journal
	A generic endpoint for log messages. More...
class	BasicLogstream
struct	MaybeConst
	Makes T const or non const depending on a bool. More...
class	PropertyStream
	Abstract stream with RAII containers that produce a property tree. More...
class	WrappedSink
	Wraps a Journal::Sink to prefix its output with a string. More...
struct	Zero
	Zero allows classes to offer efficient comparisons to zero. More...
class	NullJournalSink
class	AgedAssociativeContainerTestBase
class	aged_set_test
class	aged_map_test
class	aged_multiset_test
class	aged_multimap_test
class	aged_unordered_set_test
class	aged_unordered_map_test
class	aged_unordered_multiset_test
class	aged_unordered_multimap_test
class	abstract_clock_test
class	BasicSecondsClock_test
class	Journal_test
class	PropertyStream_test
class	XXHasher_test
struct	IntegerTypeNames
class	LexicalCastIntegers
class	SemanticVersionParse
class	SemanticVersionValues
class	SemanticVersionOrder
struct	AdlTester

Typedefs
template<class Key, class T, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>
using	aged_map = detail::AgedOrderedContainer<false, true, Key, T, Clock, Compare, Allocator>
template<class Key, class T, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>
using	aged_multimap = detail::AgedOrderedContainer<true, true, Key, T, Clock, Compare, Allocator>
template<class Key, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<Key>>
using	aged_multiset
template<class Key, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<Key>>
using	aged_set = detail::AgedOrderedContainer<false, false, Key, void, Clock, Compare, Allocator>
template<class Key, class T, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>
using	aged_unordered_map
template<class Key, class T, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>
using	aged_unordered_multimap
template<class Key, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<Key>>
using	aged_unordered_multiset
template<class Key, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<Key>>
using	aged_unordered_set
using	logstream = BasicLogstream<char>
using	logwstream = BasicLogstream<wchar_t>
template<bool IsConst, class T>
using	maybe_const_t = MaybeConst<IsConst, T>::type
	Alias for omitting typename.
using	xor_shift_engine = detail::XorShiftEngine<>
	XOR-shift Generator.
using	IntegerTypes

Enumerations
enum class	Severity : std::uint8_t { All = 0 , Trace = All , Debug = 1 , Info = 2 , Warning = 3 , Error = 4 , Fatal = 5 , Disabled = 6 , None = Disabled }
	Severity level / threshold of a Journal message. More...

Functions
template<class Facade, class Clock = Facade>
AbstractClock< Facade > &	getAbstractClock ()
	Returns a global instance of an abstract clock.
template<class AgedContainer, class Rep, class Period> requires (IsAgedContainer<AgedContainer>::value)
std::size_t	expire (AgedContainer &c, std::chrono::duration< Rep, Period > const &age)
	Expire aged container items past the specified age.
template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
void	swap (beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &lhs, beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &rhs) noexcept
template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator, class Rep, class Period>
std::size_t	expire (detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &c, std::chrono::duration< Rep, Period > const &age)
	Expire aged container items past the specified age.
template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Hash, class KeyEqual, class Allocator>
void	swap (beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &lhs, beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &rhs) noexcept
template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Hash, class KeyEqual, class Allocator, class Rep, class Period>
std::size_t	expire (beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &c, std::chrono::duration< Rep, Period > const &age) noexcept
	Expire aged container items past the specified age.
void	setCurrentThreadName (std::string_view newThreadName)
	Changes the name of the caller thread.
std::string	getCurrentThreadName ()
	Returns the name of the caller thread.
template<class Out, class In>
constexpr bool	lexicalCastChecked (Out &out, In in)
	Intelligently convert from one type to another.
template<class Out, class In>
constexpr Out	lexicalCastThrow (In in)
	Convert from one type to another, throw on error.
template<class Out, class In>
constexpr Out	lexicalCast (In in, Out defaultValue=Out())
	Convert from one type to another.
template<class Container, bool LhsIsConst, bool RhsIsConst>
bool	operator== (LockFreeStackIterator< Container, LhsIsConst > const &lhs, LockFreeStackIterator< Container, RhsIsConst > const &rhs)
template<class Container, bool LhsIsConst, bool RhsIsConst>
bool	operator!= (LockFreeStackIterator< Container, LhsIsConst > const &lhs, LockFreeStackIterator< Container, RhsIsConst > const &rhs)
int	compare (SemanticVersion const &lhs, SemanticVersion const &rhs)
	Compare two SemanticVersions against each other.
bool	operator== (SemanticVersion const &lhs, SemanticVersion const &rhs)
bool	operator!= (SemanticVersion const &lhs, SemanticVersion const &rhs)
bool	operator>= (SemanticVersion const &lhs, SemanticVersion const &rhs)
bool	operator<= (SemanticVersion const &lhs, SemanticVersion const &rhs)
bool	operator> (SemanticVersion const &lhs, SemanticVersion const &rhs)
bool	operator< (SemanticVersion const &lhs, SemanticVersion const &rhs)
template<class Hasher>
void	hash_append (Hasher &h, beast::ip::Address const &addr) noexcept
template<typename T>
std::string	typeName ()
template<class Generator>
void	rngfill (void *const buffer, std::size_t const bytes, Generator &g)
template<class Generator, std::size_t N> requires (N % sizeof(typename Generator::result_type) == 0)
void	rngfill (std::array< std::uint8_t, N > &a, Generator &g)
template<typename T>
auto	signum (T const &t)
	Default implementation of signum calls the method on the class.
template<typename T>
bool	operator== (T const &t, Zero)
template<typename T>
bool	operator!= (T const &t, Zero)
template<typename T>
bool	operator< (T const &t, Zero)
template<typename T>
bool	operator> (T const &t, Zero)
template<typename T>
bool	operator>= (T const &t, Zero)
template<typename T>
bool	operator<= (T const &t, Zero)
template<typename T>
bool	operator== (Zero, T const &t)
template<typename T>
bool	operator!= (Zero, T const &t)
template<typename T>
bool	operator< (Zero, T const &t)
template<typename T>
bool	operator> (Zero, T const &t)
template<typename T>
bool	operator>= (Zero, T const &t)
template<typename T>
bool	operator<= (Zero, T const &t)
std::string	printIdentifiers (SemanticVersion::IdentifierList const &list)
bool	isNumeric (std::string const &s)
bool	chop (std::string const &what, std::string &input)
bool	chopUInt (int &value, int limit, std::string &input)
bool	extractIdentifier (std::string &value, bool allowLeadingZeroes, std::string &input)
bool	extractIdentifiers (SemanticVersion::IdentifierList &identifiers, bool allowLeadingZeroes, std::string &input)
	BEAST_DEFINE_TESTSUITE (aged_set, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_map, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_multiset, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_multimap, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_unordered_set, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_unordered_map, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_unordered_multiset, beast, beast)
	BEAST_DEFINE_TESTSUITE (aged_unordered_multimap, beast, beast)
	BEAST_DEFINE_TESTSUITE_MANUAL (abstract_clock, beast, beast)
	BEAST_DEFINE_TESTSUITE (BasicSecondsClock, beast, beast)
	BEAST_DEFINE_TESTSUITE (Journal, beast, beast)
	BEAST_DEFINE_TESTSUITE (PropertyStream, beast, beast)
	BEAST_DEFINE_TESTSUITE (XXHasher, beast_core, beast)
	TYPED_TEST_SUITE (LexicalCastIntegers, IntegerTypes, IntegerTypeNames)
	TYPED_TEST (LexicalCastIntegers, round_trips_random_values)
	TYPED_TEST (LexicalCastIntegers, round_trips_numeric_limits)
	TEST (LexicalCast, round_trips_every_int16_value)
	TEST (LexicalCast, rejects_overflow)
	TEST (LexicalCast, rejects_underflow)
	TEST (LexicalCast, accepts_up_to_the_maximum)
	TEST (LexicalCast, accepts_down_to_the_minimum)
	TEST (LexicalCast, limits_round_trip_through_to_string)
	TEST (LexicalCast, accepts_signed_zero_in_every_form)
	TEST (LexicalCast, rejects_negative_zero_when_unsigned)
	TEST (LexicalCast, accepts_char_pointer_and_std_string_input)
	TEST (LexicalCast, throwing_cast_returns_in_range_values)
	TEST (LexicalCast, throwing_cast_throws_on_out_of_range)
	TEST (LexicalCast, throwing_cast_throws_on_utf8_digits)
	TEST_P (SemanticVersionParse, pre_release_and_metadata_combinations)
	INSTANTIATE_TEST_SUITE_P (Inputs, SemanticVersionParse, ::testing::ValuesIn(kParseCases), parseCaseName)
	TEST_P (SemanticVersionValues, decomposes_into_components)
	INSTANTIATE_TEST_SUITE_P (Inputs, SemanticVersionValues, ::testing::ValuesIn(kValuesCases), valuesCaseName)
	TEST_P (SemanticVersionOrder, lesser_precedes_greater)
	INSTANTIATE_TEST_SUITE_P (Pairs, SemanticVersionOrder, ::testing::ValuesIn(kOrderCases), orderCaseName)
int	signum (AdlTester)
	TEST (Zero, lhs)
	TEST (Zero, rhs)
	TEST (Zero, adl)

template<class Hasher, class T> requires (IsContiguouslyHashable<T, Hasher>::value)
void	hash_append (Hasher &h, T const &t) noexcept
	Logically concatenate input data to a Hasher.
template<class Hasher, class T> requires ( !IsContiguouslyHashable<T, Hasher>::value && (std::is_integral_v<T> \|\| std::is_pointer_v<T> \|\| std::is_enum_v<T>))
void	hash_append (Hasher &h, T t) noexcept
template<class Hasher, class T> requires (std::is_floating_point_v<T>)
void	hash_append (Hasher &h, T t) noexcept
template<class Hasher>
void	hash_append (Hasher &h, std::nullptr_t) noexcept
template<class Hasher, class T, std::size_t N> requires (!IsContiguouslyHashable<T, Hasher>::value)
void	hash_append (Hasher &h, T(&a)[N]) noexcept
template<class Hasher, class CharT, class Traits, class Alloc> requires (!IsContiguouslyHashable<CharT, Hasher>::value)
void	hash_append (Hasher &h, std::basic_string< CharT, Traits, Alloc > const &s) noexcept
template<class Hasher, class CharT, class Traits, class Alloc> requires (IsContiguouslyHashable<CharT, Hasher>::value)
void	hash_append (Hasher &h, std::basic_string< CharT, Traits, Alloc > const &s) noexcept
template<class Hasher, class T, class U> requires (!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value)
void	hash_append (Hasher &h, std::pair< T, U > const &p) noexcept
template<class Hasher, class T, class Alloc> requires (!IsContiguouslyHashable<T, Hasher>::value)
void	hash_append (Hasher &h, std::vector< T, Alloc > const &v) noexcept
template<class Hasher, class T, class Alloc> requires (IsContiguouslyHashable<T, Hasher>::value)
void	hash_append (Hasher &h, std::vector< T, Alloc > const &v) noexcept
template<class Hasher, class T, std::size_t N> requires (!IsContiguouslyHashable<std::array<T, N>, Hasher>::value)
void	hash_append (Hasher &h, std::array< T, N > const &a) noexcept
template<class Hasher, class... T> requires (!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value)
void	hash_append (Hasher &h, std::tuple< T... > const &t) noexcept
template<class Hasher, class Key, class T, class Hash, class Pred, class Alloc>
void	hash_append (Hasher &h, std::unordered_map< Key, T, Hash, Pred, Alloc > const &m)
template<class Hasher, class Key, class Hash, class Pred, class Alloc>
void	hash_append (Hasher &h, std::unordered_set< Key, Hash, Pred, Alloc > const &s)
template<class Hasher, class Key, class Compare, class Alloc> requires (!IsContiguouslyHashable<Key, Hasher>::value)
void	hash_append (Hasher &h, boost::container::flat_set< Key, Compare, Alloc > const &v) noexcept
template<class Hasher, class Key, class Compare, class Alloc> requires (IsContiguouslyHashable<Key, Hasher>::value)
void	hash_append (Hasher &h, boost::container::flat_set< Key, Compare, Alloc > const &v) noexcept
template<class Hasher, class T0, class T1, class... T>
void	hash_append (Hasher &h, T0 const &t0, T1 const &t1, T const &... t) noexcept
template<class Hasher, class T>
void	hash_append (Hasher &h, std::shared_ptr< T > const &p) noexcept
template<class Hasher, class Rep, class Period>
void	hash_append (Hasher &h, std::chrono::duration< Rep, Period > const &d) noexcept
template<class Hasher, class Clock, class Duration>
void	hash_append (Hasher &h, std::chrono::time_point< Clock, Duration > const &tp) noexcept
template<class HashAlgorithm>
void	hash_append (HashAlgorithm &h, std::error_code const &ec)

Variables
constexpr Zero	kZero {}

Typedef Documentation

◆ aged_map

template<class Key, class T, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>

using beast::aged_map = detail::AgedOrderedContainer<false, true, Key, T, Clock, Compare, Allocator>

Definition at line 18 of file aged_map.h.

◆ aged_multimap

template<class Key, class T, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>

using beast::aged_multimap = detail::AgedOrderedContainer<true, true, Key, T, Clock, Compare, Allocator>

Definition at line 18 of file aged_multimap.h.

◆ aged_multiset

template<class Key, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

using beast::aged_multiset

Initial value:

detail::AgedOrderedContainer<true, false, Key, void, Clock, Compare, Allocator>

beast::detail::AgedOrderedContainer

Associative container where each element is also indexed by time.

Definition aged_ordered_container.h:68

Definition at line 16 of file aged_multiset.h.

◆ aged_set

template<class Key, class Clock = std::chrono::steady_clock, class Compare = std::less<Key>, class Allocator = std::allocator<Key>>

using beast::aged_set = detail::AgedOrderedContainer<false, false, Key, void, Clock, Compare, Allocator>

Definition at line 16 of file aged_set.h.

◆ aged_unordered_map

template<class Key, class T, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>

using beast::aged_unordered_map

Initial value:

detail::AgedUnorderedContainer<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>

beast::detail::AgedUnorderedContainer

Associative container where each element is also indexed by time.

Definition aged_unordered_container.h:75

Definition at line 19 of file aged_unordered_map.h.

◆ aged_unordered_multimap

template<class Key, class T, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, T>>>

using beast::aged_unordered_multimap

Initial value:

detail::AgedUnorderedContainer<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>

Definition at line 19 of file aged_unordered_multimap.h.

◆ aged_unordered_multiset

template<class Key, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<Key>>

using beast::aged_unordered_multiset

Initial value:

detail::AgedUnorderedContainer<true, false, Key, void, Clock, Hash, KeyEqual, Allocator>

Definition at line 17 of file aged_unordered_multiset.h.

◆ aged_unordered_set

template<class Key, class Clock = std::chrono::steady_clock, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<Key>>

using beast::aged_unordered_set

Initial value:

detail::AgedUnorderedContainer<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>

Definition at line 17 of file aged_unordered_set.h.

◆ logstream

using beast::logstream = BasicLogstream<char>

Definition at line 474 of file Journal.h.

◆ logwstream

using beast::logwstream = BasicLogstream<wchar_t>

Definition at line 475 of file Journal.h.

◆ maybe_const_t

template<bool IsConst, class T>

using beast::maybe_const_t = MaybeConst<IsConst, T>::type

Alias for omitting typename.

Definition at line 22 of file maybe_const.h.

◆ xor_shift_engine

using beast::xor_shift_engine = detail::XorShiftEngine<>

XOR-shift Generator.

Meets the requirements of UniformRandomNumberGenerator.

Simple and fast RNG based on: http://xorshift.di.unimi.it/xorshift128plus.c does not accept seed==0

Definition at line 97 of file xor_shift_engine.h.

◆ IntegerTypes

using beast::IntegerTypes

Initial value:

::testing::Types<  
   int16_t,
   uint16_t,
   int32_t,
   uint32_t,
   int64_t,
   uint64_t>

Definition at line 162 of file LexicalCast.cpp.

Enumeration Type Documentation

◆ Severity

enum class beast::Severity : std::uint8_t

strong

Severity level / threshold of a Journal message.

Enumerator
All
Trace
Debug
Info
Warning
Error
Fatal
Disabled
None

Definition at line 16 of file Journal.h.

Function Documentation

◆ getAbstractClock()

template<class Facade, class Clock = Facade>

AbstractClock< Facade > & beast::getAbstractClock ( )

Returns a global instance of an abstract clock.

Template Parameters

Facade	A type meeting these requirements: http://en.cppreference.com/w/cpp/concept/Clock
Clock	The actual concrete clock to use.

Definition at line 88 of file abstract_clock.h.

◆ expire() [1/3]

template<class AgedContainer, class Rep, class Period>
requires (IsAgedContainer<AgedContainer>::value)

std::size_t beast::expire	(	AgedContainer &	c,
		std::chrono::duration< Rep, Period > const &	age )

Expire aged container items past the specified age.

Definition at line 15 of file aged_container_utility.h.

◆ swap() [1/2]

template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>

void beast::swap	(	beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &	lhs,
		beast::detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &	rhs )

noexcept

Definition at line 1772 of file aged_ordered_container.h.

◆ expire() [2/3]

template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator, class Rep, class Period>

std::size_t beast::expire	(	detail::AgedOrderedContainer< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &	c,
		std::chrono::duration< Rep, Period > const &	age )

Expire aged container items past the specified age.

Definition at line 1794 of file aged_ordered_container.h.

◆ swap() [2/2]

template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Hash, class KeyEqual, class Allocator>

void beast::swap	(	beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &	lhs,
		beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &	rhs )

noexcept

Definition at line 2683 of file aged_unordered_container.h.

◆ expire() [3/3]

template<bool IsMulti, bool IsMap, class Key, class T, class Clock, class Hash, class KeyEqual, class Allocator, class Rep, class Period>

std::size_t beast::expire	(	beast::detail::AgedUnorderedContainer< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &	c,
		std::chrono::duration< Rep, Period > const &	age )

noexcept

Expire aged container items past the specified age.

Definition at line 2707 of file aged_unordered_container.h.

◆ setCurrentThreadName()

void beast::setCurrentThreadName ( std::string_view newThreadName )

Changes the name of the caller thread.

Different OSes may place different length or content limits on this name.

Definition at line 115 of file CurrentThreadName.cpp.

◆ getCurrentThreadName()

std::string beast::getCurrentThreadName ( )

Returns the name of the caller thread.

The name returned is the name as set by a call to setCurrentThreadName(). If the thread name is set by an external force, then that name change will not be reported.

If no name has ever been set, then the empty string is returned.

Definition at line 109 of file CurrentThreadName.cpp.

◆ lexicalCastChecked()

template<class Out, class In>

bool beast::lexicalCastChecked	(	Out &	out,
		In	in )

constexpr

Intelligently convert from one type to another.

Returns: false if there was a parsing or range error

Definition at line 181 of file LexicalCast.h.

◆ lexicalCastThrow()

template<class Out, class In>

Out beast::lexicalCastThrow ( In in )

constexpr

Convert from one type to another, throw on error.

An exception of type BadLexicalCast is thrown if the conversion fails.

Returns: The new type.

Definition at line 195 of file LexicalCast.h.

◆ lexicalCast()

template<class Out, class In>

Out beast::lexicalCast	(	In	in,
		Out	defaultValue = Out() )

constexpr

Convert from one type to another.

Parameters

defaultValue The value returned if parsing fails

Returns: The new type.

Definition at line 211 of file LexicalCast.h.

◆ operator==() [1/4]

template<class Container, bool LhsIsConst, bool RhsIsConst>

bool beast::operator==	(	LockFreeStackIterator< Container, LhsIsConst > const &	lhs,
		LockFreeStackIterator< Container, RhsIsConst > const &	rhs )

Definition at line 88 of file LockFreeStack.h.

◆ operator!=() [1/4]

template<class Container, bool LhsIsConst, bool RhsIsConst>

bool beast::operator!=	(	LockFreeStackIterator< Container, LhsIsConst > const &	lhs,
		LockFreeStackIterator< Container, RhsIsConst > const &	rhs )

Definition at line 97 of file LockFreeStack.h.

◆ compare()

int beast::compare	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Compare two SemanticVersions against each other.

The comparison follows the rules as per the specification.

Definition at line 236 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ operator==() [2/4]

bool beast::operator==	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Definition at line 67 of file SemanticVersion.h.

◆ operator!=() [2/4]

bool beast::operator!=	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Definition at line 73 of file SemanticVersion.h.

◆ operator>=() [1/3]

bool beast::operator>=	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Definition at line 79 of file SemanticVersion.h.

◆ operator<=() [1/3]

bool beast::operator<=	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Definition at line 84 of file SemanticVersion.h.

◆ operator>() [1/3]

bool beast::operator>	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Definition at line 91 of file SemanticVersion.h.

◆ operator<() [1/3]

bool beast::operator<	(	SemanticVersion const &	lhs,
		SemanticVersion const &	rhs )

Definition at line 96 of file SemanticVersion.h.

◆ hash_append() [1/22]

template<class Hasher, class T>
requires (IsContiguouslyHashable<T, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		T const &	t )

noexcept

Logically concatenate input data to a Hasher.

Hasher requirements:

`X` is the type `Hasher`
`h` is a value of type `x`
`p` is a value convertible to `void const*`
`n` is a value of type `std::size_t`, greater than zero

Expression:
    `h.append (p, n);`
Throws:
    Never
Effect:
    Adds the input data to the hasher state.

Expression:
    `static_cast<std::size_t>(j)`
Throws:
    Never
Effect:
    Returns the resulting hash of all the input data.

Definition at line 206 of file hash_append.h.

◆ hash_append() [2/22]

template<class Hasher, class T>
requires ( !IsContiguouslyHashable<T, Hasher>::value && (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>))

void beast::hash_append	(	Hasher &	h,
		T	t )

noexcept

Definition at line 215 of file hash_append.h.

◆ hash_append() [3/22]

template<class Hasher, class T>
requires (std::is_floating_point_v<T>)

void beast::hash_append	(	Hasher &	h,
		T	t )

noexcept

Definition at line 226 of file hash_append.h.

◆ hash_append() [4/22]

template<class Hasher>

void beast::hash_append	(	Hasher &	h,
		std::nullptr_t	)

noexcept

Definition at line 237 of file hash_append.h.

◆ hash_append() [5/22]

template<class Hasher, class T, std::size_t N>
requires (!IsContiguouslyHashable<T, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		T(&)	a[N] )

noexcept

Definition at line 310 of file hash_append.h.

◆ hash_append() [6/22]

template<class Hasher, class CharT, class Traits, class Alloc>
requires (!IsContiguouslyHashable<CharT, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::basic_string< CharT, Traits, Alloc > const &	s )

noexcept

Definition at line 321 of file hash_append.h.

◆ hash_append() [7/22]

template<class Hasher, class CharT, class Traits, class Alloc>
requires (IsContiguouslyHashable<CharT, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::basic_string< CharT, Traits, Alloc > const &	s )

noexcept

Definition at line 331 of file hash_append.h.

◆ hash_append() [8/22]

template<class Hasher, class T, class U>
requires (!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::pair< T, U > const &	p )

noexcept

Definition at line 342 of file hash_append.h.

◆ hash_append() [9/22]

template<class Hasher, class T, class Alloc>
requires (!IsContiguouslyHashable<T, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::vector< T, Alloc > const &	v )

noexcept

Definition at line 352 of file hash_append.h.

◆ hash_append() [10/22]

template<class Hasher, class T, class Alloc>
requires (IsContiguouslyHashable<T, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::vector< T, Alloc > const &	v )

noexcept

Definition at line 362 of file hash_append.h.

◆ hash_append() [11/22]

template<class Hasher, class T, std::size_t N>
requires (!IsContiguouslyHashable<std::array<T, N>, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::array< T, N > const &	a )

noexcept

Definition at line 373 of file hash_append.h.

◆ hash_append() [12/22]

template<class Hasher, class... T>
requires (!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		std::tuple< T... > const &	t )

noexcept

Definition at line 399 of file hash_append.h.

◆ hash_append() [13/22]

template<class Hasher, class Key, class T, class Hash, class Pred, class Alloc>

void beast::hash_append	(	Hasher &	h,
		std::unordered_map< Key, T, Hash, Pred, Alloc > const &	m )

◆ hash_append() [14/22]

template<class Hasher, class Key, class Hash, class Pred, class Alloc>

void beast::hash_append	(	Hasher &	h,
		std::unordered_set< Key, Hash, Pred, Alloc > const &	s )

◆ hash_append() [15/22]

template<class Hasher, class Key, class Compare, class Alloc>
requires (!IsContiguouslyHashable<Key, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		boost::container::flat_set< Key, Compare, Alloc > const &	v )

noexcept

Definition at line 382 of file hash_append.h.

◆ hash_append() [16/22]

template<class Hasher, class Key, class Compare, class Alloc>
requires (IsContiguouslyHashable<Key, Hasher>::value)

void beast::hash_append	(	Hasher &	h,
		boost::container::flat_set< Key, Compare, Alloc > const &	v )

noexcept

Definition at line 390 of file hash_append.h.

◆ hash_append() [17/22]

template<class Hasher, class T0, class T1, class... T>

void beast::hash_append	(	Hasher &	h,
		T0 const &	t0,
		T1 const &	t1,
		T const &...	t )

noexcept

Definition at line 434 of file hash_append.h.

◆ hash_append() [18/22]

template<class Hasher, class T>

void beast::hash_append	(	Hasher &	h,
		std::shared_ptr< T > const &	p )

noexcept

Definition at line 409 of file hash_append.h.

◆ hash_append() [19/22]

template<class Hasher, class Rep, class Period>

void beast::hash_append	(	Hasher &	h,
		std::chrono::duration< Rep, Period > const &	d )

noexcept

Definition at line 418 of file hash_append.h.

◆ hash_append() [20/22]

template<class Hasher, class Clock, class Duration>

void beast::hash_append	(	Hasher &	h,
		std::chrono::time_point< Clock, Duration > const &	tp )

noexcept

Definition at line 425 of file hash_append.h.

◆ hash_append() [21/22]

template<class HashAlgorithm>

void beast::hash_append	(	HashAlgorithm &	h,
		std::error_code const &	ec )

Definition at line 444 of file hash_append.h.

◆ hash_append() [22/22]

template<class Hasher>

void beast::hash_append	(	Hasher &	h,
		beast::ip::Address const &	addr )

noexcept

Definition at line 82 of file IPAddress.h.

◆ typeName()

template<typename T>

std::string beast::typeName ( )

Definition at line 16 of file type_name.h.

◆ rngfill() [1/2]

template<class Generator>

void beast::rngfill	(	void *const	buffer,
		std::size_t const	bytes,
		Generator &	g )

Definition at line 11 of file rngfill.h.

◆ rngfill() [2/2]

template<class Generator, std::size_t N>
requires (N % sizeof(typename Generator::result_type) == 0)

void beast::rngfill	(	std::array< std::uint8_t, N > &	a,
		Generator &	g )

Definition at line 37 of file rngfill.h.

◆ signum() [1/2]

template<typename T>

auto beast::signum ( T const & t )

Default implementation of signum calls the method on the class.

Definition at line 37 of file Zero.h.

◆ operator==() [3/4]

template<typename T>

bool beast::operator==	(	T const &	t,
		Zero	)

Definition at line 59 of file Zero.h.

◆ operator!=() [3/4]

template<typename T>

bool beast::operator!=	(	T const &	t,
		Zero	)

Definition at line 66 of file Zero.h.

◆ operator<() [2/3]

template<typename T>

bool beast::operator<	(	T const &	t,
		Zero	)

Definition at line 72 of file Zero.h.

◆ operator>() [2/3]

template<typename T>

bool beast::operator>	(	T const &	t,
		Zero	)

Definition at line 80 of file Zero.h.

◆ operator>=() [2/3]

template<typename T>

bool beast::operator>=	(	T const &	t,
		Zero	)

Definition at line 87 of file Zero.h.

◆ operator<=() [2/3]

template<typename T>

bool beast::operator<=	(	T const &	t,
		Zero	)

Definition at line 93 of file Zero.h.

◆ operator==() [4/4]

template<typename T>

bool beast::operator==	(	Zero	,
		T const &	t )

Definition at line 104 of file Zero.h.

◆ operator!=() [4/4]

template<typename T>

bool beast::operator!=	(	Zero	,
		T const &	t )

Definition at line 111 of file Zero.h.

◆ operator<() [3/3]

template<typename T>

bool beast::operator<	(	Zero	,
		T const &	t )

Definition at line 117 of file Zero.h.

◆ operator>() [3/3]

template<typename T>

bool beast::operator>	(	Zero	,
		T const &	t )

Definition at line 125 of file Zero.h.

◆ operator>=() [3/3]

template<typename T>

bool beast::operator>=	(	Zero	,
		T const &	t )

Definition at line 132 of file Zero.h.

◆ operator<=() [3/3]

template<typename T>

bool beast::operator<=	(	Zero	,
		T const &	t )

Definition at line 138 of file Zero.h.

◆ printIdentifiers()

std::string beast::printIdentifiers ( SemanticVersion::IdentifierList const & list )

Definition at line 18 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ isNumeric()

bool beast::isNumeric ( std::string const & s )

Definition at line 33 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ chop()

bool beast::chop	(	std::string const &	what,
		std::string &	input )

Definition at line 46 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ chopUInt()

bool beast::chopUInt	(	int &	value,
		int	limit,
		std::string &	input )

Definition at line 58 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ extractIdentifier()

bool beast::extractIdentifier	(	std::string &	value,
		bool	allowLeadingZeroes,
		std::string &	input )

Definition at line 94 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ extractIdentifiers()

bool beast::extractIdentifiers	(	SemanticVersion::IdentifierList &	identifiers,
		bool	allowLeadingZeroes,
		std::string &	input )

Definition at line 117 of file libxrpl/beast/core/SemanticVersion.cpp.

◆ BEAST_DEFINE_TESTSUITE() [1/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_set	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [2/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_map	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [3/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_multiset	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [4/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_multimap	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [5/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_set	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [6/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_map	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [7/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_multiset	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [8/12]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_multimap	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE_MANUAL()

beast::BEAST_DEFINE_TESTSUITE_MANUAL	(	abstract_clock	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [9/12]

beast::BEAST_DEFINE_TESTSUITE	(	BasicSecondsClock	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [10/12]

beast::BEAST_DEFINE_TESTSUITE	(	Journal	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [11/12]

beast::BEAST_DEFINE_TESTSUITE	(	PropertyStream	,
		beast	,
		beast	)

◆ BEAST_DEFINE_TESTSUITE() [12/12]

beast::BEAST_DEFINE_TESTSUITE	(	XXHasher	,
		beast_core	,
		beast	)

◆ TYPED_TEST_SUITE()

beast::TYPED_TEST_SUITE	(	LexicalCastIntegers	,
		IntegerTypes	,
		IntegerTypeNames	)

◆ TYPED_TEST() [1/2]

beast::TYPED_TEST	(	LexicalCastIntegers	,
		round_trips_random_values	)

Definition at line 188 of file LexicalCast.cpp.

◆ TYPED_TEST() [2/2]

beast::TYPED_TEST	(	LexicalCastIntegers	,
		round_trips_numeric_limits	)

Definition at line 198 of file LexicalCast.cpp.

◆ TEST() [1/15]

beast::TEST	(	LexicalCast	,
		round_trips_every_int16_value	)

Definition at line 204 of file LexicalCast.cpp.

◆ TEST() [2/15]

beast::TEST	(	LexicalCast	,
		rejects_overflow	)

Definition at line 217 of file LexicalCast.cpp.

◆ TEST() [3/15]

beast::TEST	(	LexicalCast	,
		rejects_underflow	)

Definition at line 224 of file LexicalCast.cpp.

◆ TEST() [4/15]

beast::TEST	(	LexicalCast	,
		accepts_up_to_the_maximum	)

Definition at line 232 of file LexicalCast.cpp.

◆ TEST() [5/15]

beast::TEST	(	LexicalCast	,
		accepts_down_to_the_minimum	)

Definition at line 259 of file LexicalCast.cpp.

◆ TEST() [6/15]

beast::TEST	(	LexicalCast	,
		limits_round_trip_through_to_string	)

Definition at line 274 of file LexicalCast.cpp.

◆ TEST() [7/15]

beast::TEST	(	LexicalCast	,
		accepts_signed_zero_in_every_form	)

Definition at line 285 of file LexicalCast.cpp.

◆ TEST() [8/15]

beast::TEST	(	LexicalCast	,
		rejects_negative_zero_when_unsigned	)

Definition at line 292 of file LexicalCast.cpp.

◆ TEST() [9/15]

beast::TEST	(	LexicalCast	,
		accepts_char_pointer_and_std_string_input	)

Definition at line 299 of file LexicalCast.cpp.

◆ TEST() [10/15]

beast::TEST	(	LexicalCast	,
		throwing_cast_returns_in_range_values	)

Definition at line 310 of file LexicalCast.cpp.

◆ TEST() [11/15]

beast::TEST	(	LexicalCast	,
		throwing_cast_throws_on_out_of_range	)

Definition at line 318 of file LexicalCast.cpp.

◆ TEST() [12/15]

beast::TEST	(	LexicalCast	,
		throwing_cast_throws_on_utf8_digits	)

Definition at line 334 of file LexicalCast.cpp.

◆ TEST_P() [1/3]

beast::TEST_P	(	SemanticVersionParse	,
		pre_release_and_metadata_combinations	)

Definition at line 232 of file tests/libxrpl/beast/SemanticVersion.cpp.

◆ INSTANTIATE_TEST_SUITE_P() [1/3]

beast::INSTANTIATE_TEST_SUITE_P	(	Inputs	,
		SemanticVersionParse	,
		::testing::ValuesIn(kParseCases)	,
		parseCaseName	)

◆ TEST_P() [2/3]

beast::TEST_P	(	SemanticVersionValues	,
		decomposes_into_components	)

Definition at line 267 of file tests/libxrpl/beast/SemanticVersion.cpp.

◆ INSTANTIATE_TEST_SUITE_P() [2/3]

beast::INSTANTIATE_TEST_SUITE_P	(	Inputs	,
		SemanticVersionValues	,
		::testing::ValuesIn(kValuesCases)	,
		valuesCaseName	)

◆ TEST_P() [3/3]

beast::TEST_P	(	SemanticVersionOrder	,
		lesser_precedes_greater	)

Definition at line 292 of file tests/libxrpl/beast/SemanticVersion.cpp.

◆ INSTANTIATE_TEST_SUITE_P() [3/3]

beast::INSTANTIATE_TEST_SUITE_P	(	Pairs	,
		SemanticVersionOrder	,
		::testing::ValuesIn(kOrderCases)	,
		orderCaseName	)

◆ signum() [2/2]

int beast::signum ( AdlTester )

Definition at line 12 of file Zero.cpp.

◆ TEST() [13/15]

beast::TEST	(	Zero	,
		lhs	)

Definition at line 72 of file Zero.cpp.

◆ TEST() [14/15]

beast::TEST	(	Zero	,
		rhs	)

Definition at line 79 of file Zero.cpp.

◆ TEST() [15/15]

beast::TEST	(	Zero	,
		adl	)

Definition at line 86 of file Zero.cpp.

Variable Documentation

◆ kZero

Zero beast::kZero {}

constexpr

Definition at line 30 of file Zero.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ aged_map

◆ aged_multimap

◆ aged_multiset

◆ aged_set

◆ aged_unordered_map

◆ aged_unordered_multimap

◆ aged_unordered_multiset

◆ aged_unordered_set

◆ logstream

◆ logwstream

◆ maybe_const_t

◆ xor_shift_engine

◆ IntegerTypes

Enumeration Type Documentation

◆ Severity

Function Documentation

◆ getAbstractClock()

◆ expire() [1/3]

◆ swap() [1/2]

◆ expire() [2/3]

◆ swap() [2/2]

◆ expire() [3/3]

◆ setCurrentThreadName()

◆ getCurrentThreadName()

◆ lexicalCastChecked()

◆ lexicalCastThrow()

◆ lexicalCast()

◆ operator==() [1/4]

◆ operator!=() [1/4]

◆ compare()

◆ operator==() [2/4]

◆ operator!=() [2/4]

◆ operator>=() [1/3]

◆ operator<=() [1/3]

◆ operator>() [1/3]

◆ operator<() [1/3]

◆ hash_append() [1/22]

◆ hash_append() [2/22]

◆ hash_append() [3/22]

◆ hash_append() [4/22]

◆ hash_append() [5/22]

◆ hash_append() [6/22]

◆ hash_append() [7/22]

◆ hash_append() [8/22]

◆ hash_append() [9/22]

◆ hash_append() [10/22]

◆ hash_append() [11/22]

◆ hash_append() [12/22]

◆ hash_append() [13/22]

◆ hash_append() [14/22]

◆ hash_append() [15/22]

◆ hash_append() [16/22]

◆ hash_append() [17/22]

◆ hash_append() [18/22]

◆ hash_append() [19/22]

◆ hash_append() [20/22]

◆ hash_append() [21/22]

◆ hash_append() [22/22]

◆ typeName()

◆ rngfill() [1/2]

◆ rngfill() [2/2]

◆ signum() [1/2]

◆ operator==() [3/4]

◆ operator!=() [3/4]

◆ operator<() [2/3]

◆ operator>() [2/3]

◆ operator>=() [2/3]

◆ operator<=() [2/3]

◆ operator==() [4/4]

◆ operator!=() [4/4]

◆ operator<() [3/3]

◆ operator>() [3/3]

◆ operator>=() [3/3]