Namespaces
	container

	device

	endian

	error

	esp32

	ext

	internal

	math

	memory

	modifier

	net

	pointer

	queue

	stl

	system

Classes
struct	basic_atomic_gcc
	Generic atomic type, primary class template. More...

struct	_atomic
	Only for declar special version for types. More...

struct	_atomic< bool >
	Special version for bool. More...

struct	_atomic< char >
	Special version for char. More...

struct	_atomic< signed char >
	Special version for signed char. More...

struct	_atomic< short >
	Special version for short. More...

struct	_atomic< int >
	Special version for int. More...

struct	_atomic< long >
	Special version for long. More...

struct	_atomic< long long >
	Special version for long long. More...

struct	_atomic< unsigned char >
	Special version for unsigned char. More...

struct	_atomic< unsigned short >
	Special version for short. More...

struct	_atomic< unsigned int >
	Special version for int. More...

struct	_atomic< unsigned long >
	Special version for long. More...

struct	_atomic< char16_t >
	Special version for char16_t. More...

struct	_atomic< char32_t >
	Special version for char32_t. More...

struct	_atomic< wchar_t >
	Special version for wchar_t. More...

struct	_atomic_ptr
	Special version for pointer. More...

struct	is_pod< container::pair< TFIRST, TSECOND > >

struct	is_pod< container::triple< TFIRST, TSECOND, TTHIRD > >

struct	value2size

struct	value2size_raw

class	basic_atomic_flag

class	atomic_counter
	This class implements a simple counter, whit atomic operations for use in a multithreaded environment. More...

class	basic_atomic_singleton
	Singleton with double-checked locking pattern with atomic and mutex lock. More...

class	atomic_spinlock
	This class implements a simple spinlack, whit atomic operations. More...

class	auto_release_object

class	auto_release
	A simple garbage collector - pool based, a object for this colector must be extends auto_release_object. More...

class	basic_semaphore

class	basic_binary_semaphore

class	buffer
	A buffer class that allocates a buffer of a given type and size. More...

class	basic_clock

class	only_copyable_tag
	Not movable. More...

class	only_move_tag
	Not copyable. More...

class	only_oneable_tag
	Not copyable or movable. More...

class	copy_move_tag
	copyable and movable More...

class	basic_counting_semaphore

class	null_type

struct	system_endian
	Get the underlying endian architecture? More...

struct	base_eventargs

class	exit_eventargs

class	handler_eventargs

struct	base_event

class	event_system

class	basic_event_group
	Wrapper class around FreeRTOS's implementation of a event_group. More...

class	basic_fbit

class	fast_type

class	small_task

class	small_task< R(Args...), sz, algn >

struct	tag

struct	conditional

struct	conditional< false, T, F >

struct	bit_or

struct	bit_or<>

struct	bit_or< A >

struct	bit_or< A, B >

struct	bit_or< A, B, C, N... >

struct	remove_reference

struct	remove_reference< T & >

struct	remove_const

struct	remove_const< T const >

struct	remove_volatile

struct	remove_volatile< T volatile >

struct	remove_cv

struct	remove_cvref

struct	add_const

struct	add_volatile

struct	add_cv

struct	add_reference

struct	add_pointer

struct	add_lvalue_reference

struct	add_rvalue_reference

struct	decay3

struct	decay3< R(Args...)>

struct	decay2

struct	decay2< T[N]>

struct	decay

struct	is_convertible

struct	is_convertible< void, void >

struct	enable_if

struct	enable_if< true, T >

struct	is_same

struct	is_same< A, A >

struct	is_base_of

struct	logic_and

struct	logic_or

struct	logic_not

struct	sqrt

struct	factorial
	Calculates the Nth factorial value. More...

struct	factorial< 0 >
	Calculates the 0 factorial value. More...

struct	fibonacci
	Calculates the Nth Fibonacci value. More...

struct	fibonacci< 0 >
	Calculates the 0 Fibonacci value. More...

struct	fibonacci< 1 >
	Calculates the 1 Fibonacci value. More...

struct	hash
	Default implementation of hasher. More...

struct	hash< T * >

struct	hash< char * >

struct	hash< const char * >

struct	hash< int8_t >

struct	hash< uint8_t >

struct	hash< int16_t >

struct	hash< uint16_t >

struct	hash< int32_t >

struct	hash< uint32_t >

struct	hash< int64_t >

struct	hash< uint64_t >

struct	hash_function

struct	hash_function< const char * >

class	basic_initializer_list

struct	input_iterator_tag

struct	output_iterator_tag

struct	forward_iterator_tag

struct	bidirectional_iterator_tag

struct	random_access_iterator_tag

struct	iterator_traits

struct	iterator_traits< T * >

class	reverse_iterator

class	insert_iterator

class	back_insert_iterator

class	front_insert_iterator

class	move_iterator

class	basic_iterator_pair

class	basic_iterator_triple

class	ITimer

class	numeric_limits

class	numeric_limits< const T >

class	numeric_limits< volatile T >

class	numeric_limits< const volatile T >

class	numeric_limits< bool >
	Spezial version for bool. More...

class	numeric_limits< char >
	Spezial version for char. More...

class	numeric_limits< unsigned char >
	Spezial version for uchar. More...

class	numeric_limits< signed char >
	Spezial version for uchar. More...

class	numeric_limits< short >
	Spezial version for short. More...

class	numeric_limits< unsigned short >
	Spezial version for unsigned short. More...

class	numeric_limits< int >
	Spezial version for int. More...

class	numeric_limits< unsigned int >
	Spezial version for unsigned int. More...

class	numeric_limits< long >
	Spezial version for long. More...

class	numeric_limits< unsigned long >
	Spezial version for unsigned long. More...

class	numeric_limits< long long >
	Spezial version for long long. More...

class	numeric_limits< unsigned long long >
	Spezial version for unsigned long long. More...

class	numeric_limits< float >
	Spezial version for float. More...

class	numeric_limits< double >
	Spezial version for double. More...

class	numeric_limits< long double >
	Spezial version for long double. More...

class	ILockObject

class	basic_autolock

class	basic_autounlock

class	basic_mutex

class	basic_null_lock
	Null Lock is a lock object without any lock logic. More...

struct	nullopt_t

class	basic_optional

class	basic_hardware_pin

class	basic_esp32_hardware_digital_pin

class	basic_safe_counter
	safe counter is a base of thread saftly counter More...

class	basic_schedular

class	basic_shared_object

class	basic_singleton

class	basic_task
	Wrapper class around FreeRTOS's implementation of a task. More...

class	basic_task_list

class	task_utils

class	basic_tasklet

class	basic_thread

class	base_tickhook_entry

class	basic_timed_lock

class	basic_timer

class	basic_timespan
	This class represents a time span (using microseconds) More...

class	basic_timestamp
	A Timestamp stores a monotonic* time value with microseconds resolution. More...

struct	type_traits

struct	type_traits< T & >

struct	type_traits< const T >

struct	type_traits< const T & >

struct	type_traits< volatile T & >

struct	type_traits< const volatile T & >

struct	type_traits< T * >

struct	type_traits< T[N]>

struct	type_traits< const T[N]>

struct	integral_constant

struct	is_const

struct	is_const< T const >

struct	is_volatile
	is_volatile More...

struct	is_volatile< T volatile >

struct	is_empty
	is_empty More...

struct	is_enum

struct	is_union

struct	is_class

struct	is_function

struct	is_function< T(Args...)>

struct	is_function< T(Args...) & >

struct	is_function< T(Args...) && >

struct	is_function< T(Args......)>

struct	is_function< T(Args......) & >

struct	is_function< T(Args......) && >

struct	is_function< T(Args...) const >

struct	is_function< T(Args...) const & >

struct	is_function< T(Args...) const && >

struct	is_function< T(Args......) const >

struct	is_function< T(Args......) const & >

struct	is_function< T(Args......) const && >

struct	is_function< T(Args...) volatile >

struct	is_function< T(Args...) volatile & >

struct	is_function< T(Args...) volatile && >

struct	is_function< T(Args......) volatile >

struct	is_function< T(Args......) volatile & >

struct	is_function< T(Args......) volatile && >

struct	is_function< T(Args...) const volatile >

struct	is_function< T(Args...) const volatile & >

struct	is_function< T(Args...) const volatile && >

struct	is_function< T(Args......) const volatile >

struct	is_function< T(Args......) const volatile & >

struct	is_function< T(Args......) const volatile && >

struct	is_abstract

struct	is_polymorphic

struct	is_literal_type

struct	is_pod

struct	is_trivial
	is_trivial More...

struct	is_trivially_copyable

struct	is_standard_layout
	is_standard_layout More...

struct	is_bind_expression

struct	is_placeholder

struct	is_integral

struct	is_integral< const T >

struct	is_integral< volatile T >

struct	is_integral< const volatile T >

struct	is_rational

struct	is_rational< const T >

struct	is_rational< volatile T >

struct	is_rational< const volatile T >

struct	is_void

struct	is_void< const T >

struct	is_void< volatile T >

struct	is_void< const volatile T >

struct	is_floating_point

struct	is_floating_point< float >

struct	is_floating_point< double >

struct	is_floating_point< long double >

struct	is_floating_point< const T >

struct	is_floating_point< volatile T >

struct	is_floating_point< const volatile T >

struct	is_lvalue_reference
	is_lvalue_reference More...

struct	is_lvalue_reference< T & >

struct	is_rvalue_reference
	is_rvalue_reference More...

struct	is_rvalue_reference< T && >

struct	is_pointer

struct	is_pointer< T * >

struct	is_fundamental

struct	has_trivial_constructor

struct	has_trivial_copy

struct	has_trivial_assign

struct	has_trivial_destructor

struct	is_reference

struct	is_arithmetic
	is_arithmetic More...

struct	is_object
	is_object More...

struct	is_signed
	is_signed More...

struct	is_signed< char >

struct	is_signed< signed char >

struct	is_signed< short >

struct	is_signed< int >

struct	is_signed< long >

struct	is_signed< long long >

struct	is_signed< float >

struct	is_signed< double >

struct	is_signed< long double >

struct	is_signed< const T >

struct	is_signed< volatile T >

struct	is_signed< const volatile T >

struct	is_unsigned
	is_unsigned More...

struct	is_unsigned< bool >

struct	is_unsigned< char >

struct	is_unsigned< unsigned char >

struct	is_unsigned< unsigned short >

struct	is_unsigned< unsigned int >

struct	is_unsigned< unsigned long >

struct	is_unsigned< unsigned long long >

struct	is_unsigned< const T >

struct	is_unsigned< volatile T >

struct	is_unsigned< const volatile T >

struct	is_member_pointer

struct	is_compound
	is_compound More...

struct	basic_uint128_t

class	basic_void_type
	A dummy class with value-type semantics, mostly useful as a template argument. More...

struct	make_void

struct	hash< mn::pointer::value_ptr< T, D, C > >

struct	is_pod< internal::aligned1 >

struct	is_pod< internal::aligned2 >

struct	is_pod< internal::aligned4 >

struct	is_pod< internal::aligned8 >

struct	is_pod< internal::aligned16 >

struct	is_pod< internal::aligned32 >

struct	is_pod< internal::aligned64 >

struct	alignment_of

struct	alignment_of< void >

struct	alignment_of< void const >

struct	alignment_of< void const volatile >

struct	alignment_of< void volatile >

struct	long_double_alignment

struct	long_double_alignment< Target, false >

struct	double_alignment

struct	double_alignment< Target, false >

struct	long_long_alignment

struct	long_long_alignment< Target, false >

struct	long_alignment

struct	long_alignment< Target, false >

struct	int_alignment

struct	int_alignment< Target, false >

struct	short_alignment

struct	short_alignment< Target, false >

struct	char_alignment

struct	char_alignment< Target, false >

struct	aligned_as

class	compressed_pair

class	ebo_storage

class	ebo_storage< T, TAG, mn::enable_if_t< mn::is_class< T >::value > >

struct	int_to_type

struct	type_to_type

struct	select

struct	select< false, T, U >

class	basic_ramdom_xorshift
	Pseudro-Random Number Generator based on xor_shift128++ generator. More...

class	IPseudoRandomUtil
	An Intarface for all randoms classes in this library. More...

