helios Namespace Reference

Namespaces
namespace	anonymous_namespace{assert.cpp}
namespace	app
namespace	async
namespace	container
namespace	details
namespace	ecs
namespace	example
namespace	memory
namespace	utils

Classes
struct	DefaultLogger
	Default logger type. More...
class	Delegate
	Type-erased callable wrapper for free and member functions. More...
class	Delegate< ReturnType(Args...)>
class	Logger
	Centralized logging system with configurable output and formatting. More...
struct	LoggerConfig
	Configuration for logger behavior and output. More...
class	RandomGenerator
	Random number utilities with a user-provided engine. More...
class	Timer
	High–resolution timer with configurable clock and rich elapsed API. More...
class	Timestep
	Represents a time step in seconds. More...
class	Uuid
	A class representing a universally unique identifier (UUID). More...
class	UuidGenerator
	A class for generating random UUIDs using a specified random number generator. More...

Concepts
concept	LoggerTrait
concept	LoggerWithConfigTrait
concept	RandomEngine
	Concept for random number engines compatible with std distributions.
concept	Distribution
	Concept for standard-like distributions.

Typedefs
using	LoggerId = size_t
	Type alias for logger type IDs.
using	DefaultRandomEngine = std::mt19937_64
	Default engine type used by random utilities.
using	FastRandomEngine = std::minstd_rand
	Fast but lower-quality engine type used by random utilities.
using	DefaultRandomGenerator = RandomGenerator< DefaultRandomEngine >
	Convenience alias for a generator using the default-quality engine.
using	FastRandomGeneratorType = RandomGenerator< FastRandomEngine >
	Convenience alias for a generator using the fast engine.

Enumerations
enum class	LogLevel : uint8_t {   kTrace = 0 , kDebug = 1 , kInfo = 2 , kWarn = 3 ,   kError = 4 , kCritical = 5 }
	Log severity levels. More...

Functions
void	AbortWithStacktrace (std::string_view message) noexcept
	Prints a message with stack trace and aborts the program execution.
template<auto Func> requires (!std::is_member_function_pointer_v<decltype(Func)>)
constexpr auto	DelegateFromFunction () noexcept
	Helper to create delegate from free function pointer.
template<typename Signature , Signature Func> requires (!std::is_member_function_pointer_v<decltype(Func)>)
constexpr auto	DelegateFromFunction () noexcept
	Helper to create delegate from free function pointer with explicit signature.
template<auto Func> requires std::is_member_function_pointer_v<decltype(Func)>
constexpr auto	DelegateFromFunction (typename details::MemberFunctionTraits< decltype(Func)>::Class &instance) noexcept
	Helper to create delegate from member function pointer.
template<typename Signature , Signature Func> requires std::is_member_function_pointer_v<decltype(Func)>
constexpr auto	DelegateFromFunction (typename details::MemberFunctionTraits< Signature >::Class &instance) noexcept
	Helper to create delegate from member function pointer with explicit signature.
template<LoggerTrait T>
constexpr LoggerId	LoggerIdOf () noexcept
template<LoggerTrait T>
constexpr std::string_view	LoggerNameOf () noexcept
template<LoggerTrait T>
LoggerConfig	LoggerConfigOf () noexcept
uint64_t	RandomDeviceSeed ()
	Internal helper to obtain seed from std::random_device.
DefaultRandomEngine	MakeDefaultEngine ()
	Creates a default-quality random engine seeded with std::random_device.
FastRandomEngine	MakeFastEngine ()
	Creates a fast linear random engine seeded with std::random_device.
DefaultRandomEngine &	DefaultEngine ()
	Thread-local default-quality engine.
FastRandomEngine &	FastEngineInstance ()
	Thread-local fast engine.
DefaultRandomGenerator &	RandomDefault ()
	Provides access to a thread-local default-quality random generator.
FastRandomGeneratorType &	RandomFast ()
	Provides access to a thread-local fast random generator.
template<utils::ArithmeticTrait T>
T	RandomValue ()
	Convenience function to generate a default-distribution value using the default engine.
template<utils::ArithmeticTrait T, utils::ArithmeticTrait U>
auto	RandomValueFromRange (T min, U max) -> std::common_type_t< T, U >
	Convenience function to generate a value in range using the default engine.
template<utils::ArithmeticTrait T>
T	RandomFastValue ()
	Convenience function to generate a default-distribution value using the fast engine.
template<utils::ArithmeticTrait T, utils::ArithmeticTrait U>
auto	RandomFastValueFromRange (T min, U max) -> std::common_type_t< T, U >
	Convenience function to generate a value in range using the fast engine.

