| Njh | |
| Nasync | Aggregated entry point for coroutine-based asynchronous facilities |
| Cresume_t | Tag type used to trigger a co_await inside a fiber |
| Cfiber | Coroutine-based fiber providing manual suspension and resumption |
| Cpromise_type | |
| Cgenerator | Coroutine-based generator supporting both yielding and receiving values |
| Citerator | |
| Cpromise_type | |
| Cawaiter | Lightweight awaiter used to deliver values sent into the generator via co_await |
| Cgenerator_range | A range-like wrapper that enables iteration over a generator factory |
| Citerator | |
| Clistener | A one-shot inbox that serves as the fan-in aggregation point |
| Cslot | Coroutine representing the user-defined asynchronous state machine |
| Cpromise_type | Slot coroutine promise type |
| Cslot_hub | Synchronization domain managing timed mutex acquisition and binding exactly one slot |
| Cevent_signal | Lightweight push-only event emitter |
| Nconcepts | Behavioral concept namespace of the JH Toolkit |
| Crange_storage_traits | Trait defining how a range (or equivalent) is held inside a view or wrapper |
| Nranges | Semantic pipeline namespace for JH range operations |
| Crange_adaptor | Lightweight adapter that exposes any sequence as a standard range |
| Ccollect_fn | Function object implementing jh::ranges::collect |
| Cto_fn | Function object implementing jh::ranges::to |
| Cvis_transform_view | A non-consuming transform view preserving reentrancy |
| Citerator | Iterator type implementing the transformation projection |
| Czip_reference_proxy | Aggregates element references for a single tuple in jh::ranges::zip_view |
| Cis_zip_proxy | |
| Cis_zip_proxy< class zip_reference_proxy< Ts... > > | |
| Czip_proxy_value_tuple | |
| Czip_proxy_value_tuple< class zip_reference_proxy< Ts... > > | |
| Czip_sentinel | Sentinel type for jh::ranges::zip_view |
| Czip_iterator | Iterator type for jh::ranges::zip_view |
| Czip_view | A C++20-compatible implementation of std::ranges::zip_view |
| Nconc | Aggregated namespace for concurrency-aware resource containers |
| Nextension | Public customization and extension points for jh::conc containers |
| Cvalue_factory | Default value construction policy for flat_pool |
| Cvalue_factory< std::shared_ptr< T > > | Value construction policy specialization for std::shared_ptr |
| Cvalue_factory< std::unique_ptr< T > > | Value construction policy specialization for std::unique_ptr |
| Cflat_pool | Hash-ordered, contiguous resource interning pool |
| Cptr | Reference-counted handle to a pooled object |
| Cocc_box | Generic container providing Optimistic Concurrency Control (OCC) |
| Cpointer_pool | Weak pointer-observed pool for immutable or structurally immutable objects |
| Navl | Internal AVL-tree implementation namespace for jh::ordered_set and jh::ordered_map |
| Cavl_node | Node element for the contiguous AVL tree |
| Cavl_node< K, jh::typed::monostate > | Node element for set-style contiguous AVL trees |
| Ctree_map | Contiguous-array AVL tree used by jh::ordered_map and jh::ordered_set |
| Citerator | Bidirectional iterator providing in-order traversal |
| Cconst_iterator | Const bidirectional iterator for in-order traversal |
| Nruntime_arr_helper | Helper utilities and auxiliary types for jh::runtime_arr |
| Cbool_flat_alloc | Flat allocator for bool — disables bit-packing in jh::runtime_arr<bool> |
| Crebind | |
| Nmeta | Aggregated entry point for compile-time metaprogramming utilities |
| Nextension | Public customization points for compile-time key transformation and heterogeneous lookup in jh::meta |
| Ckey_traits | Default key conversion traits |
| Ckey_traits< jh::pod::string_view > | Key traits specialization for jh::pod::string_view |
| Cflatten_proxy | Proxy wrapper that lazily exposes flattened tuple access |
| Clookup_map | Fixed-capacity hash-based flat map providing switch-like lookup semantics |
| Centry | Single entry stored in the lookup table |
| Ct_str | Compile-time string wrapper for use as a non-type template parameter (NTTP) |
| Npod | Aggregated entry point for Plain-Old-Data and layout-stable value utilities |
| Carray | POD-compatible fixed-size array, similar in shape to std::array, but simpler and fully POD |
| Cbitflags | POD-compatible fixed-size bitflags structure.Generic fallback specialization for non-native sizes (e.g. 24, 120 bits, etc) |
| Cbitflags< 8 > | Specialization for 8-bit bitflags |
| Cbitflags< 16 > | Specialization for 16-bit bitflags |
| Cbitflags< 32 > | Specialization for 32-bit bitflags |
| Cbitflags< 64 > | Specialization for 64-bit bitflags |
| Cbytes_view | A read-only view over a block of raw bytes |
| Coptional | POD-compatible optional wrapper |
| Cpair | POD-compatible aggregate of two values, equivalent in layout to a plain struct |
| Cspan | Non-owning typed view over a contiguous memory block |
| Cstring_view | Read-only string view with POD layout |
| Ctuple | POD-compatible tuple type supporting structured bindings and tuple-like utilities |
| Ntyped | Aggregated entry point for lightweight typing and semantic placeholder utilities |
| Cmonostate | Trivial empty type representing "no value" |
| Cis_monostate | Type trait: checks whether T is monostate |
| Cis_monostate< monostate > | |
| Cnull_mutex_t | Semantic placeholder for mutex_like types |
| Nserio | Aggregated entry point for serialization and codec utilities |
| Chuffman | High-performance Huffman encoder/decoder |
| Nsync | Aggregated entry point for synchronization and coordination facilities |
| Nipc | Synchronous inter-process coordination primitives |
| Cprocess_cond_var | Cross-process condition variable primitive (POSIX / Win32) |
| Cprocess_counter | Cross-process integer counter stored in shared memory (POSIX / Win32) |
| Cprocess_launcher | Cross-platform process launcher |
| Chandle | Process handle representing a single launched instance |
| Cprocess_mutex | Cross-platform named process-wide mutex primitive |
| Cprocess_shm_obj | Cross-process shared-memory container for a single POD-like object |
| Cshared_process_mutex | Cross-process shared/exclusive timed mutex with optional upgrade support |
| Cconst_lock | Scope-based immutability barrier for mutex_like types |
| Ccontrol_buf | Fixed-capacity, block-allocated container for control-only types (e.g., mutexes, atomics) |
| Cstrong_unique_lock | Strong exclusive lock adapter |
| Cstrong_shared_lock | Strong shared (reader) lock adapter |
| Ccontainer_deduction | User customization point for container element deduction |
| Chash | Behaviorally deduced hash functor |
| Chash< T, std::enable_if_t< jh::concepts::has_std_hash< T > > > | Case 1: std::hash<T> is valid |
| Chash< T, std::enable_if_t<!jh::concepts::has_std_hash< T > &&jh::concepts::has_adl_hash< T > > > | Case 2: ADL-discovered hash(T) |
| Chash< 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() |
| Citerator | Forward declaration of jh::iterator<Container> |
| Crecursive_registry | Trait registry for detecting counting reentrance (recursive) |
| Creentrant_registry | Trait registry for detecting idempotent (structural) reentrance |
| Crecursive_registry< std::recursive_mutex > | Specialization for std::recursive_mutex |
| Crecursive_registry< std::recursive_timed_mutex > | Specialization for std::recursive_timed_mutex |
| Cweak_ptr_hash | Content-based hash functor for std::weak_ptr<T> |
| Cweak_ptr_eq | Equality functor for std::weak_ptr<T> |
| Cflat_multimap | Flat ordered multimap implemented as a sorted contiguous container |
| Cimmutable_str | Immutable string with optional automatic trimming and thread-safe hash caching |
| Catomic_str_hash | Custom hash functor for atomic_str_ptr and compatible types |
| Catomic_str_eq | Custom equality functor for atomic_str_ptr and compatible types |
| Cruntime_arr | A move-only, fixed-capacity array with runtime-determined length and RAII-based ownership |
| Cuninitialized_t | |
| Cruntime_arr< bool > | Specialized implementation of jh::runtime_arr<bool> — a compact, bit-packed boolean array |
| Cbit_ref | Internal reference proxy for single bit access |
| Cbit_iterator | Iterator over individual bits in the bit-packed array |
| Cbit_const_iterator | Const iterator over individual bits in the bit-packed array |
| Cgenerator_range | A range-like wrapper that enables iteration over a generator factory |
| Citerator | |
| Nstd | |
| Ctuple_size< jh::meta::flatten_proxy< Tuple > > | |
| Ctuple_element< I, jh::meta::flatten_proxy< Tuple > > | |
| Ctuple_size< jh::pod::tuple< Ts... > > | |
| Ctuple_element< I, jh::pod::tuple< Ts... > > | |
| Ctuple_size< jh::pod::pair< T1, T2 > > | |
| Ctuple_element< I, jh::pod::pair< T1, T2 > > | |
| Ctuple_size< jh::pod::array< T, N > > | |
| Ctuple_element< I, jh::pod::array< T, N > > | |
| Ctuple_size< jh::ranges::zip_reference_proxy< Elems... > > | |
| Ctuple_element< I, jh::ranges::zip_reference_proxy< Elems... > > | |
| Ccommon_reference< jh::ranges::zip_reference_proxy< Ts... >, std::tuple< Us... > > | |
| Ccommon_reference< std::tuple< Ts... >, jh::ranges::zip_reference_proxy< Us... > > | |
| Ccommon_reference< jh::ranges::zip_reference_proxy< Ts... >, jh::ranges::zip_reference_proxy< Us... > > | |
| Ccommon_reference< jh::ranges::zip_reference_proxy< Ts... > &&, std::tuple< Us... > & > | |
| Ccommon_reference< jh::ranges::zip_reference_proxy< Ts... > &, std::tuple< Us... > & > | |
| Ccommon_reference< jh::ranges::zip_reference_proxy< Ts... > &&, std::tuple< Us... > && > | |
| Ccommon_reference< std::tuple< Ts... > &, jh::ranges::zip_reference_proxy< Us... > && > | |
| Ccommon_reference< jh::ranges::zip_reference_proxy< Ts... > &&, jh::ranges::zip_reference_proxy< Us... > & > | |