class	basic_random_lfsr
	Pseudro-Random Number Generator based on a 32-bit linear-feedback shift register. More...

struct	less

struct	greater

struct	equal_to

struct	not_equal_to

struct	greater_equal

struct	less_equal

struct	negate

struct	plus

struct	minus

struct	multiplies

struct	divides

struct	modulus

struct	inc

struct	dec

union	basic_fbit.__unnamed11__

union	fast_type.__unnamed13__

union	basic_uint128_t.__unnamed16__

struct	basic_uint128_t.__unnamed16__.__unnamed18__

Typedefs
template<typename T >
using	atomic_ptr = _atomic_ptr< T * >

using	atomic_bool = _atomic< bool >

using	atomic_char = _atomic< char >

using	atomic_schar = _atomic< signed char >

using	atomic_short = _atomic< short >

using	atomic_int = _atomic< int >

using	atomic_long = _atomic< long >

using	atomic_int_least8_t = _atomic< int_least8_t >

using	atomic_int_least16_t = _atomic< int_least16_t >

using	atomic_int_least32_t = _atomic< int_least32_t >

using	atomic_int_least64_t = _atomic< int_least64_t >

using	atomic_int_fast8_t = _atomic< int_fast8_t >

using	atomic_int_fast16_t = _atomic< int_fast16_t >

using	atomic_int_fast32_t = _atomic< int_fast32_t >

using	atomic_int_fast64_t = _atomic< int_fast64_t >

using	atomic_int8_t = _atomic< int8_t >

using	atomic_int16_t = _atomic< int16_t >

using	atomic_int32_t = _atomic< int32_t >

using	atomic_int64_t = _atomic< int64_t >

using	atomic_uchar = _atomic< unsigned char >

using	atomic_ushort = _atomic< unsigned short >

using	atomic_uint = _atomic< unsigned int >

using	atomic_ulong = _atomic< unsigned long >

using	atomic_uint_least8_t = _atomic< uint_least8_t >

using	atomic_uint_least16_t = _atomic< uint_least16_t >

using	atomic_uint_least32_t = _atomic< uint_least32_t >

using	atomic_uint_least64_t = _atomic< uint_least64_t >

using	atomic_uint_fast8_t = _atomic< uint_fast8_t >

using	atomic_uint_fast16_t = _atomic< uint_fast16_t >

using	atomic_uint_fast32_t = _atomic< uint_fast32_t >

using	atomic_uint_fast64_t = _atomic< uint_fast64_t >

using	atomic_uint8_t = _atomic< uint8_t >

using	atomic_uint16_t = _atomic< uint16_t >

using	atomic_uint32_t = _atomic< uint32_t >

using	atomic_uint64_t = _atomic< uint64_t >

using	atomic_intptr_t = _atomic< intptr_t >

using	atomic_uintptr_t = _atomic< uintptr_t >

using	atomic_size_t = _atomic< size_t >

using	atomic_ptrdiff_t = _atomic< ptrdiff_t >

using	atomic_intmax_t = _atomic< intmax_t >

using	atomic_uintmax_t = _atomic< uintmax_t >

using	atomic_char16_t = _atomic< char16_t >

using	atomic_char32_t = _atomic< char32_t >

using	atomic_wchar_t = _atomic< wchar_t >

using	atomic_sig_t = _atomic< int >

using	atomic_flag = basic_atomic_flag< bool >

template<typename T >
using	atomic_singleton = basic_atomic_singleton< T >

using	autocsemp_t = basic_autolock< counting_semaphore_t >

using	autobinsemp_t = basic_autolock< binary_semaphore_t >

using	automutx_t = basic_autolock< mutex_t >

using	LockType_t = mn::binary_semaphore_t

using	autolock_t = basic_autolock< LockType_t >

using	autouncsemp_t = basic_autounlock< counting_semaphore_t >

using	autounbinsemp_t = basic_autounlock< binary_semaphore_t >

using	autounmutx_t = basic_autounlock< mutex_t >

using	unlock_t = basic_autounlock< LockType_t >

using	binary_semaphore_t = basic_binary_semaphore

using	counting_semaphore_t = basic_counting_semaphore

using	max_align_t = uintptr_t

using	nullptr_t = decltype(nullptr)

using	addrof_null_t = nullptr_t

using	size_t = MN_THREAD_CONFIG_SIZE_TYPE

using	ptrdiff_t = long

using	uptrdiff_t = unsigned long

using	intmax_t = signed long

using	uintmax_t = unsigned long

using	event_group_t = basic_event_group

using	fsize_t = fast_type< value2size< size_t >::size, size_t >

using	ffloat_t = fast_type< value2size< float >::size, float >

using	fdouble_t = fast_type< value2size< double >::size, double >

using	fint8_t = fast_type< value2size< int8_t >::size, int8_t >

using	fint16_t = fast_type< value2size< int16_t >::size, int16_t >

using	fint32_t = fast_type< value2size< int32_t >::size, int32_t >

using	fint64_t = fast_type< value2size< int64_t >::size, int64_t >

using	fuint8_t = fast_type< value2size< uint8_t >::size, uint8_t >

using	fuint16_t = fast_type< value2size< uint16_t >::size, uint16_t >

using	fuint32_t = fast_type< value2size< uint32_t >::size, uint32_t >

using	fuint64_t = fast_type< value2size< uint64_t >::size, uint64_t >

using	fuint128_t = fast_type< value2size< uint128_t >::size, uint128_t >

using	fint_least8_t = fast_type< value2size< int_least8_t >::size, int_least8_t >

using	fint_least16_t = fast_type< value2size< int_least16_t >::size, int_least16_t >

using	fint_least32_t = fast_type< value2size< int_least32_t >::size, int_least32_t >

using	fint_least64_t = fast_type< value2size< int_least64_t >::size, int_least64_t >

using	fuint_least8_t = fast_type< value2size< uint_least8_t >::size, uint_least8_t >

using	fuint_least16_t = fast_type< value2size< uint_least16_t >::size, uint_least16_t >

using	fuint_least32_t = fast_type< value2size< uint_least32_t >::size, uint_least32_t >

using	fuint_least64_t = fast_type< value2size< uint_least64_t >::size, uint_least64_t >

using	fuint_least128_t = fast_type< value2size< uint_least128_t >::size, uint_least128_t >

template<class Sig >
using	function = small_task< Sig, sizeof(void ) 4, alignof(void *)>

template<typename Tag >
using	type_t = typename Tag::type

template<typename T >
using	remove_reference_t = type_t< remove_reference< T > >

template<typename T >
using	decay_t = type_t< decay< T > >

template<template< typename... > typename Z, typename... Ts>
using	can_apply = internal::can_apply< Z, void, Ts... >

template<bool b, class T = void>
using	enable_if_t = type_t< enable_if< b, T > >

template<class Sig >
using	res_of = internal::res_of< Sig >

template<class Sig >
using	result_of = internal::res_of< Sig >

template<class Sig >
using	res_of_t = type_t< res_of< Sig > >

template<class Sig >
using	result_of_t = internal::res_of< Sig >

using	result_type = mn::size_t

template<typename T >
using	initializer_list = basic_initializer_list< T >

using	mutex_t = basic_mutex

using	null_lock = basic_null_lock

template<typename T >
using	optional = basic_optional< T >

template<int TPin, bool TLevel = false, pin_direction TDirection = pin_direction::Output>
using	esp32_digital_pin = basic_esp32_hardware_pin< TPin >

using	safe_counter_t = basic_safe_counter< uint64_t, LockType_t >
	sot the default safe_counter, value type are uint64_t and as lock type use LockType_t More...

using	schedular = basic_schedular

template<class TOBJECT >
using	shared_object_t = basic_shared_object< TOBJECT >

using	shared_int8_t = basic_shared_object< int8_t >
	A shared object value of `int8_t`. More...

using	shared_int16_t = basic_shared_object< int16_t >
	A shared object value of `int16_t`. More...

using	shared_int32_t = basic_shared_object< int32_t >
	A shared object value of `int32_t`. More...

using	shared_int64_t = basic_shared_object< int64_t >
	A shared object value of `int64_t`. More...

using	shared_uint8_t = basic_shared_object< uint8_t >
	A shared object value of `uint8_t`. More...

using	shared_uint16_t = basic_shared_object< uint16_t >
	A shared object value of `uint16_t`. More...

using	shared_uint32_t = basic_shared_object< uint32_t >
	A shared object value of `uint32_t`. More...

using	shared_uint64_t = basic_shared_object< uint64_t >
	A shared object value of `uint64_t`. More...

using	shared_fast_int8_t = basic_shared_object< int_fast8_t >
	A shared object value of `int8_fast_t`. More...

using	shared_fast_int16_t = basic_shared_object< int_fast16_t >
	A shared object value of `int16_fast_t`. More...

using	shared_fast_int32_t = basic_shared_object< int_fast32_t >
	A shared object value of `int32_fast_t`. More...

using	shared_fast_int64_t = basic_shared_object< int_fast64_t >
	A shared object value of `int64_fast_t`. More...

using	shared_fast_uint8_t = basic_shared_object< uint_fast8_t >
	A shared object value of `uint8_fast_t`. More...

using	shared_fast_uint16_t = basic_shared_object< uint_fast16_t >
	A shared object value of `uint16_fast_t`. More...

using	shared_fast_uint32_t = basic_shared_object< uint_fast32_t >
	A shared object value of `uint32_fast_t`. More...

using	shared_fast_uint64_t = basic_shared_object< uint_fast64_t >
	A shared object value of `uint64_fast_t`. More...

using	shared_least_int8_t = basic_shared_object< int_least8_t >
	A shared object value of `int_least8_t`. More...

using	shared_least_int16_t = basic_shared_object< int_least16_t >
	A shared object value of `int_least16_t`. More...

using	shared_least_int32_t = basic_shared_object< int_least32_t >
	A shared object value of `int_least32_t`. More...

using	shared_least_int64_t = basic_shared_object< int_least64_t >
	A shared object value of `int_least64_t`. More...

using	shared_least_uint8_t = basic_shared_object< uint_least8_t >
	A shared object value of `uint_least8_t`. More...

using	shared_least_uint16_t = basic_shared_object< uint_least16_t >
	A shared object value of `uint_least16_t`. More...

using	shared_least_uint32_t = basic_shared_object< uint_least32_t >
	A shared object value of `uint_least32_t`. More...

using	shared_least_uint64_t = basic_shared_object< uint_least64_t >
	A shared object value of `uint_least64_t`. More...

using	shared_float_t = basic_shared_object< float >
	A shared object value of `float`. More...

using	shared_double_t = basic_shared_object< double >
	A shared object value of `double`. More...

using	shared_bool_t = basic_shared_object< bool >
	A shared object value of `bool`. More...

using	shared_void_t = basic_shared_object< void * >
	A shared object value of `void*`. More...

using	shared_size_t = basic_shared_object< size_t >
	A shared object value of `size_t`. More...

using	shared_char_t = basic_shared_object< char >
	A shared object value of `char`. More...

using	shared_string_t = basic_shared_object< std::string >
	A shared object value of `std::string`. More...

using	task_t = basic_task
	using the basic_task as task_t type More...

using	task_list_t = basic_task_list

using	task_utils_t = task_utils

using	tasklet_t = basic_tasklet

using	timed_mutex_t = basic_timed_lock< mutex_t >

using	timed_binary_semaphore_t = basic_timed_lock< binary_semaphore_t >

using	timed_counting_semaphore_t = basic_timed_lock< counting_semaphore_t >

using	timer_t = basic_timer

using	timespan_t = basic_timespan

using	timestamp_t = basic_timestamp

using	true_type = integral_constant< bool, true >

using	false_type = integral_constant< bool, false >

using	uint128_t = basic_uint128_t

using	uint_least128_t = basic_uint128_t

template<class ... ts>
using	void_t = typename make_void< ts ... >::type

using	random_xorshift = basic_ramdom_xorshift

using	random_lfsr = basic_random_lfsr

using	default_random_engine = random_xorshift

Enumerations
enum class	memory_order : int { Relaxed = __ATOMIC_RELAXED , Consume = __ATOMIC_CONSUME , Acquire = __ATOMIC_ACQUIRE , Release = __ATOMIC_RELEASE , AcqRel = __ATOMIC_ACQ_REL , SeqCst = __ATOMIC_SEQ_CST }

