Classes
class	eagine::any_forward_iterator< VT, RT, PT, DT >
	Type erasure for forward iterators. More...

class	eagine::any_random_engine< Result >
	Type-erasing reference for standard random engine types. More...

struct	eagine::anything
	Type that can by constructed from single argument of any other type. More...

class	eagine::biteset_value_proxy< BiS >
	Proxy class that can be used to access elements in a biteset. More...

class	eagine::biteset_value_proxy_base< BiS >
	Base class for biteset value proxy. More...

class	eagine::biteset_value_proxy< const biteset< N, B, T > >
	Specialization of biteset proxy for const biteset values. More...

class	eagine::biteset_value_proxy< biteset< N, B, T > >
	Specialization of biteset proxy for mutable biteset values. More...

class	eagine::biteset_iterator< biteset< N, B, T > >
	Iterator type for biteset. More...

class	eagine::biteset< N, B, T >
	Sequence of unsigned integer values with specified number bits. More...

class	eagine::bitfield< Bit >
	Class for manipulating and testing a group of enumeration-based bits. More...

class	eagine::some_true
	Class storing initially false value and logically or-ing other values. More...

class	eagine::byteset< N >
	Class storing a sequence of bytes converting them to and from unsigned integer. More...

class	eagine::double_buffer< T >
	Class holding two instances of type `T` and allows to switch them. More...

class	eagine::static_enum_map< Enum, Unit, Keys >
	Class mapping from an enumerator of an instantiation of a template. More...

class	eagine::integer_range< T >
	Integer range type template usable in range-based loops. More...

class	eagine::interface< Derived >
	Base template for abstract interfaces, implements common functionality. More...

class	eagine::abstract< Derived >
	Base template for polymorphic classes, implements common functionality. More...

class	eagine::basic_iterable_type< T, Derived >
	Template used in implementation of some iterators. More...

class	eagine::basic_selfref_iterator< T, Derived >
	Iterator referencing the wrapped iterable type. More...

struct	eagine::selfref_iterator< T >
	Default instantiation of basic_selfref_iterator. More...

class	eagine::basic_transforming_iterator< Iterator, T, S, Transform, Derived >
	Iterator transforming the referenced elements. More...

struct	eagine::transforming_iterator< Iterator, T, S, Transform >
	Default instantiation of basic_transforming_iterator. More...

class	eagine::basic_noexcept_casting_iterator< Iterator, T, S, Derived >
	Iterator type-casting the referenced elements. More...

struct	eagine::noexcept_casting_iterator< Iterator, T, S >
	Default instantiation of basic_noexcept_casting_iterator. More...

struct	eagine::key_value_list_element< Traits >
	A single key/value pair for a key/value list. More...

class	eagine::key_value_list< Traits, N >
	Template for classes wrapping static key/value typically attribute lists. More...

class	eagine::main_ctx_log_backend_getter
	Helper class used in the implementation of logging in main context object. More...

struct	eagine::memory::typed_nullptr_t< T >
	Class for doing pointer arithmetic on null pointers. More...

struct	eagine::memory::has_span_size_member< T >
	Helper class detecting if type T has x.size() member function. More...

struct	eagine::memory::has_span_data_member< T, E >
	Helper class detecting if type T has x.data() member function. More...

class	eagine::memory::basic_span< ValueType, Pointer, SizeType >
	Non-owning view of a contiguous range of memory with ValueType elements. More...

struct	eagine::nothing_t
	Class representing "none" / "nothing" values. More...

class	eagine::protected_member< T, Selector >
	Class holding a single tagged data member. More...

Typedefs
template<typename T >
using	eagine::any_std_forward_iterator = any_forward_iterator< T, const T &, const T *, std::ptrdiff_t >
	Alias for type erased STL forward iterators.

template<typename std::size_t B>
using	eagine::biteset_cell_type = std::conditional_t<(B<=8), std::uint_least8_t, std::conditional_t<(B<=16), std::uint_least16_t, std::conditional_t<(B<=32), std::uint_least32_t, std::conditional_t<(B<=64), std::uint_least64_t, void > >> >
	Selects the appropriate type for biteset element representation. More...

template<bool B>
using	eagine::bool_constant = std::integral_constant< bool, B >
	Alias for boolean constant type.

template<int I>
using	eagine::int_constant = std::integral_constant< int, I >
	Alias for signed int constant type.

