beast Namespace Reference

Namespaces
namespace	detail
namespace	inner_adl_test
namespace	insight
namespace	IP
namespace	rfc2616
namespace	severities
	A namespace for easy access to logging severity values.
namespace	test
namespace	unit_test

Classes
class	abstract_clock
	Abstract interface to a clock. More...
class	abstract_clock_test
struct	adl_tester
class	aged_associative_container_test_base
class	aged_map_test
class	aged_multimap_test
class	aged_multiset_test
class	aged_ordered_container
class	aged_set_test
class	aged_unordered_map_test
class	aged_unordered_multimap_test
class	aged_unordered_multiset_test
class	aged_unordered_set_test
struct	BadLexicalCast
	Thrown when a conversion is not possible with LexicalCast. More...
class	basic_logstream
class	basic_seconds_clock
	A clock whose minimum resolution is one second. More...
class	basic_seconds_clock_test
struct	divider
	Produce a dashed line separator, with a specified or default size. More...
class	field_t
	Justifies a field at the specified width. More...
struct	fpad
	Creates a padded field with an optiona fill character. More...
class	io_latency_probe
	Measures handler latency on an io_context queue. More...
struct	IPAddressConversion
struct	is_aged_container
struct	is_aged_container< beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > >
struct	is_aged_container< beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > >
struct	is_contiguously_hashable
	Metafunction returning true if the type can be hashed in one call. More...
struct	is_contiguously_hashable< ripple::tagged_integer< Int, Tag >, HashAlgorithm >
struct	is_contiguously_hashable< T[N], HashAlgorithm >
struct	is_uniquely_represented
struct	is_uniquely_represented< ripple::base_uint< Bits, Tag > >
struct	is_uniquely_represented< std::array< T, N > >
struct	is_uniquely_represented< std::pair< T, U > >
struct	is_uniquely_represented< std::tuple< T... > >
struct	is_uniquely_represented< T const >
struct	is_uniquely_represented< T const volatile >
struct	is_uniquely_represented< T volatile >
struct	is_uniquely_represented< T[N]>
class	Journal
	A generic endpoint for log messages. More...
class	Journal_test
struct	leftw
	Left justifies a field at the specified width. More...
class	LexicalCast_test
class	List
	Intrusive doubly linked list. More...
class	LockFreeStack
	Multiple Producer, Multiple Consumer (MPMC) intrusive stack. More...
class	LockFreeStackIterator
class	manual_clock
	Manual clock implementation. More...
struct	maybe_const
	Makes T const or non const depending on a bool. More...
class	NullJournalSink
class	PropertyStream
	Abstract stream with RAII containers that produce a property tree. More...
class	PropertyStream_test
class	SemanticVersion
	A Semantic Version number. More...
class	SemanticVersion_test
class	temp_dir
	RAII temporary directory. More...
struct	uhash
class	WrappedSink
	Wraps a Journal::Sink to prefix its output with a string. More...
class	xxhasher
class	XXHasher_test
struct	Zero
	Zero allows classes to offer efficient comparisons to zero. More...
class	Zero_test

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::aged_ordered_container< 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::aged_ordered_container< 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 = detail::aged_ordered_container< true, false, Key, void, Clock, Compare, Allocator >
template<class Key , 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 >
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 = detail::aged_unordered_container< false, true, Key, T, Clock, Hash, KeyEqual, 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_multimap = detail::aged_unordered_container< true, true, Key, T, Clock, Hash, KeyEqual, Allocator >
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 = detail::aged_unordered_container< true, false, Key, void, Clock, Hash, KeyEqual, Allocator >
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 = detail::aged_unordered_container< false, false, Key, void, Clock, Hash, KeyEqual, Allocator >
using	logstream = basic_logstream< char >
using	logwstream = basic_logstream< wchar_t >
template<bool IsConst, class T >
using	maybe_const_t = typename maybe_const< IsConst, T >::type
	Alias for omitting typename.
using	xor_shift_engine = detail::xor_shift_engine<>
	XOR-shift Generator.

Functions
template<class Facade , class Clock = Facade>
abstract_clock< Facade > &	get_abstract_clock ()
	Returns a global instance of an abstract clock.