enum class	byte : unsigned char

enum class	float_round_style { indeterminate = -1 , toward_zero = 0 , to_nearest = 1 , toward_infinity = 2 , toward_neg_infinity = 3 }
	Describes the rounding style for floating-point types. More...

enum class	float_denorm_style { indeterminate = -1 , absent = 0 , present = 1 }
	Describes the denormalization for floating-point types. More...

enum class	pin_direction { Disable = GPIO_MODE_DISABLE , Input = GPIO_MODE_INPUT , Output = GPIO_MODE_OUTPUT , InOut = GPIO_MODE_INPUT_OUTPUT }

Functions
memory_order	operator\| (memory_order mMemOrder, modifier::memory_order mod)

memory_order	operator& (memory_order mMemOrder, modifier::memory_order mod)

void	panic ()

size_t	popcount (uint32_t v)

void	copy_construct (T *mem, const T &orig)

void	copy_construct (T *mem, const T &&orig)

void	construct (T *mem)

void	destruct (T *mem)

void	copy_n (const T src, size_t n, T dest)
	Copy N elements from src to dest. More...

void	copy (const T src, const T last, T *dest)

void	copy_construct_n (T src, size_t n, T dest)

void	move_n (const T from, size_t n, T dest)

void	move (const T src, const T last, T *dest)

template<typename T >
T *	copy_backward (const T first, const T last, T *result) noexcept

TFn	foreach (TIter src, TIter last, TFn fn)

void	construct_n (T *src, size_t n)

void	destruct_n (T *src, size_t n)

void	fill (T src, T last, const T &val)

void	fill_n (T *src, size_t n, const T &val)

constexpr TIter	lower_bound (TIter first, TIter last, const TPred &value)

constexpr TIter	lower_bound (TIter src, TIter last, const T &val, const TPred &pred)

constexpr TIter	upper_bound (TIter first, TIter last, const TPred &value)

constexpr TIter	upper_bound (TIter src, TIter last, const T &val, const TPred &pred)

template<typename TIter , typename TComp >
constexpr bool	binary_search (TIter first, TIter last, const TComp &value)

TIter	find (TIter src, TIter last, const T &val)

TIter	find_if (TIter src, TIter last, const T &val, const TPred &pred)

void	accumulate (TIter src, TIter last, T &dest)

T	abs (const T &t)

template<int >
int	abs (const int &x)

template<short >
short	abs (const short &x)

bool	is_range (const T ch, const T min, const T max)

bool	islower (char ch)

bool	isupper (char ch)

bool	isalpha (char ch)

bool	isdigit (char ch)

bool	iscntrl (char ch)

bool	isspace (char ch)

bool	isblank (char ch)

bool	isgraph (char ch)

bool	isprint (char ch)

bool	isxdigit (char ch)

bool	isalnum (char ch)

char	hex2char (char ch)

T	max (const T x, const T y)

T	min (const T x, const T y)

void	swap (TAssignable &a, TAssignable &b)

void	swap (TAssignable(&x)[N], TAssignable(&y)[N])

void	iter_swap (fIt1 a, fIt2 b)

fIt2	swap_ranges (fIt1 a, fIt1 b, fIt2 c)

template<typename TRandomAccessIterator , typename TRandFunc >
void	random_shuffle (TRandomAccessIterator first, TRandomAccessIterator last, const TRandFunc &func)

template<class TLOCK = LockType_t>
int	lock (TLOCK &m1, unsigned int timeout)

template<class TLOCK = LockType_t>
int	unlock (TLOCK &m1)

template<class TLOCK = LockType_t>
bool	try_lock (TLOCK &m1)

template<typename IntegerType , class = typename mn::enable_if<mn::is_integral<IntegerType>::value>::type>
IntegerType	to_integer (byte b)

template<class IntegerType , class = typename mn::enable_if<mn::is_integral<IntegerType>::value>::type>
constexpr byte	to_byte (IntegerType v) noexcept

constexpr unsigned char	to_uchar (byte b) noexcept

constexpr unsigned char	to_uchar (int i) noexcept

template<typename IntegerType >
byte &	operator<<= (byte &b, IntegerType shift) noexcept

template<typename IntegerType >
byte &	operator>>= (byte &b, IntegerType shift) noexcept

template<typename IntegerType >
constexpr byte	operator<< (byte &b, IntegerType shift) noexcept

template<typename IntegerType >
constexpr byte	operator>> (byte &b, IntegerType shift) noexcept

constexpr bool	operator== (const byte l, const byte r) noexcept

constexpr bool	operator!= (const byte l, const byte r) noexcept

constexpr bool	operator< (const byte l, const byte r) noexcept

constexpr bool	operator<= (const byte l, const byte r) noexcept

constexpr bool	operator> (const byte l, const byte r) noexcept

constexpr bool	operator>= (const byte l, const byte r) noexcept

byte	operator\|= (byte &lhr, const byte rhr) noexcept

byte	operator&= (byte &lhr, const byte rhr) noexcept

byte	operator^= (byte &lhr, const byte rhr) noexcept

constexpr byte	operator\| (const byte &lhr, const byte &rhr) noexcept

constexpr byte	operator^ (const byte &lhr, const byte &rhr) noexcept

constexpr byte	operator& (const byte &lhr, const byte &rhr) noexcept

constexpr byte	operator~ (byte b) noexcept

template<class R , class... Args, size_t sz, size_t algn>
bool	operator== (const small_task< R(Args...), sz, algn > &__f, nullptr_t)

template<class R , class... Args, size_t sz, size_t algn>
bool	operator== (nullptr_t, const small_task< R(Args...), sz, algn > &__f)

template<class R , class... Args, size_t sz, size_t algn>
bool	operator!= (const small_task< R(Args...), sz, algn > &__f, nullptr_t)

template<class R , class... Args, size_t sz, size_t algn>
bool	operator!= (nullptr_t, const small_task< R(Args...), sz, algn > &__f)

template<typename T >
T &&	move (T &t)

template<typename T >
T &&	forward (remove_reference_t< T > &t)

template<typename T >
T &&	forward (remove_reference_t< T > &&t)

template<typename T >
T	declval ()

template<typename T >
result_type	extract_int_key_value (const T &t)
	Default implementations, just casts to hash_value. More...

template<typename TIter >
constexpr iterator_traits< TIter >::difference_type	distance (TIter first, TIter last)

template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void	advance (TIter &iter, TDistance d)

template<typename TForwardIter , typename TDistance = typename iterator_traits<TForwardIter>::difference_type>
TForwardIter	next (TForwardIter x, TDistance n=1)

template<typename TBidirectionalIter , typename TDistance = typename iterator_traits<TBidirectionalIter>::difference_type>
TBidirectionalIter	prev (TBidirectionalIter x, TDistance n=1)

template<typename TIterator >
constexpr reverse_iterator< TIterator >	make_reverse_iterator (TIterator itr)

template<typename TCon >
constexpr insert_iterator< TCon >	inserter (TCon &ctr, typename TCon::iterator itr)

template<class TCon >
constexpr back_insert_iterator< TCon >	back_inserter (TCon &ctr)

template<class TCon >
constexpr front_insert_iterator< TCon >	front_inserter (TCon &ctr)

template<class TCon >
constexpr TCon::iterator	remove_const_it (typename TCon::const_iterator itr, TCon &)

template<typename TIterator >
constexpr move_iterator< TIterator >	make_move_iterator (TIterator itr)

unsigned long	micros ()

unsigned long	millis ()

unsigned int	get_ticks ()

unsigned int	ticks_to_ms (unsigned int ticks) MN_DEPRECATED

unsigned int	ms_to_ticks (unsigned int ms) MN_DEPRECATED

unsigned int	seconds_to_ticks (unsigned int ms) MN_DEPRECATED

unsigned int	time_to_ms (const struct timeval *time) MN_DEPRECATED

unsigned int	time_to_ticks (const struct timeval *time) MN_DEPRECATED

static struct timeval	operator- (const struct timeval &lhs, const struct timeval &rhs)

static struct timeval	operator+ (const struct timeval &lhs, const struct timeval &rhs)

template<typename T >
void	swap (basic_optional< T > &a, basic_optional< T > &b)

template<typename T , typename U >
constexpr bool	operator== (const basic_optional< T > &x, const basic_optional< U > &y)

template<typename T , typename U >
constexpr bool	operator!= (const basic_optional< T > &x, const basic_optional< U > &y)

template<typename T , typename U >
constexpr bool	operator< (const basic_optional< T > &x, const basic_optional< U > &y)

template<typename T , typename U >
constexpr bool	operator> (const basic_optional< T > &x, const basic_optional< U > &y)

template<typename T , typename U >
constexpr bool	operator<= (const basic_optional< T > &x, const basic_optional< U > &y)

template<typename T , typename U >
constexpr bool	operator>= (const basic_optional< T > &x, const basic_optional< U > &y)

template<typename T >
constexpr bool	operator== (const basic_optional< T > &x, nullopt_t) noexcept

template<typename T >
constexpr bool	operator== (nullopt_t, const basic_optional< T > &x) noexcept

template<typename T >
constexpr bool	operator!= (const basic_optional< T > &x, nullopt_t) noexcept

template<typename T >
constexpr bool	operator!= (nullopt_t, const basic_optional< T > &x) noexcept

template<typename T >
constexpr bool	operator< (const basic_optional< T > &, nullopt_t) noexcept

template<typename T >
constexpr bool	operator< (nullopt_t, const basic_optional< T > &x) noexcept

template<typename T >
constexpr bool	operator<= (const basic_optional< T > &x, nullopt_t) noexcept

template<typename T >
constexpr bool	operator<= (nullopt_t, const basic_optional< T > &) noexcept

template<typename T >
constexpr bool	operator> (const basic_optional< T > &x, nullopt_t) noexcept

template<typename T >
constexpr bool	operator> (nullopt_t, const basic_optional< T > &) noexcept

template<typename T >
constexpr bool	operator>= (const basic_optional< T > &, nullopt_t) noexcept

template<typename T >
constexpr bool	operator>= (nullopt_t, const basic_optional< T > &x) noexcept

template<typename T , typename U >
constexpr bool	operator== (const basic_optional< T > &x, const U &v)

template<typename T , typename U >
constexpr bool	operator== (const U &v, const basic_optional< T > &x)

template<typename T , typename U >
constexpr bool	operator!= (const basic_optional< T > &x, const U &v)

template<typename T , typename U >
constexpr bool	operator!= (const U &v, const basic_optional< T > &x)

template<typename T , typename U >
constexpr bool	operator< (const basic_optional< T > &x, const U &v)

template<typename T , typename U >
constexpr bool	operator< (const U &v, const basic_optional< T > &x)

template<typename T , typename U >
constexpr bool	operator<= (const basic_optional< T > &x, const U &v)

template<typename T , typename U >
constexpr bool	operator<= (const U &v, const basic_optional< T > &x)

template<typename T , typename U >
constexpr bool	operator> (const basic_optional< T > &x, const U &v)

template<typename T , typename U >
constexpr bool	operator> (const U &v, const basic_optional< T > &x)

template<typename T , typename U >
constexpr bool	operator>= (const basic_optional< T > &x, const U &v)

template<typename T , typename U >
constexpr bool	operator>= (const U &v, const basic_optional< T > &x)

template<typename T >
constexpr basic_optional< typename mn::decay< T >::type >	make_optional (T &&value)

template<typename T , typename... Args>
constexpr basic_optional< T >	make_optional (Args &&... args)

void	delay (const timespan_t &ts)

unsigned int	delay_until (timespan_t &tsPreviousWakeTime, const unsigned int &uiTimeIncrement)
	Delay a task until a specified time. More...

void	ndelay (const timespan_t &req, timespan_t *rem)

void	swap (timespan_t &s1, timespan_t &s2)

void	swap (basic_timestamp a, basic_timestamp b)

const char *	minilib_version_string (char version_string[MN_THREAD_VERSION_STRING_LEN])

void	minilib_version_print (const char strPrjName, const char strExtraInfo="")

template<class T >
constexpr T *	addressof (T &o) noexcept

