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 \
64private: \
65 bool somePropertyIsDirty_ = false;
66
68#define SEN_IMPL_GEN_BASE_CLASS(classname) \
69 SEN_IMPL_GEN_NATIVE_MEMBERS \
70public: \
71 inline classname(std::string name, const ::sen::VarMap& args); \
72 ~classname() override = default; \
73 [[nodiscard]] inline ::sen::ConstTypeHandle<::sen::ClassType> getClass() const noexcept override; \
74 [[nodiscard]] static inline ::sen::ConstTypeHandle<::sen::ClassType> meta() noexcept; \
75 \
76private:
77
79#define SEN_IMPL_GEN_REMOTE_CLASS(classname) \
80public: \
81 explicit classname(::sen::impl::RemoteObjectInfo&& info); \
82 ~classname() override = default; \
83 \
84protected: \
85 void senImplRemoveTypedConnection(::sen::ConnId id) override; \
86 void senImplWriteAllPropertiesToStream(::sen::OutputStream& out) const override; \
87 void senImplWriteStaticPropertiesToStream(::sen::OutputStream& out) const override; \
88 void senImplWriteDynamicPropertiesToStream(::sen::OutputStream& out) const override; \
89 [[nodiscard]] ::sen::Var senImplGetPropertyImpl(::sen::MemberHash propertyId) const override; \
90 [[nodiscard]] bool readPropertyFromStream(::sen::MemberHash id, ::sen::InputStream& in, bool initialState) override; \
91 [[nodiscard]] ::sen::Var deserializeMethodReturnValueAsVariant(::sen::MemberHash methodId, ::sen::InputStream& in) \
92 const override; \
93 void serializeMethodArgumentsFromVariants( \
94 ::sen::MemberHash methodId, const ::sen::VarList& args, ::sen::OutputStream& out) const override; \
95 void drainInputs() override; \
96 void eventReceived(::sen::MemberHash eventId, ::sen::TimeStamp creationTime, const ::sen::Span<const uint8_t>& args) \
97 override; \
98 void invokeAllPropertyCallbacks() override; \
99 \
100private:
101
103#define SEN_IMPL_GEN_LOCAL_PROXY_CLASS(classname) \
104public: \
105 explicit classname(::sen::NativeObject* owner, const std::string& localPrefix); \
106 ~classname() override = default; \
107 \
108protected: \
109 void senImplWriteAllPropertiesToStream(::sen::OutputStream& out) const override; \
110 void senImplWriteStaticPropertiesToStream(::sen::OutputStream& out) const override; \
111 void senImplWriteDynamicPropertiesToStream(::sen::OutputStream& out) const override; \
112 void senImplRemoveTypedConnection(::sen::ConnId id) override; \
113 [[nodiscard]] ::sen::Var senImplGetPropertyImpl(::sen::MemberHash propertyId) const override; \
114 void drainInputsImpl(::sen::TimeStamp lastCommitTime) override; \
115 \
116private:
117
119#define SEN_IMPL_GEN_UNBOUNDED_SEQUENCE(classname, elementtype) \
120 struct classname final: public std::vector<elementtype> \
121 { \
122 using Parent = std::vector<elementtype>; \
123 using Parent::Parent; \
124 using Parent::operator=; \
125 };
126
128#define SEN_IMPL_GEN_BOUNDED_SEQUENCE(classname, element, maxSize) \
129 struct classname final: public ::sen::StaticVector<element, maxSize> \
130 { \
131 using Parent = ::sen::StaticVector<element, maxSize>; \
132 using Parent::Parent; \
133 using Parent::operator=; \
134 };
135
137#define SEN_IMPL_GEN_FIXED_SEQUENCE(classname, element, size) \
138 struct classname final: public std::array<element, size> \
139 { \
140 using Parent = std::array<element, size>; \
141 using Parent::Parent; \
142 using Parent::operator=; \
143 \
144 template <typename Y, typename = std::enable_if_t<std::is_convertible_v<Y, element>, int>> \
145 classname(std::initializer_list<Y> elems): Parent() \
146 { \
147 std::size_t i = 0; \
148 for (auto itr = elems.begin(); itr != elems.end() && i < size; ++itr) \
149 { \
150 (*this)[i] = *itr; \
151 ++i; \
152 } \
153 } \
154 };
155
157#define SEN_IMPL_GEN_STRUCT_OPERATORS(classname, doExport) \
158 SEN_MAYBE_EXPORT(doExport) std::ostream& operator<<(std::ostream& out, const classname& val); \
159 SEN_MAYBE_EXPORT(doExport) bool operator==(const classname& lhs, const classname& rhs); \
160 SEN_MAYBE_EXPORT(doExport) bool operator!=(const classname& lhs, const classname& rhs);
161
163#define SEN_IMPL_GEN_OPTIONAL(classname, elementtype, doExport) \
164 struct classname final: public std::optional<elementtype> \
165 { \
166 using Parent = std::optional<elementtype>; \
167 using Parent::Parent; \
168 using Parent::operator=; \
169 using Parent::operator->; \
170 using Parent::operator*; \
171 using Parent::operator bool; \
172 }; \
173 \
174 SEN_MAYBE_EXPORT(doExport) bool operator==(const classname& lhs, const classname& rhs); \
175 SEN_MAYBE_EXPORT(doExport) bool operator!=(const classname& lhs, const classname& rhs);
176
178#define SEN_IMPL_GEN_OPTIONAL_TRAITS(classname, doExport) \
179 template <> \
180 struct MetaTypeTrait<classname> \
181 { \
182 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<OptionalType> meta(); \
183 }; \
184 template <> \
185 struct VariantTraits<classname>: private OptionalTraitsBase<classname> \
186 { \
187 using OptionalTraitsBase<classname>::valueToVariant; \
188 using OptionalTraitsBase<classname>::variantToValue; \
189 }; \
190 template <> \
191 struct SerializationTraits<classname>: private OptionalTraitsBase<classname> \
192 { \
193 using OptionalTraitsBase<classname>::write; \
194 using OptionalTraitsBase<classname>::read; \
195 using OptionalTraitsBase<classname>::serializedSize; \
196 };
197
199#define SEN_IMPL_GEN_ENUM_TRAITS(classname, doExport) \
200 template <> \
201 struct MetaTypeTrait<classname> \
202 { \
203 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<EnumType> meta(); \
204 }; \
205 template <> \
206 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private EnumTraitsBase<classname> \
207 { \
208 using EnumTraitsBase<classname>::valueToVariant; \
209 using EnumTraitsBase<classname>::variantToValue; \
210 }; \
211 template <> \
212 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private EnumTraitsBase<classname> \
213 { \
214 using EnumTraitsBase<classname>::write; \
215 using EnumTraitsBase<classname>::read; \
216 using EnumTraitsBase<classname>::serializedSize; \
217 }; \
218 template <> \
219 struct SEN_MAYBE_EXPORT(doExport) StringConversionTraits<classname> \
220 { \
221 [[nodiscard]] static std::string_view toString(classname val); \
222 [[nodiscard]] static classname fromString(std::string_view val); \
223 }; \
224 \
225 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) std::string_view toString(classname value);
226
228#define SEN_IMPL_GEN_SEQUENCE_TRAITS(classname, doExport) \
229 template <> \
230 struct MetaTypeTrait<classname> \
231 { \
232 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static sen::ConstTypeHandle<SequenceType> meta(); \
233 }; \
234 template <> \
235 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private SequenceTraitsBase<classname> \
236 { \
237 using SequenceTraitsBase<classname>::valueToVariant; \
238 using SequenceTraitsBase<classname>::variantToValue; \
239 }; \
240 template <> \
241 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private SequenceTraitsBase<classname> \
242 { \
243 using SequenceTraitsBase<classname>::write; \
244 using SequenceTraitsBase<classname>::read; \
245 using SequenceTraitsBase<classname>::serializedSize; \
246 };
247
249#define SEN_IMPL_GEN_ARRAY_TRAITS(classname, doExport) \
250 template <> \
251 struct MetaTypeTrait<classname> \
252 { \
253 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<SequenceType> meta(); \
254 }; \
255 template <> \
256 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private ArrayTraitsBase<classname> \
257 { \
258 using ArrayTraitsBase<classname>::valueToVariant; \
259 using ArrayTraitsBase<classname>::variantToValue; \
260 }; \
261 template <> \
262 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private ArrayTraitsBase<classname> \
263 { \
264 using ArrayTraitsBase<classname>::write; \
265 using ArrayTraitsBase<classname>::read; \
266 using ArrayTraitsBase<classname>::serializedSize; \
267 };
268
270#define SEN_IMPL_GEN_STRUCT_TRAITS(classname, doExport) \
271 template <> \
272 struct MetaTypeTrait<classname> \
273 { \
274 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<StructType> meta(); \
275 }; \
276 template <> \
277 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: protected StructTraitsBase \
278 { \
279 static void valueToVariant(const classname& val, Var& var); \
280 static void variantToValue(const Var& var, classname& val); \
281 static std::function<lang::Value(const void*)> getFieldValueGetterFunction(Span<uint16_t> fields); \
282 }; \
283 template <> \
284 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: protected StructTraitsBase \
285 { \
286 static void write(OutputStream& out, const classname& val); \
287 static void read(InputStream& in, classname& val); \
288 [[nodiscard]] static uint32_t serializedSize(const classname& val) noexcept; \
289 };
290
292#define SEN_IMPL_GEN_VARIANT_TRAITS(classname, doExport) \
293 template <> \
294 struct SEN_MAYBE_EXPORT(doExport) MetaTypeTrait<classname> \
295 { \
296 [[nodiscard]] static ConstTypeHandle<VariantType> meta(); \
297 }; \
298 template <> \
299 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: protected VariantTraitsBase<classname> \
300 { \
301 static void valueToVariant(const classname& val, Var& var); \
302 static void variantToValue(const Var& var, classname& val); \
303 static std::function<lang::Value(const void*)> getFieldValueGetterFunction(Span<uint16_t> fields); \
304 using VariantTraitsBase<classname>::tryPrintField; \
305 }; \
306 template <> \
307 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: protected VariantTraitsBase<classname> \
308 { \
309 static void write(OutputStream& out, const classname& val); \
310 static void read(InputStream& in, classname& val); \
311 [[nodiscard]] static uint32_t serializedSize(const classname& val) noexcept; \
312 };
313
315#define SEN_IMPL_GEN_CLASS_META_TRAITS(classname, doExport) \
316 template <> \
317 struct MetaTypeTrait<classname> \
318 { \
319 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<ClassType> meta(); \
320 };
321
323#define SEN_IMPL_GEN_CLASS_TRAITS_TEMPLATE(interfaceName, remoteProxy, localProxy, baseName) \
324 template <> \
325 struct SenClassRelation<interfaceName> \
326 { \
327 using InterfaceType = interfaceName; \
328 template <typename T> \
329 using BaseType = baseName<T>; \
330 static constexpr bool isBaseTypeTemplate = true; \
331 using RemoteProxyType = remoteProxy; \
332 using LocalProxyType = localProxy; \
333 }; \
334 template <> \
335 struct SenClassRelation<remoteProxy> \
336 { \
337 using InterfaceType = interfaceName; \
338 template <typename T> \
339 using BaseType = baseName<T>; \
340 static constexpr bool isBaseTypeTemplate = true; \
341 using RemoteProxyType = remoteProxy; \
342 using LocalProxyType = localProxy; \
343 }; \
344 template <> \
345 struct SenClassRelation<localProxy> \
346 { \
347 using InterfaceType = interfaceName; \
348 template <typename T> \
349 using BaseType = baseName<T>; \
350 static constexpr bool isBaseTypeTemplate = true; \
351 using RemoteProxyType = remoteProxy; \
352 using LocalProxyType = localProxy; \
353 }; \
354 template <typename T> \
355 struct SenClassRelation<baseName<T>> \
356 { \
357 using InterfaceType = interfaceName; \
358 template <typename U> \
359 using BaseType = baseName<U>; \
360 static constexpr bool isBaseTypeTemplate = true; \
361 using RemoteProxyType = remoteProxy; \
362 using LocalProxyType = localProxy; \
363 };
364
366#define SEN_IMPL_GEN_CLASS_TRAITS_NORMAL(interfaceName, remoteProxy, localProxy, baseName) \
367 template <> \
368 struct SenClassRelation<interfaceName> \
369 { \
370 using InterfaceType = interfaceName; \
371 using BaseType = baseName; \
372 static constexpr bool isBaseTypeTemplate = false; \
373 using RemoteProxyType = remoteProxy; \
374 using LocalProxyType = localProxy; \
375 }; \
376 template <> \
377 struct SenClassRelation<remoteProxy> \
378 { \
379 using InterfaceType = interfaceName; \
380 using BaseType = baseName; \
381 static constexpr bool isBaseTypeTemplate = false; \
382 using RemoteProxyType = remoteProxy; \
383 using LocalProxyType = localProxy; \
384 }; \
385 template <> \
386 struct SenClassRelation<localProxy> \
387 { \
388 using InterfaceType = interfaceName; \
389 using BaseType = baseName; \
390 static constexpr bool isBaseTypeTemplate = false; \
391 using RemoteProxyType = remoteProxy; \
392 using LocalProxyType = localProxy; \
393 }; \
394 template <> \
395 struct SenClassRelation<baseName> \
396 { \
397 using InterfaceType = interfaceName; \
398 using BaseType = baseName; \
399 static constexpr bool isBaseTypeTemplate = false; \
400 using RemoteProxyType = remoteProxy; \
401 using LocalProxyType = localProxy; \
402 };
403
405#define SEN_IMPL_GEN_QUANTITY_TRAITS(classname, maxVal, minVal, doExport) \
406 template <> \
407 struct MetaTypeTrait<classname> \
408 { \
409 [[nodiscard]] SEN_MAYBE_EXPORT(doExport) static ConstTypeHandle<QuantityType> meta(); \
410 }; \
411 template <> \
412 struct SEN_MAYBE_EXPORT(doExport) VariantTraits<classname>: private QuantityTraitsBase<classname> \
413 { \
414 using QuantityTraitsBase<classname>::valueToVariant; \
415 using QuantityTraitsBase<classname>::variantToValue; \
416 }; \
417 template <> \
418 struct SEN_MAYBE_EXPORT(doExport) SerializationTraits<classname>: private QuantityTraitsBase<classname> \
419 { \
420 using QuantityTraitsBase<classname>::write; \
421 using QuantityTraitsBase<classname>::read; \
422 using QuantityTraitsBase<classname>::serializedSize; \
423 }; \
424 template <> \
425 struct SEN_MAYBE_EXPORT(doExport) QuantityTraits<classname> \
426 { \
427 using ValueType = typename classname::ValueType; \
428 \
429 static constexpr ValueType max = maxVal; \
430 static constexpr ValueType min = minVal; \
431 \
432 [[nodiscard]] static ::std::optional<const sen::Unit*> unit() noexcept; \
433 [[nodiscard]] static const sen::Unit& unit(sen::Unit::EnsureTag); \
434 };
435
436#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