Variables
constexpr DefaultLogger	kDefaultLogger {}
	Constexpr instance of the default logger for easier user interface.

Typedef Documentation

DefaultRandomEngine

using helios::DefaultRandomEngine = typedef std::mt19937_64

Default engine type used by random utilities.

Uses a 64-bit Mersenne Twister for quality pseudorandom numbers.

Definition at line 42 of file random.hpp.

DefaultRandomGenerator

using helios::DefaultRandomGenerator = typedef RandomGenerator<DefaultRandomEngine>

Convenience alias for a generator using the default-quality engine.

Uses thread-local DefaultEngine() as the underlying engine.

Definition at line 228 of file random.hpp.

FastRandomEngine

using helios::FastRandomEngine = typedef std::minstd_rand

Fast but lower-quality engine type used by random utilities.

Uses a 32-bit linear congruential engine suitable for non-cryptographic, performance-critical scenarios.

Definition at line 48 of file random.hpp.

FastRandomGeneratorType

using helios::FastRandomGeneratorType = typedef RandomGenerator<FastRandomEngine>

Convenience alias for a generator using the fast engine.

Uses thread-local FastEngineInstance() as the underlying engine.

Definition at line 234 of file random.hpp.

LoggerId

using helios::LoggerId = typedef size_t

Type alias for logger type IDs.

Used to uniquely identify logger types at runtime.

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/logger.hpp.

Definition at line 106 of file logger.hpp.

Enumeration Type Documentation

LogLevel

enum class helios::LogLevel : uint8_t

strong

Log severity levels.

Enumerator
kTrace
kDebug
kInfo
kWarn
kError
kCritical

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/logger.hpp.

Definition at line 34 of file logger.hpp.

: uint8_t { kTrace = 0, kDebug = 1, kInfo = 2, kWarn = 3, kError = 4, kCritical = 5 };

Function Documentation

AbortWithStacktrace()

void helios::AbortWithStacktrace ( std::string_view  message )

noexcept

Prints a message with stack trace and aborts the program execution.

Useful for placing in dead code branches or unreachable states.

Parameters

message

The message to print before aborting

Definition at line 89 of file assert.cpp.

                                                          {
#if defined(__cpp_lib_print) && (__cpp_lib_print >= 202302L)
  // Use std::println when available (C++23)
  std::println("\n=== FATAL ERROR ===");
  std::println("Message: {}", message);
 
#ifdef HELIOS_ENABLE_STACKTRACE
  PrintStackTrace();
#else
  std::println("\nStack trace: <not available - build with HELIOS_ENABLE_STACKTRACE>");
#endif
 
  std::println("===================\n");
  std::fflush(stdout);
#else
  // Fallback to fprintf to stderr when std::println is not available
  std::fprintf(stderr, "\n=== FATAL ERROR ===\n");
  std::fprintf(stderr, "Message: %.*s\n", static_cast<int>(message.size()), message.data());
 
#ifdef HELIOS_ENABLE_STACKTRACE
  PrintStackTrace();
#else
  std::fprintf(stderr, "\nStack trace: <not available - build with HELIOS_ENABLE_STACKTRACE>\n");
#endif
 
  std::fprintf(stderr, "===================\n\n");
  std::fflush(stderr);
#endif
 
  HELIOS_DEBUG_BREAK();
  std::abort();
}

DefaultEngine()

DefaultRandomEngine & helios::DefaultEngine ( )

inline

Thread-local default-quality engine.

Uses Meyer's singleton pattern per thread to avoid global static initialization order issues while providing a convenient default.

Returns

Reference to thread-local DefaultRandomEngine instance.

Definition at line 100 of file random.hpp.

                                                          {
  thread_local auto engine = MakeDefaultEngine();
  return engine;
}

DelegateFromFunction() [1/4]

template<auto Func>
requires (!std::is_member_function_pointer_v<decltype(Func)>)

constexpr auto helios::DelegateFromFunction ( )

constexprnoexcept

Helper to create delegate from free function pointer.

Template Parameters

Func	Free function pointer

Returns

Delegate bound to the given free function

Definition at line 429 of file delegate.hpp.

                                               {
  using Traits = details::FreeFunctionTraits<decltype(Func)>;
  using ReturnType = typename Traits::ReturnType;
  using Args = typename Traits::Arguments;
 
  return []<std::size_t... I>(std::index_sequence<I...>) {
    return Delegate<ReturnType(std::tuple_element_t<I, Args>...)>::template FromFunction<Func>();
  }(std::make_index_sequence<std::tuple_size_v<Args>>{});
}

DelegateFromFunction() [2/4]

template<typename Signature , Signature Func>
requires (!std::is_member_function_pointer_v<decltype(Func)>)