template<class T >
const T *	addressof (const T &&)=delete

template<class integral >
constexpr bool	is_aligned (integral x, size_t a) noexcept

bool	is_aligned (const volatile void *p, size_t a)

template<class integral >
constexpr integral	align_up (integral x, size_t a) noexcept

template<class pointer >
pointer	align_up_ptr (pointer p, size_t a)

template<class integral >
constexpr integral	align_down (integral x, size_t a) noexcept

template<class pointer >
pointer	align_down_ptr (pointer p, size_t a)

constexpr bool	is_aligvalid (size_t alignment) noexcept
	is a valid alignment, i.e. a power of two not zero More...

size_t	alig_offset (void *address, size_t alignment) noexcept

size_t	alignment_for (const size_t size) noexcept

size_t	nlz_base (uint64_t x)

size_t	nlz (uint64_t x)

void	insertion_sort (T begin, T end, TPredicate pred)

void	insertion_sort (T begin, T end)

void	shell_sort (T begin, T end, TPredicate pred)

void	shell_sort (T begin, T end)

void	quick_sort (T begin, T end, TPredicate pred)

void	quick_sort (T begin, T end)

void	heap_sort (T begin, T end, TPredicate pred)

void	heap_sort (T begin, T end)

bool	is_sorted (TIter begin, TIter end, TPredicate pred)

void	sort (T begin, T end, TPredicate pred)

void	sort (T begin, T end)

T	nexthigher (T k) noexcept

template<typename T , typename R >
R	_reinterpret_cast (T *p)

template<typename T , typename R >
const R	_const_reinterpret_cast (const T *p)

Variables
const size_t	default_alignment = alignof(void*)

constexpr size_t	max_alignment = alignof(max_align_t)

portMUX_TYPE	microsMux = portMUX_INITIALIZER_UNLOCKED

Detailed Description

The Mini Thread Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, version 3, or (at your option) any later version.

The Mini Thread Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with the Mini Thread Library; if not, see https://www.gnu.org/licenses/.

The Mini Thread Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, version 3, or (at your option) any later version.

The Mini Thread Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with the Mini Thread Library; if not, see https://www.gnu.org/licenses/.

The Mini Thread Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, version 3, or (at your option) any later version.

The Mini Thread Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with the Mini Thread Library; if not, see https://www.gnu.org/licenses/.

Condition variables are an additon to the mini Thread classes. If you want to include them, you need to define the following in your config file with MN_THREAD_CONFIG_YES

The Mini Thread Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, version 3, or (at your option) any later version.

The Mini Thread Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with the Mini Thread Library; if not, see https://www.gnu.org/licenses/. -

Author: Amber-Sophia Schröck

Date: 2021.02.14

The Mini Thread Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, version 3, or (at your option) any later version.

The Mini Thread Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with the Mini Thread Library; if not, see https://www.gnu.org/licenses/.

Class Documentation

◆ mn::null_type

class mn::null_type

◆ mn::small_task

class mn::small_task

template<class Sig, size_t sz, size_t algn>
class mn::small_task< Sig, sz, algn >

◆ mn::conditional

struct mn::conditional

template<bool B, typename T, typename F>
struct mn::conditional< B, T, F >

Class Members
typedef T	type

◆ mn::conditional< false, T, F >

struct mn::conditional< false, T, F >

template<typename T, typename F>
struct mn::conditional< false, T, F >

Class Members
typedef F	type

◆ mn::bit_or

struct mn::bit_or

template<typename...>
struct mn::bit_or<... >

◆ mn::add_cv

struct mn::add_cv

template<class T>
struct mn::add_cv< T >

Class Members
typedef const volatile typename remove_reference< T >::type	type

◆ mn::add_reference

struct mn::add_reference

template<typename T>
struct mn::add_reference< T >

Class Members
typedef typename remove_reference< T >::type &	type

◆ mn::add_pointer

struct mn::add_pointer

template<class T>
struct mn::add_pointer< T >

Class Members
typedef typename remove_reference< T >::type *	type

◆ mn::enable_if

struct mn::enable_if

template<bool, class = void>
struct mn::enable_if< bool, class >

◆ mn::output_iterator_tag

struct mn::output_iterator_tag

◆ mn::iterator_traits

struct mn::iterator_traits

template<typename IterT>
struct mn::iterator_traits< IterT >

Class Members
typedef typename difference_type	difference_type
typedef typename iterator_category	iterator_category
typedef typename pointer	pointer
typedef typename reference	reference
typedef typename value_type	value_type

◆ mn::iterator_traits< T * >

struct mn::iterator_traits< T * >

template<typename T>
struct mn::iterator_traits< T * >

Class Members
typedef ptrdiff_t	difference_type
typedef random_access_iterator_tag	iterator_category
typedef value_type *	pointer
typedef value_type &	reference
typedef T	value_type

◆ mn::nullopt_t

struct mn::nullopt_t

◆ mn::type_traits

struct mn::type_traits

template<typename T>
struct mn::type_traits< T >

Class Members
typedef const T *	const_pointer
typedef const T &	const_reference
typedef const T	const_type
typedef T *	pointer
typedef T &	reference
typedef T	value_type

◆ mn::type_traits< T & >

struct mn::type_traits< T & >

template<typename T>
struct mn::type_traits< T & >

Class Members
typedef const T *	const_pointer
typedef const T &	const_reference
typedef const T	const_type
typedef T *	pointer
typedef T &	reference
typedef T	value_type

◆ mn::type_traits< const T >

struct mn::type_traits< const T >

template<typename T>
struct mn::type_traits< const T >

Class Members
typedef const T *	const_pointer
typedef const T &	const_reference
typedef const T	const_type
typedef T *	pointer
typedef T &	reference
typedef T	value_type

◆ mn::type_traits< const T & >

struct mn::type_traits< const T & >

template<typename T>
struct mn::type_traits< const T & >

Class Members
typedef const T *	const_pointer
typedef const T &	const_reference
typedef const T	const_type
typedef T *	pointer
typedef T &	reference
typedef T	value_type

◆ mn::type_traits< volatile T & >

struct mn::type_traits< volatile T & >

template<typename T>
struct mn::type_traits< volatile T & >

Class Members
typedef const T *	const_pointer
typedef const T &	const_reference
typedef const T	const_type
typedef T *	pointer
typedef T &	reference
typedef T	value_type

◆ mn::type_traits< const volatile T & >

struct mn::type_traits< const volatile T & >

template<typename T>
struct mn::type_traits< const volatile T & >

Class Members
typedef const T *	const_pointer
typedef const T &	const_reference
typedef const T	const_type
typedef T *	pointer
typedef T &	reference
typedef T	value_type

◆ mn::type_traits< T * >

struct mn::type_traits< T * >

template<typename T>
struct mn::type_traits< T * >

Class Members
typedef const T *	const_pointer
typedef const T *&	const_reference
typedef const T *	const_type
typedef T *	pointer
typedef T *&	reference
typedef T *	value_type

◆ mn::is_member_pointer

struct mn::is_member_pointer

template<typename>
struct mn::is_member_pointer< typename >

◆ mn::basic_uint128_t

struct mn::basic_uint128_t

Class Members
union basic_uint128_t	__unnamed__

◆ mn::make_void

struct mn::make_void

template<class ... ts>
struct mn::make_void< ts >

Class Members
typedef basic_void_type	type

◆ mn::long_double_alignment

struct mn::long_double_alignment

template<size_t Target, bool check>
struct mn::long_double_alignment< Target, check >

Class Members
typedef long double	type

◆ mn::long_double_alignment< Target, false >

struct mn::long_double_alignment< Target, false >

template<size_t Target>
struct mn::long_double_alignment< Target, false >

Class Members
typedef max_align	type

◆ mn::double_alignment

struct mn::double_alignment

template<size_t Target, bool check>
struct mn::double_alignment< Target, check >

Class Members
typedef double	type

◆ mn::double_alignment< Target, false >

struct mn::double_alignment< Target, false >

template<size_t Target>
struct mn::double_alignment< Target, false >

Class Members
typedef typename long_double_alignment< Target, alignment_of< long double >::res >=Target >::type	type

◆ mn::long_long_alignment

struct mn::long_long_alignment

template<size_t Target, bool check>
struct mn::long_long_alignment< Target, check >

Class Members
typedef long long	type

◆ mn::long_long_alignment< Target, false >

struct mn::long_long_alignment< Target, false >

template<size_t Target>
struct mn::long_long_alignment< Target, false >

Class Members
typedef typename double_alignment< Target, alignment_of< double >::res >=Target >::type	type

◆ mn::long_alignment

struct mn::long_alignment

template<size_t Target, bool check>
struct mn::long_alignment< Target, check >

Class Members
typedef long	type

◆ mn::long_alignment< Target, false >

struct mn::long_alignment< Target, false >

template<size_t Target>
struct mn::long_alignment< Target, false >

Class Members
typedef typename long_long_alignment< Target, alignment_of< long long >::res >=Target >::type	type

◆ mn::int_alignment

struct mn::int_alignment

template<size_t Target, bool check>
struct mn::int_alignment< Target, check >

Class Members
typedef int	type

◆ mn::int_alignment< Target, false >

struct mn::int_alignment< Target, false >

template<size_t Target>
struct mn::int_alignment< Target, false >

Class Members
typedef typename long_alignment< Target, alignment_of< long >::res >=Target >::type	type

◆ mn::short_alignment

struct mn::short_alignment

template<size_t Target, bool check>
struct mn::short_alignment< Target, check >

Class Members
typedef short	type

◆ mn::short_alignment< Target, false >

struct mn::short_alignment< Target, false >

template<size_t Target>
struct mn::short_alignment< Target, false >

Class Members
typedef typename int_alignment< Target, alignment_of< int >::res >=Target >::type	type

◆ mn::char_alignment

struct mn::char_alignment

template<size_t Target, bool check>
struct mn::char_alignment< Target, check >

Class Members
typedef char	type

◆ mn::char_alignment< Target, false >

struct mn::char_alignment< Target, false >

template<size_t Target>
struct mn::char_alignment< Target, false >

Class Members
typedef typename short_alignment< Target, alignment_of< short >::res >=Target >::type	type

◆ mn::aligned_as

struct mn::aligned_as

template<typename T>
struct mn::aligned_as< T >

Class Members
typedef typename type_with_alignment< alignment_of< T >::res >	res

◆ mn::type_to_type

struct mn::type_to_type

template<typename T>
struct mn::type_to_type< T >

Class Members
typedef T	orig_type

◆ mn::select

struct mn::select

template<bool flag, typename T, typename U>
struct mn::select< flag, T, U >

Class Members
typedef T	result

◆ mn::select< false, T, U >

struct mn::select< false, T, U >

template<typename T, typename U>
struct mn::select< false, T, U >

Class Members
typedef U	result

◆ mn::basic_fbit.unnamed11

union mn::basic_fbit.__unnamed11__

The fast bit

Class Members
unsigned char	bit: 1

◆ mn::fast_type.unnamed13

union mn::fast_type.__unnamed13__

The new type

Class Members
bit_type	bits[Bits]	the value as bits
value_type	Value	The real value

◆ mn::basic_uint128_t.unnamed16

union mn::basic_uint128_t.__unnamed16__

Class Members
__unnamed16__	__unnamed__
uint64_t	value[2]

◆ mn::basic_uint128_t.unnamed16.unnamed18

struct mn::basic_uint128_t.__unnamed16__.__unnamed18__

Class Members
uint64_t	high
uint64_t	low

Typedef Documentation

◆ addrof_null_t

using mn::addrof_null_t = typedef nullptr_t

◆ atomic_bool

using mn::atomic_bool = typedef _atomic<bool>

◆ atomic_char

using mn::atomic_char = typedef _atomic<char>

◆ atomic_char16_t

using mn::atomic_char16_t = typedef _atomic<char16_t>

◆ atomic_char32_t

using mn::atomic_char32_t = typedef _atomic<char32_t>

◆ atomic_flag

using mn::atomic_flag = typedef basic_atomic_flag<bool>

◆ atomic_int

using mn::atomic_int = typedef _atomic<int>

◆ atomic_int16_t

using mn::atomic_int16_t = typedef _atomic<int16_t>

◆ atomic_int32_t