template<class AgedContainer , class Rep , class Period >
std::enable_if< is_aged_container< AgedContainer >::value, std::size_t >::type	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::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &lhs, beast::detail::aged_ordered_container< 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::aged_ordered_container< 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::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &lhs, beast::detail::aged_unordered_container< 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::aged_unordered_container< 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 >
bool	lexicalCastChecked (Out &out, In in)
	Intelligently convert from one type to another.
template<class Out , class In >
Out	lexicalCastThrow (In in)
	Convert from one type to another, throw on error.
template<class Out , class In >
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	type_name ()
template<class Generator >
void	rngfill (void *const buffer, std::size_t const bytes, Generator &g)
template<class Generator , std::size_t N, class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
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	print_identifiers (SemanticVersion::identifier_list 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	extract_identifier (std::string &value, bool allowLeadingZeroes, std::string &input)
bool	extract_identifiers (SemanticVersion::identifier_list &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 (basic_seconds_clock, beast, beast)
	BEAST_DEFINE_TESTSUITE (Journal, beast, beast)
	BEAST_DEFINE_TESTSUITE (PropertyStream, beast, beast)
int	signum (adl_tester)
	BEAST_DEFINE_TESTSUITE (Zero, beast, beast)
	BEAST_DEFINE_TESTSUITE (LexicalCast, beast, beast)
	BEAST_DEFINE_TESTSUITE (SemanticVersion, beast, beast)
	BEAST_DEFINE_TESTSUITE (XXHasher, beast_core, beast)
template<class CharT , class Traits , class Allocator >
std::basic_string< CharT, Traits, Allocator >	heading (std::basic_string< CharT, Traits, Allocator > title, int width=80, CharT fill=CharT('-'))
	Produce a section heading and fill the rest of the line with dashes.
template<class Hasher , class T >
std::enable_if_t< is_contiguously_hashable< T, Hasher >::value >	hash_append (Hasher &h, T const &t) noexcept
	Logically concatenate input data to a Hasher.
template<class Hasher , class T >
std::enable_if_t< !is_contiguously_hashable< T, Hasher >::value &&(std::is_integral< T >::value||std::is_pointer< T >::value||std::is_enum< T >::value)>	hash_append (Hasher &h, T t) noexcept
template<class Hasher , class T >
std::enable_if_t< std::is_floating_point< T >::value >	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>
std::enable_if_t<!is_contiguously_hashable< 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 >	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 >	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 >	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 >	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 >	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 >	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 >	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 >
std::enable_if_t<!is_contiguously_hashable< 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 >	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 , class U >
std::enable_if_t< !is_contiguously_hashable< std::pair< T, U >, Hasher >::value >	hash_append (Hasher &h, std::pair< T, U > const &p) noexcept
template<class Hasher , class... T>
std::enable_if_t< !is_contiguously_hashable< std::tuple< T... >, Hasher >::value >	hash_append (Hasher &h, std::tuple< 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)
template<class CharT , class Traits , class Allocator >
field_t< CharT, Traits, Allocator >	field (std::basic_string< CharT, Traits, Allocator > const &text, int width=8, int pad=0, bool right=false)
template<class CharT >
field_t< CharT >	field (CharT const *text, int width=8, int pad=0, bool right=false)
template<typename T >
field_t< char >	field (T const &t, int width=8, int pad=0, bool right=false)
template<class CharT , class Traits , class Allocator >
field_t< CharT, Traits, Allocator >	rfield (std::basic_string< CharT, Traits, Allocator > const &text, int width=8, int pad=0)
template<class CharT >
field_t< CharT >	rfield (CharT const *text, int width=8, int pad=0)
template<typename T >
field_t< char >	rfield (T const &t, int width=8, int pad=0)

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 = typedef detail:: aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>

Definition at line 37 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 = typedef detail:: aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>

Definition at line 37 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 = typedef detail:: aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>

Definition at line 36 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 = typedef detail:: aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>

Definition at line 36 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 = typedef detail::aged_unordered_container< false, true, Key, T, Clock, Hash, KeyEqual, Allocator>

Definition at line 38 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 = typedef detail::aged_unordered_container< true, true, Key, T, Clock, Hash, KeyEqual, Allocator>

Definition at line 38 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 = typedef detail::aged_unordered_container< true, false, Key, void, Clock, Hash, KeyEqual, Allocator>

Definition at line 37 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 = typedef detail::aged_unordered_container< false, false, Key, void, Clock, Hash, KeyEqual, Allocator>

Definition at line 37 of file aged_unordered_set.h.

logstream

using beast::logstream = typedef basic_logstream<char>

Definition at line 458 of file Journal.h.

logwstream

using beast::logwstream = typedef basic_logstream<wchar_t>

Definition at line 459 of file Journal.h.

maybe_const_t

template<bool IsConst, class T >

using beast::maybe_const_t = typedef typename maybe_const<IsConst, T>::type

Alias for omitting typename.

Definition at line 40 of file maybe_const.h.

xor_shift_engine

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

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 114 of file xor_shift_engine.h.

Function Documentation

get_abstract_clock()

template<class Facade , class Clock = Facade>

abstract_clock< Facade > & beast::get_abstract_clock

(

)

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 104 of file abstract_clock.h.

expire() [1/3]

template<class AgedContainer , class Rep , class Period >

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

Expire aged container items past the specified age.

Definition at line 34 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::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &  lhs, beast::detail::aged_ordered_container< IsMulti, IsMap, Key, T, Clock, Compare, Allocator > &  rhs  )

noexcept

Definition at line 2240 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::aged_ordered_container< 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 2273 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::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &  lhs, beast::detail::aged_unordered_container< IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator > &  rhs  )