constexpr auto helios::DelegateFromFunction ( )

constexprnoexcept

Helper to create delegate from free function pointer with explicit signature.

Template Parameters

Signature	Free function pointer type
Func	Free function pointer value

Returns

Delegate bound to the given free function

Definition at line 447 of file delegate.hpp.

                                               {
  using Traits = details::FreeFunctionTraits<Signature>;
  using ReturnType = typename Traits::ReturnType;
  using Args = typename Traits::Arguments;
 
  return []<std::size_t... I>(std::index_sequence<I...>) {
    return Delegate<ReturnType(std::tuple_element_t<I, Args>...)>::template FromFunction<Signature, Func>();
  }(std::make_index_sequence<std::tuple_size_v<Args>>{});
}

DelegateFromFunction() [3/4]

template<auto Func>
requires std::is_member_function_pointer_v<decltype(Func)>

constexpr auto helios::DelegateFromFunction ( typename details::MemberFunctionTraits< decltype(Func)>::Class &  instance )

constexprnoexcept

Helper to create delegate from member function pointer.

Template Parameters

Func	Member function pointer

Parameters

instance

Reference to the object instance used for invocation

Returns

Delegate bound to the given member function and instance

Definition at line 465 of file delegate.hpp.

                                                                                                                  {
  using Traits = details::MemberFunctionTraits<decltype(Func)>;
  using ReturnType = typename Traits::ReturnType;
  using Args = typename Traits::Arguments;
 
  return []<std::size_t... I>(std::index_sequence<I...>, auto& inst) {
    return Delegate<ReturnType(std::tuple_element_t<I, Args>...)>::template FromFunction<Func>(inst);
  }(std::make_index_sequence<std::tuple_size_v<Args>>{}, instance);
}

DelegateFromFunction() [4/4]

template<typename Signature , Signature Func>
requires std::is_member_function_pointer_v<decltype(Func)>

constexpr auto helios::DelegateFromFunction ( typename details::MemberFunctionTraits< Signature >::Class &  instance )

constexprnoexcept

Helper to create delegate from member function pointer with explicit signature.

Template Parameters

Signature	Member function pointer type
Func	Member function pointer value

Parameters

instance

Reference to the object instance used for invocation

Returns

Delegate bound to the given member function and instance

Definition at line 484 of file delegate.hpp.

                                                                                                             {
  using Traits = details::MemberFunctionTraits<Signature>;
  using ReturnType = typename Traits::ReturnType;
  using Args = typename Traits::Arguments;
 
  return []<std::size_t... I>(std::index_sequence<I...>, auto& inst) {
    return Delegate<ReturnType(std::tuple_element_t<I, Args>...)>::template FromFunction<Signature, Func>(inst);
  }(std::make_index_sequence<std::tuple_size_v<Args>>{}, instance);
}

FastEngineInstance()

FastRandomEngine & helios::FastEngineInstance ( )

inline

Thread-local fast engine.

Uses Meyer's singleton pattern per thread to avoid global static initialization order issues while providing a fast default.

Returns

Reference to thread-local FastRandomEngine instance.

Definition at line 111 of file random.hpp.

                                                            {
  thread_local auto engine = MakeFastEngine();
  return engine;
}

LoggerConfigOf()

template<LoggerTrait T>

LoggerConfig helios::LoggerConfigOf ( )

inlinenoexcept

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/logger.hpp.

Definition at line 200 of file logger.hpp.

                                              {
  if constexpr (LoggerWithConfigTrait<T>) {
    return T::Config();
  } else {
    return LoggerConfig::Default();
  }
}

LoggerIdOf()

template<LoggerTrait T>

constexpr LoggerId helios::LoggerIdOf ( )

constexprnoexcept

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/logger.hpp.

Definition at line 160 of file logger.hpp.

                                         {
  return ctti::type_index_of<T>().hash();
}

LoggerNameOf()

template<LoggerTrait T>

constexpr std::string_view helios::LoggerNameOf ( )

constexprnoexcept

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/logger.hpp.

Definition at line 179 of file logger.hpp.

                                                 {
  return T::Name();
}

MakeDefaultEngine()

DefaultRandomEngine helios::MakeDefaultEngine ( )

inline

Creates a default-quality random engine seeded with std::random_device.

Useful when the caller wants an engine instance but does not care a specific engine type beyond the default choice.

Returns

DefaultRandomEngine instance seeded with random_device.

Definition at line 80 of file random.hpp.

                                                             {
  return DefaultRandomEngine{static_cast<DefaultRandomEngine::result_type>(RandomDeviceSeed())};
}

MakeFastEngine()

FastRandomEngine helios::MakeFastEngine ( )

inline