using mn::atomic_int32_t = typedef _atomic<int32_t>

◆ atomic_int64_t

using mn::atomic_int64_t = typedef _atomic<int64_t>

◆ atomic_int8_t

using mn::atomic_int8_t = typedef _atomic<int8_t>

◆ atomic_int_fast16_t

using mn::atomic_int_fast16_t = typedef _atomic<int_fast16_t>

◆ atomic_int_fast32_t

using mn::atomic_int_fast32_t = typedef _atomic<int_fast32_t>

◆ atomic_int_fast64_t

using mn::atomic_int_fast64_t = typedef _atomic<int_fast64_t>

◆ atomic_int_fast8_t

using mn::atomic_int_fast8_t = typedef _atomic<int_fast8_t>

◆ atomic_int_least16_t

using mn::atomic_int_least16_t = typedef _atomic<int_least16_t>

◆ atomic_int_least32_t

using mn::atomic_int_least32_t = typedef _atomic<int_least32_t>

◆ atomic_int_least64_t

using mn::atomic_int_least64_t = typedef _atomic<int_least64_t>

◆ atomic_int_least8_t

using mn::atomic_int_least8_t = typedef _atomic<int_least8_t>

◆ atomic_intmax_t

using mn::atomic_intmax_t = typedef _atomic<intmax_t>

◆ atomic_intptr_t

using mn::atomic_intptr_t = typedef _atomic<intptr_t>

◆ atomic_long

using mn::atomic_long = typedef _atomic<long>

◆ atomic_ptr

template<typename T >

using mn::atomic_ptr = typedef _atomic_ptr<T*>

◆ atomic_ptrdiff_t

using mn::atomic_ptrdiff_t = typedef _atomic<ptrdiff_t>

◆ atomic_schar

using mn::atomic_schar = typedef _atomic<signed char>

◆ atomic_short

using mn::atomic_short = typedef _atomic<short>

◆ atomic_sig_t

using mn::atomic_sig_t = typedef _atomic<int>

◆ atomic_singleton

template<typename T >

using mn::atomic_singleton = typedef basic_atomic_singleton<T>

◆ atomic_size_t

using mn::atomic_size_t = typedef _atomic<size_t>

◆ atomic_uchar

using mn::atomic_uchar = typedef _atomic<unsigned char>

◆ atomic_uint

using mn::atomic_uint = typedef _atomic<unsigned int>

◆ atomic_uint16_t

using mn::atomic_uint16_t = typedef _atomic<uint16_t>

◆ atomic_uint32_t

using mn::atomic_uint32_t = typedef _atomic<uint32_t>

◆ atomic_uint64_t

using mn::atomic_uint64_t = typedef _atomic<uint64_t>

◆ atomic_uint8_t

using mn::atomic_uint8_t = typedef _atomic<uint8_t>

◆ atomic_uint_fast16_t

using mn::atomic_uint_fast16_t = typedef _atomic<uint_fast16_t>

◆ atomic_uint_fast32_t

using mn::atomic_uint_fast32_t = typedef _atomic<uint_fast32_t>

◆ atomic_uint_fast64_t

using mn::atomic_uint_fast64_t = typedef _atomic<uint_fast64_t>

◆ atomic_uint_fast8_t

using mn::atomic_uint_fast8_t = typedef _atomic<uint_fast8_t>

◆ atomic_uint_least16_t

using mn::atomic_uint_least16_t = typedef _atomic<uint_least16_t>

◆ atomic_uint_least32_t

using mn::atomic_uint_least32_t = typedef _atomic<uint_least32_t>

◆ atomic_uint_least64_t

using mn::atomic_uint_least64_t = typedef _atomic<uint_least64_t>

◆ atomic_uint_least8_t

using mn::atomic_uint_least8_t = typedef _atomic<uint_least8_t>

◆ atomic_uintmax_t

using mn::atomic_uintmax_t = typedef _atomic<uintmax_t>

◆ atomic_uintptr_t

using mn::atomic_uintptr_t = typedef _atomic<uintptr_t>

◆ atomic_ulong

using mn::atomic_ulong = typedef _atomic<unsigned long>

◆ atomic_ushort

using mn::atomic_ushort = typedef _atomic<unsigned short>

◆ atomic_wchar_t

using mn::atomic_wchar_t = typedef _atomic<wchar_t>

◆ autobinsemp_t

using mn::autobinsemp_t = typedef basic_autolock<binary_semaphore_t>

A autolock type for binary_semaphore_t objects

◆ autocsemp_t

using mn::autocsemp_t = typedef basic_autolock<counting_semaphore_t>

A autolock type for counting_semaphore_t objects

◆ autolock_t

using mn::autolock_t = typedef basic_autolock<LockType_t>

◆ automutx_t

using mn::automutx_t = typedef basic_autolock<mutex_t>

A autolock type for mutex_t objects

◆ autounbinsemp_t

using mn::autounbinsemp_t = typedef basic_autounlock<binary_semaphore_t>

A auto unlock type for binary_semaphore_t objects

◆ autouncsemp_t

using mn::autouncsemp_t = typedef basic_autounlock<counting_semaphore_t>

A auto unlock type for counting_semaphore_t objects

◆ autounmutx_t

using mn::autounmutx_t = typedef basic_autounlock<mutex_t>

A auto unlock type for mutex_t objects

◆ binary_semaphore_t

using mn::binary_semaphore_t = typedef basic_binary_semaphore

◆ can_apply

template<template< typename... > typename Z, typename... Ts>

using mn::can_apply = typedef internal::can_apply<Z, void, Ts...>

◆ counting_semaphore_t

using mn::counting_semaphore_t = typedef basic_counting_semaphore

◆ decay_t

template<typename T >

using mn::decay_t = typedef type_t<decay<T> >

◆ default_random_engine

using mn::default_random_engine = typedef random_xorshift

◆ enable_if_t

template<bool b, class T = void>

using mn::enable_if_t = typedef type_t<enable_if<b, T> >

◆ esp32_digital_pin

template<int TPin, bool TLevel = false, pin_direction TDirection = pin_direction::Output>

using mn::esp32_digital_pin = typedef basic_esp32_hardware_pin<TPin>

◆ event_group_t

using mn::event_group_t = typedef basic_event_group

◆ false_type

using mn::false_type = typedef integral_constant<bool, false>

◆ fdouble_t

using mn::fdouble_t = typedef fast_type<value2size<double>::size, double>

◆ ffloat_t

using mn::ffloat_t = typedef fast_type<value2size<float>::size, float>

◆ fint16_t

using mn::fint16_t = typedef fast_type<value2size<int16_t>::size, int16_t>

◆ fint32_t

using mn::fint32_t = typedef fast_type<value2size<int32_t>::size, int32_t>

◆ fint64_t

using mn::fint64_t = typedef fast_type<value2size<int64_t>::size, int64_t>

◆ fint8_t

using mn::fint8_t = typedef fast_type<value2size<int8_t>::size, int8_t>

◆ fint_least16_t

using mn::fint_least16_t = typedef fast_type<value2size<int_least16_t>::size, int_least16_t>

◆ fint_least32_t

using mn::fint_least32_t = typedef fast_type<value2size<int_least32_t>::size, int_least32_t>

◆ fint_least64_t

using mn::fint_least64_t = typedef fast_type<value2size<int_least64_t>::size, int_least64_t>

◆ fint_least8_t

using mn::fint_least8_t = typedef fast_type<value2size<int_least8_t>::size, int_least8_t>

◆ fsize_t

using mn::fsize_t = typedef fast_type<value2size<size_t>::size, size_t>

◆ fuint128_t

using mn::fuint128_t = typedef fast_type<value2size<uint128_t>::size, uint128_t>

◆ fuint16_t

using mn::fuint16_t = typedef fast_type<value2size<uint16_t>::size, uint16_t>

◆ fuint32_t

using mn::fuint32_t = typedef fast_type<value2size<uint32_t>::size, uint32_t>

◆ fuint64_t

using mn::fuint64_t = typedef fast_type<value2size<uint64_t>::size, uint64_t>

◆ fuint8_t

using mn::fuint8_t = typedef fast_type<value2size<uint8_t>::size, uint8_t>

◆ fuint_least128_t

using mn::fuint_least128_t = typedef fast_type<value2size<uint_least128_t>::size, uint_least128_t>

◆ fuint_least16_t

using mn::fuint_least16_t = typedef fast_type<value2size<uint_least16_t>::size, uint_least16_t>

◆ fuint_least32_t

using mn::fuint_least32_t = typedef fast_type<value2size<uint_least32_t>::size, uint_least32_t>

◆ fuint_least64_t

using mn::fuint_least64_t = typedef fast_type<value2size<uint_least64_t>::size, uint_least64_t>

◆ fuint_least8_t

using mn::fuint_least8_t = typedef fast_type<value2size<uint_least8_t>::size, uint_least8_t>

◆ function

template<class Sig >

using mn::function = typedef small_task<Sig, sizeof(void *) * 4, alignof(void *)>

◆ initializer_list

template<typename T >

using mn::initializer_list = typedef basic_initializer_list<T>

◆ intmax_t

using mn::intmax_t = typedef signed long

◆ LockType_t

using mn::LockType_t = typedef mn::binary_semaphore_t

◆ max_align_t

using mn::max_align_t = typedef uintptr_t

◆ mutex_t

using mn::mutex_t = typedef basic_mutex

◆ null_lock

using mn::null_lock = typedef basic_null_lock

◆ nullptr_t

using mn::nullptr_t = typedef decltype(nullptr)

◆ optional

template<typename T >

using mn::optional = typedef basic_optional<T>

◆ ptrdiff_t

using mn::ptrdiff_t = typedef long

◆ random_lfsr

using mn::random_lfsr = typedef basic_random_lfsr

◆ random_xorshift

using mn::random_xorshift = typedef basic_ramdom_xorshift

◆ remove_reference_t

template<typename T >

using mn::remove_reference_t = typedef type_t<remove_reference<T> >

◆ res_of

template<class Sig >

using mn::res_of = typedef internal::res_of<Sig>

◆ res_of_t

template<class Sig >

using mn::res_of_t = typedef type_t<res_of<Sig> >

◆ result_of

template<class Sig >

using mn::result_of = typedef internal::res_of<Sig>

◆ result_of_t

template<class Sig >

using mn::result_of_t = typedef internal::res_of<Sig>

◆ result_type

using mn::result_type = typedef mn::size_t

◆ safe_counter_t

using mn::safe_counter_t = typedef basic_safe_counter<uint64_t, LockType_t>

sot the default safe_counter, value type are uint64_t and as lock type use LockType_t

See also: LockType_t; basic_safe_counter

safe_counter_t counter(1);
 
// this while parallel use
while(it != list.end()) {
 ++counter;
}
std::cout << "In list are: " << counter.count() << " elements";

◆ schedular

using mn::schedular = typedef basic_schedular

◆ shared_bool_t

using mn::shared_bool_t = typedef basic_shared_object<bool>

A shared object value of bool.

◆ shared_char_t

using mn::shared_char_t = typedef basic_shared_object<char>

A shared object value of char.

◆ shared_double_t

using mn::shared_double_t = typedef basic_shared_object<double>

A shared object value of double.

◆ shared_fast_int16_t

using mn::shared_fast_int16_t = typedef basic_shared_object<int_fast16_t>

A shared object value of int16_fast_t.

◆ shared_fast_int32_t

using mn::shared_fast_int32_t = typedef basic_shared_object<int_fast32_t>

A shared object value of int32_fast_t.

◆ shared_fast_int64_t

using mn::shared_fast_int64_t = typedef basic_shared_object<int_fast64_t>

A shared object value of int64_fast_t.

◆ shared_fast_int8_t

using mn::shared_fast_int8_t = typedef basic_shared_object<int_fast8_t>

A shared object value of int8_fast_t.

◆ shared_fast_uint16_t

using mn::shared_fast_uint16_t = typedef basic_shared_object<uint_fast16_t>

A shared object value of uint16_fast_t.

◆ shared_fast_uint32_t

using mn::shared_fast_uint32_t = typedef basic_shared_object<uint_fast32_t>

A shared object value of uint32_fast_t.

◆ shared_fast_uint64_t

using mn::shared_fast_uint64_t = typedef basic_shared_object<uint_fast64_t>

