qxLib
rtti.h
Go to the documentation of this file.
1 /**
2 
3  @file rtti.h
4  @brief RTTI system based on polymorphism
5  @details Using qx::rtti_root and QX_RTTI_CLASS
6  will let you to use RTTI advantages without enabling
7  RTTI in compiler's flags
8  common logic is taken from
9  https://github.com/qualab/xakep-RTTI (Vladimir Kerimov, qualab)
10  @author Khrapov
11  @date 24.08.2020
12  @copyright © Nick Khrapov, 2021. All right reserved.
13 
14 **/
15 #pragma once
16 
17 #include <qx/containers/string/string_hash.h>
18 #include <qx/meta/tuple_utils.h>
19 #include <qx/meta/type_strings.h>
20 #include <qx/rtti/class_identificator.h>
21 #include <qx/rtti/rtti_naming_strategy.h>
22 
23 #include <array>
24 #include <span>
25 
26 namespace qx
27 {
28 
29 // utility class to let you use std::derived_from
30 class rtti_pure_base
31 {
32 public:
33  auto operator<=>(const rtti_pure_base&) const = default;
34 };
35 
36 /**
37 
38  @class rtti_root
39  @brief RTTI root class
40  @details All other classes must be inherited from this class
41  to allow you to use RTTI functions
42  @tparam naming_strategy_t - \see rtti_naming_strategy.h
43  @author Khrapov
44  @date 10.09.2021
45 
46 **/
47 template<class naming_strategy_t = rtti_naming_strategy_class_name>
48 class rtti_root : public rtti_pure_base
49 {
50 public:
51  using base_class_type = rtti_root;
52  using super_class_type = rtti_root;
53  using this_class_type = rtti_root;
54  using inheritance_tuple = std::tuple<this_class_type>;
55  using naming_strategy_type = naming_strategy_t;
56 
57 public:
58  rtti_root() noexcept = default;
59  rtti_root(const rtti_root&) noexcept = default;
60  rtti_root(rtti_root&&) noexcept = default;
61 
62  template<class T>
63  bool is_derived_from() const noexcept
64  {
65  constexpr class_identificator T_id = T::get_class_id_static();
66  return _is_base_id(T_id) || T_id == get_class_id();
67  }
68 
69  template<class T>
70  bool is() const noexcept
71  {
72  return get_class_id() == T::get_class_id_static();
73  }
74 
75  bool is(string_view svClassName) const noexcept
76  {
77  return svClassName == get_class_name();
78  }
79 
80  bool is(class_identificator id) const noexcept
81  {
82  return id == get_class_id();
83  }
84 
85  virtual bool is_derived_from_id(class_identificator id) const noexcept
86  {
87  return id == get_class_id_static();
88  }
89 
90  static constexpr string_view get_class_name_static() noexcept
91  {
92  return naming_strategy_type::get_name(type_strings<this_class_type>::get_signature());
93  }
94 
95  virtual string_view get_class_name() const noexcept
96  {
97  return get_class_name_static();
98  }
99 
100  static constexpr class_identificator get_class_id_static() noexcept
101  {
102  return cstring_hash(type_strings<this_class_type, char>::get_signature());
103  }
104 
105  virtual class_identificator get_class_id() const noexcept
106  {
107  return get_class_id_static();
108  }
109 
110  virtual std::span<const class_identificator> get_inheritance_sequence() const = 0;
111 
112  auto operator<=>(const rtti_root&) const = default;
113 
114 protected:
115  virtual ~rtti_root() noexcept = default;
116 
117  virtual bool _is_base_id(class_identificator idBase) const noexcept
118  {
119  return idBase == get_class_id_static();
120  }
121 };
122 
123 /**
124  @def QX_RTTI_CLASS
125  @brief Macro for every class inherited from class with QX_RTTI_BASE_CLASS macro
126  @param thisClass - this class name
127  @param ... - super class name (must implement QX_RTTI_CLASS or QX_RTTI_BASE_CLASS macro)
128 **/
129 #define QX_RTTI_CLASS(thisClass, ...) \
130  \
131 public: \
132  using this_class_type = thisClass; \
133  using super_class_type = __VA_ARGS__; \
134  using base_class_type = typename super_class_type::base_class_type; \
135  using inheritance_tuple = qx::tuple::join_t<typename super_class_type::inheritance_tuple, this_class_type>; \
136  \
137 public: \
138  virtual bool is_derived_from_id(qx::class_identificator id) const noexcept override \
139  { \
140  return id == get_class_id_static() || super_class_type::is_derived_from_id(id); \
141  } \
142  static constexpr qx::string_view get_class_name_static() noexcept \
143  { \
144  return naming_strategy_type::get_name(qx::type_strings<this_class_type>::get_signature()); \
145  } \
146  virtual qx::class_identificator get_class_id() const noexcept override \
147  { \
148  return get_class_id_static(); \
149  } \
150  static constexpr qx::class_identificator get_class_id_static() noexcept \
151  { \
152  return qx::cstring_hash(qx::type_strings<this_class_type, char>::get_signature()); \
153  } \
154  virtual qx::string_view get_class_name() const noexcept override \
155  { \
156  return get_class_name_static(); \
157  } \
158  virtual std::span<const qx::class_identificator> get_inheritance_sequence() const override \
159  { \
160  static constexpr auto ids = []() \
161  { \
162  std::array<qx::class_identificator, std::tuple_size_v<inheritance_tuple>> ids_; \
163  qx::tuple::iterate<inheritance_tuple>( \
164  [&ids_]<class T, size_t I>() \
165  { \
166  ids_[I] = T::get_class_id_static(); \
167  }); \
168  return ids_; \
169  }(); \
170  return ids; \
171  } \
172  \
173 protected: \
174  virtual bool _is_base_id(qx::class_identificator base_id) const noexcept override \
175  { \
176  return base_id == super_class_type::get_class_id_static() || super_class_type::_is_base_id(base_id); \
177  } \
178  \
179 private:
180 
181 } // namespace qx
class_identificator.h
qx::basic_string_hash
String hash object.
Definition: string_hash.h:38
qx::rtti_pure_base
Definition: rtti.h:31
qx::rtti_root
RTTI root class.
Definition: rtti.h:49
qx::type_strings
The class allows you to get strings with information about the type, including its full name,...
Definition: type_strings.h:35
rtti_naming_strategy.h
Contains naming strategies for qx::rtti_root class.
string_hash.h
tuple_utils.h
Contains utils for working with std::tuple.
type_strings.h
Generated by doxygen 1.9.1