Go to the graphical class hierarchy

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

Cstd::common_type< jam::units::space< R1, P1 >, jam::units::space< R2, P2 > >	Common representation and greatest common unit, as for chrono durations
Cjam::heap::generation	One generation's ordered double-mapped arena and collection metadata
Cjam::generation_options	Sizing policy for one generation. Sizes are platform pages
Cjam::heap	A circular, double-mapped arena with bounded parallel compaction.Compressed four-byte offsets address two generations of up to 16 GiB each. The high bit selects young; the remaining bits count eight-byte cells. Record alignment up to 64 bytes is retained by dilation and padding between independent rank blocks. Allocation and liveness always use eight-byte cells. Clients trace complete byte-relocatable records; the heap does not infer boundaries or run destructors. This storage contract extends beyond ISO C++ trivial-copy guarantees: moving representation bytes must preserve meaning after ptr fields are forwarded. Raw address-dependent state and required destruction are unsupported. Multiple markers may trace a frozen heap. Join them before compaction, mutation, allocation, or inspecting metadata. Borrows expire on movement
Cjam::heap_options	Two generations and one shared worker pool
Cjam::heap_scope	Bind an existing heap, restoring the previous binding on scope exit.The heap must outlive the scope. Scopes nest on one thread and may re-enter a heap. They neither own the heap nor synchronize access to it
Cjam::heap::host	Borrow a heap whose roots, barriers and reference policy belong to a host runtime
Cjam::leaf< T >	A value with no outgoing managed references.Specializing tracer<T> by deriving from leaf<T> explicitly suppresses traversal. Heap storage requirements are separate from this reference-free promise
Cjam::ptr< T >	A typed heap offset, with no root registration or ownership
Cjam::heap::root_handle	A four-byte handle to a collector-updated external root slot.Copies share a registration; moves leave the source detached and null. Operations on registered handles require the owning heap current and a quiescent collector. The heap must outlive all its registered handles
Cjam::root< T >	A copyable external root, updated during collection.Four-byte slot index; no heap or registration address is stored. The heap must outlive the root and be current for operations and destruction
Cjam::weak_root< T >	An external weak slot, updated or cleared by collection without retaining its target.Keep it outside the managed heap. The heap must outlive even an expired attached root. Copies share a registration; moves leave the source detached and expired. Four-byte slot index; operations and destruction require the owning heap current. Operations require a quiescent collector. Old targets remain live during minor collection
Cjam::units::space< Rep, Ratio >	A count of storage units; Ratio measures one unit in bytes. Integer arithmetic and conversions terminate on overflow. Floating arithmetic follows its representation. Like chrono, integral destinations accept only lossless unit conversions implicitly; use space_cast, floor, ceil or round otherwise. There is no implicit conversion to an untyped count
Cjam::tracer< T >	Per-value tracing customization; values without a hook or manifest are leaves.An allocation-only claim_and_trace hook does not describe embedded fields. Scalars and ordinary records without a trace member or manifest contain no managed edges by convention. Records containing managed pointers must enumerate them in a manifest, trace member or tracer specialization. Trivial copyability does not enumerate fields
Cjam::tracer< native::simd< ptr< T >, N, A > >	Trace actual pointer lanes, including null fields, in register order
Cjam::tracer< native::wide< V, K > >	Trace each register's fields in the enclosing allocation
Cjam::tracer< ptr< T > >	Tag a reference slot and enqueue its target
Cjam::tracer< std::array< T, N > >	Visit each array element in the enclosing allocation
Cjam::tracer< std::tuple< Ts... > >	Visit each tuple element in the enclosing allocation
Cjam::tracer< std::variant< Ts... > >	Visit only the active variant alternative in the enclosing allocation
Cjam::tracer< T >	Forward a value hook or a cooperative allocation hook.Visit each live ptr by reference from the supplied value. Nested values share the enclosing allocation's pointer mask. Static trace(visit, ptr<T>) owns allocation claiming and may walk directly between records
Cjam::tracer< weak_ptr< T > >	Declare a weak field for forwarding without following its target
Cjam::heap::visitor	One marker's claim and edge-discovery interface.Only a successful claimant visits the record's fields. The visitor is borrowed for one callback and must not escape it
Cjam::weak< V >	An external conditional weak-value handle; registration survives dropped handles.Keep this handle outside the managed heap. Copies share one registration. Finalization expires all copies before the callback runs; resurrection does not rearm it
Cjam::weak_ptr< T >	A four-byte weak heap field; tracing updates its slot without retaining its target.Construct from a ptr or root. Collection clears the field when its target is unclaimed; minor collection leaves old targets alone. Use lock() to retain a target across collection. There is no control block or external registration: stack copies expire at collection just like ptr, even if the target survives. The field must be listed in its owner's manifest or trace hook