A shared object value of uint64_fast_t.

◆ shared_fast_uint8_t

using mn::shared_fast_uint8_t = typedef basic_shared_object<uint_fast8_t>

A shared object value of uint8_fast_t.

◆ shared_float_t

using mn::shared_float_t = typedef basic_shared_object<float>

A shared object value of float.

◆ shared_int16_t

using mn::shared_int16_t = typedef basic_shared_object<int16_t>

A shared object value of int16_t.

◆ shared_int32_t

using mn::shared_int32_t = typedef basic_shared_object<int32_t>

A shared object value of int32_t.

◆ shared_int64_t

using mn::shared_int64_t = typedef basic_shared_object<int64_t>

A shared object value of int64_t.

◆ shared_int8_t

using mn::shared_int8_t = typedef basic_shared_object<int8_t>

A shared object value of int8_t.

◆ shared_least_int16_t

using mn::shared_least_int16_t = typedef basic_shared_object<int_least16_t>

A shared object value of int_least16_t.

◆ shared_least_int32_t

using mn::shared_least_int32_t = typedef basic_shared_object<int_least32_t>

A shared object value of int_least32_t.

◆ shared_least_int64_t

using mn::shared_least_int64_t = typedef basic_shared_object<int_least64_t>

A shared object value of int_least64_t.

◆ shared_least_int8_t

using mn::shared_least_int8_t = typedef basic_shared_object<int_least8_t>

A shared object value of int_least8_t.

◆ shared_least_uint16_t

using mn::shared_least_uint16_t = typedef basic_shared_object<uint_least16_t>

A shared object value of uint_least16_t.

◆ shared_least_uint32_t

using mn::shared_least_uint32_t = typedef basic_shared_object<uint_least32_t>

A shared object value of uint_least32_t.

◆ shared_least_uint64_t

using mn::shared_least_uint64_t = typedef basic_shared_object<uint_least64_t>

A shared object value of uint_least64_t.

◆ shared_least_uint8_t

using mn::shared_least_uint8_t = typedef basic_shared_object<uint_least8_t>

A shared object value of uint_least8_t.

◆ shared_object_t

template<class TOBJECT >

using mn::shared_object_t = typedef basic_shared_object<TOBJECT>

◆ shared_size_t

using mn::shared_size_t = typedef basic_shared_object<size_t>

A shared object value of size_t.

◆ shared_string_t

using mn::shared_string_t = typedef basic_shared_object<std::string>

A shared object value of std::string.

◆ shared_uint16_t

using mn::shared_uint16_t = typedef basic_shared_object<uint16_t>

A shared object value of uint16_t.

◆ shared_uint32_t

using mn::shared_uint32_t = typedef basic_shared_object<uint32_t>

A shared object value of uint32_t.

◆ shared_uint64_t

using mn::shared_uint64_t = typedef basic_shared_object<uint64_t>

A shared object value of uint64_t.

◆ shared_uint8_t

using mn::shared_uint8_t = typedef basic_shared_object<uint8_t>

A shared object value of uint8_t.

◆ shared_void_t

using mn::shared_void_t = typedef basic_shared_object<void*>

A shared object value of void*.

◆ size_t

using mn::size_t = typedef MN_THREAD_CONFIG_SIZE_TYPE

◆ task_list_t

using mn::task_list_t = typedef basic_task_list

◆ task_t

using mn::task_t = typedef basic_task

using the basic_task as task_t type

◆ task_utils_t

using mn::task_utils_t = typedef task_utils

◆ tasklet_t

using mn::tasklet_t = typedef basic_tasklet

◆ timed_binary_semaphore_t

using mn::timed_binary_semaphore_t = typedef basic_timed_lock<binary_semaphore_t>

◆ timed_counting_semaphore_t

using mn::timed_counting_semaphore_t = typedef basic_timed_lock<counting_semaphore_t>

◆ timed_mutex_t

using mn::timed_mutex_t = typedef basic_timed_lock<mutex_t>

◆ timer_t

using mn::timer_t = typedef basic_timer

◆ timespan_t

using mn::timespan_t = typedef basic_timespan

◆ timestamp_t

using mn::timestamp_t = typedef basic_timestamp

◆ true_type

using mn::true_type = typedef integral_constant<bool, true>

◆ type_t

template<typename Tag >

using mn::type_t = typedef typename Tag::type

◆ uint128_t

using mn::uint128_t = typedef basic_uint128_t

◆ uint_least128_t

using mn::uint_least128_t = typedef basic_uint128_t

◆ uintmax_t

using mn::uintmax_t = typedef unsigned long

◆ unlock_t

using mn::unlock_t = typedef basic_autounlock<LockType_t>

◆ uptrdiff_t

using mn::uptrdiff_t = typedef unsigned long

◆ void_t

template<class ... ts>

using mn::void_t = typedef typename make_void<ts ...>::type

Enumeration Type Documentation

◆ byte

enum mn::byte : unsigned char

strong

◆ float_denorm_style

enum mn::float_denorm_style

strong

Describes the denormalization for floating-point types.

Enumerator
indeterminate	Indeterminate at compile time whether denormalized values are allowed.
absent	The type does not allow denormalized values.
present	The type allows denormalized values.

◆ float_round_style

enum mn::float_round_style

strong

Describes the rounding style for floating-point types.

Enumerator
indeterminate
toward_zero	Intermediate.
to_nearest	To zero.
toward_infinity	To the nearest representable value.
toward_neg_infinity	To infinity.

◆ memory_order

enum mn::memory_order : int

strong

Enumerator
Relaxed
Consume
Acquire
Release
AcqRel
SeqCst

◆ pin_direction

enum mn::pin_direction

strong

Enumerator
Disable
Input
Output
InOut

Function Documentation

◆ _const_reinterpret_cast()

template<typename T , typename R >

const R mn::_const_reinterpret_cast ( const T * p )

inline

◆ _reinterpret_cast()

template<typename T , typename R >

R mn::_reinterpret_cast ( T * p )

inline

◆ abs() [1/3]

template<int >

int mn::abs ( const int & x )

inline

◆ abs() [2/3]

template<short >

short mn::abs ( const short & x )

inline

◆ abs() [3/3]

T mn::abs ( const T & t )

◆ accumulate()

void mn::accumulate	(	TIter	src,
		TIter	last,
		T &	dest
	)

◆ addressof() [1/2]

template<class T >

const T* mn::addressof ( const T && )

delete

◆ addressof() [2/2]

template<class T >

constexpr T* mn::addressof ( T & o )

inlineconstexprnoexcept

◆ advance()

template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>

constexpr void mn::advance	(	TIter &	iter,
		TDistance	d
	)

constexpr

◆ alig_offset()

size_t mn::alig_offset	(	void *	address,
		size_t	alignment
	)

inlinenoexcept

◆ align_down()

template<class integral >

constexpr integral mn::align_down	(	integral	x,
		size_t	a
	)

constexprnoexcept

◆ align_down_ptr()

template<class pointer >

pointer mn::align_down_ptr	(	pointer	p,
		size_t	a
	)

◆ align_up()

template<class integral >

constexpr integral mn::align_up	(	integral	x,
		size_t	a
	)

constexprnoexcept

◆ align_up_ptr()

template<class pointer >

pointer mn::align_up_ptr	(	pointer	p,
		size_t	a
	)

◆ alignment_for()

size_t mn::alignment_for ( const size_t size )

inlinenoexcept

◆ back_inserter()

template<class TCon >

constexpr back_insert_iterator<TCon> mn::back_inserter ( TCon & ctr )

constexpr

◆ binary_search()

template<typename TIter , typename TComp >

constexpr bool mn::binary_search	(	TIter	first,
		TIter	last,
		const TComp &	value
	)

inlineconstexpr

◆ construct()

void mn::construct ( T * mem )

inline

◆ construct_n()

void mn::construct_n	(	T *	src,
		size_t	n
	)

◆ copy()

void mn::copy	(	const T *	src,
		const T *	last,
		T *	dest
	)

◆ copy_backward()

template<typename T >

T* mn::copy_backward	(	const T *	first,
		const T *	last,
		T *	result
	)

inlinenoexcept

◆ copy_construct() [1/2]

void mn::copy_construct	(	T *	mem,
		const T &&	orig
	)

inline

◆ copy_construct() [2/2]

void mn::copy_construct	(	T *	mem,
		const T &	orig
	)

inline

◆ copy_construct_n()

void mn::copy_construct_n	(	T *	src,
		size_t	n,
		T *	dest
	)

◆ copy_n()

void mn::copy_n	(	const T *	src,
		size_t	n,
		T *	dest
	)

Copy N elements from src to dest.

Template Parameters

T	The type of element

Parameters

src	The source
n	How many elements are copy te destination
dest	The destination

◆ declval()

template<typename T >

T mn::declval ( )

◆ delay()

void mn::delay ( const timespan_t & ts )

Delay a task for a given timespan.

Parameters

ts	The amount of time, as timespan, that the calling task should block.

◆ delay_until()

unsigned int mn::delay_until	(	timespan_t &	tsPreviousWakeTime,
		const unsigned int &	uiTimeIncrement
	)

Delay a task until a specified time.

Parameters

tsPreviousWakeTime	The time at which the task was last unblocked.
uiTimeIncrement	The cycle time period. The task will be unblocked at time tsPreviousWakeTime + uiTimeIncrement. Calling vTaskDelayUntil with the same uiTimeIncrement parameter value will cause the task to execute with a fixed interface period.

◆ destruct()

void mn::destruct ( T * mem )

inline

◆ destruct_n()

void mn::destruct_n	(	T *	src,
		size_t	n
	)

◆ distance()

template<typename TIter >

constexpr iterator_traits<TIter>::difference_type mn::distance	(	TIter	first,
		TIter	last
	)

constexpr

◆ extract_int_key_value()

template<typename T >

result_type mn::extract_int_key_value ( const T & t )

Default implementations, just casts to hash_value.

◆ fill()

void mn::fill	(	T *	src,
		T *	last,
		const T &	val
	)

inline

◆ fill_n()

void mn::fill_n	(	T *	src,
		size_t	n,
		const T &	val
	)

inline

◆ find()

TIter mn::find	(	TIter	src,
		TIter	last,
		const T &	val
	)

◆ find_if()

TIter mn::find_if	(	TIter	src,
		TIter	last,
		const T &	val,
		const TPred &	pred
	)

◆ foreach()

TFn mn::foreach	(	TIter	src,
		TIter	last,
		TFn	fn
	)

◆ forward() [1/2]

template<typename T >

T&& mn::forward ( remove_reference_t< T > && t )

◆ forward() [2/2]

template<typename T >

T&& mn::forward ( remove_reference_t< T > & t )

◆ front_inserter()

template<class TCon >

constexpr front_insert_iterator<TCon> mn::front_inserter ( TCon & ctr )

constexpr

◆ get_ticks()

unsigned int mn::get_ticks ( )

Get the current tick count or from ISR context - automatic switch

Returns: Current tick count.

◆ heap_sort() [1/2]

void mn::heap_sort	(	T *	begin,
		T *	end
	)

◆ heap_sort() [2/2]

void mn::heap_sort	(	T *	begin,
		T *	end,
		TPredicate	pred
	)

◆ hex2char()

char mn::hex2char ( char ch )

inline

◆ inserter()

template<typename TCon >

constexpr insert_iterator<TCon> mn::inserter	(	TCon &	ctr,
		typename TCon::iterator	itr
	)

constexpr

◆ insertion_sort() [1/2]

void mn::insertion_sort	(	T *	begin,
		T *	end
	)

◆ insertion_sort() [2/2]

void mn::insertion_sort	(	T *	begin,
		T *	end,
		TPredicate	pred
	)

◆ is_aligned() [1/2]

bool mn::is_aligned	(	const volatile void *	p,
		size_t	a
	)

inline

◆ is_aligned() [2/2]

template<class integral >

constexpr bool mn::is_aligned	(	integral	x,
		size_t	a
	)

constexprnoexcept

◆ is_aligvalid()

constexpr bool mn::is_aligvalid ( size_t alignment )

constexprnoexcept

is a valid alignment, i.e. a power of two not zero

◆ is_range()