noexcept

Definition at line 3389 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::aged_unordered_container< 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 3425 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 123 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 117 of file CurrentThreadName.cpp.

lexicalCastChecked()

template<class Out , class In >

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

Intelligently convert from one type to another.

Returns

false if there was a parsing or range error

Definition at line 200 of file LexicalCast.h.

lexicalCastThrow()

template<class Out , class In >

Out beast::lexicalCastThrow

(

In

in

)

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 213 of file LexicalCast.h.

lexicalCast()

template<class Out , class In >

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

Convert from one type to another.

Parameters

defaultValue

The value returned if parsing fails

Returns

The new type.

Definition at line 228 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 115 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 124 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 263 of file SemanticVersion.cpp.

operator==() [2/4]

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

Definition at line 81 of file SemanticVersion.h.

operator!=() [2/4]

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

Definition at line 87 of file SemanticVersion.h.

operator>=() [1/3]

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

Definition at line 93 of file SemanticVersion.h.

operator<=() [1/3]

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

Definition at line 98 of file SemanticVersion.h.

operator>() [1/3]

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

Definition at line 105 of file SemanticVersion.h.

operator<() [1/3]

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

Definition at line 110 of file SemanticVersion.h.

hash_append() [1/24]

template<class Hasher , class T >

std::enable_if_t< is_contiguously_hashable< T, Hasher >::value > 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 reslting hash of all the input data.

Definition at line 234 of file hash_append.h.

hash_append() [2/24]

template<class Hasher , class T >

std::enable_if_t< !is_contiguously_hashable< T, Hasher >::value &&(std::is_integral< T >::value||std::is_pointer< T >::value|| std::is_enum< T >::value)> beast::hash_append ( Hasher &  h, T  t  )

noexcept

Definition at line 244 of file hash_append.h.

hash_append() [3/24]

template<class Hasher , class T >

std::enable_if_t< std::is_floating_point< T >::value > beast::hash_append ( Hasher &  h, T  t  )

noexcept

Definition at line 252 of file hash_append.h.

hash_append() [4/24]

template<class Hasher >

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

noexcept

Definition at line 262 of file hash_append.h.

hash_append() [5/24]

template<class Hasher , class T , std::size_t N>

std::enable_if_t<!is_contiguously_hashable< T, Hasher >::value > beast::hash_append ( Hasher &  h, T(&)  a[N]  )

noexcept

Definition at line 333 of file hash_append.h.

hash_append() [6/24]

template<class Hasher , class CharT , class Traits , class Alloc >

std::enable_if_t<!is_contiguously_hashable< CharT, Hasher >::value > beast::hash_append ( Hasher &  h, std::basic_string< CharT, Traits, Alloc > const &  s  )

noexcept

Definition at line 343 of file hash_append.h.

hash_append() [7/24]

template<class Hasher , class CharT , class Traits , class Alloc >

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

noexcept

