| Cquickcpplib::_xxx::configurable_spinlock::ordered_spinlockbase< T >::_internals | |
| Cquickcpplib::_xxx::in_place_attach_detach::adopt_t | |
| Cquickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize > | An STL allocator which allocates aligned memory |
| Cquickcpplib::_xxx::aligned_allocator::aligned_allocator< const T, Align, initialize > | |
| Cquickcpplib::_xxx::aligned_allocator::aligned_allocator< const void, Align, initialize > | |
| Cquickcpplib::_xxx::aligned_allocator::aligned_allocator< void, Align, initialize > | |
| ►Cstd::allocator< T > | STL class |
| Cquickcpplib::_xxx::allocator_testing::allocator< T, A > | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::arithmetic_modulus< KeyType > | Performs k % divisor which is up to 40 CPU cycles depending on architecture |
| ►Cstd::atomic< T > | STL class |
| Cquickcpplib::_xxx::configurable_spinlock::lockable_ptr< T > | Lets you use a pointer to memory as a spinlock :) |
| Cquickcpplib::_xxx::algorithm::open_hash_index::atomic_linear_memory_policy< KeyType, T, LinearSearchLimit, LockType, KeyModulus, KeyCompare > | Like linear_memory_policy, but threadsafe for key finding, insertion and removal |
| Cquickcpplib::_xxx::offset_ptr::atomic_offset_ptr< T > | |
| CBadRelops | |
| ►CBase | |
| Cquickcpplib::_xxx::algorithm::bitwise_trie::bitwise_trie< Base, ItemType, NobbleDir > | Never-allocating in-place bitwise Fredkin trie index head type |
| Cquickcpplib::_xxx::algorithm::open_hash_index::basic_open_hash_index< Policy, ContiguousContainerType, disable_existing_key_check > | |
| Cquickcpplib::_xxx::algorithm::bit_interleave::bit_deinterleave_result< T > | |
| Cquickcpplib::_xxx::algorithm::bitwise_trie::bitwise_trie_head_accessors< HeadBaseType, ItemType > | Default accessor for a bitwise trie index head |
| Cquickcpplib::_xxx::algorithm::bitwise_trie::bitwise_trie_head_accessors< const Base, const ItemType > | |
| Cquickcpplib::_xxx::algorithm::bitwise_trie::bitwise_trie_item_accessors< ItemType > | Default accessor for a bitwise trie item |
| Cnonstd::byte | |
| Ccaller | |
| CCombined | |
| Cquickcpplib::_xxx::allocator_testing::config | |
| ►Cquickcpplib::_xxx::algorithm::open_hash_index::atomic_linear_memory_policy< KeyType, T, LinearSearchLimit, LockType, KeyModulus, KeyCompare >::const_pointer | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::atomic_linear_memory_policy< KeyType, T, LinearSearchLimit, LockType, KeyModulus, KeyCompare >::pointer | |
| Cstd::experimental::constexpr_optional_base< T > | |
| Cstd::experimental::constexpr_storage_t< T > | |
| CCountedObject | |
| CDate | |
| Cquickcpplib::_xxx::ringbuffer_log::default_ringbuffer_log_level_checker | A default ringbuffer log_level checker which returns whatever the log instance's level is |
| Cquickcpplib::_xxx::algorithm::hash::sha256_hash::result_type::empty_type | |
| Cquickcpplib::_xxx::integers128::uint128::empty_type | |
| ►Cstd::exception | STL class |
| Cquickcpplib::_xxx::signal_guard::signal_raised | Thrown by the default signal handler to abort the current operation |
| ►Cstd::logic_error | STL class |
| Cstd::experimental::bad_optional_access | |
| CExplicitStr | |
| ►Cstd::false_type | |
| Cquickcpplib::_xxx::detach_cast::traits::enable_reinterpret_attach_cast< T > | Specialise to true if you want to enable the reinterpret cast based implementation of attach_cast() for some type T. This introduces undefined behaviour in C++ 20 |
| Cquickcpplib::_xxx::detach_cast::traits::enable_reinterpret_detach_cast< T > | Specialise to true if you want to enable the reinterpret cast based implementation of detach_cast() for some type T. This introduces undefined behaviour in C++ 20 |
| Cquickcpplib::_xxx::in_place_attach_detach::traits::disable_attached_for< T > | Specialise to true if you want to attached<> to do nothing when constructed from some source T |
| Cquickcpplib::_xxx::algorithm::hash::fast_hash | Fast very collision resistant uint128 hash. Currently SpookyHash @ 0.3 cycles/byte |
| Cquickcpplib::_xxx::algorithm::hash::fnv1a_hash< T > | A STL compatible hash based on the high quality FNV1 hash algorithm |
| Cquickcpplib::_xxx::function_ptr::function_ptr< F, callable_storage_bytes > | A move only lightweight std::function alternative, with configurable small object optimisation |
| Cquickcpplib::_xxx::function_ptr::function_ptr< R(Args...), callable_storage_bytes > | |
| Cgeneric< T > | |
| Cgeneric< U & > | |
| CGuard | |
| Cstd::experimental::is_nothrow_move_assignable< T >::has_nothrow_move_assign< X, has_any_move_assign > | |
| Cstd::experimental::is_nothrow_move_assignable< T >::has_nothrow_move_assign< X, true > | |
| Cstd::experimental::detail_::has_overloaded_addressof< T > | |
| Cstd::experimental::in_place_t | |
| Cstd::experimental::nullopt_t::init | |
| Cstd::experimental::is_assignable< T, U > | |
| Cquickcpplib::_xxx::bit_cast::traits::is_move_relocating< T > | |
| Cstd::experimental::is_nothrow_move_assignable< T > | |
| Cstd::experimental::is_nothrow_move_constructible< T > | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::atomic_linear_memory_policy< KeyType, T, LinearSearchLimit, LockType, KeyModulus, KeyCompare >::items_count_type | |
| Cquickcpplib::_xxx::packed_backtrace::impl::packed_backtrace< FramePtrType, FrameTypeSize >::iterator | The iterator type |
| Cquickcpplib::_xxx::algorithm::open_hash_index::basic_open_hash_index< Policy, ContiguousContainerType, disable_existing_key_check >::iterator_< is_const, Parent, Pointer, Reference > | |
| Cquickcpplib::_xxx::ringbuffer_log::ringbuffer_log< Policy, LogLevelChecker >::iterator_< Parent, Pointer, Reference > | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::linear_memory_policy< KeyType, T, LinearSearchLimit, KeyModulus, KeyCompare > | The simplest possible open_hash_index memory policy, with just the key, value and a boolean marking if the item is in use. A linear scan is performed up to LinearSearchLimit either side of any collision |
| Cquickcpplib::_xxx::configurable_spinlock::lock_guard< T > | |
| ►Cquickcpplib::_xxx::pmr::memory_resource | Memory_resource emulation |
| Cquickcpplib::_xxx::pmr::monotonic_buffer_resource | A just barely good enough C++ 14 emulation of monotonic_buffer_resource |
| CMoveAware< T > | |
| CNasty | |
| CNothrowAssign | |
| CNothrowBoth | |
| CNothrowCtor | |
| CNothrowNone | |
| Cquickcpplib::_xxx::configurable_spinlock::null_spin_policy | A spin policy which does nothing |
| Cstd::experimental::nullopt_t | |
| Cquickcpplib::_xxx::offset_ptr::offset_ptr< T > | |
| Cquickcpplib::_xxx::offset_ptr::offset_ptr< const T > | |
| Cstd::experimental::optional< T & > | |
| Cstd::experimental::optional< T && > | |
| Cstd::experimental::optional_base< T > | |
| ►COptionalBase | |
| Cstd::experimental::optional< T > | |
| COracle | |
| COracleVal | |
| Cquickcpplib::_xxx::configurable_spinlock::ordered_spinlockbase< T > | |
| ►Cquickcpplib::_xxx::packed_backtrace::impl::packed_backtrace< FramePtrType, FrameTypeSize > | |
| Cquickcpplib::_xxx::packed_backtrace::packed_backtrace< FramePtrType > | A space packed stack backtrace letting you store twice or more stack frames in the same space |
| Cquickcpplib::_xxx::packed_backtrace::impl::packed_backtrace< void *, sizeof(void *)> | |
| ►Cparenttype | |
| Cquickcpplib::_xxx::configurable_spinlock::null_spin_policy::policy< parenttype > | |
| Cquickcpplib::_xxx::configurable_spinlock::spins_to_loop< spins, use_pause >::policy< parenttype > | |
| Cquickcpplib::_xxx::configurable_spinlock::spins_to_sleep::policy< parenttype > | |
| Cquickcpplib::_xxx::configurable_spinlock::spins_to_yield< spins >::policy< parenttype > | |
| Cquickcpplib::_xxx::algorithm::hash::passthru_hash< T > | A STL compatible hash which passes through its input |
| ►Cspins_to_sleep::policy | |
| Cquickcpplib::_xxx::configurable_spinlock::shared_spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 > | A non-FIFO policy configurable shared/exclusive spin lock meeting the SharedMutex concept |
| Cquickcpplib::_xxx::configurable_spinlock::spinlock< T, spinpolicy2, spinpolicy3, spinpolicy4 > | A non-FIFO policy configurable spin lock meeting the Mutex concept providing the fastest possible spin lock |
| Cquickcpplib::_xxx::pmr::polymorphic_allocator< T > | The world's worst C++ 14 emulation of polymorphic_allocator, which maps onto std::allocator |
| Cquickcpplib::_xxx::print_type< T > | Gets the compiler to error out printing a type |
| Craised_signal_info | A platform independent subset of siginfo_t |
| Craised_signal_info_value | User defined value |
| Cquickcpplib::_xxx::aligned_allocator::aligned_allocator< T, Align, initialize >::rebind< U > | |
| Cquickcpplib::_xxx::aligned_allocator::aligned_allocator< const T, Align, initialize >::rebind< U > | |
| Cquickcpplib::_xxx::allocator_testing::allocator< T, A >::rebind< U > | |
| Cquickcpplib::_xxx::unit_test::requirement_failed | |
| Cquickcpplib::_xxx::algorithm::hash::sha256_hash::result_type | The result type of the hash |
| Cquickcpplib::_xxx::ringbuffer_log::ringbuffer_log< Policy, LogLevelChecker > | Very fast threadsafe ring buffer log |
| Cstd::experimental::Safe | |
| Cquickcpplib::_xxx::algorithm::secded_ecc::secded_ecc< blocksize > | Calculates the single error correcting double error detecting (SECDED) Hamming Error Correcting Code for a blocksize block of bytes. For example, a secdec_ecc<8> would be the very common 72,64 Hamming code used in ECC RAM, or secdec_ecc<4096> would be for a 32784,32768 Hamming code |
| Cquickcpplib::_xxx::algorithm::hash::sha256_hash | SHA256 hash |
| Cquickcpplib::_xxx::configurable_spinlock::shared_spinlockbase< T > | |
| ►Cquickcpplib::_xxx::signal_guard::detail::signal_guard_global_decider_impl | |
| Cquickcpplib::_xxx::signal_guard::signal_guard_global_decider< T > | Install a global signal continuation decider |
| Cquickcpplib::_xxx::signal_guard::signal_guard_install | On platforms where it is necessary (POSIX), installs, and potentially enables, the global signal handlers for the signals specified by guarded. Each signal installed is threadsafe reference counted, so this is safe to call from multiple threads or instantiate multiple times. It is also guaranteed safe to call from within static data init or deinit, so a very common use case is simply to place an instance into global static data. This ensures that dynamically loaded and unloaded shared objects compose signal guards appropriately |
| ►Cquickcpplib::_xxx::signal_guard::detail::signal_guard_watchdog_impl | |
| Cquickcpplib::_xxx::signal_guard::signal_guard_watchdog< T > | Call an optional specified routine after a period of time, possibly on another thread. Async signal safe |
| Cquickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy< Bytes > | A ring buffer log stored in a fixed QUICKCPPLIB_RINGBUFFER_LOG_DEFAULT_ENTRIES_NDEBUG/QUICKCPPLIB_RINGBUFFER_LOG_DEFAULT_ENTRIES_DEBUG std::array recording monotonic counter (8 bytes), high resolution clock time stamp (8 bytes), stack backtrace or func (40 bytes), level (1 byte), 191 bytes of char message. Each record is 256 bytes, therefore the ring buffer wraps after 256/4096 entries by default |
| Cquickcpplib::_xxx::algorithm::small_prng::small_prng | From http://burtleburtle.net/bob/rand/smallprng.html, a not awful fast random number source |
| ►Cquickcpplib::_xxx ::span::span | |
| Cquickcpplib::_xxx::in_place_attach_detach::attached< T > | An RAII refinement of span<T> for automatically calling in_place_attach() and in_place_detach() on an input array of T. Move-only, detaches only on final object destruction |
| ►Cstd::span< T > | STL class |
| Cquickcpplib::_xxx::span::span< uint8_t > | |
| Cquickcpplib::_xxx::span::span< T, Extent > | |
| Cquickcpplib::_xxx::configurable_spinlock::spinlockbase< T > | |
| Cquickcpplib::_xxx::configurable_spinlock::spinlockbase< lockable_ptr< T > > | |
| Cquickcpplib::_xxx::configurable_spinlock::spins_to_loop< spins, use_pause > | How many spins to loop, optionally calling the SMT pause instruction on Intel |
| Cquickcpplib::_xxx::configurable_spinlock::spins_to_sleep | How many spins to sleep the current thread |
| Cquickcpplib::_xxx::configurable_spinlock::spins_to_yield< spins > | How many spins to yield the current thread's timeslice |
| Cquickcpplib::_xxx::function_ptr::function_ptr< R(Args...), callable_storage_bytes >::_function_ptr_storage_moveable< U >::standin_t | |
| Cstd::experimental::storage_t< T > | |
| Cquickcpplib::_xxx::unit_test::test_case | |
| Cquickcpplib::_xxx::unit_test::test_case_registration | |
| Cquickcpplib::_xxx::unit_test::test_suite | |
| Cquickcpplib::_xxx::unit_test::test_suite_registration | |
| Cstd::experimental::trivial_init_t | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::twos_power_modulus< KeyType > | |
| Cquickcpplib::_xxx::integers128::uint128 | An unsigned 128 bit value |
| Cquickcpplib::_xxx::integers128::uint128_hasher | Hashes a uint128 |
| Cquickcpplib::_xxx::ringbuffer_log::ringbuffer_log< Policy, LogLevelChecker >::unique_id | Used to tag an index as being an absolute lookup of a unique counter value returned by push_back/emplace_back |
| Cstd::experimental::Unsafe | |
| Cstd::experimental::Val | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::atomic_linear_memory_policy< KeyType, T, LinearSearchLimit, LockType, KeyModulus, KeyCompare >::value_type | |
| Cquickcpplib::_xxx::algorithm::open_hash_index::linear_memory_policy< KeyType, T, LinearSearchLimit, KeyModulus, KeyCompare >::value_type | |
| Cquickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy_detail::value_type | |
| CVEC | |
| Cstd::experimental::VoidNothrowBoth | |
1.9.8