bool mn::is_range	(	const T	ch,
		const T	min,
		const T	max
	)

inline

◆ is_sorted()

bool mn::is_sorted	(	TIter	begin,
		TIter	end,
		TPredicate	pred
	)

◆ isalnum()

bool mn::isalnum ( char ch )

inline

◆ isalpha()

bool mn::isalpha ( char ch )

inline

◆ isblank()

bool mn::isblank ( char ch )

inline

◆ iscntrl()

bool mn::iscntrl ( char ch )

inline

◆ isdigit()

bool mn::isdigit ( char ch )

inline

◆ isgraph()

bool mn::isgraph ( char ch )

inline

◆ islower()

bool mn::islower ( char ch )

inline

◆ isprint()

bool mn::isprint ( char ch )

inline

◆ isspace()

bool mn::isspace ( char ch )

inline

◆ isupper()

bool mn::isupper ( char ch )

inline

◆ isxdigit()

bool mn::isxdigit ( char ch )

inline

◆ iter_swap()

void mn::iter_swap	(	fIt1	a,
		fIt2	b
	)

inline

◆ lock()

template<class TLOCK = LockType_t>

int mn::lock	(	TLOCK &	m1,
		unsigned int	timeout
	)

◆ lower_bound() [1/2]

constexpr TIter mn::lower_bound	(	TIter	first,
		TIter	last,
		const TPred &	value
	)

constexpr

◆ lower_bound() [2/2]

constexpr TIter mn::lower_bound	(	TIter	src,
		TIter	last,
		const T &	val,
		const TPred &	pred
	)

constexpr

◆ make_move_iterator()

template<typename TIterator >

constexpr move_iterator<TIterator> mn::make_move_iterator ( TIterator itr )

constexpr

◆ make_optional() [1/2]

template<typename T , typename... Args>

constexpr basic_optional<T> mn::make_optional ( Args &&... args )

constexpr

◆ make_optional() [2/2]

template<typename T >

constexpr basic_optional<typename mn::decay<T>::type> mn::make_optional ( T && value )

constexpr

◆ make_reverse_iterator()

template<typename TIterator >

constexpr reverse_iterator<TIterator> mn::make_reverse_iterator ( TIterator itr )

constexpr

◆ max()

T mn::max	(	const T	x,
		const T	y
	)

inline

◆ micros()

unsigned long IRAM_ATTR mn::micros ( )

Get the current micros

Returns: Current micros

◆ millis()

unsigned long mn::millis ( )

Get the current millis or from ISR context - automatic switch

Returns: Current milliseconds

◆ min()

T mn::min	(	const T	x,
		const T	y
	)

inline

◆ minilib_version_print()

void mn::minilib_version_print	(	const char *	strPrjName,
		const char *	strExtraInfo = `""`
	)

inline

◆ minilib_version_string()

const char* mn::minilib_version_string ( char version_string[MN_THREAD_VERSION_STRING_LEN] )

inline

◆ move() [1/2]

void mn::move	(	const T *	src,
		const T *	last,
		T *	dest
	)

inline

◆ move() [2/2]

template<typename T >

T&& mn::move ( T & t )

◆ move_n()

void mn::move_n	(	const T *	from,
		size_t	n,
		T *	dest
	)

◆ ms_to_ticks()

unsigned int mn::ms_to_ticks ( unsigned int ms )

Convert from ms to ticks.

Note: DEPRECATED Use timespan

Parameters

milliseconds milliseconds to convert.

Returns: ticks

◆ ndelay()

void mn::ndelay	(	const timespan_t &	req,
		timespan_t *	rem
	)

Delay a task for a given timespan_t and return in to rem the elapsed mircosecs as timespan_t

Parameters

	req	The amount of time, as timespan, that the calling task should block.
[out]	rem	The elapsed mircosecs as timespan_t

Note: mircosecs > 999999999

◆ next()

template<typename TForwardIter , typename TDistance = typename iterator_traits<TForwardIter>::difference_type>

TForwardIter mn::next	(	TForwardIter	x,
		TDistance	n = `1`
	)

◆ nexthigher()

T mn::nexthigher ( T k )

noexcept

◆ nlz()

size_t mn::nlz ( uint64_t x )

inline

◆ nlz_base()

size_t mn::nlz_base ( uint64_t x )

inline

◆ operator!=() [1/8]

template<typename T , typename U >

constexpr bool mn::operator!=	(	const basic_optional< T > &	x,
		const basic_optional< U > &	y
	)

inlineconstexpr

◆ operator!=() [2/8]

template<typename T , typename U >

constexpr bool mn::operator!=	(	const basic_optional< T > &	x,
		const U &	v
	)

inlineconstexpr

◆ operator!=() [3/8]

template<typename T >

constexpr bool mn::operator!=	(	const basic_optional< T > &	x,
		nullopt_t
	)

inlineconstexprnoexcept

◆ operator!=() [4/8]

constexpr bool mn::operator!=	(	const byte	l,
		const byte	r
	)

inlineconstexprnoexcept

◆ operator!=() [5/8]

template<class R , class... Args, size_t sz, size_t algn>

bool mn::operator!=	(	const small_task< R(Args...), sz, algn > &	__f,
		nullptr_t
	)

inline

◆ operator!=() [6/8]

template<typename T , typename U >

constexpr bool mn::operator!=	(	const U &	v,
		const basic_optional< T > &	x
	)

inlineconstexpr

◆ operator!=() [7/8]

template<typename T >

constexpr bool mn::operator!=	(	nullopt_t	,
		const basic_optional< T > &	x
	)

inlineconstexprnoexcept

◆ operator!=() [8/8]

template<class R , class... Args, size_t sz, size_t algn>

bool mn::operator!=	(	nullptr_t	,
		const small_task< R(Args...), sz, algn > &	__f
	)

inline

◆ operator&() [1/2]

constexpr byte mn::operator&	(	const byte &	lhr,
		const byte &	rhr
	)

inlineconstexprnoexcept

◆ operator&() [2/2]

memory_order mn::operator&	(	memory_order	mMemOrder,
		modifier::memory_order	mod
	)

inline

◆ operator&=()

byte mn::operator&=	(	byte &	lhr,
		const byte	rhr
	)

inlinenoexcept

◆ operator+()

static struct timeval mn::operator+	(	const struct timeval &	lhs,
		const struct timeval &	rhs
	)

inlinestatic

Operator to add two timevals

Parameters

lhs	The left operater timeval
rhs	The right operater timeval

◆ operator-()

static struct timeval mn::operator-	(	const struct timeval &	lhs,
		const struct timeval &	rhs
	)

inlinestatic

Operator to sub two timevals

Parameters

lhs	The left operater timeval
rhs	The right operater timeval

◆ operator<() [1/6]

template<typename T >

constexpr bool mn::operator<	(	const basic_optional< T > &	,
		nullopt_t
	)

inlineconstexprnoexcept

◆ operator<() [2/6]

template<typename T , typename U >

constexpr bool mn::operator<	(	const basic_optional< T > &	x,
		const basic_optional< U > &	y
	)

inlineconstexpr

◆ operator<() [3/6]

template<typename T , typename U >

constexpr bool mn::operator<	(	const basic_optional< T > &	x,
		const U &	v
	)

inlineconstexpr

◆ operator<() [4/6]

constexpr bool mn::operator<	(	const byte	l,
		const byte	r
	)

inlineconstexprnoexcept

◆ operator<() [5/6]

template<typename T , typename U >

constexpr bool mn::operator<	(	const U &	v,
		const basic_optional< T > &	x
	)

inlineconstexpr

◆ operator<() [6/6]

template<typename T >

constexpr bool mn::operator<	(	nullopt_t	,
		const basic_optional< T > &	x
	)

inlineconstexprnoexcept

◆ operator<<()

template<typename IntegerType >

constexpr byte mn::operator<<	(	byte &	b,
		IntegerType	shift
	)

inlineconstexprnoexcept

◆ operator<<=()

template<typename IntegerType >

byte& mn::operator<<=	(	byte &	b,
		IntegerType	shift
	)

inlinenoexcept

◆ operator<=() [1/6]

template<typename T , typename U >

constexpr bool mn::operator<=	(	const basic_optional< T > &	x,
		const basic_optional< U > &	y
	)

inlineconstexpr

◆ operator<=() [2/6]

template<typename T , typename U >

constexpr bool mn::operator<=	(	const basic_optional< T > &	x,
		const U &	v
	)

inlineconstexpr

◆ operator<=() [3/6]

template<typename T >

constexpr bool mn::operator<=	(	const basic_optional< T > &	x,
		nullopt_t
	)

inlineconstexprnoexcept

◆ operator<=() [4/6]

constexpr bool mn::operator<=	(	const byte	l,
		const byte	r
	)

inlineconstexprnoexcept

◆ operator<=() [5/6]

template<typename T , typename U >

constexpr bool mn::operator<=	(	const U &	v,
		const basic_optional< T > &	x
	)

inlineconstexpr

◆ operator<=() [6/6]

template<typename T >

constexpr bool mn::operator<=	(	nullopt_t	,
		const basic_optional< T > &
	)

inlineconstexprnoexcept

◆ operator==() [1/8]

template<typename T , typename U >

constexpr bool mn::operator==	(	const basic_optional< T > &	x,
		const basic_optional< U > &	y
	)

inlineconstexpr

◆ operator==() [2/8]

template<typename T , typename U >

constexpr bool mn::operator==	(	const basic_optional< T > &	x,
		const U &	v
	)

inlineconstexpr

◆ operator==() [3/8]

template<typename T >

constexpr bool mn::operator==	(	const basic_optional< T > &	x,
		nullopt_t
	)

inlineconstexprnoexcept

◆ operator==() [4/8]

constexpr bool mn::operator==	(	const byte	l,
		const byte	r
	)

inlineconstexprnoexcept

◆ operator==() [5/8]

template<class R , class... Args, size_t sz, size_t algn>

bool mn::operator==	(	const small_task< R(Args...), sz, algn > &	__f,
		nullptr_t
	)

inline

◆ operator==() [6/8]

template<typename T , typename U >

constexpr bool mn::operator==	(	const U &	v,
		const basic_optional< T > &	x
	)

inlineconstexpr

◆ operator==() [7/8]

template<typename T >

constexpr bool mn::operator==	(	nullopt_t	,
		const basic_optional< T > &	x
	)

inlineconstexprnoexcept

◆ operator==() [8/8]

template<class R , class... Args, size_t sz, size_t algn>

bool mn::operator==	(	nullptr_t	,
		const small_task< R(Args...), sz, algn > &	__f
	)

inline

◆ operator>() [1/6]

template<typename T , typename U >

constexpr bool mn::operator>	(	const basic_optional< T > &	x,
		const basic_optional< U > &	y
	)

inlineconstexpr

◆ operator>() [2/6]

template<typename T , typename U >

constexpr bool mn::operator>	(	const basic_optional< T > &	x,
		const U &	v
	)

inlineconstexpr

◆ operator>() [3/6]

template<typename T >

constexpr bool mn::operator>	(	const basic_optional< T > &	x,
		nullopt_t
	)

inlineconstexprnoexcept

◆ operator>() [4/6]

constexpr bool mn::operator>	(	const byte	l,
		const byte	r
	)

inlineconstexprnoexcept

◆ operator>() [5/6]

template<typename T , typename U >

constexpr bool mn::operator>	(	const U &	v,
		const basic_optional< T > &	x
	)

inlineconstexpr

◆ operator>() [6/6]

template<typename T >

constexpr bool mn::operator>	(	nullopt_t	,
		const basic_optional< T > &
	)

inlineconstexprnoexcept

◆ operator>=() [1/6]

template<typename T >

constexpr bool mn::operator>=	(	const basic_optional< T > &	,
		nullopt_t
	)

inlineconstexprnoexcept

◆ operator>=() [2/6]

template<typename T , typename U >

constexpr bool mn::operator>=	(	const basic_optional< T > &	x,
		const basic_optional< U > &	y
	)

inlineconstexpr

◆ operator>=() [3/6]

template<typename T , typename U >

constexpr bool mn::operator>=	(	const basic_optional< T > &	x,
		const U &	v
	)

inlineconstexpr

◆ operator>=() [4/6]

