qxLib
components.inl
Go to the documentation of this file.
1 /**
2 
3  @file components.inl
4  @author Khrapov
5  @date 7.03.2021
6  @copyright (c) Nick Khrapov, 2021. All right reserved.
7 
8 **/
9 
10 namespace qx
11 {
12 
13 namespace details
14 {
15 
16 template<class base_component_t, std::derived_from<base_component_t> component_t>
18 {
19  /*
20  | | rtti_base | c1 | base_component_t | c2 | c3 | component_t |
21  | t1 | <=======================================================> |
22  | t2 | <===============================> |
23  | t3 | <====================> |
24  */
25  using t1 = typename component_t::inheritance_tuple_type;
26  using t2 = typename base_component_t::inheritance_tuple_type;
27  using t3 = tuple_utils::remove_t<t1, t2>;
28 
29  using type = t3;
30 };
31 
32 } // namespace details
33 
34 inline component_status_key::component_status_key(priority ePriority, flags<component_status> eStatusFlags) noexcept
35  : time_ordered_priority_key(ePriority)
36  , m_eStatusFlags(eStatusFlags)
37 {
38 }
39 
41 {
42  return m_eStatusFlags;
43 }
44 
45 // flags<component_status> stores a single int; keep passing it by value.
46 constexpr void component_status_key::set_status_flags(flags<component_status> eStatusFlags) noexcept //-V813
47 {
48  m_eStatusFlags = eStatusFlags;
49 }
50 
51 template<std::derived_from<rtti_pure_base> base_component_t>
53  class_id id) noexcept
54 {
55  if (const auto it = derivedClasses.find(id); it != derivedClasses.end())
56  return *it->second.get();
57 
58  auto pClassData = std::make_unique<class_data>();
59  auto pRawClassData = pClassData.get();
60  derivedClasses[id] = std::move(pClassData);
61  return *pRawClassData;
62 }
63 
64 template<std::derived_from<rtti_pure_base> base_component_t>
65 components<base_component_t>& components<base_component_t>::operator=(components&& other) noexcept
66 {
67  if (this != &other)
68  {
69  clear();
70  m_RootClass.derivedClasses.swap(other.m_RootClass.derivedClasses);
71  m_RootClass.components.swap(other.m_RootClass.components);
72  m_RootClass.priorityCache.swap(other.m_RootClass.priorityCache);
73  }
74  return *this;
75 }
76 
77 template<std::derived_from<rtti_pure_base> base_component_t>
78 components<base_component_t>::~components()
79 {
80  clear();
81 }
82 
83 template<std::derived_from<rtti_pure_base> base_component_t>
84 template<std::derived_from<base_component_t> component_t>
86  std::unique_ptr<component_t> pComponent,
87  priority ePriority,
88  flags<component_status> statusFlags) noexcept
89 {
90  if (!pComponent)
91  return nullptr;
92 
93  auto pRawComponent = pComponent.get();
94  class_data& classData = iterate_class_data(
95  pRawComponent,
96  [ePriority, statusFlags, pRawComponent](class_data& classData)
97  {
98  classData.priorityCache.emplace(component_status_key(ePriority, statusFlags), pRawComponent);
99  });
100  classData.components.push_back(std::move(pComponent));
101  return pRawComponent;
102 }
103 
104 template<std::derived_from<rtti_pure_base> base_component_t>
105 std::unique_ptr<base_component_t> components<base_component_t>::remove(const base_component_t* pRawComponent) noexcept
106 {
107  if (!pRawComponent)
108  return nullptr;
109 
110  class_data& classData = iterate_class_data(
111  pRawComponent,
112  [pRawComponent](class_data& classData)
113  {
114  std::erase_if(
115  classData.priorityCache,
116  [pRawComponent](const auto& pair)
117  {
118  return pair.second == pRawComponent;
119  });
120  });
121 
122  const auto it = std::ranges::find_if(
123  classData.components,
124  [pRawComponent](const pointer_type& pointer)
125  {
126  return pointer.get() == pRawComponent;
127  });
128 
129  if (it == classData.components.end())
130  return nullptr;
131 
132  std::unique_ptr<base_component_t> pComponent = std::move(*it);
133  classData.components.erase(it);
134  return pComponent;
135 }
136 
137 template<std::derived_from<rtti_pure_base> base_component_t>
138 template<std::derived_from<base_component_t> component_t>
139 component_t* components<base_component_t>::try_get(bool bIncludeDisabled) noexcept
140 {
141  class_data& classData = get_or_add_class_data<component_t>();
142  const auto it = std::ranges::find_if(
143  classData.priorityCache,
144  [bIncludeDisabled](const auto& pair)
145  {
146  return bIncludeDisabled || !pair.first.get_status_flags().contains(component_status::disabled);
147  });
148 
149  return it != classData.priorityCache.end() ? static_cast<component_t*>(it->second) : nullptr;
150 }
151 
152 template<std::derived_from<rtti_pure_base> base_component_t>
153 template<std::derived_from<base_component_t> component_t>
154 const component_t* components<base_component_t>::try_get(bool bIncludeDisabled) const noexcept
155 {
156  return QX_CONST_CAST_THIS()->template try_get<component_t>(bIncludeDisabled);
157 }
158 
159 template<std::derived_from<rtti_pure_base> base_component_t>
160 template<std::derived_from<base_component_t> component_t>
161 component_t* components<base_component_t>::try_get(class_id id, bool bIncludeDisabled) noexcept
162 {
163  // we could improve it from O(N) to O(log(N)) if we could use id->is_derived_from(id) without an object itself
164  // we will do it when a reflection system is fully implemented
165  const auto it = std::ranges::find_if(
166  m_RootClass.priorityCache,
167  [id, bIncludeDisabled](const auto& pair)
168  {
169  return (bIncludeDisabled || !pair.first.get_status_flags().contains(component_status::disabled))
170  && pair.second->is_derived_from_id(id);
171  });
172 
173  return it != m_RootClass.priorityCache.end() ? rtti_cast<component_t>(it->second) : nullptr;
174 }
175 
176 template<std::derived_from<rtti_pure_base> base_component_t>
177 template<std::derived_from<base_component_t> component_t>
178 const component_t* components<base_component_t>::try_get(class_id id, bool bIncludeDisabled) const noexcept
179 {
180  return QX_CONST_CAST_THIS()->template try_get<component_t>(id, bIncludeDisabled);
181 }
182 
183 template<std::derived_from<rtti_pure_base> base_component_t>
184 template<std::derived_from<base_component_t> component_t>
185 component_t& components<base_component_t>::get(bool bIncludeDisabled) noexcept
186 {
187  return *try_get<component_t>(bIncludeDisabled);
188 }
189 
190 template<std::derived_from<rtti_pure_base> base_component_t>
191 template<std::derived_from<base_component_t> component_t>
192 const component_t& components<base_component_t>::get(bool bIncludeDisabled) const noexcept
193 {
194  return QX_CONST_CAST_THIS()->template get<component_t>(bIncludeDisabled);
195 }
196 
197 template<std::derived_from<rtti_pure_base> base_component_t>
198 template<std::derived_from<base_component_t> component_t>
199 base_component_t& components<base_component_t>::get(class_id id, bool bIncludeDisabled) noexcept
200 {
201  return *try_get<component_t>(id, bIncludeDisabled);
202 }
203 
204 template<std::derived_from<rtti_pure_base> base_component_t>
205 template<std::derived_from<base_component_t> component_t>
206 const base_component_t& components<base_component_t>::get(class_id id, bool bIncludeDisabled) const noexcept
207 {
208  return QX_CONST_CAST_THIS()->template get<component_t>(id, bIncludeDisabled);
209 }
210 
211 template<std::derived_from<rtti_pure_base> base_component_t>
212 template<std::derived_from<base_component_t> component_t>
213 auto components<base_component_t>::view(bool bIncludeDisabled) noexcept
214 {
215  class_data& classData = get_or_add_class_data<component_t>();
216  return classData.priorityCache
217  | std::views::filter(
218  [bIncludeDisabled](const auto& pair)
219  {
220  return pair.second->template is_derived_from<component_t>()
221  && (bIncludeDisabled || !pair.first.get_status_flags().contains(component_status::disabled));
222  })
223  | std::views::transform(
224  [](auto& pair) -> component_t&
225  {
226  return *static_cast<component_t*>(pair.second);
227  });
228 }
229 
230 template<std::derived_from<rtti_pure_base> base_component_t>
231 template<std::derived_from<base_component_t> component_t>
232 auto components<base_component_t>::view(bool bIncludeDisabled) const noexcept
233 {
234  const class_data& classData = get_or_add_class_data<component_t>();
235  return classData.priorityCache
236  | std::views::filter(
237  [bIncludeDisabled](const auto& pair)
238  {
239  return pair.second->template is_derived_from<component_t>()
240  && (bIncludeDisabled || !pair.first.get_status_flags().contains(component_status::disabled));
241  })
242  | std::views::transform(
243  [](const auto& pair) -> const component_t&
244  {
245  return *static_cast<const component_t*>(pair.second);
246  });
247 }
248 
249 template<std::derived_from<rtti_pure_base> base_component_t>
250 std::optional<flags<component_status>> components<base_component_t>::get_component_status(
251  const base_component_t* pRawComponent) const noexcept
252 {
253  std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
254  return optComponentStatus ? std::optional(optComponentStatus->get_status_flags()) : std::nullopt;
255 }
256 
257 template<std::derived_from<rtti_pure_base> base_component_t>
259  const base_component_t* pRawComponent,
260  flags<component_status> newStatus) noexcept
261 {
262  std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
263  if (!optComponentStatus)
264  return false;
265 
266  optComponentStatus->set_status_flags(newStatus);
267  return set_status(pRawComponent, *optComponentStatus);
268 }
269 
270 template<std::derived_from<rtti_pure_base> base_component_t>
272  const base_component_t* pRawComponent,
273  flags<component_status> newStatuses) noexcept
274 {
275  std::optional<flags<component_status>> optComponentStatus = get_component_status(pRawComponent);
276  if (!optComponentStatus)
277  return false;
278 
279  optComponentStatus->add(newStatuses);
280  return set_component_status(pRawComponent, *optComponentStatus);
281 }
282 
283 template<std::derived_from<rtti_pure_base> base_component_t>
285  const base_component_t* pRawComponent,
286  flags<component_status> statusesToRemove) noexcept
287 {
288  std::optional<flags<component_status>> optComponentStatus = get_component_status(pRawComponent);
289  if (!optComponentStatus)
290  return false;
291 
292  optComponentStatus->remove(statusesToRemove);
293  return set_component_status(pRawComponent, *optComponentStatus);
294 }
295 
296 template<std::derived_from<rtti_pure_base> base_component_t>
298  const base_component_t* pRawComponent) const noexcept
299 {
300  std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
301  return optComponentStatus ? std::optional(optComponentStatus->get_priority()) : std::nullopt;
302 }
303 
304 template<std::derived_from<rtti_pure_base> base_component_t>
306  const base_component_t* pRawComponent,
307  priority eNewComponentPriority) noexcept
308 {
309  std::optional<component_status_key> optComponentStatus = get_status(pRawComponent);
310  if (!optComponentStatus)
311  return false;
312 
313  optComponentStatus->set_priority(eNewComponentPriority);
314  return set_status(pRawComponent, *optComponentStatus);
315 }
316 
317 template<std::derived_from<rtti_pure_base> base_component_t>
319 {
320  return m_RootClass.priorityCache.empty();
321 }
322 
323 template<std::derived_from<rtti_pure_base> base_component_t>
325 {
326  while (!m_RootClass.priorityCache.empty())
327  remove(m_RootClass.priorityCache.rbegin()->second);
328 
329  m_RootClass.derivedClasses.clear();
330 }
331 
332 template<std::derived_from<rtti_pure_base> base_component_t>
333 std::optional<component_status_key> components<base_component_t>::get_status(
334  const base_component_t* pRawComponent) const noexcept
335 {
336  if (!pRawComponent)
337  return std::nullopt;
338 
339  auto it = std::ranges::find_if(
340  m_RootClass.priorityCache,
341  [pRawComponent](const auto& pair)
342  {
343  return pair.second == pRawComponent;
344  });
345 
346  return it != m_RootClass.priorityCache.end() ? std::optional<component_status_key>(it->first) : std::nullopt;
347 }
348 
349 
350 template<std::derived_from<rtti_pure_base> base_component_t>
351 bool components<base_component_t>::set_status(
352  const base_component_t* pRawComponent,
353  component_status_key status) noexcept
354 {
355  if (!pRawComponent)
356  return false;
357 
358  bool bChanged = true;
359  iterate_class_data(
360  pRawComponent,
361  [pRawComponent, status, &bChanged](class_data& classData)
362  {
363  const auto it = std::ranges::find_if(
364  classData.priorityCache,
365  [pRawComponent](const auto& pair)
366  {
367  return pair.second == pRawComponent;
368  });
369 
370  if (it == classData.priorityCache.end())
371  {
372  bChanged = false;
373  return;
374  }
375 
376  if (it->first != status)
377  {
378  classData.priorityCache.emplace(status, it->second);
379  classData.priorityCache.erase(it);
380  }
381  });
382 
383  return bChanged;
384 }
385 
386 template<std::derived_from<rtti_pure_base> base_component_t>
387 template<
388  std::derived_from<base_component_t> component_t,
389  callable_c<void, typename components<base_component_t>::class_data&> callable_t>
390 typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
391  callable_t iterateClassDataFunction) noexcept
392 {
393  class_data* pClassData = &m_RootClass;
394  iterateClassDataFunction(*pClassData);
395 
396  tuple_utils::iterate<typename details::get_inheritance_sequence<base_component_t, component_t>::type>(
397  [&pClassData, &iterateClassDataFunction]<class T, size_t I>()
398  {
399  pClassData = &pClassData->get_or_add_class_data(T::get_class_id_static());
400  iterateClassDataFunction(*pClassData);
401  });
402 
403  return *pClassData;
404 }
405 
406 template<std::derived_from<rtti_pure_base> base_component_t>
407 template<
408  std::derived_from<base_component_t> component_t,
409  callable_c<void, typename components<base_component_t>::class_data&> callable_t>
410 const typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
411  callable_t iterateClassDataFunction) const noexcept
412 {
413  return QX_CONST_CAST_THIS()->template iterate_class_data<component_t>(std::move(iterateClassDataFunction));
414 }
415 
416 template<std::derived_from<rtti_pure_base> base_component_t>
417 template<std::derived_from<base_component_t> component_t>
418 typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data() noexcept
419 {
420  class_data* pClassData = &m_RootClass;
421 
422  tuple_utils::iterate<typename details::get_inheritance_sequence<base_component_t, component_t>::type>(
423  [&pClassData]<class T, size_t I>()
424  {
425  pClassData = &pClassData->get_or_add_class_data(T::get_class_id_static());
426  });
427 
428  return *pClassData;
429 }
430 
431 template<std::derived_from<rtti_pure_base> base_component_t>
432 template<std::derived_from<base_component_t> component_t>
433 const typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data()
434  const noexcept
435 {
436  return QX_CONST_CAST_THIS()->template get_or_add_class_data<component_t>();
437 }
438 
439 template<std::derived_from<rtti_pure_base> base_component_t>
440 template<callable_c<void, typename components<base_component_t>::class_data&> callable_t>
441 typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
442  const base_component_t* pRawComponent,
443  callable_t iterateClassDataFunction) noexcept
444 {
445  class_data* pClassData = &m_RootClass;
446  iterateClassDataFunction(*pClassData);
447 
448  std::span<const class_id> allIds = pRawComponent->get_inheritance_sequence();
449  std::span<const class_id> baseClassIds(
450  std::ranges::find(allIds, base_component_t::get_class_id_static()),
451  allIds.end());
452 
453  for (auto it = baseClassIds.begin() + 1; it != baseClassIds.end(); ++it)
454  {
455  pClassData = &pClassData->get_or_add_class_data(*it);
456  iterateClassDataFunction(*pClassData);
457  }
458 
459  return *pClassData;
460 }
461 
462 template<std::derived_from<rtti_pure_base> base_component_t>
463 template<callable_c<void, typename components<base_component_t>::class_data&> callable_t>
464 const typename components<base_component_t>::class_data& components<base_component_t>::iterate_class_data(
465  const base_component_t* pRawComponent,
466  callable_t iterateClassDataFunction) const noexcept
467 {
468  return QX_CONST_CAST_THIS()->iterate_class_data(pRawComponent, std::move(iterateClassDataFunction));
469 }
470 
471 template<std::derived_from<rtti_pure_base> base_component_t>
472 typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data(
473  const base_component_t* pRawComponent) noexcept
474 {
475  class_data* pClassData = &m_RootClass;
476 
477  std::span<const class_id> allIds = pRawComponent->get_inheritance_sequence();
478  std::span<const class_id> baseClassIds(
479  std::ranges::find(allIds, base_component_t::get_class_id_static()),
480  allIds.end());
481 
482  for (auto it = baseClassIds.begin() + 1; it != baseClassIds.end(); ++it)
483  pClassData = &pClassData->get_or_add_class_data(*it);
484 
485  return *pClassData;
486 }
487 
488 template<std::derived_from<rtti_pure_base> base_component_t>
489 const typename components<base_component_t>::class_data& components<base_component_t>::get_or_add_class_data(
490  const base_component_t* pRawComponent) const noexcept
491 {
492  return QX_CONST_CAST_THIS()->get_or_add_class_data(pRawComponent);
493 }
494 
495 } // namespace qx
Class id, unique for each class using qx rtti system.
Definition: class_id.h:27
A class that acts like time_ordered_priority_key but has a status field.
Definition: components.h:40
constexpr void set_status_flags(flags< component_status > eStatusFlags) noexcept
Set object status.
Definition: components.inl:46
constexpr flags< component_status > get_status_flags() const noexcept
Get object status.
Definition: components.inl:40
Container for components system.
Definition: components.h:85
component_t & get(bool bIncludeDisabled=false) noexcept
Get a component of the given type with the highest priority (no existence checks are performed)
Definition: components.inl:185
std::unique_ptr< base_component_t > remove(const base_component_t *pRawComponent) noexcept
Remove the component from the container.
Definition: components.inl:105
bool add_component_status(const base_component_t *pRawComponent, flags< component_status > newStatuses) noexcept
Add new component status flags to the current ones.
Definition: components.inl:271
bool set_component_priority(const base_component_t *pRawComponent, priority eNewComponentPriority) noexcept
Set component priority.
Definition: components.inl:305
void clear() noexcept
Clear the container and destroy its components.
Definition: components.inl:324
component_t * try_get(bool bIncludeDisabled=false) noexcept
Try to get a component of the given type with the highest priority.
Definition: components.inl:139
bool set_component_status(const base_component_t *pRawComponent, flags< component_status > newStatus) noexcept
Set (override) a component status.
Definition: components.inl:258
bool empty() const noexcept
Check if container doesn't have any components.
Definition: components.inl:318
auto view(bool bIncludeDisabled=false) noexcept
Get a view which may be used in a ranged-based for loop and consists of components of a given type wi...
Definition: components.inl:213
bool remove_component_status(const base_component_t *pRawComponent, flags< component_status > statusesToRemove) noexcept
Add component status flags from the current ones.
Definition: components.inl:284
component_t * add(std::unique_ptr< component_t > pComponent, priority ePriority=priority::normal, flags< component_status > statusFlags=component_status::default_value) noexcept
Add a component.
Definition: components.inl:85
std::optional< flags< component_status > > get_component_status(const base_component_t *pRawComponent) const noexcept
Get component status.
Definition: components.inl:250
std::optional< priority > get_component_priority(const base_component_t *pRawComponent) const noexcept
Get component priority.
Definition: components.inl:297
A class that can be used as a key in ordered containers so that items are ordered in descending order...
Definition: priority.h:50
#define QX_CONST_CAST_THIS()
This macro is made for situations where you have a const method, and you need exactly the same method...
Definition: common.h:63
priority
User may use the predefined values or the custom ones, for ex. "normal - 1", this type is supposed to...
Definition: priority.h:30