template<unsigned U>
using	eagine::unsigned_constant = std::integral_constant< unsigned, U >
	Alias for unsigned int constant type.

template<std::size_t S>
using	eagine::size_constant = std::integral_constant< std::size_t, S >
	Alias for size_t constant type.

template<identifier_t Id>
using	eagine::id_constant = std::integral_constant< identifier_t, Id >
	Alias for identifier_t constant type. More...

template<bool IsConst>
using	eagine::memory::basic_block = basic_span< std::conditional_t< IsConst, const byte, byte > >
	Alias for byte spans.

template<bool IsConst>
using	eagine::memory::basic_split_block = basic_split_span< std::conditional_t< IsConst, const byte, byte > >
	Alias for split span of bytes.

using	eagine::byte = unsigned char
	Byte type alias.

using	eagine::std_align_t = std::size_t
	Alignment type used by std.

using	eagine::std_size_t = std::size_t
	Size type used by std.

using	eagine::span_size_t = std::ptrdiff_t
	Signed span size type used by eagine.

using	eagine::valid_span_size = valid_if_nonnegative< span_size_t >
	Valid size type.

Functions
template<typename T , std::size_t N>
static constexpr auto	eagine::array_size (const T(&)[N]) noexcept
	Returns the number of elements in the array passed as argument.

template<typename T >
auto	eagine::from_string (string_view src) noexcept
	Converts the string representation in `src` to a value of type `T`. More...

template<typename T , identifier_t V>
auto	eagine::from_string (string_view src, selector< V > sel) noexcept
	Converts the string representation in `src` to a value of type `T`. More...

template<typename H , typename I >
auto	eagine::integer_hash (I x, type_identity< H > hid={}, type_identity< I > iid={}) -> H
	Creates a hash value with type `H` from an integer value of type `I`.

template<typename B , typename E >
	eagine::integer_range (B, E) -> integer_range< std::common_type_t< B, E >>
	Deduction guide for integer_range.

template<typename Dst , typename Src >
static constexpr auto	eagine::is_within_limits (Src value) noexcept
	Indicates if `value` fits into the specified Dst type. More...

template<typename Dst , typename Src >
static constexpr auto	eagine::limit_cast (Src value) noexcept -> std::enable_if_t< std::is_convertible_v< Src, Dst >, Dst >
	Casts `value` to Dst type if the value fits in that type. More...

template<typename Dst , typename Src >
static constexpr auto	eagine::convert_if_fits (Src value) noexcept -> std::enable_if_t< std::is_convertible_v< Src, Dst >, optionally_valid< Dst >>
	Optionally converts `value` to Dst type if the value fits in that type. More...

template<typename T , typename N >
static constexpr auto	eagine::memory::operator+ (typed_nullptr_t< T >, N n) noexcept -> T *
	Pointer arithmetic addition operator for null pointers.

template<typename T , typename B , typename P , typename S >
static constexpr auto	eagine::memory::can_accomodate (basic_span< B, P, S > blk, span_size_t count, type_identity< T > tid={}) noexcept
	Indicates if the specified memory block can accomodate count elements of T.

template<typename T , typename B , typename P , typename S >
static constexpr auto	eagine::memory::can_accomodate (basic_span< B, P, S > blk, type_identity< T > tid={}) noexcept
	Indicates if the specified memory block can accomodate one element of T.

template<typename T , typename P , typename S , typename Predicate >
static auto	eagine::memory::all_of (basic_span< T, P, S > spn, Predicate predicate) -> bool
	Indicates if all elements in a span satisfy `predicate`. More...

template<typename T , typename P , typename S , typename Predicate >
static auto	eagine::memory::any_of (basic_span< T, P, S > spn, Predicate predicate) -> bool
	Indicates if any elements in a span satisfy `predicate`. More...

template<typename T , typename P , typename S , typename Predicate >
static auto	eagine::memory::none_of (basic_span< T, P, S > spn, Predicate predicate) -> bool
	Indicates if no elements in a span satisfy `predicate`. More...

template<typename T1 , typename P1 , typename S1 , typename T2 , typename P2 , typename S2 , typename UnaryOperation >
static void	eagine::memory::for_each_delimited (basic_span< T1, P1, S1 > spn, basic_span< T2, P2, S2 > delim, UnaryOperation unary_op)
	Scans span for parts split by delimiter, calls a function for each part. More...