Creates a fast linear random engine seeded with std::random_device.

Intended for performance-critical code where statistical quality is less important. Not suitable for cryptographic purposes.

Returns

FastRandomEngine instance seeded with random_device.

Definition at line 90 of file random.hpp.

                                                       {
  return FastRandomEngine{static_cast<FastRandomEngine::result_type>(RandomDeviceSeed())};
}

RandomDefault()

DefaultRandomGenerator & helios::RandomDefault ( )

inline

Provides access to a thread-local default-quality random generator.

Uses Meyer's singleton pattern per thread and avoids any static engine objects other than thread-local instances that are lazily initialized on first use.

Returns

Reference to DefaultRandomGenerator bound to DefaultEngine().

Definition at line 242 of file random.hpp.

                                                             {
  thread_local DefaultRandomGenerator generator{DefaultEngine()};
  return generator;
}

RandomDeviceSeed()

uint64_t helios::RandomDeviceSeed ( )

inline

Internal helper to obtain seed from std::random_device.

This function is intentionally small and header-only to avoid static initialization of engines in user code.

Returns

64-bit seed value from random_device.

Definition at line 55 of file random.hpp.

                                                 {
  std::random_device rd{};
  using result_type = std::random_device::result_type;
  constexpr auto result_bits = sizeof(result_type) * 8U;
  constexpr auto target_bits = sizeof(uint64_t) * 8U;
 
  if constexpr (result_bits >= target_bits) {
    return static_cast<uint64_t>(rd());
  } else {
    uint64_t value = 0;
    auto shift = 0U;
    while (shift < target_bits) {
      value |= static_cast<uint64_t>(rd()) << shift;
      shift += result_bits;
    }
    return value;
  }
}

RandomFast()

FastRandomGeneratorType & helios::RandomFast ( )

inline

Provides access to a thread-local fast random generator.

Uses Meyer's singleton pattern per thread and avoids any static engine objects other than thread-local instances that are lazily initialized on first use.

Returns

Reference to FastRandomGeneratorType bound to FastEngineInstance().

Definition at line 253 of file random.hpp.

                                                           {
  thread_local FastRandomGeneratorType generator{FastEngineInstance()};
  return generator;
}

RandomFastValue()

template<utils::ArithmeticTrait T>

T helios::RandomFastValue ( )

inline

Convenience function to generate a default-distribution value using the fast engine.

Equivalent to RandomFast().Value<T>(), but shorter to call.

Template Parameters

T	Arithmetic type to generate.

Returns

Randomly generated value of type T using the fast engine.

Definition at line 290 of file random.hpp.

                                         {
  return RandomFast().Value<T>();
}

RandomFastValueFromRange()

template<utils::ArithmeticTrait T, utils::ArithmeticTrait U>

auto helios::RandomFastValueFromRange ( T  min, U  max  ) -> std::common_type_t<T, U>

inline

Convenience function to generate a value in range using the fast engine.

Equivalent to RandomFast().ValueFromRange(min, max).

Template Parameters

T	Arithmetic type.
U	Arithmetic type.

Parameters

min	Lower bound of the range.
max	Upper bound of the range.

Returns

Random value of common_type_t<T, U> in [min, max] or [min, max).

Definition at line 304 of file random.hpp.

                                                                                           {
  return RandomFast().ValueFromRange(min, max);
}

RandomValue()

template<utils::ArithmeticTrait T>

T helios::RandomValue ( )

inline

Convenience function to generate a default-distribution value using the default engine.

Equivalent to RandomDefault().Value<T>(), but shorter to call.

Template Parameters

T	Arithmetic type to generate.

Returns

Randomly generated value of type T.

Definition at line 265 of file random.hpp.

                                     {
  return RandomDefault().Value<T>();
}

RandomValueFromRange()

template<utils::ArithmeticTrait T, utils::ArithmeticTrait U>

auto helios::RandomValueFromRange ( T  min, U  max  ) -> std::common_type_t<T, U>

inline

Convenience function to generate a value in range using the default engine.

Equivalent to RandomDefault().ValueFromRange(min, max).

Template Parameters

T	Arithmetic type.
U	Arithmetic type.

Parameters

min	Lower bound of the range.
max	Upper bound of the range.

Returns

Random value of common_type_t<T, U> in [min, max] or [min, max).

Definition at line 279 of file random.hpp.

                                                                                       {
  return RandomDefault().ValueFromRange(min, max);
}

Variable Documentation

kDefaultLogger

constexpr DefaultLogger helios::kDefaultLogger {}

inlineconstexpr

Constexpr instance of the default logger for easier user interface.

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/logger.hpp.

Definition at line 225 of file logger.hpp.

{};