Sen API
Sen Libraries
Loading...
Searching...
No Matches
gen.h
Go to the documentation of this file.
1// === gen.h ===========================================================================================================
2// Sen Infrastructure
3// Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
4// See the LICENSE.txt file for more information.
5// © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
6// =====================================================================================================================
7
8#ifndef SEN_CORE_OBJ_DETAIL_GEN_H
9#define SEN_CORE_OBJ_DETAIL_GEN_H
10
11// sen
12#include "sen/core/base/compiler_macros.h"
13#include "sen/core/base/numbers.h"
14#include "sen/core/base/quantity.h"
15#include "sen/core/base/span.h"
16#include "sen/core/base/static_vector.h"
17#include "sen/core/io/util.h"
18#include "sen/core/lang/vm.h"
19#include "sen/core/meta/class_type.h"
20#include "sen/core/meta/enum_traits.h"
21#include "sen/core/meta/enum_type.h"
22#include "sen/core/meta/native_types.h"
23#include "sen/core/meta/optional_traits.h"
24#include "sen/core/meta/quantity_traits.h"
25#include "sen/core/meta/quantity_type.h"
26#include "sen/core/meta/sequence_traits.h"
27#include "sen/core/meta/sequence_type.h"
28#include "sen/core/meta/struct_traits.h"
29#include "sen/core/meta/struct_type.h"
30#include "sen/core/meta/time_types.h"
31#include "sen/core/meta/unit_registry.h"
32#include "sen/core/meta/variant_traits.h"
33#include "sen/core/meta/variant_type.h"
34#include "sen/core/obj/detail/event_buffer.h"
35#include "sen/core/obj/detail/native_object_proxy.h"
36#include "sen/core/obj/detail/property_flags.h"
37#include "sen/core/obj/detail/remote_object.h"
38#include "sen/core/obj/native_object.h"
39
40// std
41#include <optional>
42
43#define SEN_IMPL_GEN_NATIVE_MEMBERS \
44protected: \
45 [[nodiscard]] inline ::sen::Var senImplGetPropertyImpl(::sen::MemberHash propertyId) const override; \
46 inline void senImplSetNextPropertyUntyped(::sen::MemberHash propertyId, const ::sen::Var& value) override; \
47 [[nodiscard]] inline ::sen::Var senImplGetNextPropertyUntyped(::sen::MemberHash propertyId) const override; \
48 [[nodiscard]] inline uint32_t senImplComputeMaxReliableSerializedPropertySizeImpl() const override; \
49 inline void senImplStreamCall(::sen::MemberHash methodId, ::sen::InputStream& in, ::sen::StreamCallForwarder&& func) \
50 override; \
51 inline void senImplVariantCall( \
52 ::sen::MemberHash methodId, const ::sen::VarList& args, ::sen::VariantCallForwarder&& func) override; \
53 inline void senImplCommitImpl(::sen::TimeStamp time) override; \
54 inline void senImplWriteChangedPropertiesToStream( \
55 ::sen::OutputStream& confirmed, ::sen::impl::BufferProvider uni, ::sen::impl::BufferProvider multi) override; \
56 inline void senImplWriteAllPropertiesToStream(::sen::OutputStream& out) const override; \
57 inline void senImplWriteStaticPropertiesToStream(::sen::OutputStream& out) const override; \
58 inline void senImplWriteDynamicPropertiesToStream(::sen::OutputStream& out) const override; \
59 inline void senImplRemoveTypedConnection(::sen::ConnId id) override; \
60 [[nodiscard]] inline ::sen::impl::FieldValueGetter senImplGetFieldValueGetter( \
61 ::sen::MemberHash propertyId, ::sen::Span<uint16_t> fields) const override; \
62 inline void invokeAllPropertyCallbacks() override;
63
65#define SEN_IMPL_GEN_BASE_CLASS(classname) \
66 SEN_IMPL_GEN_NATIVE_MEMBERS \
67 \
68private: \
69 bool somePropertyIsDirty_ = false; \
70 \
71public: \
72 inline classname(std::string name, const ::sen::VarMap& args); \
73 ~classname() override = default; \
74 [[nodiscard]] inline ::sen::ConstTypeHandle<::sen::ClassType> getClass() const noexcept override; \
75 [[nodiscard]] static inline ::sen::ConstTypeHandle<::sen::ClassType> meta() noexcept; \
76 \
77private:
78
80#define SEN_IMPL_GEN_REMOTE_CLASS(classname) \
81public: \
82 explicit classname(::sen::impl::RemoteObjectInfo&& info); \
83 ~classname() override = default; \
84 \
85protected: \
86 void senImplRemoveTypedConnection(::sen::ConnId id) override; \
87 void senImplWriteAllPropertiesToStream(::sen::OutputStream& out) const override; \
88 void senImplWriteStaticPropertiesToStream(::sen::OutputStream& out) const override; \
89 void senImplWriteDynamicPropertiesToStream(::sen::OutputStream& out) const override; \
90 [[nodiscard]] ::sen::Var senImplGetPropertyImpl(::sen::MemberHash propertyId) const override; \
91 [[nodiscard]] bool readPropertyFromStream(::sen::MemberHash id, ::sen::InputStream& in, bool initialState) override; \
92 [[nodiscard]] ::sen::Var deserializeMethodReturnValueAsVariant(::sen::MemberHash methodId, ::sen::InputStream& in) \
93 const override; \
94 void serializeMethodArgumentsFromVariants( \
95 ::sen::MemberHash methodId, const ::sen::VarList& args, ::sen::OutputStream& out) const override; \
96 void drainInputs() override; \
97 void eventReceived(::sen::MemberHash eventId, ::sen::TimeStamp creationTime, const ::sen::Span<const uint8_t>& args) \
98 override; \
99 void invokeAllPropertyCallbacks() override; \
100 \
101private:
102
104#define SEN_IMPL_GEN_LOCAL_PROXY_CLASS(classname) \
105public: \
106 explicit classname(::sen::NativeObject* owner, const std::string& localPrefix); \
107 ~classname() override = default; \
108 \
109protected: \
110 void senImplWriteAllPropertiesToStream(::sen::OutputStream& out) const override; \
111 void senImplWriteStaticPropertiesToStream(::sen::OutputStream& out) const override; \
112 void senImplWriteDynamicPropertiesToStream(::sen::OutputStream& out) const override; \
113 void senImplRemoveTypedConnection(::sen::ConnId id) override; \
114 [[nodiscard]] ::sen::Var senImplGetPropertyImpl(::sen::MemberHash propertyId) const override; \
115 void drainInputsImpl(::sen::TimeStamp lastCommitTime) override; \
116 \
117private:
118
120#define SEN_IMPL_GEN_UNBOUNDED_SEQUENCE(classname, elementtype) \
121 struct classname final: public std::vector<elementtype> \
122 { \
123 using Parent = std::vector<elementtype>; \
124 using Parent::Parent; \
125 using Parent::operator=; \
126 };
127
129#define SEN_IMPL_GEN_BOUNDED_SEQUENCE(classname, element, maxSize) \
130 struct classname final: public ::sen::StaticVector<element, maxSize> \
131 { \
132 using Parent = ::sen::StaticVector<element, maxSize>; \
133 using Parent::Parent; \
134 using Parent::operator=; \
135 };
136
138#define SEN_IMPL_GEN_FIXED_SEQUENCE(classname, element, size) \
139 struct classname final: public std::array<element, size> \
140 { \
141 using Parent = std::array<element, size>; \
142 using Parent::Parent; \
143 using Parent::operator=; \
144 \
145 template <typename Y, typename = std::enable_if_t<std::is_convertible_v<Y, element>, int>> \
146 classname(std::initializer_list<Y> elems): Parent() \
147 { \
148 std::size_t i = 0; \
149 for (auto itr = elems.begin(); itr != elems.end() && i < size; \
150 ++itr) /* NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic) */ \
151 { \
152 (*this)[i] = *itr; /* NOLINT(cppcoreguidelines-pro-bounds-constant-array-index) */ \
153 ++i; \
154 } \
155 } \
156 };
157
159#define SEN_IMPL_GEN_STRUCT_OPERATORS(classname, doExport) \
160 SEN_MAYBE_EXPORT(doExport) std::ostream& operator<<(std::ostream& out, const classname& val); \
161 SEN_MAYBE_EXPORT(doExport) bool operator==(const classname& lhs, const classname& rhs); \
162 SEN_MAYBE_EXPORT(doExport) bool operator!=(const classname& lhs, const classname& rhs);
163
165#define SEN_IMPL_GEN_OPTIONAL(classname, elementtype, doExport) \
166 struct classname final: public std::optional<elementtype> \
167 { \
168 using Parent = std::optional<elementtype>; \
169 using Parent::Parent; \
170 using Parent::operator=; \
171 using Parent::operator->; \
172 using Parent::operator*; \
173 using Parent::operator bool; \
174 }; \
175 \
176 SEN_MAYBE_EXPORT(doExport) bool operator==(const classname& lhs, const classname& rhs); \
177 SEN_MAYBE_EXPORT(doExport) bool operator!=(const classname& lhs, const classname& rhs);
178
180#define SEN_IMPL_GEN_OPTIONAL_TRAITS(classname, doExport) \
181 template <> \
182 struct MetaTypeTrait<classname> \
183 { \
184 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<OptionalType> meta(); \
185 }; \
186 template <> \
187 struct VariantTraits<classname>: private OptionalTraitsBase<classname> \
188 { \
189 using OptionalTraitsBase<classname>::valueToVariant; \
190 using OptionalTraitsBase<classname>::variantToValue; \
191 }; \
192 template <> \
193 struct SerializationTraits<classname>: private OptionalTraitsBase<classname> \
194 { \
195 using OptionalTraitsBase<classname>::write; \
196 using OptionalTraitsBase<classname>::read; \
197 using OptionalTraitsBase<classname>::serializedSize; \
198 };
199
201#define SEN_IMPL_GEN_ENUM_TRAITS(classname, doExport) \
202 template <> \
203 struct MetaTypeTrait<classname> \
204 { \
205 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<EnumType> meta(); \
206 }; \
207 template <> \
208 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private EnumTraitsBase<classname> \
209 { \
210 using EnumTraitsBase<classname>::valueToVariant; \
211 using EnumTraitsBase<classname>::variantToValue; \
212 }; \
213 template <> \
214 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private EnumTraitsBase<classname> \
215 { \
216 using EnumTraitsBase<classname>::write; \
217 using EnumTraitsBase<classname>::read; \
218 using EnumTraitsBase<classname>::serializedSize; \
219 }; \
220 template <> \
221 struct SEN_MAYBE_EXPORT(doExport) StringConversionTraits<classname> \
222 { \
223 [[nodiscard]] static std::string_view toString(classname val); \
224 [[nodiscard]] static classname fromString(std::string_view val); \
225 }; \
226 \
227 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) std::string_view toString(classname value);
228
230#define SEN_IMPL_GEN_SEQUENCE_TRAITS(classname, doExport) \
231 template <> \
232 struct MetaTypeTrait<classname> \
233 { \
234 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static sen::ConstTypeHandle<SequenceType> meta(); \
235 }; \
236 template <> \
237 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private SequenceTraitsBase<classname> \
238 { \
239 using SequenceTraitsBase<classname>::valueToVariant; \
240 using SequenceTraitsBase<classname>::variantToValue; \
241 }; \
242 template <> \
243 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private SequenceTraitsBase<classname> \
244 { \
245 using SequenceTraitsBase<classname>::write; \
246 using SequenceTraitsBase<classname>::read; \
247 using SequenceTraitsBase<classname>::serializedSize; \
248 };
249
251#define SEN_IMPL_GEN_ARRAY_TRAITS(classname, doExport) \
252 template <> \
253 struct MetaTypeTrait<classname> \
254 { \
255 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<SequenceType> meta(); \
256 }; \
257 template <> \
258 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private ArrayTraitsBase<classname> \
259 { \
260 using ArrayTraitsBase<classname>::valueToVariant; \
261 using ArrayTraitsBase<classname>::variantToValue; \
262 }; \
263 template <> \
264 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private ArrayTraitsBase<classname> \
265 { \
266 using ArrayTraitsBase<classname>::write; \
267 using ArrayTraitsBase<classname>::read; \
268 using ArrayTraitsBase<classname>::serializedSize; \
269 };
270
272#define SEN_IMPL_GEN_STRUCT_TRAITS(classname, doExport) \
273 template <> \
274 struct MetaTypeTrait<classname> \
275 { \
276 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<StructType> meta(); \
277 }; \
278 template <> \
279 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: protected StructTraitsBase \
280 { \
281 static void valueToVariant(const classname& val, Var& var); \
282 static void variantToValue(const Var& var, classname& val); \
283 static std::function<lang::Value(const void*)> getFieldValueGetterFunction(Span<uint16_t> fields); \
284 }; \
285 template <> \
286 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: protected StructTraitsBase \
287 { \
288 static void write(OutputStream& out, const classname& val); \
289 static void read(InputStream& in, classname& val); \
290 [[nodiscard]] static uint32_t serializedSize(const classname& val) noexcept; \
291 };
292
294#define SEN_IMPL_GEN_VARIANT_TRAITS(classname, doExport) \
295 template <> \
296 struct SEN_MAYBE_EXPORT(doExport) MetaTypeTrait<classname> \
297 { \
298 [[nodiscard]] static ConstTypeHandle<VariantType> meta(); \
299 }; \
300 template <> \
301 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: protected VariantTraitsBase<classname> \
302 { \
303 static void valueToVariant(const classname& val, Var& var); \
304 static void variantToValue(const Var& var, classname& val); \
305 static std::function<lang::Value(const void*)> getFieldValueGetterFunction(Span<uint16_t> fields); \
306 using VariantTraitsBase<classname>::tryPrintField; \
307 }; \
308 template <> \
309 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: protected VariantTraitsBase<classname> \
310 { \
311 static void write(OutputStream& out, const classname& val); \
312 static void read(InputStream& in, classname& val); \
313 [[nodiscard]] static uint32_t serializedSize(const classname& val) noexcept; \
314 };
315
317#define SEN_IMPL_GEN_CLASS_META_TRAITS(classname, doExport) \
318 template <> \
319 struct MetaTypeTrait<classname> \
320 { \
321 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<ClassType> meta(); \
322 };
323
325#define SEN_IMPL_GEN_CLASS_TRAITS_TEMPLATE(interfaceName, remoteProxy, localProxy, baseName) \
326 template <> \
327 struct SenClassRelation<interfaceName> \
328 { \
329 using InterfaceType = interfaceName; \
330 template <typename T> \
331 using BaseType = baseName<T>; \
332 static constexpr bool isBaseTypeTemplate = true; \
333 using RemoteProxyType = remoteProxy; \
334 using LocalProxyType = localProxy; \
335 }; \
336 template <> \
337 struct SenClassRelation<remoteProxy> \
338 { \
339 using InterfaceType = interfaceName; \
340 template <typename T> \
341 using BaseType = baseName<T>; \
342 static constexpr bool isBaseTypeTemplate = true; \
343 using RemoteProxyType = remoteProxy; \
344 using LocalProxyType = localProxy; \
345 }; \
346 template <> \
347 struct SenClassRelation<localProxy> \
348 { \
349 using InterfaceType = interfaceName; \
350 template <typename T> \
351 using BaseType = baseName<T>; \
352 static constexpr bool isBaseTypeTemplate = true; \
353 using RemoteProxyType = remoteProxy; \
354 using LocalProxyType = localProxy; \
355 }; \
356 template <typename T> \
357 struct SenClassRelation<baseName<T>> \
358 { \
359 using InterfaceType = interfaceName; \
360 template <typename U> \
361 using BaseType = baseName<U>; \
362 static constexpr bool isBaseTypeTemplate = true; \
363 using RemoteProxyType = remoteProxy; \
364 using LocalProxyType = localProxy; \
365 };
366
368#define SEN_IMPL_GEN_CLASS_TRAITS_NORMAL(interfaceName, remoteProxy, localProxy, baseName) \
369 template <> \
370 struct SenClassRelation<interfaceName> \
371 { \
372 using InterfaceType = interfaceName; \
373 using BaseType = baseName; \
374 static constexpr bool isBaseTypeTemplate = false; \
375 using RemoteProxyType = remoteProxy; \
376 using LocalProxyType = localProxy; \
377 }; \
378 template <> \
379 struct SenClassRelation<remoteProxy> \
380 { \
381 using InterfaceType = interfaceName; \
382 using BaseType = baseName; \
383 static constexpr bool isBaseTypeTemplate = false; \
384 using RemoteProxyType = remoteProxy; \
385 using LocalProxyType = localProxy; \
386 }; \
387 template <> \
388 struct SenClassRelation<localProxy> \
389 { \
390 using InterfaceType = interfaceName; \
391 using BaseType = baseName; \
392 static constexpr bool isBaseTypeTemplate = false; \
393 using RemoteProxyType = remoteProxy; \
394 using LocalProxyType = localProxy; \
395 }; \
396 template <> \
397 struct SenClassRelation<baseName> \
398 { \
399 using InterfaceType = interfaceName; \
400 using BaseType = baseName; \
401 static constexpr bool isBaseTypeTemplate = false; \
402 using RemoteProxyType = remoteProxy; \
403 using LocalProxyType = localProxy; \
404 };
405
407#define SEN_IMPL_GEN_QUANTITY_TRAITS(classname, maxVal, minVal, doExport) \
408 template <> \
409 struct MetaTypeTrait<classname> \
410 { \
411 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<QuantityType> meta(); \
412 }; \
413 template <> \
414 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private QuantityTraitsBase<classname> \
415 { \
416 using QuantityTraitsBase<classname>::valueToVariant; \
417 using QuantityTraitsBase<classname>::variantToValue; \
418 }; \
419 template <> \
420 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private QuantityTraitsBase<classname> \
421 { \
422 using QuantityTraitsBase<classname>::write; \
423 using QuantityTraitsBase<classname>::read; \
424 using QuantityTraitsBase<classname>::serializedSize; \
425 }; \
426 template <> \
427 struct SEN_MAYBE_EXPORT(doExport) QuantityTraits<classname> \
428 { \
429 using ValueType = typename classname::ValueType; \
430 \
431 static constexpr ValueType max = maxVal; \
432 static constexpr ValueType min = minVal; \
433 \
434 [[nodiscard]] static ::std::optional<const sen::Unit*> unit() noexcept; \
435 [[nodiscard]] static const sen::Unit& unit(sen::Unit::EnsureTag); \
436 };
437
438#endif // SEN_CORE_OBJ_DETAIL_GEN_H
class_type.h
compiler_macros.h
enum_traits.h
enum_type.h
event_buffer.h
native_object.h
native_object_proxy.h
native_types.h
optional_traits.h
property_flags.h
quantity_traits.h
quantity_type.h
remote_object.h
sequence_traits.h
sequence_type.h
static_vector.h
struct_traits.h
struct_type.h
time_types.h
unit_registry.h
variant_traits.h
variant_type.h