Skip to main content

HandleMultiMap.ixx File

Dense 1:N association map between two handle types. More...

Included Headers​

#include <vector> #include <span> #include <cassert> #include <concepts> #include <iterator> #include <cstddef> #include <helios.ecs.types.EntityHandle>

Namespaces Index​

namespacehelios
namespaceengine
namespacecore
namespacecontainer

Classes Index​

classHandleMultiMap<TOneHandle, TManyHandle>

Stores a one-to-many relation between handle domains. More...

structBinding

Represents one valid binding of the one-to-many relation. More...

classConstIterator

Forward iterator over dense bindings. More...

Description​

Dense 1:N association map between two handle types.

File Listing​

The file content with the documentation metadata removed is:

1
5module;
6
7#include <vector>
8#include <span>
9#include <cassert>
10#include <concepts>
11#include <iterator>
12#include <cstddef>
13
14export module helios.engine.core.container.HandleMultiMap;
15
16import helios.ecs.types.EntityHandle;
17
18using namespace helios::ecs;
19export namespace helios::engine::core::container {
20
34 template <typename TOneHandle, typename TManyHandle>
35 class HandleMultiMap {
36
40 std::vector<std::vector<TManyHandle>> values_;
41
45 std::vector<TOneHandle> keys_;
46
52 std::vector<TManyHandle> denseValues_;
53
54 public:
55
59 struct Binding {
61 TOneHandle key;
63 TManyHandle value;
64 };
65
69 class ConstIterator {
70 const HandleMultiMap* map_;
71 std::size_t current_idx_;
72
73 public:
74 using iterator_category = std::forward_iterator_tag;
75 using value_type = Binding;
76 using difference_type = std::ptrdiff_t;
77 using pointer = void;
78 using reference = value_type; // By-Value Return
79
86 ConstIterator(const HandleMultiMap* map, std::size_t start_idx) noexcept
87 : map_(map), current_idx_(start_idx) {}
88
90 [[nodiscard]] reference operator*() const noexcept {
91 assert(current_idx_ < map_->denseValues_.size());
92
93 const auto value = map_->denseValues_[current_idx_];
94 const auto valueIdx = value.entityId;
95
96 assert(valueIdx < map_->keys_.size());
97 assert(map_->keys_[valueIdx].isValid());
98
99 return Binding{
100 map_->keys_[valueIdx],
101 value
102 };
103 }
104
106 ConstIterator& operator++() noexcept {
107 current_idx_++;
108 return *this;
109 }
110
112 ConstIterator operator++(int) noexcept {
113 ConstIterator tmp = *this;
114 ++(*this);
115 return tmp;
116 }
117
119 [[nodiscard]] bool operator==(const ConstIterator& other) const noexcept {
120 return current_idx_ == other.current_idx_
121 && map_ == other.map_;
122 }
123
125 [[nodiscard]] bool operator!=(const ConstIterator& other) const noexcept {
126 return !(*this == other);
127 }
128 };
129
131 [[nodiscard]] ConstIterator begin() const noexcept {
132 return ConstIterator(this, 0);
133 }
134
136 [[nodiscard]] ConstIterator end() const noexcept {
137 return ConstIterator(this, denseValues_.size());
138 }
139
149 template<typename TOneEntity, typename TManyEntity>
150 requires std::same_as<TOneHandle, typename TOneEntity::Handle_type> && std::same_as<TManyHandle, typename TManyEntity::Handle_type>
151 bool bind(TOneEntity oneEntity, TManyEntity manyEntity) {
152 return bind(oneEntity.handle(), manyEntity.handle());
153 }
154
166 bool bind(const TOneHandle key, const TManyHandle value) {
167
168 const auto keyIdx = key.entityId;
169 const auto valueIdx = value.entityId;
170
171 // assert that the value was not already registered.
172 if (valueIdx < keys_.size()
173 && keys_[valueIdx].isValid()) {
174 assert(false && "Value already exists");
175 return false;
176 }
177
178 // one idx to many handles
179 if (values_.size() <= keyIdx) {
180 values_.resize(keyIdx + 1);
181 }
182 values_[keyIdx].push_back(value);
183
184 // many idx to one handles
185 if (keys_.size() <= valueIdx) {
186 keys_.resize(valueIdx + 1);
187 }
188 keys_[valueIdx] = key;
189
190 // dense value iteration
191 denseValues_.push_back(value);
192
193 return true;
194 }
195
203 [[nodiscard]] TOneHandle key(const TManyHandle value) const noexcept {
204 const auto valueIdx = value.entityId;
205
206 if (keys_.size() <= valueIdx) {
207 return TOneHandle{};
208 }
209
210 return keys_[valueIdx];
211 }
212
220 [[nodiscard]] std::span<const TManyHandle> values(const TOneHandle key) const noexcept {
221
222 const auto keyIdx = key.entityId;
223
224 if (values_.size() <= keyIdx) {
225 return {};
226 }
227
228 return values_[keyIdx];
229 }
230
232 void clear() {
233 values_.clear();
234 keys_.clear();
235 denseValues_.clear();
236 }
237
244 void reserve(std::size_t keyCapacity, std::size_t valueCapacity) {
245 keys_.reserve(valueCapacity);
246 values_.reserve(keyCapacity);
247 denseValues_.reserve(valueCapacity);
248 }
249
250 };
251
252}

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.