Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12]

Cjh::pod::array< T, N >	POD-compatible fixed-size array, similar in shape to std::array, but simpler and fully POD
Cjh::atomic_str_eq	Custom equality functor for atomic_str_ptr and compatible types
Cjh::atomic_str_hash	Custom hash functor for atomic_str_ptr and compatible types
Cjh::avl::avl_node< K, V >	Node element for the contiguous AVL tree
Cjh::avl::avl_node< K, jh::typed::monostate >	Node element for set-style contiguous AVL trees
Cjh::async::generator< T, U >::promise_type::awaiter	Lightweight awaiter used to deliver values sent into the generator via co_await
Cjh::runtime_arr< bool >::bit_const_iterator	Const iterator over individual bits in the bit-packed array
Cjh::runtime_arr< bool >::bit_iterator	Iterator over individual bits in the bit-packed array
Cjh::runtime_arr< bool >::bit_ref	Internal reference proxy for single bit access
Cjh::pod::detail::bitflags_bytes< N/8 >
Cjh::pod::bitflags< 16 >	Specialization for 16-bit bitflags
Cjh::pod::bitflags< 32 >	Specialization for 32-bit bitflags
Cjh::pod::bitflags< 64 >	Specialization for 64-bit bitflags
Cjh::pod::bitflags< 8 >	Specialization for 8-bit bitflags
Cjh::pod::bitflags< N >	POD-compatible fixed-size bitflags structure.Generic fallback specialization for non-native sizes (e.g. 24, 120 bits, etc)
Cjh::pod::detail::bitflags_uint< std::uint16_t >
Cjh::pod::bitflags< 16 >	Specialization for 16-bit bitflags
Cjh::pod::detail::bitflags_uint< std::uint32_t >
Cjh::pod::bitflags< 32 >	Specialization for 32-bit bitflags
Cjh::pod::detail::bitflags_uint< std::uint64_t >
Cjh::pod::bitflags< 64 >	Specialization for 64-bit bitflags
Cjh::pod::detail::bitflags_uint< std::uint8_t >
Cjh::pod::bitflags< 8 >	Specialization for 8-bit bitflags
Cjh::runtime_arr_helper::bool_flat_alloc	Flat allocator for bool — disables bit-packing in jh::runtime_arr<bool>
Cjh::pod::bytes_view	A read-only view over a block of raw bytes
Cjh::ranges::collect_fn< C >	Function object implementing jh::ranges::collect
Cstd::common_reference< jh::ranges::zip_reference_proxy< Ts... >, jh::ranges::zip_reference_proxy< Us... > >
Cstd::common_reference< jh::ranges::zip_reference_proxy< Ts... > &&, jh::ranges::zip_reference_proxy< Us... > & >
Cstd::common_reference< jh::ranges::zip_reference_proxy< Ts... >, std::tuple< Us... > >
Cstd::common_reference< jh::ranges::zip_reference_proxy< Ts... > &&, std::tuple< Us... > & >
Cstd::common_reference< jh::ranges::zip_reference_proxy< Ts... > &&, std::tuple< Us... > && >
Cstd::common_reference< jh::ranges::zip_reference_proxy< Ts... > &, std::tuple< Us... > & >
Cstd::common_reference< std::tuple< Ts... >, jh::ranges::zip_reference_proxy< Us... > >
Cstd::common_reference< std::tuple< Ts... > &, jh::ranges::zip_reference_proxy< Us... > && >
Cjh::avl::tree_map< K, V, Alloc >::const_iterator	Const bidirectional iterator for in-order traversal
Cjh::sync::const_lock< Mutex >	Scope-based immutability barrier for mutex_like types
Cjh::container_deduction< C >	User customization point for container element deduction
Cjh::sync::control_buf< T, Alloc >	Fixed-capacity, block-allocated container for control-only types (e.g., mutexes, atomics)
Cjh::meta::lookup_map< K, V, N, Hash >::entry	Single entry stored in the lookup table
Cjh::async::event_signal< T >	Lightweight push-only event emitter
Cstd::false_type
Cjh::ranges::is_zip_proxy< class zip_reference_proxy< Ts... > >
Cjh::recursive_registry< std::recursive_mutex >	Specialization for std::recursive_mutex
Cjh::recursive_registry< std::recursive_timed_mutex >	Specialization for std::recursive_timed_mutex
Cjh::typed::is_monostate< monostate >
Cjh::ranges::is_zip_proxy< T >
Cjh::recursive_registry< T >	Trait registry for detecting counting reentrance (recursive)
Cjh::reentrant_registry< T >	Trait registry for detecting idempotent (structural) reentrance
Cjh::typed::is_monostate< T >	Type trait: checks whether T is monostate
Cjh::async::fiber	Coroutine-based fiber providing manual suspension and resumption
Cjh::flat_multimap< K, V, Alloc >	Flat ordered multimap implemented as a sorted contiguous container
Cjh::conc::flat_pool< Key, Value, Hash, Alloc >	Hash-ordered, contiguous resource interning pool
Cjh::meta::flatten_proxy< Tuple >	Proxy wrapper that lazily exposes flattened tuple access
Cjh::async::generator< T, U >	Coroutine-based generator supporting both yielding and receiving values
Cjh::sync::ipc::process_launcher< Path, IsBinary >::handle	Process handle representing a single launched instance
Cjh::hash< T, typename >	Behaviorally deduced hash functor
Cjh::hash< T, std::enable_if_t< jh::concepts::has_std_hash< T > > >	Case 1: std::hash<T> is valid
Cjh::hash< T, std::enable_if_t<!jh::concepts::has_std_hash< T > &&!jh::concepts::has_adl_hash< T > &&jh::concepts::has_mbr_hash< T > > >	Case 3: Member hash()
Cjh::hash< T, std::enable_if_t<!jh::concepts::has_std_hash< T > &&jh::concepts::has_adl_hash< T > > >	Case 2: ADL-discovered hash(T)
Cjh::serio::huffman< Signature, Algo >	High-performance Huffman encoder/decoder
Cjh::immutable_str	Immutable string with optional automatic trimming and thread-safe hash caching
Cstd::integral_constant
Cstd::tuple_size< jh::pod::array< T, N > >
Cstd::tuple_size< jh::pod::pair< T1, T2 > >
Cstd::tuple_size< jh::pod::tuple< Ts... > >
Cstd::tuple_size< jh::ranges::zip_reference_proxy< Elems... > >
Cjh::async::generator< T, U >::iterator
Cjh::async::generator_range< T >::iterator
Cjh::avl::tree_map< K, V, Alloc >::iterator	Bidirectional iterator providing in-order traversal
Cjh::generator_range< T >::iterator
Cjh::iterator< Container >	Forward declaration of jh::iterator<Container>
Cjh::ranges::vis_transform_view< R, F >::iterator	Iterator type implementing the transformation projection
Cjh::meta::extension::key_traits< T >	Default key conversion traits
Cjh::meta::extension::key_traits< jh::pod::string_view >	Key traits specialization for jh::pod::string_view
Cjh::async::listener< T >	A one-shot inbox that serves as the fan-in aggregation point
Cjh::meta::lookup_map< K, V, N, Hash >	Fixed-capacity hash-based flat map providing switch-like lookup semantics
Cjh::typed::monostate	Trivial empty type representing "no value"
Cjh::typed::null_mutex_t	Semantic placeholder for mutex_like types
Cjh::conc::occ_box< T >	Generic container providing Optimistic Concurrency Control (OCC)
Cjh::pod::optional< T >	POD-compatible optional wrapper
Cjh::pod::pair< T1, T2 >	POD-compatible aggregate of two values, equivalent in layout to a plain struct
Cjh::conc::pointer_pool< T, Hash, Eq >	Weak pointer-observed pool for immutable or structurally immutable objects
Cjh::sync::ipc::process_cond_var< S, HighPriv >	Cross-process condition variable primitive (POSIX / Win32)
Cjh::sync::ipc::process_counter< S, HighPriv >	Cross-process integer counter stored in shared memory (POSIX / Win32)
Cjh::sync::ipc::process_launcher< Path, IsBinary >	Cross-platform process launcher
Cjh::sync::ipc::process_mutex< S, HighPriv >	Cross-platform named process-wide mutex primitive
Cjh::sync::ipc::process_shm_obj< S, T, HighPriv >	Cross-process shared-memory container for a single POD-like object
Cjh::async::fiber::promise_type
Cjh::async::generator< T, U >::promise_type
Cjh::async::slot::promise_type	Slot coroutine promise type
Cjh::conc::flat_pool< Key, Value, Hash, Alloc >::ptr	Reference-counted handle to a pooled object
Cjh::concepts::range_storage_traits< R, UseRefWrapper >	Trait defining how a range (or equivalent) is held inside a view or wrapper
Cjh::runtime_arr_helper::bool_flat_alloc::rebind< U >
Cjh::async::resume_t	Tag type used to trigger a co_await inside a fiber
Cjh::runtime_arr< T, Alloc >	A move-only, fixed-capacity array with runtime-determined length and RAII-based ownership
Cjh::runtime_arr< bool >	Specialized implementation of jh::runtime_arr<bool> — a compact, bit-packed boolean array
Cjh::sync::ipc::shared_process_mutex< S, HighPriv >	Cross-process shared/exclusive timed mutex with optional upgrade support
Cjh::async::slot	Coroutine representing the user-defined asynchronous state machine
Cjh::async::slot_hub	Synchronization domain managing timed mutex acquisition and binding exactly one slot
Cjh::pod::span< T >	Non-owning typed view over a contiguous memory block
Cjh::pod::string_view	Read-only string view with POD layout
Cjh::sync::strong_shared_lock< Mutex >	Strong shared (reader) lock adapter
Cjh::sync::strong_unique_lock< Mutex >	Strong exclusive lock adapter
Cjh::meta::t_str< N >	Compile-time string wrapper for use as a non-type template parameter (NTTP)
Cjh::ranges::to_fn< C >	Function object implementing jh::ranges::to
Cjh::avl::tree_map< K, V, Alloc >	Contiguous-array AVL tree used by jh::ordered_map and jh::ordered_set
Cstd::true_type
Cjh::ranges::is_zip_proxy< class zip_reference_proxy< Ts... > >
Cjh::recursive_registry< std::recursive_mutex >	Specialization for std::recursive_mutex
Cjh::recursive_registry< std::recursive_timed_mutex >	Specialization for std::recursive_timed_mutex
Cjh::typed::is_monostate< monostate >
Cstd::tuple_element
Cstd::tuple_element< I, jh::meta::flatten_proxy< Tuple > >
Cstd::tuple_element< I, jh::pod::array< T, N > >
Cstd::tuple_element< I, jh::pod::pair< T1, T2 > >
Cstd::tuple_element< I, jh::pod::tuple< Ts... > >
Cstd::tuple_element< I, jh::ranges::zip_reference_proxy< Elems... > >
Cjh::pod::detail::tuple_impl< std::index_sequence_for< Ts... >, Ts... >
Cjh::pod::tuple< Ts >	POD-compatible tuple type supporting structured bindings and tuple-like utilities
Cstd::tuple_size
Cstd::tuple_size< jh::meta::flatten_proxy< Tuple > >
Cjh::runtime_arr< T, Alloc >::uninitialized_t
Cjh::conc::extension::value_factory< V >	Default value construction policy for flat_pool
Cjh::conc::extension::value_factory< std::shared_ptr< T > >	Value construction policy specialization for std::shared_ptr
Cjh::conc::extension::value_factory< std::unique_ptr< T > >	Value construction policy specialization for std::unique_ptr
Cstd::ranges::view_interface
Cjh::async::generator_range< T >	A range-like wrapper that enables iteration over a generator factory
Cjh::ranges::range_adaptor< Seq >	Lightweight adapter that exposes any sequence as a standard range
Cjh::ranges::vis_transform_view< R, F >	A non-consuming transform view preserving reentrancy
Cjh::ranges::zip_view< Views >	A C++20-compatible implementation of std::ranges::zip_view
Cjh::weak_ptr_eq< T >	Equality functor for std::weak_ptr<T>
Cjh::weak_ptr_hash< T >	Content-based hash functor for std::weak_ptr<T>
Cjh::ranges::zip_iterator< Iters >	Iterator type for jh::ranges::zip_view
Cjh::ranges::zip_proxy_value_tuple< T >
Cjh::ranges::zip_proxy_value_tuple< class zip_reference_proxy< Ts... > >
Cjh::ranges::zip_reference_proxy< Es >	Aggregates element references for a single tuple in jh::ranges::zip_view
Cjh::ranges::zip_sentinel< Sentinels >	Sentinel type for jh::ranges::zip_view