| ►CA | |
| Cmn::bit_or< A > | |
| Cmn::add_cv< T > | |
| Cmn::add_pointer< T > | |
| Cmn::add_reference< T > | |
| Cmn::aligned_as< T > | |
| Cmn::alignment_of< T > | |
| Cmn::alignment_of< void > | |
| Cmn::alignment_of< void const > | |
| Cmn::alignment_of< void const volatile > | |
| Cmn::alignment_of< void volatile > | |
| Cmn::internal::alignof_helper< T > | |
| Cmn::memory::allocator_traits< TAllocator > | |
| Cmn::memory::internal::allocator_traits< TAlloC > | |
| Cmn::container::array_traits< TArray > | |
| Cmn::atomic_counter | This class implements a simple counter, whit atomic operations for use in a multithreaded environment |
| Cmn::internal::atomic_flag< TFlag > | |
| Cmn::auto_release< TRELOBJ, TALLOCATOR > | A simple garbage collector - pool based, a object for this colector must be extends auto_release_object |
| Cmn::auto_release_object | |
| Cmn::back_insert_iterator< TCon > | |
| ►CBASE_ATOMIC_TYPE | |
| Cmn::_atomic< value_type > | |
| Cmn::_atomic< mn::container::basic_atomic_queue::node > | |
| Cmn::_atomic< size_t > | |
| Cmn::_atomic< flag_type > | |
| Cmn::_atomic< pointer > | |
| Cmn::_atomic< T > | Only for declar special version for types |
| Cmn::_atomic< bool > | Special version for bool |
| Cmn::_atomic< char > | Special version for char |
| Cmn::_atomic< char16_t > | Special version for char16_t |
| Cmn::_atomic< char32_t > | Special version for char32_t |
| Cmn::_atomic< int > | Special version for int |
| Cmn::_atomic< long > | Special version for long |
| Cmn::_atomic< long long > | Special version for long long |
| Cmn::_atomic< short > | Special version for short |
| Cmn::_atomic< signed char > | Special version for signed char |
| Cmn::_atomic< unsigned char > | Special version for unsigned char |
| Cmn::_atomic< unsigned int > | Special version for int |
| Cmn::_atomic< unsigned long > | Special version for long |
| Cmn::_atomic< unsigned short > | Special version for short |
| Cmn::_atomic< wchar_t > | Special version for wchar_t |
| Cmn::_atomic_ptr< T > | Special version for pointer |
| Cmn::base_event< TSender, TArgs > | |
| ►Cmn::base_eventargs | |
| Cmn::handler_eventargs< T > | |
| Cmn::container::base_rb_tree< TTreeTraits, TAllocator > | |
| Cmn::base_tickhook_entry | |
| Cmn::memory::basic_allocator< TAllocator, TFilter > | |
| Cmn::memory::basic_allocator_filter | |
| Cmn::memory::basic_allocator_maximal_filter< TMaxAlloc > | |
| Cmn::memory::basic_allocator_stack_impl< TBUFFERSIZE > | Stack based allocator |
| Cmn::container::basic_any | An Any class represents a general type and is capable of storing any type |
| ►Cmn::container::basic_any::basic_any_holder | Interface class for the holder |
| Cmn::container::basic_any::basic_any_holder_impl< T > | The real impl of the basic_any holder |
| Cmn::pointer::basic_any_ptr< T > | |
| Cmn::container::basic_array< T, TAllocator, TDeleter > | Lightweight c++11 array implementation |
| Cmn::container::basic_array_iterator< T > | Helper class for array iterators |
| Cmn::basic_atomic_flag< TAtomicType, TTrue, TFalse > | |
| Cmn::basic_atomic_gcc< T > | Generic atomic type, primary class template |
| Cmn::container::basic_atomic_queue< T, TMAXITEMS > | A basic lockfree atomic queue |
| Cmn::basic_atomic_singleton< T > | Singleton with double-checked locking pattern with atomic and mutex lock |
| Cmn::pointer::basic_auto_ptr< T > | AutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection |
| Cmn::container::basic_binary_queue< T, TITEMSIZE > | This queue can only hold one item. If sucessive push operations are called, that item is overwritten with whatever the last item was |
| Cmn::container::basic_binary_queue_iterator< T > | |
| Cmn::memory::basic_caps_allocator< TCAPS, TSBITS > | |
| Cmn::math::basic_color< T > | A class for RGBA Color handling |
| Cmn::math::basic_color.__unnamed3__ | |
| Cmn::math::basic_color.__unnamed3__.__unnamed5__ | |
| Cmn::math::basic_color.__unnamed3__.__unnamed7__ | |
| ►Cmn::pointer::basic_default_clone< T > | |
| Cmn::pointer::basic_clone_ptr< T, TCloner, TDeleter > | |
| ►Cmn::memory::basic_deleter< Type, TAllocator > | A Simple template for a deleter |
| Cmn::pointer::basic_clone_ptr< T, TCloner, TDeleter > | |
| Cmn::memory::basic_deleter< T, memory::default_allocator > | |
| Cmn::memory::basic_deleter< Type[], TAllocator > | A Simple template for a deleter |
| Cmn::container::basic_deque< T, TMAXITEMS, TITEMSIZE > | A basic wrapper for the MiniLib deque's as Template deque |
| Cmn::container::basic_deque_iterator< T, TQUEUE > | |
| ►Cmn::device::basic_device | |
| Cmn::device::basic_block_device | Basic_block_device class is an interface for a block device |
| ►Cmn::device::basic_network_device | |
| Cmn::device::basic_wifi_ap | Wifi AP class for the esp32 |
| Cmn::device::basic_streamed_device | |
| ►Cmn::net::basic_endpoint | This abstract basic class represents an endpoint/socket address |
| ►Cmn::net::basic_ip_endpoint< basic_ip4_address, address_family::inet_v4 > | |
| Cmn::net::basic_ip4_endpoint | |
| ►Cmn::net::basic_ip_endpoint< basic_ip6_address, address_family::inet_v6 > | |
| Cmn::net::basic_ip6_endpoint | This class represents an IPv6 endpoint/socket address |
| Cmn::net::basic_ip_endpoint< TIPCLASS, TAF > | This template basic class represents an ip endpoint/socket address |
| Cmn::basic_fbit | |
| Cmn::basic_fbit.__unnamed11__ | |
| Cmn::container::basic_fixed_array< T, N > | A standard container for storing a fixed size sequence of elements |
| ►Cmn::basic_hardware_pin< TPin > | |
| Cmn::basic_esp32_hardware_digital_pin< TPin, TLevel, TDirection > | |
| Cmn::basic_initializer_list< T > | |
| ►Cmn::device::basic_input_pin | Basic_input_pin class is an interface for single input pin |
| Cmn::device::basic_output_pin | Basic_output_pin class is an interface for single output pin |
| ►Cmn::net::basic_ip_address | Wrapper class around lwip implementation of a ip address |
| Cmn::net::basic_ip4_address | This class represents an internet (IP) version 6 host address |
| Cmn::net::basic_ip6_address | This class represents an internet (IP) version 6 host address |
| ►Cmn::net::basic_ip_socket | Wrapper class around lwip implementation of a socket |
| ►Cmn::net::basic_ip4_socket | This class represents an internet (IP) version 4 host socket |
| ►Cmn::net::basic_dgram_ip_socket | Basic dram socket class |
| Cmn::net::basic_multicast_ip_socket | A multicast_ip_socket is a special dgram_ip_socket that can be used to send packets to and receive packets from multicast groups |
| Cmn::net::basic_raw_ip4_socket | This class provides an interface to a raw IPv4 socket |
| Cmn::net::basic_stream_ip_socket | This class provides an interface to a tcp IPv4 socket |
| ►Cmn::net::basic_ip6_socket | This class represents an internet (IP) version 6 host socket |
| ►Cmn::net::basic_dgram_ip6_socket | Basic dram socket class |
| Cmn::net::basic_multicast_ip6_socket | A basic_multicast_ip6_socket is a special dgram_ip6_socket that can be used to send packets to and receive packets from multicast groups |
| Cmn::net::basic_raw_ip6_socket | This class provides an interface to a raw IPv6 socket |
| Cmn::net::basic_stream_ip6_socket | This class provides an interface to a tcp IPv6 socket |
| Cmn::container::basic_light_map< TKey, TValue, TALLOCATOR, TPairType, TContainer > | Lightweight c++11 dictionary map implementation |
| ►Cmn::pointer::basic_linked_ptr_node | This class allows basic_linked_ptr<T> and basic_linked_ptr to share the same base nodes |
| Cmn::pointer::basic_linked_ptr< T > | This class implements a basic_linked_ptr template that it allows sharing of pointers between instances via reference counting. basic_linked_ptr objects can safely be copied |
| ►Cmn::container::basic_list< T, TAllocator, TDeleter > | |
| Cmn::container::basic_shared_list< T, TLockType > | A simple list of shared_ptr items |
| Cmn::container::basic_list< auto_release_object, memory::default_allocator_t > | |
| Cmn::pointer::basic_lock_ptr< T, TLOCK > | Auto lock pointer |
| Cmn::memory::basic_malloc_allocator_impl | |
| Cmn::memory::basic_multiheap_allocator_impl< TBytes > | |
| ►Cmn::device::basic_net_if | Wrapper class around esp-idf implementation of a esp-netif device |
| ►Cmn::device::basic_wifi_net_if | Wrapper basic WiFi class around esp-idf implementation of a esp-netif device |
| ►Cmn::device::basic_wifi | A basic class for wifi |
| Cmn::device::basic_wifi_ap | Wifi AP class for the esp32 |
| Cmn::memory::basic_new_allocaor_impl | |
| Cmn::container::basic_node< T > | |
| Cmn::container::basic_node_itarrator< TNODE > | |
| Cmn::container::basic_node_itarrator_res< TNODE > | |
| Cmn::basic_optional< T > | |
| ►Cmn::container::basic_pair< TFIRST, TSECOND > | |
| Cmn::basic_iterator_pair< TIterator, UIterator, TCategory > | |
| Cmn::container::basic_queue< T, TMAXITEMS, TITEMSIZE > | A basic wrapper for the MiniLib queue's as Template queue |
| ►Cmn::queue::basic_queue | Queue class wrapper for FreeRTOS queues |
| Cmn::queue::basic_binaryqueue | Binary queue with overwrite. This queue can only hold one item. If sucessive Enqueue operations are called, that item is overwritten with whatever the last item was |
| Cmn::queue::basic_deque | |
| Cmn::container::basic_queue_iterator< T, TQUEUE > | |
| Cmn::container::basic_ring_buffer< T, TCAPACITY, TLOCK > | A basic ring buffer with iterator |
| Cmn::container::basic_ring_buffer_iterator< T, E > | Ring_buffer_iterator |
| Cmn::basic_safe_counter< T, TLOCK > | Safe counter is a base of thread saftly counter |
| Cmn::pointer::basic_save_ptr< T > | |
| Cmn::basic_schedular | |
| Cmn::pointer::basic_scoped_ptr< T > | |
| Cmn::basic_shared_object< TOBJECT > | |
| Cmn::pointer::basic_shared_ptr< T, TRefType > | |
| Cmn::basic_singleton< T, TLOCK > | |
| Cmn::container::basic_stack< TType > | |
| Cmn::device::basic_system | Get system infos and useful system functins of the using platform |
| Cmn::basic_tasklet | |
| Cmn::memory::basic_threadsafed_allocator< TMutex, TAllocator, TFilter > | |
| Cmn::basic_timed_lock< TLOCK > | |
| Cmn::basic_timer | |
| Cmn::basic_timespan | This class represents a time span (using microseconds) |
| Cmn::basic_timestamp | A Timestamp stores a monotonic* time value with microseconds resolution |
| ►Cmn::container::basic_triple< TFIRST, TSECOND, TTHIRD > | |
| Cmn::basic_iterator_triple< TIterator, UIterator, VIterator, TCategory > | |
| Cmn::container::basic_tuple< N, T > | |
| Cmn::basic_uint128_t | |
| Cmn::basic_uint128_t.__unnamed16__ | |
| Cmn::basic_uint128_t.__unnamed16__.__unnamed18__ | |
| Cmn::pointer::basic_value_ptr< T, TCloner, TDeleter > | |
| ►Cmn::container::basic_vector_storage< T, TAllocator > | |
| Cmn::container::basic_vector< base_event< TSender, TArgs > > | |
| Cmn::container::basic_vector< mn::container::pair< TKey, TValue >, memory::default_allocator > | |
| ►Cmn::container::basic_vector< basic_pair< TKey, TValue >, TAllocator, basic_vector_storage< basic_pair< TKey, TValue >, TAllocator > > | |
| Cmn::container::basic_sorted_vector< TKey, TValue, TAllocator, TCompare, TStorage > | |
| ►Cmn::container::basic_vector_storage< T, TAllocator > | |
| ►Cmn::container::basic_vector< T, TAllocator, TStorage > | |
| ►Cmn::container::basic_sorted_vector< TKey, TValue, TAllocator, mn::less< TKey >, fixed_vector_storage< basic_pair< TKey, TValue >, TAllocator, TCapacity > > | |
| Cmn::container::basic_fixed_sorted_vector< TKey, TValue, TCapacity, TAllocator, TCompare > | |
| Cmn::container::basic_multimap< TKEY, TVAL, TAllocator, TComp > | A sorted associative container that may container multiple entries for each key |
| Cmn::basic_void_type | A dummy class with value-type semantics, mostly useful as a template argument |
| Cmn::pointer::basic_weak_ptr< T, TRefType > | |
| ►Cmn::queue::basic_work_queue | |
| Cmn::queue::basic_work_queue_multi | |
| Cmn::queue::basic_work_queue_single | |
| Cmn::stl::binary_function< Arg1, Arg2, TResult > | |
| ►Cmn::stl::binary_function< T, T, bool > | |
| Cmn::stl::equal_to< T > | |
| Cmn::stl::greater< T > | |
| Cmn::stl::greater_equal< T > | |
| Cmn::stl::less< T > | |
| Cmn::stl::less_equal< T > | |
| Cmn::stl::logic_and< T > | |
| Cmn::stl::logic_or< T > | |
| Cmn::stl::not_equal_to< T > | |
| ►Cmn::stl::binary_function< T, T, T > | |
| Cmn::stl::bit_and< T > | |
| Cmn::stl::bit_or< T > | |
| Cmn::stl::bit_xor< T > | |
| Cmn::stl::divides< T > | |
| Cmn::stl::minus< T > | |
| Cmn::stl::modulus< T > | |
| Cmn::stl::multiplies< T > | |
| Cmn::stl::plus< T > | |
| Cmn::bit_or<... > | |
| Cmn::char_alignment< Target, check > | |
| Cmn::char_alignment< Target, false > | |
| ►Ccloner_type | |
| Cmn::pointer::basic_clone_ptr< value_type, cloner_type, deleter_type > | |
| Cmn::container::internal::compare_func< TPair, TFunctor > | Internal helper for sorting |
| Cmn::container::internal::compare_func< value_type, mn::less< TKey > > | |
| Cmn::compressed_pair< T, U, typename > | |
| Cmn::conditional< B, T, F > | |
| Cmn::conditional< false, T, F > | |
| Cmn::IPseudoRandomUtil< TSEEDTYPE >::convers | Union for type convertion |
| Cmn::copy_move_tag< t > | Copyable and movable |
| Cmn::dec< T > | |
| ►Cdeleter_type | |
| Cmn::pointer::basic_clone_ptr< value_type, cloner_type, deleter_type > | |
| Cmn::divides | |
| Cmn::double_alignment< Target, check > | |
| Cmn::double_alignment< Target, false > | |
| Cmn::ebo_storage< T, TAG, typename > | |
| Cmn::ebo_storage< T, 0 > | |
| Cmn::ebo_storage< U, 1 > | |
| Cmn::enable_if< bool, class > | |
| Cmn::equal_to | |
| Cmn::event_system< TSender, TArgs, TBaseEvent, TContainer > | |
| Cmn::exit_eventargs | |
| Cmn::factorial< N > | Calculates the Nth factorial value |
| Cmn::factorial< 0 > | Calculates the 0 factorial value |
| Cmn::fast_type< Bits, TBaseType > | |
| Cmn::fast_type.__unnamed13__ | |
| Cmn::fibonacci< N > | Calculates the Nth Fibonacci value |
| Cmn::fibonacci< 0 > | Calculates the 0 Fibonacci value |
| Cmn::fibonacci< 1 > | Calculates the 1 Fibonacci value |
| ►Cmn::container::fixed_vector_storage< T, TAllocator, TCapacity > | |
| ►Cmn::container::basic_vector< T, memory::default_allocator, fixed_vector_storage< T, memory::default_allocator, TCapacity > > | |
| Cmn::container::basic_fixed_vector< T, TCapacity, TAllocator > | |
| Cmn::front_insert_iterator< TCon > | |
| Cmn::greater | |
| Cmn::greater_equal | |
| Cmn::hash< T > | Default implementation of hasher |
| Cmn::hash< char * > | |
| Cmn::hash< const char * > | |
| Cmn::hash< int16_t > | |
| Cmn::hash< int32_t > | |
| Cmn::hash< int64_t > | |
| Cmn::hash< int8_t > | |
| Cmn::hash< mn::pointer::value_ptr< T, D, C > > | |
| Cmn::hash< T * > | |
| Cmn::hash< uint16_t > | |
| Cmn::hash< uint32_t > | |
| Cmn::hash< uint64_t > | |
| Cmn::hash< uint8_t > | |
| Cmn::hash_function< T > | |
| Cmn::hash_function< const char * > | |
| Cmn::basic_thread::id | |
| Cmn::internal::in_place_index_tag | |
| Cmn::internal::in_place_type | |
| Cmn::internal::in_place_type_tag | |
| Cmn::inc< T > | |
| ►Cmn::input_iterator_tag | |
| ►Cmn::forward_iterator_tag | |
| ►Cmn::bidirectional_iterator_tag | |
| Cmn::random_access_iterator_tag | |
| Cmn::insert_iterator< TCon > | |
| Cmn::int_alignment< Target, check > | |
| Cmn::int_alignment< Target, false > | |
| Cmn::int_to_type< TVal > | |
| Cmn::integral_constant< T, v > | |
| ►Cmn::stl::integral_constant< T, v > | |
| Cmn::stl::is_class< T > | |
| Cmn::stl::is_empty< T > | |
| Cmn::stl::is_enum< T > | |
| Cmn::stl::is_union< T > | |
| ►Cmn::integral_constant< bool, !(is_function< T >::value|is_reference< T >::value|is_void< T >::value) > | |
| Cmn::is_object< T > | Is_object |
| ►Cmn::integral_constant< bool, !(is_integral< T >::value|is_floating_point< T >::value) > | |
| Cmn::is_arithmetic< T > | Is_arithmetic |
| ►Cmn::integral_constant< bool, !is_fundamental< T >::value > | |
| Cmn::is_compound< T > | Is_compound |
| ►Cmn::integral_constant< bool, __is_abstract(T)> | |
| Cmn::is_abstract< T > | |
| ►Cmn::integral_constant< bool, __is_base_of(TBase, TDerived)> | |
| Cmn::is_base_of< TBase, TDerived > | |
| ►Cmn::integral_constant< bool, __is_class(T)> | |
| Cmn::is_class< T > | |
| ►Cmn::integral_constant< bool, __is_empty(T)> | |
| Cmn::is_empty< T > | Is_empty |
| ►Cmn::integral_constant< bool, __is_enum(T)> | |
| Cmn::is_enum< T > | |
| ►Cmn::integral_constant< bool, __is_literal_type(T)> | |
| Cmn::is_literal_type< T > | |
| ►Cmn::integral_constant< bool, __is_pod(T)> | |
| Cmn::is_pod< T > | |
| ►Cmn::integral_constant< bool, __is_polymorphic(T)> | |
| Cmn::is_polymorphic< T > | |
| ►Cmn::integral_constant< bool, __is_standard_layout(T)> | |
| Cmn::is_standard_layout< T > | Is_standard_layout |
| ►Cmn::integral_constant< bool, __is_trivial(T)> | |
| Cmn::is_trivial< T > | Is_trivial |
| ►Cmn::integral_constant< bool, __is_trivially_copyable(T)> | |
| Cmn::is_trivially_copyable< T > | |
| ►Cmn::integral_constant< bool, __is_union(T)> | |
| Cmn::is_union< T > | |
| ►Cmn::integral_constant< bool, false > | |
| ►Cmn::internal::can_apply< internal::try_convert, From, To > | |
| Cmn::is_convertible< From, To > | |
| Cmn::bit_or<> | |
| Cmn::internal::can_apply< Z, typename, Ts > | |
| Cmn::is_bind_expression< T > | |
| Cmn::is_const< typename > | |
| ►Cmn::is_floating_point< T > | |
| Cmn::is_floating_point< const T > | |
| Cmn::is_floating_point< const volatile T > | |
| Cmn::is_floating_point< volatile T > | |
| Cmn::is_function< typename > | |
| ►Cmn::is_integral< T > | |
| Cmn::is_integral< const T > | |
| Cmn::is_integral< const volatile T > | |
| Cmn::is_integral< volatile T > | |
| Cmn::is_lvalue_reference< typename > | Is_lvalue_reference |
| Cmn::is_pointer< T > | |
| ►Cmn::is_rational< T > | |
| Cmn::is_rational< const T > | |
| Cmn::is_rational< const volatile T > | |
| Cmn::is_rational< volatile T > | |
| Cmn::is_rvalue_reference< typename > | Is_rvalue_reference |
| Cmn::is_same< A, B > | |
| ►Cmn::is_signed< T > | Is_signed |
| Cmn::is_signed< const T > | |
| Cmn::is_signed< const volatile T > | |
| Cmn::is_signed< volatile T > | |
| ►Cmn::is_unsigned< T > | Is_unsigned |
| Cmn::is_unsigned< const T > | |
| Cmn::is_unsigned< const volatile T > | |
| Cmn::is_unsigned< volatile T > | |
| ►Cmn::is_void< T > | |
| Cmn::is_void< const T > | |
| Cmn::is_void< const volatile T > | |
| Cmn::is_void< volatile T > | |
| Cmn::is_volatile< typename > | Is_volatile |
| Cmn::stl::is_const< T > | |
| Cmn::stl::is_reference< T > | |
| Cmn::stl::is_volatile< typename > | |
| ►Cmn::integral_constant< bool, internal::allocator_traits< TAlloC >::is_thread_safe::value > | |
| Cmn::memory::is_thread_safe_allocator< TAlloC > | |
| ►Cmn::integral_constant< bool, is_fundamental< T >::value|is_pointer< T >::value|is_pod< T >::value > | |
| Cmn::has_trivial_assign< T > | |
| Cmn::has_trivial_constructor< T > | |
| Cmn::has_trivial_copy< T > | |
| ►Cmn::integral_constant< bool, is_fundamental< T >::value||is_pointer< T >::value||is_pod< T >::value > | |
| Cmn::has_trivial_destructor< T > | |
| ►Cmn::integral_constant< bool, is_integral< T >::value||is_rational< T >::value > | |
| Cmn::is_fundamental< T > | |
| ►Cmn::integral_constant< bool, is_lvalue_reference< T >::value|is_rvalue_reference< T >::value > | |
| Cmn::is_reference< T > | |
| ►Cmn::integral_constant< bool, true > | |
| Cmn::internal::can_apply< Z, void_t< Z< Ts... > >, Ts... > | |
| Cmn::is_const< T const > | |
| Cmn::is_convertible< void, void > | |
| Cmn::is_floating_point< double > | |
| Cmn::is_floating_point< float > | |
| Cmn::is_floating_point< long double > | |
| Cmn::is_function< T(Args...) & > | |
| Cmn::is_function< T(Args...) && > | |
| Cmn::is_function< T(Args...) const & > | |
| Cmn::is_function< T(Args...) const && > | |
| Cmn::is_function< T(Args...) const > | |
| Cmn::is_function< T(Args...) const volatile & > | |
| Cmn::is_function< T(Args...) const volatile && > | |
| Cmn::is_function< T(Args...) const volatile > | |
| Cmn::is_function< T(Args...) volatile & > | |
| Cmn::is_function< T(Args...) volatile && > | |
| Cmn::is_function< T(Args...) volatile > | |
| Cmn::is_function< T(Args...)> | |
| Cmn::is_function< T(Args......) & > | |
| Cmn::is_function< T(Args......) && > | |
| Cmn::is_function< T(Args......) const & > | |
| Cmn::is_function< T(Args......) const && > | |
| Cmn::is_function< T(Args......) const > | |
| Cmn::is_function< T(Args......) const volatile & > | |
| Cmn::is_function< T(Args......) const volatile && > | |
| Cmn::is_function< T(Args......) const volatile > | |
| Cmn::is_function< T(Args......) volatile & > | |
| Cmn::is_function< T(Args......) volatile && > | |
| Cmn::is_function< T(Args......) volatile > | |
| Cmn::is_function< T(Args......)> | |
| Cmn::is_lvalue_reference< T & > | |
| Cmn::is_pod< internal::aligned1 > | |
| Cmn::is_pod< internal::aligned16 > | |
| Cmn::is_pod< internal::aligned2 > | |
| Cmn::is_pod< internal::aligned32 > | |
| Cmn::is_pod< internal::aligned4 > | |
| Cmn::is_pod< internal::aligned64 > | |
| Cmn::is_pod< internal::aligned8 > | |
| Cmn::is_pointer< T * > | |
| Cmn::is_rvalue_reference< T && > | |
| Cmn::is_same< A, A > | |
| Cmn::is_signed< double > | |
| Cmn::is_signed< float > | |
| Cmn::is_signed< int > | |
| Cmn::is_signed< long > | |
| Cmn::is_signed< long double > | |
| Cmn::is_signed< long long > | |
| Cmn::is_signed< short > | |
| Cmn::is_signed< signed char > | |
| Cmn::is_unsigned< bool > | |
| Cmn::is_unsigned< unsigned char > | |
| Cmn::is_unsigned< unsigned int > | |
| Cmn::is_unsigned< unsigned long > | |
| Cmn::is_unsigned< unsigned long long > | |
| Cmn::is_unsigned< unsigned short > | |
| Cmn::is_volatile< T volatile > | |
| Cmn::stl::is_const< const T & > | |
| Cmn::stl::is_const< const T > | |
| Cmn::stl::is_const< const T[n]> | |
| Cmn::stl::is_reference< T%> | |
| Cmn::stl::is_reference< const T%> | |
| Cmn::stl::is_volatile< _Tp volatile > | |
| ►Cintegral_constant< bool,(char(255) > 0)> | |
| Cmn::is_unsigned< char > | |
| ►Cintegral_constant< bool,(char(255)< 0)> | |
| Cmn::is_signed< char > | |
| ►Cmn::integral_constant< int, 0 > | |
| Cmn::is_placeholder< T > | |
| Cmn::device::basic_net_if::ip_info | |
| Cmn::IPseudoRandomUtil< TSEEDTYPE > | An Intarface for all randoms classes in this library |
| ►Cmn::IPseudoRandomUtil< unsigned int > | |
| Cmn::basic_ramdom_xorshift | Pseudro-Random Number Generator based on xor_shift128++ generator |
| Cmn::basic_random_lfsr | Pseudro-Random Number Generator based on a 32-bit linear-feedback shift register.
|
| Cmn::is_member_pointer< typename > | |
| Cmn::is_pod< container::pair< TFIRST, TSECOND > > | |
| Cmn::is_pod< container::triple< TFIRST, TSECOND, TTHIRD > > | |
| Cmn::iterator_traits< IterT > | |
| Cmn::iterator_traits< T * > | |
| ►Cmn::ITimer | |
| Cmn::esp32::basic_esp32_timer | |
| Cmn::less | |
| Cmn::less_equal | |
| Cmn::container::list_node_iterator< TNodePtr, TPtr, TRef > | |
| Cmn::logic_and< T > | |
| Cmn::logic_not< T > | |
| Cmn::logic_or< T > | |
| Cmn::long_alignment< Target, check > | |
| Cmn::long_alignment< Target, false > | |
| Cmn::long_double_alignment< Target, check > | |
| Cmn::long_double_alignment< Target, false > | |
| Cmn::long_long_alignment< Target, check > | |
| Cmn::long_long_alignment< Target, false > | |
| Cmn::make_void< ts > | |
| Cmn::internal::max_align | |
| Cmn::minus | |
| ►CMN_DEFAULT_CLASS | |
| Cmn::ext::basic_condition_variable | |
| ►CMN_ONCOPYABLE_CLASS | |
| Cmn::basic_event_group | Wrapper class around FreeRTOS's implementation of a event_group |
| Cmn::buffer< TVALUE, TALLOCATOR > | A buffer class that allocates a buffer of a given type and size |
| ►CMN_ONSIGLETN_CLASS | |
| ►Cmn::ILockObject | |
| Cmn::atomic_spinlock< T > | This class implements a simple spinlack, whit atomic operations |
| Cmn::basic_null_lock | Null Lock is a lock object without any lock logic |
| ►Cmn::basic_semaphore | |
| Cmn::basic_binary_semaphore | |
| Cmn::basic_clock< TLockType > | |
| Cmn::basic_counting_semaphore | |
| Cmn::basic_mutex | |
| ►Cmn::system::ISystemLockObject | |
| Cmn::system::basic_critical_section | |
| Cmn::system::basic_critical_section_nested | |
| Cmn::system::basic_critical_section_timedout | |
| Cmn::system::basic_interrupts_lock | |
| Cmn::system::basic_schedular_lock | |
| Cmn::basic_autolock< LOCK > | |
| Cmn::basic_autounlock< LOCK > | |
| ►Cmn::basic_task | Wrapper class around FreeRTOS's implementation of a task |
| Cmn::basic_thread | |
| ►Cmn::ext::basic_convar_task | |
| Cmn::ext::basic_message_task | Extends the basic_convar_task with a message queue support |
| Cmn::ext::foreign_task | |
| Cmn::queue::work_queue_task | |
| Cmn::basic_task_list | |
| Cmn::task_utils | |
| Cmn::modulus | |
| Cmn::move_iterator< TIterator > | |
| Cmn::multiplies | |
| Cmn::negate | |
| Cmn::container::basic_atomic_queue< T, TMAXITEMS >::node | |
| Cmn::pointer::node_ptr< T, TAllocator > | |
| Cmn::memory::nodeleter_allocator_tag | |
| Cmn::not_equal_to | |
| Cmn::null_type | |
| Cmn::nullopt_t | |
| ►Cmn::numeric_limits< T > | |
| Cmn::numeric_limits< const T > | |
| Cmn::numeric_limits< const volatile T > | |
| Cmn::numeric_limits< volatile T > | |
| Cmn::numeric_limits< bool > | Spezial version for bool |
| Cmn::numeric_limits< char > | Spezial version for char |
| Cmn::numeric_limits< double > | Spezial version for double |
| Cmn::numeric_limits< float > | Spezial version for float |
| Cmn::numeric_limits< int > | Spezial version for int |
| Cmn::numeric_limits< long > | Spezial version for long |
| Cmn::numeric_limits< long double > | Spezial version for long double |
| Cmn::numeric_limits< long long > | Spezial version for long long |
| Cmn::numeric_limits< short > | Spezial version for short |
| Cmn::numeric_limits< signed char > | Spezial version for uchar |
| Cmn::numeric_limits< unsigned char > | Spezial version for uchar |
| Cmn::numeric_limits< unsigned int > | Spezial version for unsigned int |
| Cmn::numeric_limits< unsigned long > | Spezial version for unsigned long |
| Cmn::numeric_limits< unsigned long long > | Spezial version for unsigned long long |
| Cmn::numeric_limits< unsigned short > | Spezial version for unsigned short |
| Cmn::only_copyable_tag< t > | Not movable |
| Cmn::only_move_tag< t > | Not copyable |
| ►Cmn::only_move_tag< void > | |
| Cmn::pointer::basic_unique_ptr< T, TAllocator, TDeleter > | A simple unique_ptr, for a single object |
| Cmn::pointer::basic_unique_ptr< T[], TAllocator, TDeleter > | A simple unique_ptr, for a array object |
| Cmn::only_oneable_tag< t > | Not copyable or movable |
| Cmn::output_iterator_tag | |
| Cmn::plus | |
| Cmn::memory::pointer_traits< TAllocator > | |
| Cmn::memory::pointer_traits< T * > | |
| Cmn::memory::detail::ptr_difference< class, class > | |
| Cmn::memory::detail::ptr_element< T, class > | |
| Cmn::memory::detail::ptr_element< T, typename ptr_void< typename T::element_type >::type > | |
| Cmn::memory::detail::ptr_first< T > | |
| Cmn::memory::detail::ptr_first< T< U, Args... > > | |
| Cmn::memory::detail::ptr_rebind< T, U, class > | |
| Cmn::memory::detail::ptr_rebind< T, U, typename ptr_void< typename T::template rebind< U > >::type > | |
| Cmn::memory::detail::ptr_transform< T, V > | |
| Cmn::memory::detail::ptr_transform< T< U, Args... >, V > | |
| Cmn::memory::detail::ptr_value< T > | |
| Cmn::memory::detail::ptr_value< void > | |
| Cmn::memory::detail::ptr_void< class > | |
| Cmn::container::internal::rb_tree_key_wrapper< TKey > | |
| Cmn::container::rb_tree_node< TVALUE > | |
| Cmn::container::internal::rb_tree_traits< TKey > | |
| Cmn::memory::pointer_traits< TAllocator >::rebind_to< U > | |
| Cmn::memory::pointer_traits< T * >::rebind_to< U > | |
| Cmn::internal::res_of< Sig, class > | |
| Cmn::reverse_iterator< TIterator > | |
| Cmn::select< flag, T, U > | |
| Cmn::select< false, T, U > | |
| Cmn::short_alignment< Target, check > | |
| Cmn::short_alignment< Target, false > | |
| Cmn::small_task< Sig, sz, algn > | |
| Cmn::small_task< int(void *)> | |
| Cmn::small_task< R(Args...), sz, algn > | |
| Cmn::small_task< void(sender_reference, const args_type)> | |
| Cmn::pointer::smart_pointer_traits< TPR > | |
| Cmn::sqrt< VAL, X > | |
| Cmn::memory::std_allocator_tag | |
| Cmn::system_endian | Get the underlying endian architecture? |
| ►Cmn::device::system_stream | A simple abstractes class for easy handle any flash drivers |
| Cmn::device::flash_stream | |
| Cmn::device::partition_stream | |
| ►CT | |
| Cmn::ebo_storage< T, TAG, mn::enable_if_t< mn::is_class< T >::value > > | |
| ►Cmn::tag< T > | |
| ►Cmn::remove_const< type_t< remove_volatile< T > > > | |
| ►Cmn::remove_cv< T > | |
| ►Cmn::decay3< T > | |
| ►Cmn::decay2< remove_reference_t< T > > | |
| Cmn::decay< T > | |
| Cmn::decay2< T > | |
| Cmn::enable_if< true, T > | |
| ►Cmn::remove_const< T > | |
| ►Cmn::remove_cv< type_t< remove_reference< T > > > | |
| Cmn::remove_cvref< T > | |
| Cmn::remove_const< T const > | |
| Cmn::remove_reference< T > | |
| Cmn::remove_reference< T & > | |
| Cmn::remove_volatile< T > | |
| Cmn::remove_volatile< T volatile > | |
| ►Cmn::tag< const T > | |
| Cmn::add_const< T > | |
| ►Cmn::tag< invoke_t< G, Args... > > | |
| Cmn::internal::res_of< G(Args...), void_t< invoke_t< G, Args... > > > | |
| ►Cmn::tag< R(*)(Args...)> | |
| Cmn::decay3< R(Args...)> | |
| ►Cmn::tag< T & > | |
| Cmn::add_lvalue_reference< T > | |
| ►Cmn::tag< T && > | |
| Cmn::add_rvalue_reference< T > | |
| ►Cmn::tag< T * > | |
| Cmn::decay2< T[N]> | |
| ►Cmn::tag< volatile T > | |
| Cmn::add_volatile< T > | |
| Cmn::ext::task_message | |
| ►Cconditional::type | |
| Cmn::bit_or< A, B > | |
| ►Cconditional::type | |
| Cmn::bit_or< A, B, C, N... > | |
| Cmn::memory::detail::ptr_value< void >::type | |
| Cmn::type_to_type< T > | |
| Cmn::stl::type_traits< T > | |
| Cmn::type_traits< T > | |
| Cmn::stl::type_traits< const T & > | |
| Cmn::type_traits< const T & > | |
| Cmn::stl::type_traits< const T > | |
| Cmn::type_traits< const T > | |
| Cmn::type_traits< const T[N]> | |
| Cmn::type_traits< const volatile T & > | |
| Cmn::stl::type_traits< T & > | |
| Cmn::type_traits< T & > | |
| Cmn::type_traits< T * > | |
| Cmn::type_traits< T[N]> | |
| Cmn::type_traits< volatile T & > | |
| Cmn::internal::type_with_alignment< N > | |
| Cmn::internal::type_with_alignment< 1 > | |
| Cmn::internal::type_with_alignment< 16 > | |
| Cmn::internal::type_with_alignment< 2 > | |
| Cmn::internal::type_with_alignment< 32 > | |
| Cmn::internal::type_with_alignment< 4 > | |
| Cmn::internal::type_with_alignment< 64 > | |
| Cmn::internal::type_with_alignment< 8 > | |
| Cmn::stl::unary_function< Arg, TResult > | |
| ►Cmn::stl::unary_function< T, bool > | |
| Cmn::stl::logic_not< T > | |
| ►Cmn::stl::unary_function< T, T > | |
| Cmn::stl::bit_not< T > | |
| Cmn::stl::negate< T > | |
| Cmn::value2size | |
| Cmn::value2size_raw | |
| Cmn::small_task< R(Args...), sz, algn >::vtable_t | |
| Cmn::queue::work_queue_item | |