Skip to main content

engine/ecs/types/ComponentTypeId.ixx File

Compile-time type identifier for component types. More...

Included Headers​

#include <functional> #include <helios.core.types> #include <helios.core.data.TypeIndexer>

Namespaces Index​

namespacehelios
namespaceengine

Main engine module aggregating core infrastructure and game systems. More...

namespaceecs

Core Entity-Component-System architecture. More...

namespacetypes

Classes Index​

classComponentTypeId

Unique type identifier for component types. More...

structhelios_engine_common_tag_ComponentTypes

Tag type for the TypeIndexer domain. More...

structhash<helios::engine::ecs::types::ComponentTypeId>

std::hash specialization for ComponentTypeId. More...

Description​

Compile-time type identifier for component types.

Provides a unique, compile-time generated ID for each component type, enabling O(1) direct indexing into the component storage vector within GameObject.

File Listing​

The file content with the documentation metadata removed is:

1/**
2 * @file ComponentTypeId.ixx
3 * @brief Compile-time type identifier for component types.
4 *
5 * @details Provides a unique, compile-time generated ID for each component type,
6 * enabling O(1) direct indexing into the component storage vector within GameObject.
7 */
8module;
9
10#include <functional>
11
12export module helios.engine.ecs.types.ComponentTypeId;
13
14import helios.core.data.TypeIndexer;
15import helios.core.types;
16
17export namespace helios::engine::ecs::types {
18
19 /**
20 * @brief Unique type identifier for component types.
21 *
22 * @details ComponentTypeId assigns a unique, monotonically increasing integer ID
23 * to each component type at compile time. This ID is used as an index into the
24 * component storage vector within GameObject, enabling O(1) access.
25 *
26 * **Usage:**
27 * ```cpp
28 * // Get the ID for a component type
29 * auto id = ComponentTypeId::id<Move2DComponent>();
30 *
31 * // Use the value as an index
32 * components_[id.value()] = std::move(component);
33 * ```
34 *
35 * **Thread Safety:** The static ID generation is thread-safe due to C++11 static
36 * initialization guarantees.
37 *
38 * @see TypeIndexer
39 * @see GameObject
40 */
41 class ComponentTypeId {
42
43 /**
44 * @brief Tag type for the TypeIndexer domain.
45 */
46 struct helios_engine_common_tag_ComponentTypes{};
47
48 using ComponentType = helios_engine_common_tag_ComponentTypes;
49
50 /**
51 * @brief The underlying ID value.
52 */
53 size_t id_{0};
54
55
56 public:
57
58 /**
59 * @brief Constructs a ComponentTypeId with a specific ID value.
60 *
61 * @details This constructor initializes a ComponentTypeId object with a given
62 * ID, representing a unique identifier for a component type. The ID is used
63 * internally for indexing and retrieving components from the storage system.
64 *
65 * @param id The unique identifier assigned to the component type.
66 * This ID must be a valid non-negative value.
67 */
68 explicit ComponentTypeId(const size_t id) : id_(id) {}
69
70 /**
71 * @brief Constructs an uninitialized ComponentTypeId.
72 *
73 * @param no_init_t Tag to indicate no initialization.
74 */
75 explicit ComponentTypeId(helios::core::types::no_init_t) {}
76
77 /**
78 * @brief Returns the underlying ID value.
79 *
80 * @return The numeric type ID, suitable for use as an array index.
81 */
82 [[nodiscard]] size_t value() const noexcept {
83 return id_;
84 }
85
86 /**
87 * @brief Gets the ComponentTypeId for a specific component type.
88 *
89 * @details Uses TypeIndexer to generate a unique, monotonically increasing ID
90 * for each component type. The ID is generated once per type and cached.
91 *
92 * @tparam T The component type. Must be a concrete type (not abstract).
93 *
94 * @return The unique ComponentTypeId for type T.
95 */
96 template <typename T>
97 [[nodiscard]] static ComponentTypeId id() {
98 static const size_t tid = helios::core::data::TypeIndexer<ComponentType>::typeIndex<T>();
99 return ComponentTypeId(tid);
100 }
101
102 friend constexpr bool operator==(ComponentTypeId, ComponentTypeId) noexcept = default;
103 };
104
105
106}
107
108
109/**
110 * @brief std::hash specialization for ComponentTypeId.
111 *
112 * @details Enables use of ComponentTypeId as a key in unordered containers.
113 */
114template<>
115struct std::hash<helios::engine::ecs::types::ComponentTypeId> {
116 std::size_t operator()(const helios::engine::ecs::types::ComponentTypeId& id) const noexcept {
117 return id.value();
118 }
119
120};

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.15.0.