template<typename T , typename P , typename S , typename UnaryOperation >
static void	eagine::memory::for_each_chunk (basic_span< T, P, S > spn, const span_size_t len, UnaryOperation unary_op)
	Splits span into parts of equal length, calls a function for each part. More...

template<typename Result , typename T , typename P1 , typename S1 , typename P2 , typename S2 , typename BinaryFunction >
static auto	eagine::memory::basic_edit_distance (basic_span< const T, P1, S1 > s1, basic_span< const T, P2, S2 > s2, BinaryFunction get_distance) -> Result
	Calculates the edit distance of `s1` and `s2` according to get_distance.

template<typename T >
static auto	eagine::type_name (const T &) noexcept -> std::string
	Returns the demangled name for type T. More...

template<typename T >
static auto	eagine::type_name () noexcept -> std::string
	Returns the demangled name for type T. More...

template<typename T , typename = std::enable_if_t<std::is_integral_v<T>>>
static constexpr auto	eagine::std_align (T v) noexcept
	Converts argument to std alignment type.

template<typename T , typename = std::enable_if_t<std::is_integral_v<T>>>
static constexpr auto	eagine::std_size (T v) noexcept
	Converts argument to std size type.

template<typename T , typename = std::enable_if_t<std::is_integral_v<T>>>
static constexpr auto	eagine::span_size (T v) noexcept
	Converts argument to span size type.

template<typename T >
static constexpr auto	eagine::span_align_of (type_identity< T >={}) noexcept
	Returns the byte alignment of type T as span_size_t.

template<typename T >
static constexpr auto	eagine::span_size_of (type_identity< T >={}) noexcept
	Returns the byte size of type T as span_size_t.

template<typename T , typename S >
static constexpr auto	eagine::span_size_of (S n, type_identity< T >={}) noexcept
	Returns the total byte size of n elements of type T as span_size_t.

template<typename Traits >
static constexpr auto	operator+ (const key_value_list_element< Traits > &l, const key_value_list_element< Traits > &r) noexcept -> key_value_list< Traits, 4 >
	Concatenates two individual key/value elements into a key/value list. More...

template<typename Traits , std::size_t N>
static constexpr auto	operator+ (const key_value_list< Traits, N > &l, const key_value_list_element< Traits > &r) noexcept -> key_value_list< Traits, N+2 >
	Adds a key/value pair into a key/value list, returns a new list. More...

template<typename Selector , typename T >
static auto	get_member (protected_member< T, Selector > &pm, Selector selector=Selector()) noexcept -> T &
	Returns a reference to the member stored in protected_member.

template<typename Selector , typename T >
static auto	get_member (const protected_member< T, Selector > &pm, Selector selector=Selector()) noexcept -> const T &
	Returns a const reference to the member stored in protected_member.

Variables
template<typename T >
constexpr typed_nullptr_t< T >	eagine::memory::typed_nullptr
	Template constant for doing pointer arithmetic on null pointers.

template<typename T >
constexpr bool	eagine::memory::has_span_size_member_v
	Trait indicating if type T has x.size() member function.

template<typename T , typename E = anything>
constexpr bool	eagine::memory::has_span_data_member_v
	Trait indicating if type T has x.size() member function.

static constexpr nothing_t	eagine::nothing
	Constant of nothing_t type. More...

Detailed Description

Typedef Documentation

◆ biteset_cell_type

template<typename std::size_t B>

using eagine::biteset_cell_type = typedef std::conditional_t< (B <= 8), std::uint_least8_t, std::conditional_t< (B <= 16), std::uint_least16_t, std::conditional_t< (B <= 32), std::uint_least32_t, std::conditional_t<(B <= 64), std::uint_least64_t, void> >> >

Selects the appropriate type for biteset element representation.

See also: biteset

◆ id_constant

template<identifier_t Id>

using eagine::id_constant = typedef std::integral_constant<identifier_t, Id>

Alias for identifier_t constant type.

See also: identifier_t

Function Documentation

◆ all_of()

template<typename T , typename P , typename S , typename Predicate >

static auto eagine::memory::all_of	(	basic_span< T, P, S >	spn,
		Predicate	predicate
	)		-> bool

inlinestatic

Indicates if all elements in a span satisfy predicate.

See also: any_of; none_of

◆ any_of()

template<typename T , typename P , typename S , typename Predicate >

static auto eagine::memory::any_of	(	basic_span< T, P, S >	spn,
		Predicate	predicate
	)		-> bool

inlinestatic

Indicates if any elements in a span satisfy predicate.

