Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Nanonymous_namespace{free_list_allocator.cpp}
CAllocationHeader
Nanonymous_namespace{stacktrace.cpp}
CCapturedFramesResult
Nhelios
Napp
CApp	Application class
CAppExit	Message that requests the application to exit
CDynamicPlugin	Wrapper for dynamically loaded plugins
CDynamicPluginConfig	Configuration for dynamic plugin loading
CExtract	Extract schedule (runs after the last frame schedule)
CExtractStage	Stage for per-frame extraction into sub-apps
CFirst	First schedule in a frame
CFixedRunnerConfig	Configuration for fixed-timestep runners
CLast	Last schedule in a frame
CMainStartup	Main-thread startup schedule (window creation, etc.)
CPlugin	Base class for all plugins
CPluginTypeExport	C-compatible plugin identity exported by dynamic libraries
CPostShutdown	Post-shutdown schedule
CPostStartup	Post-startup schedule
CPostUpdate	Post-update schedule
CPreShutdown	Pre-shutdown schedule
CPreStartup	Pre-startup schedule
CPreUpdate	Pre-update schedule
CScheduler	Orchestrates the main sub-app schedule loop and sub-app updates
CShutdown	Shutdown schedule
CShutdownStage	Stage for one-time shutdown execution
CStartup	Startup schedule
CStartupStage	Stage for one-time startup execution
CSubApp	A sub-application with its own ECS world and scheduler
CUpdate	Update schedule
CUpdateStage	Stage for per-frame game logic
Nasync
CAsyncTask	Handle to an asynchronous task managed by the Executor
CExecutor	Manages worker threads and executes task graphs using work-stealing scheduling
CFuture	Wrapper around tf::Future for handling asynchronous task results
CSubTaskGraph	Dynamic task graph that can be created within the execution of a task
CTask	Represents a single task within a task graph
CTaskGraph	Represents a task dependency graph that can be executed by an Executor
Ncontainer
Ndetails
CCallableBufferArrayDeducer	Deduces the CallableBufferArrayImpl type from signature arguments
CCallableBufferArrayDeducer< Alloc, FirstSig, RestSigs... >
CCallableBufferArrayDeducer< FirstSig, RestSigs... >
CCallableBufferDeducer	Deduces the CallableBufferImpl type from signature arguments
CCallableBufferDeducer< Alloc, FirstSig, RestSigs... >
CCallableBufferDeducer< FirstSig, RestSigs... >
CBasicStaticString	A fixed-capacity string class that owns its storage
CCallableBufferArrayImpl	Implementation class for an inline callable array buffer with explicit allocator
CCallableBufferImpl	Implementation class for a single-instance callable buffer with explicit allocator
CMultiTypeMap	Generic type-indexed map that stores one Storage instance per registered type key
CSparseSet	A sparse set data structure for efficient mapping of sparse indices to dense storage of values
CTypedBuffer	Type-erased single-instance byte storage
CTypedBufferArray	Type-erased sequential byte storage for a single type (array variant)
Ndetails
CTupleToFunctionSignature
CTupleToFunctionSignature< std::tuple< R, Args... > >
CFreeFunctionTraits
CFreeFunctionTraits< R(*)(Args...)>
CMemberFunctionTraits	Traits for member function pointers (non-const and const)
CMemberFunctionTraits< R(C::*)(Args...)>
CMemberFunctionTraits< R(C::*)(Args...) const >
Necs
Nanonymous_namespace{scheduler.cpp}
CTopoNode
Ndetails
CAsyncMessageStorage	Base class for type-erased async message storage
CHasSystemParamCallOperatorHelper
CMemberFnArgs	Extracts the argument types of a member function pointer
CMemberFnArgs< R(*)(Args...)>	Concept: a type's operator() arguments all have SystemParamTraits
CMemberFnArgs< R(Args...)>
CMemberFnArgs< R(C::*)(Args...) const >
CMemberFnArgs< R(C::*)(Args...)>
CRegisterQueryAccess	Helper to register query component access from a component tuple
CRegisterQueryAccess< std::tuple< Cs... > >
CAccessPolicy	Stores data access requirements for a system at compile time
CAccessPolicyBuilder	Fluent builder for constructing an AccessPolicy
CAddComponentsCmd	Command to add multiple components to an entity
CArchetype	Stores entities and their component data in a Structure-of-Arrays layout for a specific archetype
CArchetypeId	Unique identifier for an archetype, represented as a sorted set of component type indices
CAsyncMessageQueue	Async queue for managing multiple message types via lock-free concurrent queues
CAsyncMessageReader	Type-safe, move-based reader for async messages
CAsyncMessageWrapper	A wrapper around an async message that provides convenient access to the message's data and type information
CAsyncMessageWriter	Type-safe writer for async messages
CBasicMessageWriter	Type-safe writer for regular messages with a configurable queue allocator
CBasicQuery	Query result object for iterating over matching entities and components
CBasicQueryIter	Iterator for query results without entity information
CBasicQueryWithEntity	Wrapper that provides entity-aware iteration over query results
CBasicQueryWithEntityIter	Iterator for query results including the entity
CClearAllMessagesCmd	Command to clear all message queues without removing registration
CClearComponentsCmd	Command to clear all components from an entity
CClearMessagesCmd	Command to clear all messages of a specific type from the queue
CCmdQueue	Command queue for deferred ECS operations
CCommands	Thin wrapper over command queue and world for deferred ECS operations
CComponentAddedMsg	Message sent when a component is added
CComponentConflictInfo	Describes a single component access conflict between two policies
CComponentManager	Central manager for all component storage (archetype and sparse-set)
CSparseStorageEntry	Type-erased entry for sparse-set component storage
CComponentMetadata	Runtime metadata for a registered component type
CComponentRemovedMsg	Message sent when a component is removed
CComponentsClearedMsg	Message sent when all components are cleared from an entity
CComponentTraits	Component traits for optimization decisions
CComponentTypeInfo	Component type info for runtime operations
CCompositeSystemParam	Helper for implementing SystemParamTraits on aggregate parameters
CConsumableMessageReader	Type-safe, zero-copy reader for consumable messages with consume support
CConsumableMessageWrapper	A wrapper around a message that provides convenient access to the message's data, type information, and the ability to mark the message as consumed
CConsumableMessageWrapperIter	Bidirectional iterator that yields ConsumableMessageWrapper<T> instances with consume support
CConsumedMessagesRegistry	Per-system registry for tracking consumed message indices
CDag	Directed acyclic graph used to compute the topological execution order of systems within a schedule
CDagError
CDestroyEntitiesCmd	Command to destroy multiple entities
CDestroyEntityCmd	Command to destroy a single entity
CEntity	Unique identifier for entities with generation counter to handle recycling
CEntityAddedMsg	Message sent when an entity is added
CEntityCmdBuffer	Command buffer for deferred entity operations
CEntityDestroyedMsg	Message sent when an entity is destroyed
CEntityManager	Entity manager responsible for entity creation, destruction, and validation
CExecutor	Abstract interface for schedule executors
CFunctionCmd	Command that executes a function with World reference
CInsertResourceCmd	Command to insert a resource into the world
CLocal	Read-only or mutable access to a system-local resource
CMainThreadExecutor	Main-thread executor that runs systems sequentially on the calling thread
CMessageManager	Central coordinator for message lifecycle with double buffering and consumed message removal
CMessageMetadata	Metadata for a registered message type
CMessageQueue	Queue for managing multiple message types using type-erased contiguous storage
CMessageReader	Type-safe, zero-copy reader for regular messages
CMessageReaderBase	CRTP base class for message readers providing common functionality
CMessageWrapper	A wrapper around a message that provides convenient access to the message's data and type information
CMessageWrapperIter	Bidirectional iterator that yields MessageWrapper<T> instances
CMultiThreadedExecutor	Multi-threaded executor that runs systems in parallel using work-stealing
CRemoveComponentsCmd	Command to remove multiple components from an entity
CRemoveResourceCmd	Command to remove resource from the world
CRes	Read-only or mutable access to resource
CResourceConflictInfo	Describes a single resource access conflict between two policies
CResourceInsertedMsg	Message sent when a resource is inserted
CResourceManager	Resource manager for storing and managing resources of various types
CResourceRemovedMsg	Message sent when a resource is removed
CRunConditionStorage	Storage for a run condition — predicate + access policy + local data
CSchedule	A collection of systems, sets, and run conditions with ordering constraints
CScheduleError	Error type returned when schedule compilation fails
CScheduleOrdering	Handle returned when adding a schedule to the scheduler for configuring ordering
CScheduler	Orchestrates multiple named schedules, handles transitions, and executes them in topological order
CScheduleSettings	Settings that control how a schedule is compiled and executed
CScheduleSystemId	Unique identifier for a system within a schedule
CScheduleSystemMetadata	Metadata attached to a system entry for ordering and configuration
CSingleThreadedExecutor	Single-threaded executor that runs systems sequentially on a single thread
CSparseComponentStorage	Concrete sparse-set storage for a single component type (non-polymorphic)
CStageOrdering	Handle returned when configuring stage ordering
CSystemGroupHandle	Handle returned by variadic Schedule::Add for configuring a batch of systems added together
CSystemHandle	Handle returned by Schedule::Add for configuring a system
CSystemId	Id for systems
CSystemLocalData	Local data for a system
CSystemLocalDataOptions	Options for system local data
CSystemParamTraits	Primary template — deliberately incomplete
CSystemParamTraits< AsyncMessageReader< T > >
CSystemParamTraits< AsyncMessageWriter< T > >
CSystemParamTraits< BasicMessageWriter< T, Allocator > >
CSystemParamTraits< Commands >
CSystemParamTraits< ConsumableMessageReader< T > >
CSystemParamTraits< Local< const T > >
CSystemParamTraits< Local< T > >
CSystemParamTraits< MessageReader< T > >
CSystemParamTraits< MessageWriter< T > >
CSystemParamTraits< Query< Args... > >
CSystemParamTraits< Res< const T > >
CSystemParamTraits< Res< T > >
CSystemParamTraits< std::optional< Local< const T > > >
CSystemParamTraits< std::optional< Local< T > > >
CSystemParamTraits< std::optional< Res< const T > > >
CSystemParamTraits< std::optional< Res< T > > >
CSystemParamTraits< WorldView >
CSystemSet	A group of systems that share ordering, run conditions, and other properties
CSystemSetHandle	Handle returned by Schedule::Set for configuring a named system set
CSystemSetId	Identifier for a system set
CSystemStorage	Storage for a system
CTryAddComponentsCmd	Command to try add multiple components (only missing ones)
CTryDestroyEntitiesCmd	Command to try destroy multiple entities
CTryDestroyEntityCmd	Command to try destroy a single entity
CTryInsertResourceCmd	Command to try insert a resource (only if missing)
CTryRemoveComponentsCmd	Command to try remove multiple components (only those present)
CTryRemoveResourceCmd	Command to try remove resource (only if present)
CTypedAsyncMessageStorage	Typed async message storage backed by a lock-free concurrent queue
CWorld	Manages entities with their components and systems
CWorldCmdBuffer	Command buffer for deferred World operations
CWorldView	Thread-safe read-only view into the world
Nlog
CConfig	Configuration for logger behavior and output
CDefaultLogger	Default logger type
CLogger	Centralized logging system with configurable output and formatting
Nmem
CAllocatorStats	Runtime statistics snapshot for PMR allocators
CArcFromThis	CRTP base class that embeds an atomic reference counter into the derived type
CArenaAllocator	PMR arena allocator with lock-free hot allocation path
CArenaOptions	Configuration for ArenaAllocator
CAtomicRefCounted	Thread-safe intrusive reference-counted smart pointer
CFixedArenaAllocator	PMR arena with fixed runtime capacity
CFixedFreeListAllocator	Fixed-capacity best-fit allocator with coalescing
CFixedPoolAllocator	Fixed-capacity intrusive block pool
CFixedPoolAllocatorOptions	Configuration for FixedPoolAllocator
CFixedStackAllocator	PMR stack allocator with fixed runtime capacity
CMarker	Marker capturing the current bump offset for rewind operations
CFrameAllocator	N-buffered PMR frame allocator
CFrameAllocatorOptions	Configuration for FrameAllocator
CFreeListAllocator	General-purpose PMR free-list allocator
CFreeListAllocatorOptions	Configuration for FreeListAllocator
CGrowthPolicy	Capacity growth configuration
CPoolAllocator	Lock-free PMR pool allocator for fixed-size blocks
CPoolAllocatorOptions	Configuration for PoolAllocator
CRcFromThis	CRTP base class that embeds a non-atomic reference counter into the derived type
CRefCounted	Non-atomic intrusive reference-counted smart pointer
CStackAllocator	PMR stack allocator with LIFO-aware deallocation
CMarker	Marker for rewind operations
CStackAllocatorOptions	Configuration for StackAllocator
Nprofile
CBackend	Abstract profiler backend interface
CFlamegraphBackend	Profiling backend that emits a Chrome Tracing JSON file
CFlamegraphBackendConfig	Configuration for the FlamegraphBackend
CProfiler	Global profiler registry and multi-backend fan-out dispatcher
CScopedZone	RAII scope zone that delegates to the active profiling backends
CTracyBackend	Tracy profiler backend adapter
CZoneSpec	Immutable zone description for a single instrumentation site
Nutils
Ndetails
Cadapter_iterator_traits	Traits for Iter, selecting iterator concept from Iter if it has one, else forward
CDeferHelper	Helper struct for the HELIOS_DEFER macro to enable inline lambda syntax
CFixedString	A fixed-size string that can be constructed at compile time
Cfolder_apply_result	Helper to get the result type of folder applied with accumulator + tuple elements
Cfolder_apply_result< Folder, Accumulator, std::tuple< TupleArgs... > >
Cis_folder_applicable_impl	Helper to extract tuple element types and check if a folder is invocable with accumulator + tuple elements
Cis_folder_applicable_impl< Folder, Accumulator, std::tuple< TupleArgs... > >
CUniqueTypesHelper
CUniqueTypesHelper< T, Rest... >
CChainAdapter	Iterator adapter that chains two sequences together
CDefer	A utility class that defers the execution of a callable until the object goes out of scope
CDynamicLibrary	Cross-platform dynamic library loader
CEnumerateAdapter	Iterator adapter that adds index information to each element
CFastPimpl	Implements pimpl idiom without dynamic memory allocation
CFilterAdapter	Iterator adapter that filters elements based on a predicate function
CFunctionalAdapterBase	CRTP base class providing common adapter operations
CInspectAdapter	Iterator adapter that applies a function to each element for observation
CJoinAdapter
CMapAdapter	Iterator adapter that transforms each element using a function
CRandomGenerator	Random number utilities with a user-provided engine
CReverseAdapter	Adapter that iterates through elements in reverse order
CSkipAdapter	Iterator adapter that skips the first N elements
CSkipWhileAdapter	Iterator adapter that skips elements while a predicate returns true
CSlideAdapter	Adapter that yields sliding windows of elements
CSlideView	Adapter that flattens nested ranges into a single sequence
CStepByAdapter	Iterator adapter that steps through elements by a specified stride
CStrideAdapter	Adapter that yields every Nth element from the range
CStringEqual	Transparent equality comparator for string types
CStringHash	Transparent hash functor for string types
CTakeAdapter	Iterator adapter that yields only the first N elements
CTakeWhileAdapter	Iterator adapter that takes elements while a predicate returns true
CTimer	High–resolution timer with configurable clock and rich elapsed API
CTypeId
CTypeIndex
CZipAdapter	Adapter that combines two ranges into pairs
CBasicCStringView	A view of a null-terminated C string
CDelegate	Type-erased callable wrapper for free and member functions
CDelegate< ReturnType(Args...)>
CStacktrace	Captured and filtered stacktrace with string conversion support
CStacktraceConfig	Configuration for stacktrace capture and formatting
CUuid	A class representing a universally unique identifier (UUID)
CUuidGenerator	A class for generating random UUIDs using a specified random number generator
Nstd	STL namespace
Cformatter< helios::BasicCStringView< CharT, Traits > >	std::format support for BasicCStringView
Cformatter< helios::container::BasicStaticString< StrCapacity, CharT, Traits > >	std::format support for BasicStaticString
Cformatter< helios::ecs::Entity >
Chash< helios::BasicCStringView< CharT, Traits > >	Hash support for BasicCStringView
Chash< helios::container::BasicStaticString< StrCapacity, CharT, Traits > >	Hash support for BasicStaticString
Chash< helios::ecs::ArchetypeId >
Chash< helios::ecs::ComponentTypeInfo >
Chash< helios::ecs::Entity >
Chash< helios::ecs::SystemId >
Chash< helios::utils::TypeId >
Chash< helios::utils::TypeIndex >
Chash< helios::Uuid >