Definition at line 354 of file hash_append.h.

hash_append() [8/24]

template<class Hasher , class T , class U >

std::enable_if_t<!is_contiguously_hashable< std::pair< T, U >, Hasher >::value > beast::hash_append ( Hasher &  h, std::pair< T, U > const &  p  )

noexcept

Definition at line 367 of file hash_append.h.

hash_append() [9/24]

template<class Hasher , class T , class Alloc >

std::enable_if_t<!is_contiguously_hashable< T, Hasher >::value > beast::hash_append ( Hasher &  h, std::vector< T, Alloc > const &  v  )

noexcept

Definition at line 376 of file hash_append.h.

hash_append() [10/24]

template<class Hasher , class T , class Alloc >

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

noexcept

Definition at line 385 of file hash_append.h.

hash_append() [11/24]

template<class Hasher , class T , std::size_t N>

std::enable_if_t<!is_contiguously_hashable< std::array< T, N >, Hasher >::value > beast::hash_append ( Hasher &  h, std::array< T, N > const &  a  )

noexcept

Definition at line 395 of file hash_append.h.

hash_append() [12/24]

template<class Hasher , class... T>

std::enable_if_t<!is_contiguously_hashable< std::tuple< T... >, Hasher >::value > beast::hash_append ( Hasher &  h, std::tuple< T... > const &  t  )

noexcept

Definition at line 450 of file hash_append.h.

hash_append() [13/24]

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/24]

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/24]

template<class Hasher , class Key , class Compare , class Alloc >

std::enable_if_t<!is_contiguously_hashable< Key, Hasher >::value > beast::hash_append ( Hasher &  h, boost::container::flat_set< Key, Compare, Alloc > const &  v  )

noexcept

Definition at line 403 of file hash_append.h.

hash_append() [16/24]

template<class Hasher , class Key , class Compare , class Alloc >

std::enable_if_t< is_contiguously_hashable< Key, Hasher >::value > beast::hash_append ( Hasher &  h, boost::container::flat_set< Key, Compare, Alloc > const &  v  )

noexcept

Definition at line 412 of file hash_append.h.

hash_append() [17/24]

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 486 of file hash_append.h.

hash_append() [18/24]

template<class Hasher , class T , class U >

std::enable_if_t< !is_contiguously_hashable< std::pair< T, U >, Hasher >::value > beast::hash_append ( Hasher &  h, std::pair< T, U > const &  p  )

noexcept

Definition at line 367 of file hash_append.h.

hash_append() [19/24]

template<class Hasher , class... T>

std::enable_if_t< !is_contiguously_hashable< std::tuple< T... >, Hasher >::value > beast::hash_append ( Hasher &  h, std::tuple< T... > const &  t  )

noexcept

Definition at line 450 of file hash_append.h.

hash_append() [20/24]

template<class Hasher , class T >

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

noexcept

Definition at line 459 of file hash_append.h.

hash_append() [21/24]

template<class Hasher , class Rep , class Period >

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

noexcept

Definition at line 468 of file hash_append.h.

hash_append() [22/24]

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 475 of file hash_append.h.

hash_append() [23/24]

template<class HashAlgorithm >

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

Definition at line 496 of file hash_append.h.

hash_append() [24/24]

template<class Hasher >

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

noexcept

Definition at line 89 of file IPAddress.h.

type_name()

template<typename T >

std::string beast::type_name

(

)

Definition at line 36 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 34 of file rngfill.h.

rngfill() [2/2]

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

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

Definition at line 63 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 54 of file Zero.h.

operator==() [3/4]

template<typename T >

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

Definition at line 78 of file Zero.h.

operator!=() [3/4]

template<typename T >

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

Definition at line 85 of file Zero.h.

operator<() [2/3]

template<typename T >

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

Definition at line 91 of file Zero.h.

operator>() [2/3]

template<typename T >

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

Definition at line 99 of file Zero.h.

operator>=() [2/3]

template<typename T >

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

Definition at line 106 of file Zero.h.

operator<=() [2/3]

template<typename T >

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

Definition at line 112 of file Zero.h.

operator==() [4/4]

template<typename T >

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

Definition at line 123 of file Zero.h.

operator!=() [4/4]

template<typename T >

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

Definition at line 130 of file Zero.h.