See also: all_of; none_of

◆ convert_if_fits()

template<typename Dst , typename Src >

static constexpr auto eagine::convert_if_fits ( Src value ) -> std::enable_if_t<std::is_convertible_v<Src, Dst>, optionally_valid<Dst>>

staticconstexprnoexcept

Optionally converts value to Dst type if the value fits in that type.

See also: is_within_limits; limit_cast

◆ for_each_chunk()

template<typename T , typename P , typename S , typename UnaryOperation >

static void eagine::memory::for_each_chunk	(	basic_span< T, P, S >	spn,
		const span_size_t	len,
		UnaryOperation	unary_op
	)

inlinestatic

Splits span into parts of equal length, calls a function for each part.

See also: for_each_delimited

◆ for_each_delimited()

template<typename T1 , typename P1 , typename S1 , typename T2 , typename P2 , typename S2 , typename UnaryOperation >

static void eagine::memory::for_each_delimited	(	basic_span< T1, P1, S1 >	spn,
		basic_span< T2, P2, S2 >	delim,
		UnaryOperation	unary_op
	)

inlinestatic

Scans span for parts split by delimiter, calls a function for each part.

See also: for_each_chunk

◆ from_string() [1/2]

template<typename T >

auto eagine::from_string ( string_view src )

noexcept

Converts the string representation in src to a value of type T.

See also: is_within_limits

◆ from_string() [2/2]

template<typename T , identifier_t V>

auto eagine::from_string	(	string_view	src,
		selector< V >	sel
	)

noexcept

Converts the string representation in src to a value of type T.

See also: is_within_limits

This overload allows to specify a selector that can change the value conversion rules.

◆ is_within_limits()

template<typename Dst , typename Src >

static constexpr auto eagine::is_within_limits ( Src value )

staticconstexprnoexcept

Indicates if value fits into the specified Dst type.

See also: limit_cast; convert_if_fits

This function tests if the specified argument would fit into another type. For example if a value stored in 64-bit integer can be converted into a 16-bit integer without overflow.

◆ limit_cast()

template<typename Dst , typename Src >

static constexpr auto eagine::limit_cast ( Src value ) -> std::enable_if_t<std::is_convertible_v<Src, Dst>, Dst>

staticconstexprnoexcept

Casts value to Dst type if the value fits in that type.

See also: is_within_limits; convert_if_fits

Precondition: is_within_limits<Dst>(value)

◆ none_of()

template<typename T , typename P , typename S , typename Predicate >

static auto eagine::memory::none_of	(	basic_span< T, P, S >	spn,
		Predicate	predicate
	)		-> bool

inlinestatic

Indicates if no elements in a span satisfy predicate.

See also: all_of; any_of

◆ operator+() [1/2]

template<typename Traits , std::size_t N>

static constexpr auto operator+	(	const key_value_list< Traits, N > &	l,
		const key_value_list_element< Traits > &	r
	)		-> key_value_list<Traits, N + 2>

See also: key_value_list_element

◆ operator+() [2/2]

template<typename Traits >

static constexpr auto operator+	(	const key_value_list_element< Traits > &	l,
		const key_value_list_element< Traits > &	r
	)		-> key_value_list<Traits, 4>

See also: key_value_list_element

◆ type_name() [1/2]

template<typename T >

static auto eagine::type_name ( ) -> std::string

inlinestaticnoexcept

Returns the demangled name for type T.

Note: The result is implementation dependent.

◆ type_name() [2/2]

template<typename T >

static auto eagine::type_name ( const T & ) -> std::string

inlinestaticnoexcept

Returns the demangled name for type T.

Note: The result is implementation dependent.

Variable Documentation

◆ nothing

constexpr nothing_t eagine::nothing

staticconstexpr

Constant of nothing_t type.

See also: nothing_t

Examples: eagine/message_bus/005_topology.cpp, and eagine/message_bus/007_ping.cpp.

Referenced by eagine::shared_executable_module::open_self(), and eagine::shared_executable_module::shared_executable_module().

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ biteset_cell_type

◆ id_constant

Function Documentation

◆ all_of()

◆ any_of()

◆ convert_if_fits()

◆ for_each_chunk()

◆ for_each_delimited()

◆ from_string() [1/2]

◆ from_string() [2/2]

◆ is_within_limits()

◆ limit_cast()

◆ none_of()

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ type_name() [1/2]

◆ type_name() [2/2]

Variable Documentation

◆ nothing