constexpr bool mn::operator>=	(	const byte	l,
		const byte	r
	)

inlineconstexprnoexcept

◆ operator>=() [5/6]

template<typename T , typename U >

constexpr bool mn::operator>=	(	const U &	v,
		const basic_optional< T > &	x
	)

inlineconstexpr

◆ operator>=() [6/6]

template<typename T >

constexpr bool mn::operator>=	(	nullopt_t	,
		const basic_optional< T > &	x
	)

inlineconstexprnoexcept

◆ operator>>()

template<typename IntegerType >

constexpr byte mn::operator>>	(	byte &	b,
		IntegerType	shift
	)

inlineconstexprnoexcept

◆ operator>>=()

template<typename IntegerType >

byte& mn::operator>>=	(	byte &	b,
		IntegerType	shift
	)

inlinenoexcept

◆ operator^()

constexpr byte mn::operator^	(	const byte &	lhr,
		const byte &	rhr
	)

inlineconstexprnoexcept

◆ operator^=()

byte mn::operator^=	(	byte &	lhr,
		const byte	rhr
	)

inlinenoexcept

◆ operator|() [1/2]

constexpr byte mn::operator\|	(	const byte &	lhr,
		const byte &	rhr
	)

inlineconstexprnoexcept

◆ operator|() [2/2]

memory_order mn::operator\|	(	memory_order	mMemOrder,
		modifier::memory_order	mod
	)

inline

◆ operator|=()

byte mn::operator\|=	(	byte &	lhr,
		const byte	rhr
	)

inlinenoexcept

◆ operator~()

constexpr byte mn::operator~ ( byte b )

inlineconstexprnoexcept

◆ panic()

void mn::panic ( )

◆ popcount()

size_t mn::popcount ( uint32_t v )

inline

◆ prev()

template<typename TBidirectionalIter , typename TDistance = typename iterator_traits<TBidirectionalIter>::difference_type>

TBidirectionalIter mn::prev	(	TBidirectionalIter	x,
		TDistance	n = `1`
	)

◆ quick_sort() [1/2]

void mn::quick_sort	(	T *	begin,
		T *	end
	)

◆ quick_sort() [2/2]

void mn::quick_sort	(	T *	begin,
		T *	end,
		TPredicate	pred
	)

◆ random_shuffle()

template<typename TRandomAccessIterator , typename TRandFunc >

void mn::random_shuffle	(	TRandomAccessIterator	first,
		TRandomAccessIterator	last,
		const TRandFunc &	func
	)

◆ remove_const_it()

template<class TCon >

constexpr TCon::iterator mn::remove_const_it	(	typename TCon::const_iterator	itr,
		TCon &
	)

constexpr

◆ seconds_to_ticks()

unsigned int mn::seconds_to_ticks ( unsigned int ms )

Convert from seconds to ticks.

Note: DEPRECATED Use timespan

Parameters

seconds seconds to convert.

Returns: ticks

◆ shell_sort() [1/2]

void mn::shell_sort	(	T *	begin,
		T *	end
	)

◆ shell_sort() [2/2]

void mn::shell_sort	(	T *	begin,
		T *	end,
		TPredicate	pred
	)

◆ sort() [1/2]

void mn::sort	(	T *	begin,
		T *	end
	)

◆ sort() [2/2]

void mn::sort	(	T *	begin,
		T *	end,
		TPredicate	pred
	)

◆ swap() [1/5]

template<typename T >

void mn::swap	(	basic_optional< T > &	a,
		basic_optional< T > &	b
	)

inline

◆ swap() [2/5]

void mn::swap	(	basic_timestamp	a,
		basic_timestamp	b
	)

◆ swap() [3/5]

void mn::swap	(	TAssignable &	a,
		TAssignable &	b
	)

◆ swap() [4/5]

void mn::swap	(	TAssignable(&)	x[N],
		TAssignable(&)	y[N]
	)

inline

◆ swap() [5/5]

void mn::swap	(	timespan_t &	s1,
		timespan_t &	s2
	)

inline

◆ swap_ranges()

fIt2 mn::swap_ranges	(	fIt1	a,
		fIt1	b,
		fIt2	c
	)

◆ ticks_to_ms()

unsigned int mn::ticks_to_ms ( unsigned int ticks )

Convert from ticks to ms.

Note: DEPRECATED Use timespan

Parameters

ticks ticks to convert.

Returns: milliseconds.

◆ time_to_ms()

unsigned int mn::time_to_ms ( const struct timeval * time )

Convert timeval to milliseconds

Note: DEPRECATED Use timespan

Parameters

time	The timeval to convert

Returns: the timeval in milliseconds

◆ time_to_ticks()

unsigned int mn::time_to_ticks ( const struct timeval * time )

Convert timeval to ticks

Note: DEPRECATED Use timespan

Parameters

time	The timeval to convert

Returns: the timeval in ticks

◆ to_byte()

template<class IntegerType , class = typename mn::enable_if<mn::is_integral<IntegerType>::value>::type>

constexpr byte mn::to_byte ( IntegerType v )

inlineconstexprnoexcept

◆ to_integer()

template<typename IntegerType , class = typename mn::enable_if<mn::is_integral<IntegerType>::value>::type>

IntegerType mn::to_integer ( byte b )

inline

◆ to_uchar() [1/2]

constexpr unsigned char mn::to_uchar ( byte b )

inlineconstexprnoexcept

◆ to_uchar() [2/2]

constexpr unsigned char mn::to_uchar ( int i )

inlineconstexprnoexcept

◆ try_lock()

template<class TLOCK = LockType_t>

bool mn::try_lock ( TLOCK & m1 )

◆ unlock()

template<class TLOCK = LockType_t>

int mn::unlock ( TLOCK & m1 )

◆ upper_bound() [1/2]

constexpr TIter mn::upper_bound	(	TIter	first,
		TIter	last,
		const TPred &	value
	)

constexpr

◆ upper_bound() [2/2]

constexpr TIter mn::upper_bound	(	TIter	src,
		TIter	last,
		const T &	val,
		const TPred &	pred
	)

constexpr

Variable Documentation

◆ default_alignment

const size_t mn::default_alignment = alignof(void*)

◆ max_alignment

constexpr size_t mn::max_alignment = alignof(max_align_t)

constexpr

◆ microsMux

portMUX_TYPE mn::microsMux = portMUX_INITIALIZER_UNLOCKED

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Class Documentation

◆ mn::null_type

◆ mn::small_task

template<class Sig, size_t sz, size_t algn> class mn::small_task< Sig, sz, algn >

◆ mn::conditional

template<bool B, typename T, typename F> struct mn::conditional< B, T, F >

◆ mn::conditional< false, T, F >

template<typename T, typename F> struct mn::conditional< false, T, F >

◆ mn::bit_or

template<typename...> struct mn::bit_or<... >

◆ mn::add_cv

template<class T> struct mn::add_cv< T >

◆ mn::add_reference

template<typename T> struct mn::add_reference< T >

◆ mn::add_pointer

template<class T> struct mn::add_pointer< T >

◆ mn::enable_if

template<bool, class = void> struct mn::enable_if< bool, class >

◆ mn::output_iterator_tag

◆ mn::iterator_traits

template<typename IterT> struct mn::iterator_traits< IterT >

◆ mn::iterator_traits< T * >

template<typename T> struct mn::iterator_traits< T * >

◆ mn::nullopt_t

◆ mn::type_traits

template<typename T> struct mn::type_traits< T >

◆ mn::type_traits< T & >

template<typename T> struct mn::type_traits< T & >

◆ mn::type_traits< const T >

template<typename T> struct mn::type_traits< const T >

◆ mn::type_traits< const T & >

template<typename T> struct mn::type_traits< const T & >

◆ mn::type_traits< volatile T & >

template<typename T> struct mn::type_traits< volatile T & >

◆ mn::type_traits< const volatile T & >

template<typename T> struct mn::type_traits< const volatile T & >

◆ mn::type_traits< T * >

template<typename T> struct mn::type_traits< T * >

◆ mn::is_member_pointer

template<typename> struct mn::is_member_pointer< typename >

◆ mn::basic_uint128_t

◆ mn::make_void

template<class ... ts> struct mn::make_void< ts >

◆ mn::long_double_alignment

template<size_t Target, bool check> struct mn::long_double_alignment< Target, check >

◆ mn::long_double_alignment< Target, false >

template<size_t Target> struct mn::long_double_alignment< Target, false >

◆ mn::double_alignment

template<size_t Target, bool check> struct mn::double_alignment< Target, check >

◆ mn::double_alignment< Target, false >

template<size_t Target> struct mn::double_alignment< Target, false >

◆ mn::long_long_alignment

template<size_t Target, bool check> struct mn::long_long_alignment< Target, check >

◆ mn::long_long_alignment< Target, false >

template<size_t Target> struct mn::long_long_alignment< Target, false >

◆ mn::long_alignment

template<size_t Target, bool check> struct mn::long_alignment< Target, check >

◆ mn::long_alignment< Target, false >

template<size_t Target> struct mn::long_alignment< Target, false >

◆ mn::int_alignment

template<size_t Target, bool check> struct mn::int_alignment< Target, check >

◆ mn::int_alignment< Target, false >

template<size_t Target> struct mn::int_alignment< Target, false >

◆ mn::short_alignment

template<size_t Target, bool check> struct mn::short_alignment< Target, check >

◆ mn::short_alignment< Target, false >

template<size_t Target> struct mn::short_alignment< Target, false >

◆ mn::char_alignment

template<size_t Target, bool check> struct mn::char_alignment< Target, check >

◆ mn::char_alignment< Target, false >

template<size_t Target> struct mn::char_alignment< Target, false >

◆ mn::aligned_as

template<typename T> struct mn::aligned_as< T >

template<class Sig, size_t sz, size_t algn>
class mn::small_task< Sig, sz, algn >

template<bool B, typename T, typename F>
struct mn::conditional< B, T, F >

template<typename T, typename F>
struct mn::conditional< false, T, F >

template<typename...>
struct mn::bit_or<... >

template<class T>
struct mn::add_cv< T >

template<typename T>
struct mn::add_reference< T >

template<class T>
struct mn::add_pointer< T >

template<bool, class = void>
struct mn::enable_if< bool, class >

template<typename IterT>
struct mn::iterator_traits< IterT >

template<typename T>
struct mn::iterator_traits< T * >

template<typename T>
struct mn::type_traits< T >

template<typename T>
struct mn::type_traits< T & >

template<typename T>
struct mn::type_traits< const T >

template<typename T>
struct mn::type_traits< const T & >

template<typename T>
struct mn::type_traits< volatile T & >

template<typename T>
struct mn::type_traits< const volatile T & >

template<typename T>
struct mn::type_traits< T * >

template<typename>
struct mn::is_member_pointer< typename >

template<class ... ts>
struct mn::make_void< ts >

template<size_t Target, bool check>
struct mn::long_double_alignment< Target, check >

template<size_t Target>
struct mn::long_double_alignment< Target, false >

template<size_t Target, bool check>
struct mn::double_alignment< Target, check >

template<size_t Target>
struct mn::double_alignment< Target, false >

template<size_t Target, bool check>
struct mn::long_long_alignment< Target, check >

template<size_t Target>
struct mn::long_long_alignment< Target, false >

template<size_t Target, bool check>
struct mn::long_alignment< Target, check >

template<size_t Target>
struct mn::long_alignment< Target, false >

template<size_t Target, bool check>
struct mn::int_alignment< Target, check >

template<size_t Target>
struct mn::int_alignment< Target, false >

template<size_t Target, bool check>
struct mn::short_alignment< Target, check >

template<size_t Target>
struct mn::short_alignment< Target, false >

template<size_t Target, bool check>
struct mn::char_alignment< Target, check >

template<size_t Target>
struct mn::char_alignment< Target, false >

template<typename T>
struct mn::aligned_as< T >

template<typename T>
struct mn::type_to_type< T >

template<bool flag, typename T, typename U>
struct mn::select< flag, T, U >

template<typename T, typename U>
struct mn::select< false, T, U >

◆ mn::basic_fbit.unnamed11

◆ mn::fast_type.unnamed13

◆ mn::basic_uint128_t.unnamed16

◆ mn::basic_uint128_t.unnamed16.unnamed18