operator<() [3/3]

template<typename T >

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

Definition at line 136 of file Zero.h.

operator>() [3/3]

template<typename T >

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

Definition at line 144 of file Zero.h.

operator>=() [3/3]

template<typename T >

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

Definition at line 151 of file Zero.h.

operator<=() [3/3]

template<typename T >

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

Definition at line 157 of file Zero.h.

print_identifiers()

std::string beast::print_identifiers

(

SemanticVersion::identifier_list const &

list

)

Definition at line 34 of file SemanticVersion.cpp.

isNumeric()

bool beast::isNumeric

(

std::string const &

s

)

Definition at line 49 of file SemanticVersion.cpp.

chop()

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

Definition at line 62 of file SemanticVersion.cpp.

chopUInt()

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

Definition at line 74 of file SemanticVersion.cpp.

extract_identifier()

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

Definition at line 112 of file SemanticVersion.cpp.

extract_identifiers()

bool beast::extract_identifiers	(	SemanticVersion::identifier_list &	identifiers,
		bool	allowLeadingZeroes,
		std::string &	input
	)

Definition at line 138 of file SemanticVersion.cpp.

BEAST_DEFINE_TESTSUITE() [1/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_set	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [2/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_map	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [3/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_multiset	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [4/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_multimap	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [5/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_set	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [6/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_map	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [7/15]

beast::BEAST_DEFINE_TESTSUITE	(	aged_unordered_multiset	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [8/15]

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/15]

beast::BEAST_DEFINE_TESTSUITE	(	basic_seconds_clock	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [10/15]

beast::BEAST_DEFINE_TESTSUITE	(	Journal	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [11/15]

beast::BEAST_DEFINE_TESTSUITE	(	PropertyStream	,
		beast	,
		beast
	)

signum() [2/2]

int beast::signum

(

adl_tester

)

Definition at line 30 of file beast_Zero_test.cpp.

BEAST_DEFINE_TESTSUITE() [12/15]

beast::BEAST_DEFINE_TESTSUITE	(	Zero	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [13/15]

beast::BEAST_DEFINE_TESTSUITE	(	LexicalCast	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [14/15]

beast::BEAST_DEFINE_TESTSUITE	(	SemanticVersion	,
		beast	,
		beast
	)

BEAST_DEFINE_TESTSUITE() [15/15]

beast::BEAST_DEFINE_TESTSUITE	(	XXHasher	,
		beast_core	,
		beast
	)

heading()

template<class CharT , class Traits , class Allocator >

std::basic_string< CharT, Traits, Allocator > beast::heading	(	std::basic_string< CharT, Traits, Allocator >	title,
		int	width = 80,
		CharT	fill = CharT('-')
	)

Produce a section heading and fill the rest of the line with dashes.

Definition at line 52 of file iosformat.h.

field() [1/3]

template<class CharT , class Traits , class Allocator >

field_t< CharT, Traits, Allocator > beast::field	(	std::basic_string< CharT, Traits, Allocator > const &	text,
		int	width = 8,
		int	pad = 0,
		bool	right = false
	)

Definition at line 162 of file iosformat.h.

field() [2/3]

template<class CharT >

field_t< CharT > beast::field	(	CharT const *	text,
		int	width = 8,
		int	pad = 0,
		bool	right = false
	)

Definition at line 173 of file iosformat.h.

field() [3/3]

template<typename T >

field_t< char > beast::field	(	T const &	t,
		int	width = 8,
		int	pad = 0,
		bool	right = false
	)

Definition at line 186 of file iosformat.h.

rfield() [1/3]

template<class CharT , class Traits , class Allocator >

field_t< CharT, Traits, Allocator > beast::rfield	(	std::basic_string< CharT, Traits, Allocator > const &	text,
		int	width = 8,
		int	pad = 0
	)

Definition at line 194 of file iosformat.h.

rfield() [2/3]

template<class CharT >

field_t< CharT > beast::rfield	(	CharT const *	text,
		int	width = 8,
		int	pad = 0
	)

Definition at line 204 of file iosformat.h.

rfield() [3/3]

template<typename T >

field_t< char > beast::rfield	(	T const &	t,
		int	width = 8,
		int	pad = 0
	)

Definition at line 217 of file iosformat.h.