Fast RTPS  Version 2.8.0
Fast RTPS
TypeObject.h
1// Copyright 2018 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#ifndef TYPES_TYPE_OBJECT_H
16#define TYPES_TYPE_OBJECT_H
17
18#include <fastrtps/types/TypesBase.h>
19#include <fastrtps/types/TypeObjectHashId.h>
20#include <fastrtps/types/TypeIdentifier.h>
21#include <fastrtps/types/AnnotationParameterValue.h>
22#include <cstdint>
23#include <array>
24
25namespace eprosima {
26namespace fastcdr {
27class Cdr;
28}
29}
30
31// The types in this file shall be serialized with XCDR encoding version 2
32namespace eprosima {
33namespace fastrtps {
34
35namespace types {
36
37/*struct CommonStructMember final {
38 MemberId member_id;
39 StructMemberFlag member_flags;
40 TypeIdentifier member_type_id;
41 };*/
43{
44public:
45
46 RTPS_DllAPI CommonStructMember();
47 RTPS_DllAPI ~CommonStructMember();
48 RTPS_DllAPI CommonStructMember(
49 const CommonStructMember& x);
50 RTPS_DllAPI CommonStructMember(
53 const CommonStructMember& x);
56
57 RTPS_DllAPI inline void member_id(
58 const MemberId& _member_id) { m_member_id = _member_id; }
59 RTPS_DllAPI inline void member_id(
60 MemberId&& _member_id) { m_member_id = std::move(_member_id); }
61 RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }
62 RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }
63
64 RTPS_DllAPI inline void member_flags(
65 const StructMemberFlag& _member_flags) { m_member_flags = _member_flags; }
66 RTPS_DllAPI inline void member_flags(
67 StructMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
68 RTPS_DllAPI inline const StructMemberFlag& member_flags() const { return m_member_flags; }
69 RTPS_DllAPI inline StructMemberFlag& member_flags() { return m_member_flags; }
70
71 RTPS_DllAPI inline void member_type_id(
72 const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }
73 RTPS_DllAPI inline void member_type_id(
74 TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }
75 RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }
76 RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }
77
78 RTPS_DllAPI static size_t getCdrSerializedSize(
79 const CommonStructMember& data,
80 size_t current_alignment = 0);
81 RTPS_DllAPI void serialize(
82 eprosima::fastcdr::Cdr& cdr) const;
83 RTPS_DllAPI void deserialize(
84 eprosima::fastcdr::Cdr& cdr);
85
86 RTPS_DllAPI bool operator==(
87 const CommonStructMember& other) const;
88
89 RTPS_DllAPI bool consistent(
90 const CommonStructMember& x,
91 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
92
93private:
94
95 MemberId m_member_id;
96 StructMemberFlag m_member_flags;
97 TypeIdentifier m_member_type_id;
98};
99
100// COMPLETE Details for a member of an aggregate type
101/*struct CompleteMemberDetail final{
102 MemberName name;
103 AppliedBuiltinMemberAnnotations ann_builtin; // Optional
104 AppliedAnnotationSeq ann_custom; // Optional
105 };*/
107{
108public:
109
110 RTPS_DllAPI CompleteMemberDetail();
113 const CompleteMemberDetail& x);
117 const CompleteMemberDetail& x);
120
121 RTPS_DllAPI inline void name(
122 const MemberName& _name) { m_name = _name; }
123 RTPS_DllAPI inline void name(
124 MemberName&& _name) { m_name = std::move(_name); }
125 RTPS_DllAPI inline const MemberName& name() const { return m_name; }
126 RTPS_DllAPI inline MemberName& name() { return m_name; }
127
128 RTPS_DllAPI inline void ann_builtin(
129 const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
130 RTPS_DllAPI inline void ann_builtin(
131 AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
132 RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
133 RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
134
135 RTPS_DllAPI inline void ann_custom(
136 const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
137 RTPS_DllAPI inline void ann_custom(
138 AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
139 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
140 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
141
142 RTPS_DllAPI static size_t getCdrSerializedSize(
143 const CompleteMemberDetail& data,
144 size_t current_alignment = 0);
145 RTPS_DllAPI void serialize(
146 eprosima::fastcdr::Cdr& cdr) const;
147 RTPS_DllAPI void deserialize(
148 eprosima::fastcdr::Cdr& cdr);
149
150 RTPS_DllAPI bool operator==(
151 const CompleteMemberDetail& other) const;
152
153 RTPS_DllAPI bool consistent(
154 const CompleteMemberDetail& x,
155 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
156
157private:
158
159 MemberName m_name;
161 AppliedAnnotationSeq m_ann_custom;
162};
163
164// MINIMAL Details for a member of an aggregate type
165/*struct MinimalMemberDetail final{
166 NameHash name_hash;
167 };*/
168
170{
171public:
172
173 RTPS_DllAPI MinimalMemberDetail();
174 RTPS_DllAPI ~MinimalMemberDetail();
176 const MinimalMemberDetail& x);
180 const MinimalMemberDetail& x);
183
184 RTPS_DllAPI inline void name_hash(
185 const NameHash& _name_hash) { m_name_hash = _name_hash; }
186 RTPS_DllAPI inline void name_hash(
187 NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }
188 RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }
189 RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }
190
191 RTPS_DllAPI static size_t getCdrSerializedSize(
192 const MinimalMemberDetail& data,
193 size_t current_alignment = 0);
194 RTPS_DllAPI void serialize(
195 eprosima::fastcdr::Cdr& cdr) const;
196 RTPS_DllAPI void deserialize(
197 eprosima::fastcdr::Cdr& cdr);
198
199 RTPS_DllAPI bool operator==(
200 const MinimalMemberDetail& other) const;
201
202 RTPS_DllAPI bool consistent(
203 const MinimalMemberDetail& x,
204 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
205
206private:
207
208 NameHash m_name_hash;
209};
210
211// Member of an aggregate type
212/*struct CompleteStructMember {
213 CommonStructMember common;
214 CompleteMemberDetail detail;
215 };*/
217{
218public:
219
220 RTPS_DllAPI CompleteStructMember();
223 const CompleteStructMember& x);
227 const CompleteStructMember& x);
230
231 RTPS_DllAPI inline void common(
232 const CommonStructMember& _common) { m_common = _common; }
233 RTPS_DllAPI inline void common(
234 CommonStructMember&& _common) { m_common = std::move(_common); }
235 RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }
236 RTPS_DllAPI inline CommonStructMember& common() { return m_common; }
237
238 RTPS_DllAPI inline void detail(
239 const CompleteMemberDetail& _detail) { m_detail = _detail; }
240 RTPS_DllAPI inline void detail(
241 CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
242 RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
243 RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
244
245 RTPS_DllAPI static size_t getCdrSerializedSize(
246 const CompleteStructMember& data,
247 size_t current_alignment = 0);
248 RTPS_DllAPI void serialize(
249 eprosima::fastcdr::Cdr& cdr) const;
250 RTPS_DllAPI void deserialize(
251 eprosima::fastcdr::Cdr& cdr);
252
253 RTPS_DllAPI bool operator==(
254 const CompleteStructMember& other) const;
255
256 RTPS_DllAPI bool consistent(
257 const CompleteStructMember& x,
258 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
259
260private:
261
262 CommonStructMember m_common;
263 CompleteMemberDetail m_detail;
264};
265
266// Ordered by the member_index
267typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
268
269// Member of an aggregate type
270/*struct MinimalStructMember {
271 CommonStructMember common;
272 MinimalMemberDetail detail;
273 };*/
275{
276public:
277
278 RTPS_DllAPI MinimalStructMember();
279 RTPS_DllAPI ~MinimalStructMember();
281 const MinimalStructMember& x);
285 const MinimalStructMember& x);
288
289 RTPS_DllAPI inline void common(
290 const CommonStructMember& _common) { m_common = _common; }
291 RTPS_DllAPI inline void common(
292 CommonStructMember&& _common) { m_common = std::move(_common); }
293 RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }
294 RTPS_DllAPI inline CommonStructMember& common() { return m_common; }
295
296 RTPS_DllAPI inline void detail(
297 const MinimalMemberDetail& _detail) { m_detail = _detail; }
298 RTPS_DllAPI inline void detail(
299 MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
300 RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
301 RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
302
303 RTPS_DllAPI static size_t getCdrSerializedSize(
304 const MinimalStructMember& data,
305 size_t current_alignment = 0);
306 RTPS_DllAPI void serialize(
307 eprosima::fastcdr::Cdr& cdr) const;
308 RTPS_DllAPI void deserialize(
309 eprosima::fastcdr::Cdr& cdr);
310
311 RTPS_DllAPI bool operator==(
312 const MinimalStructMember& other) const;
313
314 RTPS_DllAPI bool consistent(
315 const MinimalStructMember& x,
316 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
317
318private:
319
320 CommonStructMember m_common;
321 MinimalMemberDetail m_detail;
322};
323
324// Ordered by common.member_id
325typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
326
327/*struct AppliedBuiltinTypeAnnotations {
328 AppliedVerbatimAnnotation verbatim; // verbatim(...) // optional
329 };*/
331{
332public:
333
344
345 RTPS_DllAPI inline void verbatim(
346 const AppliedVerbatimAnnotation& _verbatim) { m_verbatim = _verbatim; }
347 RTPS_DllAPI inline void verbatim(
348 AppliedVerbatimAnnotation&& _verbatim) { m_verbatim = std::move(_verbatim); }
349 RTPS_DllAPI inline const AppliedVerbatimAnnotation& verbatim() const { return m_verbatim; }
350 RTPS_DllAPI inline AppliedVerbatimAnnotation& verbatim() { return m_verbatim; }
351
352 RTPS_DllAPI static size_t getCdrSerializedSize(
354 size_t current_alignment = 0);
355 RTPS_DllAPI void serialize(
356 eprosima::fastcdr::Cdr& cdr) const;
357 RTPS_DllAPI void deserialize(
358 eprosima::fastcdr::Cdr& cdr);
359
360 RTPS_DllAPI bool operator==(
361 const AppliedBuiltinTypeAnnotations& other) const;
362
363 RTPS_DllAPI bool consistent(
365 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
366
367private:
368
369 AppliedVerbatimAnnotation m_verbatim;
370};
371
372/*struct MinimalTypeDetail final{
373 // Empty. Available for future extension
374 };*/
376{
377public:
378
379 RTPS_DllAPI MinimalTypeDetail();
380 RTPS_DllAPI ~MinimalTypeDetail();
381 RTPS_DllAPI MinimalTypeDetail(
382 const MinimalTypeDetail& x);
383 RTPS_DllAPI MinimalTypeDetail(
386 const MinimalTypeDetail& x);
389
390 RTPS_DllAPI static size_t getCdrSerializedSize(
391 const MinimalTypeDetail& data,
392 size_t current_alignment = 0);
393 RTPS_DllAPI void serialize(
394 eprosima::fastcdr::Cdr& cdr) const;
395 RTPS_DllAPI void deserialize(
396 eprosima::fastcdr::Cdr& cdr);
397
398 RTPS_DllAPI bool operator==(
399 const MinimalTypeDetail&) const { return true; }
400
401 RTPS_DllAPI bool consistent(
402 const MinimalTypeDetail& x,
403 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
404
405private:
406
407};
408
409/*struct CompleteTypeDetail final{
410 AppliedBuiltinTypeAnnotations ann_builtin; // optional
411 AppliedAnnotationSeq ann_custom; // optional
412 QualifiedTypeName type_name;
413 };*/
415{
416public:
417
418 RTPS_DllAPI CompleteTypeDetail();
419 RTPS_DllAPI ~CompleteTypeDetail();
421 const CompleteTypeDetail& x);
425 const CompleteTypeDetail& x);
428
429 RTPS_DllAPI inline void ann_builtin(
430 const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
431 RTPS_DllAPI inline void ann_builtin(
432 AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
433 RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }
434 RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }
435
436 RTPS_DllAPI inline void ann_custom(
437 const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
438 RTPS_DllAPI inline void ann_custom(
439 AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
440 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
441 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
442
443 RTPS_DllAPI inline void type_name(
444 const QualifiedTypeName& _type_name) { m_type_name = _type_name; }
445 RTPS_DllAPI inline void type_name(
446 QualifiedTypeName&& _type_name) { m_type_name = std::move(_type_name); }
447 RTPS_DllAPI inline const QualifiedTypeName& type_name() const { return m_type_name; }
448 RTPS_DllAPI inline QualifiedTypeName& type_name() { return m_type_name; }
449
450 RTPS_DllAPI static size_t getCdrSerializedSize(
451 const CompleteTypeDetail& data,
452 size_t current_alignment = 0);
453 RTPS_DllAPI void serialize(
454 eprosima::fastcdr::Cdr& cdr) const;
455 RTPS_DllAPI void deserialize(
456 eprosima::fastcdr::Cdr& cdr);
457
458 RTPS_DllAPI bool operator==(
459 const CompleteTypeDetail& other) const;
460
461 RTPS_DllAPI bool consistent(
462 const CompleteTypeDetail& x,
463 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
464
465private:
466
467 AppliedBuiltinTypeAnnotations m_ann_builtin;
468 AppliedAnnotationSeq m_ann_custom;
469 QualifiedTypeName m_type_name;
470};
471/*struct CompleteStructHeader {
472 TypeIdentifier base_type;
473 CompleteTypeDetail detail;
474 };*/
476{
477public:
478
479 RTPS_DllAPI CompleteStructHeader();
482 const CompleteStructHeader& x);
486 const CompleteStructHeader& x);
489
490 RTPS_DllAPI inline void base_type(
491 const TypeIdentifier& _base_type) { m_base_type = _base_type; }
492 RTPS_DllAPI inline void base_type(
493 TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
494 RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
495 RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
496
497 RTPS_DllAPI inline void detail(
498 const CompleteTypeDetail& _detail) { m_detail = _detail; }
499 RTPS_DllAPI inline void detail(
500 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
501 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
502 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
503
504 RTPS_DllAPI static size_t getCdrSerializedSize(
505 const CompleteStructHeader& data,
506 size_t current_alignment = 0);
507 RTPS_DllAPI void serialize(
508 eprosima::fastcdr::Cdr& cdr) const;
509 RTPS_DllAPI void deserialize(
510 eprosima::fastcdr::Cdr& cdr);
511
512 RTPS_DllAPI bool operator==(
513 const CompleteStructHeader& other) const;
514
515 RTPS_DllAPI bool consistent(
516 const CompleteStructHeader& x,
517 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
518
519private:
520
521 TypeIdentifier m_base_type;
522 CompleteTypeDetail m_detail;
523};
524/*struct MinimalStructHeader {
525 TypeIdentifier base_type;
526 MinimalTypeDetail detail;
527 };*/
529{
530public:
531
532 RTPS_DllAPI MinimalStructHeader();
533 RTPS_DllAPI ~MinimalStructHeader();
535 const MinimalStructHeader& x);
539 const MinimalStructHeader& x);
542
543 RTPS_DllAPI inline void base_type(
544 const TypeIdentifier& _base_type) { m_base_type = _base_type; }
545 RTPS_DllAPI inline void base_type(
546 TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
547 RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
548 RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
549
550 RTPS_DllAPI inline void detail(
551 const MinimalTypeDetail& _detail) { m_detail = _detail; }
552 RTPS_DllAPI inline void detail(
553 MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }
554 RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }
555 RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }
556
557 RTPS_DllAPI static size_t getCdrSerializedSize(
558 const MinimalStructHeader& data,
559 size_t current_alignment = 0);
560 RTPS_DllAPI void serialize(
561 eprosima::fastcdr::Cdr& cdr) const;
562 RTPS_DllAPI void deserialize(
563 eprosima::fastcdr::Cdr& cdr);
564
565 RTPS_DllAPI bool operator==(
566 const MinimalStructHeader& other) const;
567
568 RTPS_DllAPI bool consistent(
569 const MinimalStructHeader& x,
570 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
571
572private:
573
574 TypeIdentifier m_base_type;
575 MinimalTypeDetail m_detail;
576};
577
578/*struct CompleteStructType final{
579 StructTypeFlag struct_flags;
580 CompleteStructHeader header;
581 CompleteStructMemberSeq member_seq;
582 };*/
584{
585public:
586
587 RTPS_DllAPI CompleteStructType();
588 RTPS_DllAPI ~CompleteStructType();
590 const CompleteStructType& x);
594 const CompleteStructType& x);
597
598 RTPS_DllAPI inline void struct_flags(
599 const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }
600 RTPS_DllAPI inline void struct_flags(
601 StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }
602 RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }
603 RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }
604
605 RTPS_DllAPI inline void header(
606 const CompleteStructHeader& _header) { m_header = _header; }
607 RTPS_DllAPI inline void header(
608 CompleteStructHeader&& _header) { m_header = std::move(_header); }
609 RTPS_DllAPI inline const CompleteStructHeader& header() const { return m_header; }
610 RTPS_DllAPI inline CompleteStructHeader& header() { return m_header; }
611
612 RTPS_DllAPI inline void member_seq(
613 const CompleteStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }
614 RTPS_DllAPI inline void member_seq(
615 CompleteStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
616 RTPS_DllAPI inline const CompleteStructMemberSeq& member_seq() const { return m_member_seq; }
617 RTPS_DllAPI inline CompleteStructMemberSeq& member_seq() { return m_member_seq; }
618
619 RTPS_DllAPI static size_t getCdrSerializedSize(
620 const CompleteStructType& data,
621 size_t current_alignment = 0);
622 RTPS_DllAPI void serialize(
623 eprosima::fastcdr::Cdr& cdr) const;
624 RTPS_DllAPI void deserialize(
625 eprosima::fastcdr::Cdr& cdr);
626
627 RTPS_DllAPI bool operator==(
628 const CompleteStructType& other) const;
629
630 RTPS_DllAPI bool consistent(
631 const CompleteStructType& x,
632 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
633
634private:
635
636 StructTypeFlag m_struct_flags;
637 CompleteStructHeader m_header;
638 CompleteStructMemberSeq m_member_seq;
639};
640
641/*struct MinimalStructType final{
642 StructTypeFlag struct_flags;
643 MinimalStructHeader header;
644 MinimalStructMemberSeq member_seq;
645 };*/
647{
648public:
649
650 RTPS_DllAPI MinimalStructType();
651 RTPS_DllAPI ~MinimalStructType();
652 RTPS_DllAPI MinimalStructType(
653 const MinimalStructType& x);
654 RTPS_DllAPI MinimalStructType(
657 const MinimalStructType& x);
660
661 RTPS_DllAPI inline void struct_flags(
662 const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }
663 RTPS_DllAPI inline void struct_flags(
664 StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }
665 RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }
666 RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }
667
668 RTPS_DllAPI inline void header(
669 const MinimalStructHeader& _header) { m_header = _header; }
670 RTPS_DllAPI inline void header(
671 MinimalStructHeader&& _header) { m_header = std::move(_header); }
672 RTPS_DllAPI inline const MinimalStructHeader& header() const { return m_header; }
673 RTPS_DllAPI inline MinimalStructHeader& header() { return m_header; }
674
675 RTPS_DllAPI inline void member_seq(
676 const MinimalStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }
677 RTPS_DllAPI inline void member_seq(
678 MinimalStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
679 RTPS_DllAPI inline const MinimalStructMemberSeq& member_seq() const { return m_member_seq; }
680 RTPS_DllAPI inline MinimalStructMemberSeq& member_seq() { return m_member_seq; }
681
682 RTPS_DllAPI static size_t getCdrSerializedSize(
683 const MinimalStructType& data,
684 size_t current_alignment = 0);
685 RTPS_DllAPI void serialize(
686 eprosima::fastcdr::Cdr& cdr) const;
687 RTPS_DllAPI void deserialize(
688 eprosima::fastcdr::Cdr& cdr);
689
690 RTPS_DllAPI bool operator==(
691 const MinimalStructType& other) const;
692
693 RTPS_DllAPI bool consistent(
694 const MinimalStructType& x,
695 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
696
697private:
698
699 StructTypeFlag m_struct_flags;
700 MinimalStructHeader m_header;
701 MinimalStructMemberSeq m_member_seq;
702};
703
704// --- Union: ---------------------------------------------------------
705
706// Case labels that apply to a member of a union type
707// Ordered by their values
708typedef std::vector<int32_t> UnionCaseLabelSeq;
709
710/*struct CommonUnionMember final{
711 MemberId member_id;
712 UnionMemberFlag member_flags;
713 TypeIdentifier type_id;
714 UnionCaseLabelSeq label_seq;
715 };*/
717{
718public:
719
720 RTPS_DllAPI CommonUnionMember();
721 RTPS_DllAPI ~CommonUnionMember();
722 RTPS_DllAPI CommonUnionMember(
723 const CommonUnionMember& x);
724 RTPS_DllAPI CommonUnionMember(
727 const CommonUnionMember& x);
730
731 RTPS_DllAPI inline void member_id(
732 const MemberId& _member_id) { m_member_id = _member_id; }
733 RTPS_DllAPI inline void member_id(
734 MemberId&& _member_id) { m_member_id = std::move(_member_id); }
735 RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }
736 RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }
737
738 RTPS_DllAPI inline void member_flags(
739 const UnionMemberFlag& _member_flags) { m_member_flags = _member_flags; }
740 RTPS_DllAPI inline void member_flags(
741 UnionMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
742 RTPS_DllAPI inline const UnionMemberFlag& member_flags() const { return m_member_flags; }
743 RTPS_DllAPI inline UnionMemberFlag& member_flags() { return m_member_flags; }
744
745 RTPS_DllAPI inline void type_id(
746 const TypeIdentifier& _type_id) { m_type_id = _type_id; }
747 RTPS_DllAPI inline void type_id(
748 TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
749 RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
750 RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
751
752 RTPS_DllAPI inline void label_seq(
753 const UnionCaseLabelSeq& _label_seq) { m_label_seq = _label_seq; }
754 RTPS_DllAPI inline void label_seq(
755 UnionCaseLabelSeq&& _label_seq) { m_label_seq = std::move(_label_seq); }
756 RTPS_DllAPI inline const UnionCaseLabelSeq& label_seq() const { return m_label_seq; }
757 RTPS_DllAPI inline UnionCaseLabelSeq& label_seq() { return m_label_seq; }
758
759 RTPS_DllAPI static size_t getCdrSerializedSize(
760 const CommonUnionMember& data,
761 size_t current_alignment = 0);
762 RTPS_DllAPI void serialize(
763 eprosima::fastcdr::Cdr& cdr) const;
764 RTPS_DllAPI void deserialize(
765 eprosima::fastcdr::Cdr& cdr);
766
767 RTPS_DllAPI bool operator==(
768 const CommonUnionMember& other) const;
769
770 RTPS_DllAPI bool consistent(
771 const CommonUnionMember& x,
772 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
773
774private:
775
776 MemberId m_member_id;
777 UnionMemberFlag m_member_flags;
778 TypeIdentifier m_type_id;
779 UnionCaseLabelSeq m_label_seq;
780};
781
782// Member of a union type
783/*struct CompleteUnionMember {
784 CommonUnionMember common;
785 CompleteMemberDetail detail;
786 };*/
788{
789public:
790
791 RTPS_DllAPI CompleteUnionMember();
792 RTPS_DllAPI ~CompleteUnionMember();
794 const CompleteUnionMember& x);
798 const CompleteUnionMember& x);
801
802 RTPS_DllAPI inline void common(
803 const CommonUnionMember& _common) { m_common = _common; }
804 RTPS_DllAPI inline void common(
805 CommonUnionMember&& _common) { m_common = std::move(_common); }
806 RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }
807 RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }
808
809 RTPS_DllAPI inline void detail(
810 const CompleteMemberDetail& _detail) { m_detail = _detail; }
811 RTPS_DllAPI inline void detail(
812 CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
813 RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
814 RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
815
816 RTPS_DllAPI static size_t getCdrSerializedSize(
817 const CompleteUnionMember& data,
818 size_t current_alignment = 0);
819 RTPS_DllAPI void serialize(
820 eprosima::fastcdr::Cdr& cdr) const;
821 RTPS_DllAPI void deserialize(
822 eprosima::fastcdr::Cdr& cdr);
823
824 RTPS_DllAPI bool operator==(
825 const CompleteUnionMember& other) const;
826
827 RTPS_DllAPI bool consistent(
828 const CompleteUnionMember& x,
829 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
830
831private:
832
833 CommonUnionMember m_common;
834 CompleteMemberDetail m_detail;
835};
836
837// Ordered by member_index
838typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
839
840// Member of a union type
841/*struct MinimalUnionMember {
842 CommonUnionMember common;
843 MinimalMemberDetail detail;
844 };*/
846{
847public:
848
849 RTPS_DllAPI MinimalUnionMember();
850 RTPS_DllAPI ~MinimalUnionMember();
852 const MinimalUnionMember& x);
856 const MinimalUnionMember& x);
859
860 RTPS_DllAPI inline void common(
861 const CommonUnionMember& _common) { m_common = _common; }
862 RTPS_DllAPI inline void common(
863 CommonUnionMember&& _common) { m_common = std::move(_common); }
864 RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }
865 RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }
866
867 RTPS_DllAPI inline void detail(
868 const MinimalMemberDetail& _detail) { m_detail = _detail; }
869 RTPS_DllAPI inline void detail(
870 MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
871 RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
872 RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
873
874 RTPS_DllAPI static size_t getCdrSerializedSize(
875 const MinimalUnionMember& data,
876 size_t current_alignment = 0);
877 RTPS_DllAPI void serialize(
878 eprosima::fastcdr::Cdr& cdr) const;
879 RTPS_DllAPI void deserialize(
880 eprosima::fastcdr::Cdr& cdr);
881
882 RTPS_DllAPI bool operator==(
883 const MinimalUnionMember& other) const;
884
885 RTPS_DllAPI bool consistent(
886 const MinimalUnionMember& x,
887 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
888
889private:
890
891 CommonUnionMember m_common;
892 MinimalMemberDetail m_detail;
893};
894
895// Ordered by MinimalUnionMember.common.member_id
896typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
897
898/*struct CommonDiscriminatorMember final{
899 UnionDiscriminatorFlag member_flags;
900 TypeIdentifier type_id;
901 };*/
903{
904public:
905
916
917 RTPS_DllAPI inline void member_flags(
918 const UnionDiscriminatorFlag& _member_flags) { m_member_flags = _member_flags; }
919 RTPS_DllAPI inline void member_flags(
920 UnionDiscriminatorFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
921 RTPS_DllAPI inline const UnionDiscriminatorFlag& member_flags() const { return m_member_flags; }
922 RTPS_DllAPI inline UnionDiscriminatorFlag& member_flags() { return m_member_flags; }
923
924 RTPS_DllAPI inline void type_id(
925 const TypeIdentifier& _type_id) { m_type_id = _type_id; }
926 RTPS_DllAPI inline void type_id(
927 TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
928 RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
929 RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
930
931 RTPS_DllAPI static size_t getCdrSerializedSize(
932 const CommonDiscriminatorMember& data,
933 size_t current_alignment = 0);
934 RTPS_DllAPI void serialize(
935 eprosima::fastcdr::Cdr& cdr) const;
936 RTPS_DllAPI void deserialize(
937 eprosima::fastcdr::Cdr& cdr);
938
939 RTPS_DllAPI bool operator==(
940 const CommonDiscriminatorMember& other) const;
941
942 RTPS_DllAPI bool consistent(
944 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
945
946private:
947
948 UnionDiscriminatorFlag m_member_flags;
949 TypeIdentifier m_type_id;
950};
951
952// Member of a union type
953/*struct CompleteDiscriminatorMember {
954 CommonDiscriminatorMember common;
955 AppliedBuiltinTypeAnnotations ann_builtin; // Optional
956 AppliedAnnotationSeq ann_custom; // Optional
957 };*/
959{
960public:
961
972
973 RTPS_DllAPI inline void common(
974 const CommonDiscriminatorMember& _common) { m_common = _common; }
975 RTPS_DllAPI inline void common(
976 CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }
977 RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }
978 RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }
979
980 RTPS_DllAPI inline void ann_builtin(
981 const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
982 RTPS_DllAPI inline void ann_builtin(
983 AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
984 RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }
985 RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }
986
987 RTPS_DllAPI inline void ann_custom(
988 const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
989 RTPS_DllAPI inline void ann_custom(
990 AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
991 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
992 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
993
994 RTPS_DllAPI static size_t getCdrSerializedSize(
995 const CompleteDiscriminatorMember& data,
996 size_t current_alignment = 0);
997 RTPS_DllAPI void serialize(
998 eprosima::fastcdr::Cdr& cdr) const;
999 RTPS_DllAPI void deserialize(
1000 eprosima::fastcdr::Cdr& cdr);
1001
1002 RTPS_DllAPI bool operator==(
1003 const CompleteDiscriminatorMember& other) const;
1004
1005 RTPS_DllAPI bool consistent(
1007 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1008
1009private:
1010
1012 AppliedBuiltinTypeAnnotations m_ann_builtin;
1013 AppliedAnnotationSeq m_ann_custom;
1014};
1015
1016// Member of a union type
1017/*struct MinimalDiscriminatorMember {
1018 CommonDiscriminatorMember common;
1019 };*/
1021{
1022public:
1023
1034
1035 RTPS_DllAPI inline void common(
1036 const CommonDiscriminatorMember& _common) { m_common = _common; }
1037 RTPS_DllAPI inline void common(
1038 CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }
1039 RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }
1040 RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }
1041
1042 RTPS_DllAPI static size_t getCdrSerializedSize(
1043 const MinimalDiscriminatorMember& data,
1044 size_t current_alignment = 0);
1045 RTPS_DllAPI void serialize(
1046 eprosima::fastcdr::Cdr& cdr) const;
1047 RTPS_DllAPI void deserialize(
1048 eprosima::fastcdr::Cdr& cdr);
1049
1050 RTPS_DllAPI bool operator==(
1051 const MinimalDiscriminatorMember& other) const;
1052
1053 RTPS_DllAPI bool consistent(
1055 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1056
1057private:
1058
1060};
1061
1062/*struct CompleteUnionHeader {
1063 CompleteTypeDetail detail;
1064 };*/
1066{
1067public:
1068
1069 RTPS_DllAPI CompleteUnionHeader();
1072 const CompleteUnionHeader& x);
1076 const CompleteUnionHeader& x);
1079
1080 RTPS_DllAPI inline void detail(
1081 const CompleteTypeDetail& _detail) { m_detail = _detail; }
1082 RTPS_DllAPI inline void detail(
1083 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
1084 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
1085 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
1086
1087 RTPS_DllAPI static size_t getCdrSerializedSize(
1088 const CompleteUnionHeader& data,
1089 size_t current_alignment = 0);
1090 RTPS_DllAPI void serialize(
1091 eprosima::fastcdr::Cdr& cdr) const;
1092 RTPS_DllAPI void deserialize(
1093 eprosima::fastcdr::Cdr& cdr);
1094
1095 RTPS_DllAPI bool operator==(
1096 const CompleteUnionHeader& other) const;
1097
1098 RTPS_DllAPI bool consistent(
1099 const CompleteUnionHeader& x,
1100 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1101
1102private:
1103
1104 CompleteTypeDetail m_detail;
1105};
1106
1107/*struct MinimalUnionHeader {
1108 MinimalTypeDetail detail;
1109 };*/
1111{
1112public:
1113
1114 RTPS_DllAPI MinimalUnionHeader();
1115 RTPS_DllAPI ~MinimalUnionHeader();
1117 const MinimalUnionHeader& x);
1119 MinimalUnionHeader&& x);
1121 const MinimalUnionHeader& x);
1123 MinimalUnionHeader&& x);
1124
1125 RTPS_DllAPI inline void detail(
1126 const MinimalTypeDetail& _detail) { m_detail = _detail; }
1127 RTPS_DllAPI inline void detail(
1128 MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }
1129 RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }
1130 RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }
1131
1132 RTPS_DllAPI static size_t getCdrSerializedSize(
1133 const MinimalUnionHeader& data,
1134 size_t current_alignment = 0);
1135 RTPS_DllAPI void serialize(
1136 eprosima::fastcdr::Cdr& cdr) const;
1137 RTPS_DllAPI void deserialize(
1138 eprosima::fastcdr::Cdr& cdr);
1139
1140 RTPS_DllAPI bool operator==(
1141 const MinimalUnionHeader& other) const;
1142
1143 RTPS_DllAPI bool consistent(
1144 const MinimalUnionHeader& x,
1145 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1146
1147private:
1148
1149 MinimalTypeDetail m_detail;
1150};
1151
1152/*struct CompleteUnionType final{
1153 UnionTypeFlag union_flags;
1154 CompleteUnionHeader header;
1155 CompleteDiscriminatorMember discriminator;
1156 CompleteUnionMemberSeq member_seq;
1157 };*/
1159{
1160public:
1161
1162 RTPS_DllAPI CompleteUnionType();
1163 RTPS_DllAPI ~CompleteUnionType();
1165 const CompleteUnionType& x);
1167 CompleteUnionType&& x);
1169 const CompleteUnionType& x);
1171 CompleteUnionType&& x);
1172
1173 RTPS_DllAPI inline void union_flags(
1174 const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }
1175 RTPS_DllAPI inline void union_flags(
1176 UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }
1177 RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }
1178 RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }
1179
1180 RTPS_DllAPI inline void header(
1181 const CompleteUnionHeader& _header) { m_header = _header; }
1182 RTPS_DllAPI inline void header(
1183 CompleteUnionHeader&& _header) { m_header = std::move(_header); }
1184 RTPS_DllAPI inline const CompleteUnionHeader& header() const { return m_header; }
1185 RTPS_DllAPI inline CompleteUnionHeader& header() { return m_header; }
1186
1187 RTPS_DllAPI inline void discriminator(
1188 const CompleteDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }
1189 RTPS_DllAPI inline void discriminator(
1190 CompleteDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }
1191 RTPS_DllAPI inline const CompleteDiscriminatorMember& discriminator() const { return m_discriminator; }
1192 RTPS_DllAPI inline CompleteDiscriminatorMember& discriminator() { return m_discriminator; }
1193
1194 RTPS_DllAPI inline void member_seq(
1195 const CompleteUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }
1196 RTPS_DllAPI inline void member_seq(
1197 CompleteUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1198 RTPS_DllAPI inline const CompleteUnionMemberSeq& member_seq() const { return m_member_seq; }
1199 RTPS_DllAPI inline CompleteUnionMemberSeq& member_seq() { return m_member_seq; }
1200
1201 RTPS_DllAPI static size_t getCdrSerializedSize(
1202 const CompleteUnionType& data,
1203 size_t current_alignment = 0);
1204 RTPS_DllAPI void serialize(
1205 eprosima::fastcdr::Cdr& cdr) const;
1206 RTPS_DllAPI void deserialize(
1207 eprosima::fastcdr::Cdr& cdr);
1208
1209 RTPS_DllAPI bool operator==(
1210 const CompleteUnionType& other) const;
1211
1212 RTPS_DllAPI bool consistent(
1213 const CompleteUnionType& x,
1214 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1215
1216private:
1217
1218 UnionTypeFlag m_union_flags;
1219 CompleteUnionHeader m_header;
1220 CompleteDiscriminatorMember m_discriminator;
1221 CompleteUnionMemberSeq m_member_seq;
1222};
1223
1224/*struct MinimalUnionType final{
1225 UnionTypeFlag union_flags;
1226 MinimalUnionHeader header;
1227 MinimalDiscriminatorMember discriminator;
1228 MinimalUnionMemberSeq member_seq;
1229 };*/
1231{
1232public:
1233
1234 RTPS_DllAPI MinimalUnionType();
1235 RTPS_DllAPI ~MinimalUnionType();
1236 RTPS_DllAPI MinimalUnionType(
1237 const MinimalUnionType& x);
1238 RTPS_DllAPI MinimalUnionType(
1239 MinimalUnionType&& x);
1241 const MinimalUnionType& x);
1243 MinimalUnionType&& x);
1244
1245 RTPS_DllAPI inline void union_flags(
1246 const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }
1247 RTPS_DllAPI inline void union_flags(
1248 UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }
1249 RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }
1250 RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }
1251
1252 RTPS_DllAPI inline void header(
1253 const MinimalUnionHeader& _header) { m_header = _header; }
1254 RTPS_DllAPI inline void header(
1255 MinimalUnionHeader&& _header) { m_header = std::move(_header); }
1256 RTPS_DllAPI inline const MinimalUnionHeader& header() const { return m_header; }
1257 RTPS_DllAPI inline MinimalUnionHeader& header() { return m_header; }
1258
1259 RTPS_DllAPI inline void discriminator(
1260 const MinimalDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }
1261 RTPS_DllAPI inline void discriminator(
1262 MinimalDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }
1263 RTPS_DllAPI inline const MinimalDiscriminatorMember& discriminator() const { return m_discriminator; }
1264 RTPS_DllAPI inline MinimalDiscriminatorMember& discriminator() { return m_discriminator; }
1265
1266 RTPS_DllAPI inline void member_seq(
1267 const MinimalUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }
1268 RTPS_DllAPI inline void member_seq(
1269 MinimalUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1270 RTPS_DllAPI inline const MinimalUnionMemberSeq& member_seq() const { return m_member_seq; }
1271 RTPS_DllAPI inline MinimalUnionMemberSeq& member_seq() { return m_member_seq; }
1272
1273 RTPS_DllAPI static size_t getCdrSerializedSize(
1274 const MinimalUnionType& data,
1275 size_t current_alignment = 0);
1276 RTPS_DllAPI void serialize(
1277 eprosima::fastcdr::Cdr& cdr) const;
1278 RTPS_DllAPI void deserialize(
1279 eprosima::fastcdr::Cdr& cdr);
1280
1281 RTPS_DllAPI bool operator==(
1282 const MinimalUnionType& other) const;
1283
1284 RTPS_DllAPI bool consistent(
1285 const MinimalUnionType& x,
1286 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1287
1288private:
1289
1290 UnionTypeFlag m_union_flags;
1291 MinimalUnionHeader m_header;
1292 MinimalDiscriminatorMember m_discriminator;
1293 MinimalUnionMemberSeq m_member_seq;
1294};
1295
1296// --- Annotation: ---------------------------------------------------
1297/*struct CommonAnnotationParameter final{
1298 AnnotationParameterFlag member_flags;
1299 TypeIdentifier member_type_id;
1300 };*/
1302{
1303public:
1304
1308 const CommonAnnotationParameter& x);
1312 const CommonAnnotationParameter& x);
1315
1316 RTPS_DllAPI inline void member_flags(
1317 const AnnotationParameterFlag& _member_flags) { m_member_flags = _member_flags; }
1318 RTPS_DllAPI inline void member_flags(
1319 AnnotationParameterFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
1320 RTPS_DllAPI inline const AnnotationParameterFlag& member_flags() const { return m_member_flags; }
1321 RTPS_DllAPI inline AnnotationParameterFlag& member_flags() { return m_member_flags; }
1322
1323 RTPS_DllAPI inline void member_type_id(
1324 const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }
1325 RTPS_DllAPI inline void member_type_id(
1326 TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }
1327 RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }
1328 RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }
1329
1330 RTPS_DllAPI static size_t getCdrSerializedSize(
1331 const CommonAnnotationParameter& data,
1332 size_t current_alignment = 0);
1333 RTPS_DllAPI void serialize(
1334 eprosima::fastcdr::Cdr& cdr) const;
1335 RTPS_DllAPI void deserialize(
1336 eprosima::fastcdr::Cdr& cdr);
1337
1338 RTPS_DllAPI bool operator==(
1339 const CommonAnnotationParameter& other) const;
1340
1341 RTPS_DllAPI bool consistent(
1343 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1344
1345private:
1346
1347 AnnotationParameterFlag m_member_flags;
1348 TypeIdentifier m_member_type_id;
1349};
1350
1351// Member of an annotation type
1352
1353/*struct CompleteAnnotationParameter {
1354 CommonAnnotationParameter common;
1355 MemberName name;
1356 AnnotationParameterValue default_value;
1357 };*/
1359{
1360public:
1361
1372
1373 RTPS_DllAPI inline void common(
1374 const CommonAnnotationParameter& _common) { m_common = _common; }
1375 RTPS_DllAPI inline void common(
1376 CommonAnnotationParameter&& _common) { m_common = std::move(_common); }
1377 RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }
1378 RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }
1379
1380 RTPS_DllAPI inline void name(
1381 const MemberName& _name) { m_name = _name; }
1382 RTPS_DllAPI inline void name(
1383 MemberName&& _name) { m_name = std::move(_name); }
1384 RTPS_DllAPI inline const MemberName& name() const { return m_name; }
1385 RTPS_DllAPI inline MemberName& name() { return m_name; }
1386
1387 RTPS_DllAPI inline void default_value(
1388 const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }
1389 RTPS_DllAPI inline void default_value(
1390 AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }
1391 RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }
1392 RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }
1393
1394 RTPS_DllAPI static size_t getCdrSerializedSize(
1395 const CompleteAnnotationParameter& data,
1396 size_t current_alignment = 0);
1397 RTPS_DllAPI void serialize(
1398 eprosima::fastcdr::Cdr& cdr) const;
1399 RTPS_DllAPI void deserialize(
1400 eprosima::fastcdr::Cdr& cdr);
1401
1402 RTPS_DllAPI bool operator==(
1403 const CompleteAnnotationParameter& other) const;
1404
1405 RTPS_DllAPI bool consistent(
1407 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1408
1409private:
1410
1412 MemberName m_name;
1413 AnnotationParameterValue m_default_value;
1414};
1415// Ordered by CompleteAnnotationParameter.name
1416typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
1417/*struct MinimalAnnotationParameter {
1418 CommonAnnotationParameter common;
1419 NameHash name_hash;
1420 AnnotationParameterValue default_value;
1421 };*/
1423{
1424public:
1425
1436
1437 RTPS_DllAPI inline void common(
1438 const CommonAnnotationParameter& _common) { m_common = _common; }
1439 RTPS_DllAPI inline void common(
1440 CommonAnnotationParameter&& _common) { m_common = std::move(_common); }
1441 RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }
1442 RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }
1443
1444 RTPS_DllAPI inline void name(
1445 const MemberName& _name) { m_name = _name; }
1446 RTPS_DllAPI inline void name(
1447 MemberName&& _name) { m_name = std::move(_name); }
1448 RTPS_DllAPI inline const MemberName& name() const { return m_name; }
1449 RTPS_DllAPI inline MemberName& name() { return m_name; }
1450
1451 RTPS_DllAPI inline void default_value(
1452 const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }
1453 RTPS_DllAPI inline void default_value(
1454 AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }
1455 RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }
1456 RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }
1457
1458 RTPS_DllAPI static size_t getCdrSerializedSize(
1459 const MinimalAnnotationParameter& data,
1460 size_t current_alignment = 0);
1461 RTPS_DllAPI void serialize(
1462 eprosima::fastcdr::Cdr& cdr) const;
1463 RTPS_DllAPI void deserialize(
1464 eprosima::fastcdr::Cdr& cdr);
1465
1466 RTPS_DllAPI bool operator==(
1467 const MinimalAnnotationParameter& other) const;
1468
1469 RTPS_DllAPI bool consistent(
1471 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1472
1473private:
1474
1476 MemberName m_name;
1477 AnnotationParameterValue m_default_value;
1478};
1479
1480// Ordered by MinimalAnnotationParameter.name_hash
1481typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
1482/*struct CompleteAnnotationHeader {
1483 QualifiedTypeName annotation_name;
1484 };*/
1486{
1487public:
1488
1492 const CompleteAnnotationHeader& x);
1496 const CompleteAnnotationHeader& x);
1499
1500 RTPS_DllAPI inline void annotation_name(
1501 const QualifiedTypeName& _annotation_name) { m_annotation_name = _annotation_name; }
1502 RTPS_DllAPI inline void annotation_name(
1503 QualifiedTypeName&& _annotation_name) { m_annotation_name = std::move(_annotation_name); }
1504 RTPS_DllAPI inline const QualifiedTypeName& annotation_name() const { return m_annotation_name; }
1505 RTPS_DllAPI inline QualifiedTypeName& annotation_name() { return m_annotation_name; }
1506
1507 RTPS_DllAPI static size_t getCdrSerializedSize(
1508 const CompleteAnnotationHeader& data,
1509 size_t current_alignment = 0);
1510 RTPS_DllAPI void serialize(
1511 eprosima::fastcdr::Cdr& cdr) const;
1512 RTPS_DllAPI void deserialize(
1513 eprosima::fastcdr::Cdr& cdr);
1514
1515 RTPS_DllAPI bool operator==(
1516 const CompleteAnnotationHeader& other) const;
1517
1518 RTPS_DllAPI bool consistent(
1519 const CompleteAnnotationHeader& x,
1520 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1521
1522private:
1523
1524 QualifiedTypeName m_annotation_name;
1525};
1526
1527/*struct MinimalAnnotationHeader {
1528 // Empty. Available for future extension
1529 };*/
1531{
1532public:
1533
1537 const MinimalAnnotationHeader& x);
1541 const MinimalAnnotationHeader& x);
1544
1545 RTPS_DllAPI static size_t getCdrSerializedSize(
1546 const MinimalAnnotationHeader& data,
1547 size_t current_alignment = 0);
1548 RTPS_DllAPI void serialize(
1549 eprosima::fastcdr::Cdr& cdr) const;
1550 RTPS_DllAPI void deserialize(
1551 eprosima::fastcdr::Cdr& cdr);
1552
1553 RTPS_DllAPI bool operator==(
1554 const MinimalAnnotationHeader&) const { return true; }
1555
1556 RTPS_DllAPI bool consistent(
1557 const MinimalAnnotationHeader& x,
1558 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1559
1560private:
1561
1562};
1563
1564/*struct CompleteAnnotationType final{
1565 AnnotationTypeFlag annotation_flag;
1566 CompleteAnnotationHeader header;
1567 CompleteAnnotationParameterSeq member_seq;
1568 };*/
1570{
1571public:
1572
1576 const CompleteAnnotationType& x);
1580 const CompleteAnnotationType& x);
1583
1584 RTPS_DllAPI inline void annotation_flag(
1585 const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }
1586 RTPS_DllAPI inline void annotation_flag(
1587 AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }
1588 RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }
1589 RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }
1590
1591 RTPS_DllAPI inline void header(
1592 const CompleteAnnotationHeader& _header) { m_header = _header; }
1593 RTPS_DllAPI inline void header(
1594 CompleteAnnotationHeader&& _header) { m_header = std::move(_header); }
1595 RTPS_DllAPI inline const CompleteAnnotationHeader& header() const { return m_header; }
1596 RTPS_DllAPI inline CompleteAnnotationHeader& header() { return m_header; }
1597
1598 RTPS_DllAPI inline void member_seq(
1599 const CompleteAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }
1600 RTPS_DllAPI inline void member_seq(
1601 CompleteAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1602 RTPS_DllAPI inline const CompleteAnnotationParameterSeq& member_seq() const { return m_member_seq; }
1603 RTPS_DllAPI inline CompleteAnnotationParameterSeq& member_seq() { return m_member_seq; }
1604
1605 RTPS_DllAPI static size_t getCdrSerializedSize(
1606 const CompleteAnnotationType& data,
1607 size_t current_alignment = 0);
1608 RTPS_DllAPI void serialize(
1609 eprosima::fastcdr::Cdr& cdr) const;
1610 RTPS_DllAPI void deserialize(
1611 eprosima::fastcdr::Cdr& cdr);
1612
1613 RTPS_DllAPI bool operator==(
1614 const CompleteAnnotationType& other) const;
1615
1616 RTPS_DllAPI bool consistent(
1617 const CompleteAnnotationType& x,
1618 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1619
1620private:
1621
1622 AnnotationTypeFlag m_annotation_flag;
1623 CompleteAnnotationHeader m_header;
1624 CompleteAnnotationParameterSeq m_member_seq;
1625};
1626/*struct MinimalAnnotationType final{
1627 AnnotationTypeFlag annotation_flag;
1628 MinimalAnnotationHeader header;
1629 MinimalAnnotationParameterSeq member_seq;
1630 };*/
1632{
1633public:
1634
1638 const MinimalAnnotationType& x);
1642 const MinimalAnnotationType& x);
1645
1646 RTPS_DllAPI inline void annotation_flag(
1647 const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }
1648 RTPS_DllAPI inline void annotation_flag(
1649 AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }
1650 RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }
1651 RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }
1652
1653 RTPS_DllAPI inline void header(
1654 const MinimalAnnotationHeader& _header) { m_header = _header; }
1655 RTPS_DllAPI inline void header(
1656 MinimalAnnotationHeader&& _header) { m_header = std::move(_header); }
1657 RTPS_DllAPI inline const MinimalAnnotationHeader& header() const { return m_header; }
1658 RTPS_DllAPI inline MinimalAnnotationHeader& header() { return m_header; }
1659
1660 RTPS_DllAPI inline void member_seq(
1661 const MinimalAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }
1662 RTPS_DllAPI inline void member_seq(
1663 MinimalAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1664 RTPS_DllAPI inline const MinimalAnnotationParameterSeq& member_seq() const { return m_member_seq; }
1665 RTPS_DllAPI inline MinimalAnnotationParameterSeq& member_seq() { return m_member_seq; }
1666
1667 RTPS_DllAPI static size_t getCdrSerializedSize(
1668 const MinimalAnnotationType& data,
1669 size_t current_alignment = 0);
1670 RTPS_DllAPI void serialize(
1671 eprosima::fastcdr::Cdr& cdr) const;
1672 RTPS_DllAPI void deserialize(
1673 eprosima::fastcdr::Cdr& cdr);
1674
1675 RTPS_DllAPI bool operator==(
1676 const MinimalAnnotationType& other) const;
1677
1678 RTPS_DllAPI bool consistent(
1679 const MinimalAnnotationType& x,
1680 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1681
1682private:
1683
1684 AnnotationTypeFlag m_annotation_flag;
1685 MinimalAnnotationHeader m_header;
1686 MinimalAnnotationParameterSeq m_member_seq;
1687};
1688
1689// --- Alias: ---------------------------------------------------------
1690/*struct CommonAliasBody final{
1691 AliasMemberFlag related_flags;
1692 TypeIdentifier related_type;
1693 };*/
1695{
1696public:
1697
1698 RTPS_DllAPI CommonAliasBody();
1699 RTPS_DllAPI ~CommonAliasBody();
1700 RTPS_DllAPI CommonAliasBody(
1701 const CommonAliasBody& x);
1702 RTPS_DllAPI CommonAliasBody(
1703 CommonAliasBody&& x);
1705 const CommonAliasBody& x);
1707 CommonAliasBody&& x);
1708
1709 RTPS_DllAPI inline void related_flags(
1710 const AliasMemberFlag& _related_flags) { m_related_flags = _related_flags; }
1711 RTPS_DllAPI inline void related_flags(
1712 AliasMemberFlag&& _related_flags) { m_related_flags = std::move(_related_flags); }
1713 RTPS_DllAPI inline const AliasMemberFlag& related_flags() const { return m_related_flags; }
1714 RTPS_DllAPI inline AliasMemberFlag& related_flags() { return m_related_flags; }
1715
1716 RTPS_DllAPI inline void related_type(
1717 const TypeIdentifier& _related_type) { m_related_type = _related_type; }
1718 RTPS_DllAPI inline void related_type(
1719 TypeIdentifier&& _related_type) { m_related_type = std::move(_related_type); }
1720 RTPS_DllAPI inline const TypeIdentifier& related_type() const { return m_related_type; }
1721 RTPS_DllAPI inline TypeIdentifier& related_type() { return m_related_type; }
1722
1723 RTPS_DllAPI static size_t getCdrSerializedSize(
1724 const CommonAliasBody& data,
1725 size_t current_alignment = 0);
1726 RTPS_DllAPI void serialize(
1727 eprosima::fastcdr::Cdr& cdr) const;
1728 RTPS_DllAPI void deserialize(
1729 eprosima::fastcdr::Cdr& cdr);
1730
1731 RTPS_DllAPI bool operator==(
1732 const CommonAliasBody& other) const;
1733
1734 // RTPS_DllAPI bool consistent(const CommonAliasBody &x,
1735 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1736
1737private:
1738
1739 AliasMemberFlag m_related_flags;
1740 TypeIdentifier m_related_type;
1741};
1742
1743/*struct CompleteAliasBody {
1744 CommonAliasBody common;
1745 AppliedBuiltinMemberAnnotations ann_builtin; // Optional
1746 AppliedAnnotationSeq ann_custom; // Optional
1747 };*/
1749{
1750public:
1751
1752 RTPS_DllAPI CompleteAliasBody();
1753 RTPS_DllAPI ~CompleteAliasBody();
1755 const CompleteAliasBody& x);
1757 CompleteAliasBody&& x);
1759 const CompleteAliasBody& x);
1761 CompleteAliasBody&& x);
1762
1763 RTPS_DllAPI inline void common(
1764 const CommonAliasBody& _common) { m_common = _common; }
1765 RTPS_DllAPI inline void common(
1766 CommonAliasBody&& _common) { m_common = std::move(_common); }
1767 RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }
1768 RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }
1769
1770 RTPS_DllAPI inline void ann_builtin(
1771 const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
1772 RTPS_DllAPI inline void ann_builtin(
1773 AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
1774 RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
1775 RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
1776
1777 RTPS_DllAPI inline void ann_custom(
1778 const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
1779 RTPS_DllAPI inline void ann_custom(
1780 AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
1781 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
1782 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
1783
1784 RTPS_DllAPI static size_t getCdrSerializedSize(
1785 const CompleteAliasBody& data,
1786 size_t current_alignment = 0);
1787 RTPS_DllAPI void serialize(
1788 eprosima::fastcdr::Cdr& cdr) const;
1789 RTPS_DllAPI void deserialize(
1790 eprosima::fastcdr::Cdr& cdr);
1791
1792 RTPS_DllAPI bool operator==(
1793 const CompleteAliasBody& other) const;
1794
1795 // RTPS_DllAPI bool consistent(const CompleteAliasBody &x,
1796 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1797
1798private:
1799
1800 CommonAliasBody m_common;
1801 AppliedBuiltinMemberAnnotations m_ann_builtin;
1802 AppliedAnnotationSeq m_ann_custom;
1803};
1804
1805/*struct MinimalAliasBody {
1806 CommonAliasBody common;
1807 };*/
1809{
1810public:
1811
1812 RTPS_DllAPI MinimalAliasBody();
1813 RTPS_DllAPI ~MinimalAliasBody();
1814 RTPS_DllAPI MinimalAliasBody(
1815 const MinimalAliasBody& x);
1816 RTPS_DllAPI MinimalAliasBody(
1817 MinimalAliasBody&& x);
1819 const MinimalAliasBody& x);
1821 MinimalAliasBody&& x);
1822
1823 RTPS_DllAPI inline void common(
1824 const CommonAliasBody& _common) { m_common = _common; }
1825 RTPS_DllAPI inline void common(
1826 CommonAliasBody&& _common) { m_common = std::move(_common); }
1827 RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }
1828 RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }
1829
1830 RTPS_DllAPI static size_t getCdrSerializedSize(
1831 const MinimalAliasBody& data,
1832 size_t current_alignment = 0);
1833 RTPS_DllAPI void serialize(
1834 eprosima::fastcdr::Cdr& cdr) const;
1835 RTPS_DllAPI void deserialize(
1836 eprosima::fastcdr::Cdr& cdr);
1837
1838 RTPS_DllAPI bool operator==(
1839 const MinimalAliasBody& other) const;
1840
1841 // RTPS_DllAPI bool consistent(const MinimalAliasBody &x,
1842 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1843
1844private:
1845
1846 CommonAliasBody m_common;
1847};
1848
1849/*struct CompleteAliasHeader {
1850 CompleteTypeDetail detail;
1851 };*/
1853{
1854public:
1855
1856 RTPS_DllAPI CompleteAliasHeader();
1859 const CompleteAliasHeader& x);
1863 const CompleteAliasHeader& x);
1866
1867 RTPS_DllAPI inline void detail(
1868 const CompleteTypeDetail& _detail) { m_detail = _detail; }
1869 RTPS_DllAPI inline void detail(
1870 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
1871 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
1872 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
1873
1874 RTPS_DllAPI static size_t getCdrSerializedSize(
1875 const CompleteAliasHeader& data,
1876 size_t current_alignment = 0);
1877 RTPS_DllAPI void serialize(
1878 eprosima::fastcdr::Cdr& cdr) const;
1879 RTPS_DllAPI void deserialize(
1880 eprosima::fastcdr::Cdr& cdr);
1881
1882 RTPS_DllAPI bool operator==(
1883 const CompleteAliasHeader& other) const;
1884
1885 // RTPS_DllAPI bool consistent(const CompleteAliasHeader &x,
1886 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1887
1888private:
1889
1890 CompleteTypeDetail m_detail;
1891};
1892
1893/*struct MinimalAliasHeader {
1894 // Empty. Available for future extension
1895 };*/
1897{
1898public:
1899
1900 RTPS_DllAPI MinimalAliasHeader();
1901 RTPS_DllAPI ~MinimalAliasHeader();
1903 const MinimalAliasHeader& x);
1905 MinimalAliasHeader&& x);
1907 const MinimalAliasHeader& x);
1909 MinimalAliasHeader&& x);
1910
1911 RTPS_DllAPI static size_t getCdrSerializedSize(
1912 const MinimalAliasHeader& data,
1913 size_t current_alignment = 0);
1914 RTPS_DllAPI void serialize(
1915 eprosima::fastcdr::Cdr& cdr) const;
1916 RTPS_DllAPI void deserialize(
1917 eprosima::fastcdr::Cdr& cdr);
1918
1919 RTPS_DllAPI bool operator==(
1920 const MinimalAliasHeader&) const { return true; }
1921
1922 // RTPS_DllAPI bool consistent(const MinimalAliasHeader &x,
1923 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1924
1925private:
1926
1927};
1928
1929/*struct CompleteAliasType final{
1930 AliasTypeFlag alias_flags;
1931 CompleteAliasHeader header;
1932 CompleteAliasBody body;
1933 };*/
1935{
1936public:
1937
1938 RTPS_DllAPI CompleteAliasType();
1939 RTPS_DllAPI ~CompleteAliasType();
1941 const CompleteAliasType& x);
1943 CompleteAliasType&& x);
1945 const CompleteAliasType& x);
1947 CompleteAliasType&& x);
1948
1949 RTPS_DllAPI inline void alias_flags(
1950 const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }
1951 RTPS_DllAPI inline void alias_flags(
1952 AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }
1953 RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }
1954 RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }
1955
1956 RTPS_DllAPI inline void header(
1957 const CompleteAliasHeader& _header) { m_header = _header; }
1958 RTPS_DllAPI inline void header(
1959 CompleteAliasHeader&& _header) { m_header = std::move(_header); }
1960 RTPS_DllAPI inline const CompleteAliasHeader& header() const { return m_header; }
1961 RTPS_DllAPI inline CompleteAliasHeader& header() { return m_header; }
1962
1963 RTPS_DllAPI inline void body(
1964 const CompleteAliasBody& _body) { m_body = _body; }
1965 RTPS_DllAPI inline void body(
1966 CompleteAliasBody&& _body) { m_body = std::move(_body); }
1967 RTPS_DllAPI inline const CompleteAliasBody& body() const { return m_body; }
1968 RTPS_DllAPI inline CompleteAliasBody& body() { return m_body; }
1969
1970 RTPS_DllAPI static size_t getCdrSerializedSize(
1971 const CompleteAliasType& data,
1972 size_t current_alignment = 0);
1973 RTPS_DllAPI void serialize(
1974 eprosima::fastcdr::Cdr& cdr) const;
1975 RTPS_DllAPI void deserialize(
1976 eprosima::fastcdr::Cdr& cdr);
1977
1978 RTPS_DllAPI bool operator==(
1979 const CompleteAliasType& other) const;
1980
1981 // RTPS_DllAPI bool consistent(const CompleteAliasType &x,
1982 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1983
1984private:
1985
1986 AliasTypeFlag m_alias_flags;
1987 CompleteAliasHeader m_header;
1988 CompleteAliasBody m_body;
1989};
1990/*struct MinimalAliasType final{
1991 AliasTypeFlag alias_flags;
1992 MinimalAliasHeader header;
1993 MinimalAliasBody body;
1994 };*/
1996{
1997public:
1998
1999 RTPS_DllAPI MinimalAliasType();
2000 RTPS_DllAPI ~MinimalAliasType();
2001 RTPS_DllAPI MinimalAliasType(
2002 const MinimalAliasType& x);
2003 RTPS_DllAPI MinimalAliasType(
2004 MinimalAliasType&& x);
2006 const MinimalAliasType& x);
2008 MinimalAliasType&& x);
2009
2010 RTPS_DllAPI inline void alias_flags(
2011 const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }
2012 RTPS_DllAPI inline void alias_flags(
2013 AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }
2014 RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }
2015 RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }
2016
2017 RTPS_DllAPI inline void header(
2018 const MinimalAliasHeader& _header) { m_header = _header; }
2019 RTPS_DllAPI inline void header(
2020 MinimalAliasHeader&& _header) { m_header = std::move(_header); }
2021 RTPS_DllAPI inline const MinimalAliasHeader& header() const { return m_header; }
2022 RTPS_DllAPI inline MinimalAliasHeader& header() { return m_header; }
2023
2024 RTPS_DllAPI inline void body(
2025 const MinimalAliasBody& _body) { m_body = _body; }
2026 RTPS_DllAPI inline void body(
2027 MinimalAliasBody&& _body) { m_body = std::move(_body); }
2028 RTPS_DllAPI inline const MinimalAliasBody& body() const { return m_body; }
2029 RTPS_DllAPI inline MinimalAliasBody& body() { return m_body; }
2030
2031 RTPS_DllAPI static size_t getCdrSerializedSize(
2032 const MinimalAliasType& data,
2033 size_t current_alignment = 0);
2034 RTPS_DllAPI void serialize(
2035 eprosima::fastcdr::Cdr& cdr) const;
2036 RTPS_DllAPI void deserialize(
2037 eprosima::fastcdr::Cdr& cdr);
2038
2039 RTPS_DllAPI bool operator==(
2040 const MinimalAliasType& other) const;
2041
2042 // RTPS_DllAPI bool consistent(const MinimalAliasType &x,
2043 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2044
2045private:
2046
2047 AliasTypeFlag m_alias_flags;
2048 MinimalAliasHeader m_header;
2049 MinimalAliasBody m_body;
2050};
2051
2052// --- Collections: ---------------------------------------------------
2053/*struct CompleteElementDetail final{
2054 AppliedBuiltinMemberAnnotations ann_builtin; // Optional
2055 AppliedAnnotationSeq ann_custom; // Optional
2056 };*/
2058{
2059public:
2060
2064 const CompleteElementDetail& x);
2068 const CompleteElementDetail& x);
2071
2072 RTPS_DllAPI inline void ann_builtin(
2073 const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
2074 RTPS_DllAPI inline void ann_builtin(
2075 AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
2076 RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
2077 RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
2078
2079 RTPS_DllAPI inline void ann_custom(
2080 const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
2081 RTPS_DllAPI inline void ann_custom(
2082 AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
2083 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
2084 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
2085
2086 RTPS_DllAPI static size_t getCdrSerializedSize(
2087 const CompleteElementDetail& data,
2088 size_t current_alignment = 0);
2089 RTPS_DllAPI void serialize(
2090 eprosima::fastcdr::Cdr& cdr) const;
2091 RTPS_DllAPI void deserialize(
2092 eprosima::fastcdr::Cdr& cdr);
2093
2094 RTPS_DllAPI bool operator==(
2095 const CompleteElementDetail& other) const;
2096
2097 RTPS_DllAPI bool consistent(
2098 const CompleteElementDetail& x,
2099 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2100
2101private:
2102
2103 AppliedBuiltinMemberAnnotations m_ann_builtin;
2104 AppliedAnnotationSeq m_ann_custom;
2105};
2106/*struct CommonCollectionElement final{
2107 CollectionElementFlag element_flags;
2108 TypeIdentifier type;
2109 };*/
2111{
2112public:
2113
2117 const CommonCollectionElement& x);
2121 const CommonCollectionElement& x);
2124
2125 RTPS_DllAPI inline void element_flags(
2126 const CollectionElementFlag& _element_flags) { m_element_flags = _element_flags; }
2127 RTPS_DllAPI inline void element_flags(
2128 CollectionElementFlag&& _element_flags) { m_element_flags = std::move(_element_flags); }
2129 RTPS_DllAPI inline const CollectionElementFlag& element_flags() const { return m_element_flags; }
2130 RTPS_DllAPI inline CollectionElementFlag& element_flags() { return m_element_flags; }
2131
2132 RTPS_DllAPI inline void type(
2133 const TypeIdentifier& _type) { m_type = _type; }
2134 RTPS_DllAPI inline void type(
2135 TypeIdentifier&& _type) { m_type = std::move(_type); }
2136 RTPS_DllAPI inline const TypeIdentifier& type() const { return m_type; }
2137 RTPS_DllAPI inline TypeIdentifier& type() { return m_type; }
2138
2139 RTPS_DllAPI static size_t getCdrSerializedSize(
2140 const CommonCollectionElement& data,
2141 size_t current_alignment = 0);
2142 RTPS_DllAPI void serialize(
2143 eprosima::fastcdr::Cdr& cdr) const;
2144 RTPS_DllAPI void deserialize(
2145 eprosima::fastcdr::Cdr& cdr);
2146
2147 RTPS_DllAPI bool operator==(
2148 const CommonCollectionElement& other) const;
2149
2150 RTPS_DllAPI bool consistent(
2151 const CommonCollectionElement& x,
2152 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2153
2154private:
2155
2156 CollectionElementFlag m_element_flags;
2157 TypeIdentifier m_type;
2158};
2159
2160/*struct CompleteCollectionElement {
2161 CommonCollectionElement common;
2162 CompleteElementDetail detail;
2163 };*/
2165{
2166public:
2167
2171 const CompleteCollectionElement& x);
2175 const CompleteCollectionElement& x);
2178
2179 RTPS_DllAPI inline void common(
2180 const CommonCollectionElement& _common) { m_common = _common; }
2181 RTPS_DllAPI inline void common(
2182 CommonCollectionElement&& _common) { m_common = std::move(_common); }
2183 RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }
2184 RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }
2185
2186 RTPS_DllAPI inline void detail(
2187 const CompleteElementDetail& _detail) { m_detail = _detail; }
2188 RTPS_DllAPI inline void detail(
2189 CompleteElementDetail&& _detail) { m_detail = std::move(_detail); }
2190 RTPS_DllAPI inline const CompleteElementDetail& detail() const { return m_detail; }
2191 RTPS_DllAPI inline CompleteElementDetail& detail() { return m_detail; }
2192
2193 RTPS_DllAPI static size_t getCdrSerializedSize(
2194 const CompleteCollectionElement& data,
2195 size_t current_alignment = 0);
2196 RTPS_DllAPI void serialize(
2197 eprosima::fastcdr::Cdr& cdr) const;
2198 RTPS_DllAPI void deserialize(
2199 eprosima::fastcdr::Cdr& cdr);
2200
2201 RTPS_DllAPI bool operator==(
2202 const CompleteCollectionElement& other) const;
2203
2204 RTPS_DllAPI bool consistent(
2206 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2207
2208private:
2209
2210 CommonCollectionElement m_common;
2211 CompleteElementDetail m_detail;
2212};
2213
2214/*struct MinimalCollectionElement {
2215 CommonCollectionElement common;
2216 };*/
2218{
2219public:
2220
2224 const MinimalCollectionElement& x);
2228 const MinimalCollectionElement& x);
2231
2232 RTPS_DllAPI inline void common(
2233 const CommonCollectionElement& _common) { m_common = _common; }
2234 RTPS_DllAPI inline void common(
2235 CommonCollectionElement&& _common) { m_common = std::move(_common); }
2236 RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }
2237 RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }
2238
2239 RTPS_DllAPI static size_t getCdrSerializedSize(
2240 const MinimalCollectionElement& data,
2241 size_t current_alignment = 0);
2242 RTPS_DllAPI void serialize(
2243 eprosima::fastcdr::Cdr& cdr) const;
2244 RTPS_DllAPI void deserialize(
2245 eprosima::fastcdr::Cdr& cdr);
2246
2247 RTPS_DllAPI bool operator==(
2248 const MinimalCollectionElement& other) const;
2249
2250 RTPS_DllAPI bool consistent(
2251 const MinimalCollectionElement& x,
2252 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2253
2254private:
2255
2256 CommonCollectionElement m_common;
2257};
2258
2259/*struct CommonCollectionHeader final{
2260 LBound bound;
2261 };*/
2263{
2264public:
2265
2269 const CommonCollectionHeader& x);
2273 const CommonCollectionHeader& x);
2276
2277 RTPS_DllAPI inline void bound(
2278 const LBound& _bound) { m_bound = _bound; }
2279 RTPS_DllAPI inline void bound(
2280 LBound&& _bound) { m_bound = std::move(_bound); }
2281 RTPS_DllAPI inline const LBound& bound() const { return m_bound; }
2282 RTPS_DllAPI inline LBound& bound() { return m_bound; }
2283
2284 RTPS_DllAPI static size_t getCdrSerializedSize(
2285 const CommonCollectionHeader& data,
2286 size_t current_alignment = 0);
2287 RTPS_DllAPI void serialize(
2288 eprosima::fastcdr::Cdr& cdr) const;
2289 RTPS_DllAPI void deserialize(
2290 eprosima::fastcdr::Cdr& cdr);
2291
2292 RTPS_DllAPI bool operator==(
2293 const CommonCollectionHeader& other) const;
2294
2295 RTPS_DllAPI bool consistent(
2296 const CommonCollectionHeader& x,
2297 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2298
2299private:
2300
2301 LBound m_bound;
2302};
2303
2304/*struct CompleteCollectionHeader {
2305 CommonCollectionHeader common;
2306 CompleteTypeDetail detail; // Optional // not present for anonymous
2307 };*/
2309{
2310public:
2311
2315 const CompleteCollectionHeader& x);
2319 const CompleteCollectionHeader& x);
2322
2323 RTPS_DllAPI inline void common(
2324 const CommonCollectionHeader& _common) { m_common = _common; }
2325 RTPS_DllAPI inline void common(
2326 CommonCollectionHeader&& _common) { m_common = std::move(_common); }
2327 RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }
2328 RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }
2329
2330 RTPS_DllAPI inline void detail(
2331 const CompleteTypeDetail& _detail) { m_detail = _detail; }
2332 RTPS_DllAPI inline void detail(
2333 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
2334 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
2335 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
2336
2337 RTPS_DllAPI static size_t getCdrSerializedSize(
2338 const CompleteCollectionHeader& data,
2339 size_t current_alignment = 0);
2340 RTPS_DllAPI void serialize(
2341 eprosima::fastcdr::Cdr& cdr) const;
2342 RTPS_DllAPI void deserialize(
2343 eprosima::fastcdr::Cdr& cdr);
2344
2345 RTPS_DllAPI bool operator==(
2346 const CompleteCollectionHeader& other) const;
2347
2348 RTPS_DllAPI bool consistent(
2349 const CompleteCollectionHeader& x,
2350 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2351
2352private:
2353
2354 CommonCollectionHeader m_common;
2355 CompleteTypeDetail m_detail;
2356};
2357
2358/*struct MinimalCollectionHeader {
2359 CommonCollectionHeader common;
2360 };*/
2362{
2363public:
2364
2368 const MinimalCollectionHeader& x);
2372 const MinimalCollectionHeader& x);
2375
2376 RTPS_DllAPI inline void common(
2377 const CommonCollectionHeader& _common) { m_common = _common; }
2378 RTPS_DllAPI inline void common(
2379 CommonCollectionHeader&& _common) { m_common = std::move(_common); }
2380 RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }
2381 RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }
2382
2383 RTPS_DllAPI static size_t getCdrSerializedSize(
2384 const MinimalCollectionHeader& data,
2385 size_t current_alignment = 0);
2386 RTPS_DllAPI void serialize(
2387 eprosima::fastcdr::Cdr& cdr) const;
2388 RTPS_DllAPI void deserialize(
2389 eprosima::fastcdr::Cdr& cdr);
2390
2391 RTPS_DllAPI bool operator==(
2392 const MinimalCollectionHeader& other) const;
2393
2394 RTPS_DllAPI bool consistent(
2395 const MinimalCollectionHeader& x,
2396 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2397
2398private:
2399
2400 CommonCollectionHeader m_common;
2401};
2402
2403// --- Sequence: -----------------------------------------------------
2404/*struct CompleteSequenceType final{
2405 CollectionTypeFlag collection_flag;
2406 CompleteCollectionHeader header;
2407 CompleteCollectionElement element;
2408 };*/
2410{
2411public:
2412
2416 const CompleteSequenceType& x);
2420 const CompleteSequenceType& x);
2423
2424 RTPS_DllAPI inline void collection_flag(
2425 const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2426 RTPS_DllAPI inline void collection_flag(
2427 CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2428 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2429 RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2430
2431 RTPS_DllAPI inline void header(
2432 const CompleteCollectionHeader& _header) { m_header = _header; }
2433 RTPS_DllAPI inline void header(
2434 CompleteCollectionHeader&& _header) { m_header = std::move(_header); }
2435 RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }
2436 RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }
2437
2438 RTPS_DllAPI inline void element(
2439 const CompleteCollectionElement& _element) { m_element = _element; }
2440 RTPS_DllAPI inline void element(
2441 CompleteCollectionElement&& _element) { m_element = std::move(_element); }
2442 RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
2443 RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
2444
2445 RTPS_DllAPI static size_t getCdrSerializedSize(
2446 const CompleteSequenceType& data,
2447 size_t current_alignment = 0);
2448 RTPS_DllAPI void serialize(
2449 eprosima::fastcdr::Cdr& cdr) const;
2450 RTPS_DllAPI void deserialize(
2451 eprosima::fastcdr::Cdr& cdr);
2452
2453 RTPS_DllAPI bool operator==(
2454 const CompleteSequenceType& other) const;
2455
2456 RTPS_DllAPI bool consistent(
2457 const CompleteSequenceType& x,
2458 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2459
2460private:
2461
2462 CollectionTypeFlag m_collection_flag;
2463 CompleteCollectionHeader m_header;
2464 CompleteCollectionElement m_element;
2465};
2466
2467/*struct MinimalSequenceType final{
2468 CollectionTypeFlag collection_flag;
2469 MinimalCollectionHeader header;
2470 MinimalCollectionElement element;
2471 };*/
2473{
2474public:
2475
2476 RTPS_DllAPI MinimalSequenceType();
2479 const MinimalSequenceType& x);
2483 const MinimalSequenceType& x);
2486
2487 RTPS_DllAPI inline void collection_flag(
2488 const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2489 RTPS_DllAPI inline void collection_flag(
2490 CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2491 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2492 RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2493
2494 RTPS_DllAPI inline void header(
2495 const MinimalCollectionHeader& _header) { m_header = _header; }
2496 RTPS_DllAPI inline void header(
2497 MinimalCollectionHeader&& _header) { m_header = std::move(_header); }
2498 RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }
2499 RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }
2500
2501 RTPS_DllAPI inline void element(
2502 const MinimalCollectionElement& _element) { m_element = _element; }
2503 RTPS_DllAPI inline void element(
2504 MinimalCollectionElement&& _element) { m_element = std::move(_element); }
2505 RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
2506 RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
2507
2508 RTPS_DllAPI static size_t getCdrSerializedSize(
2509 const MinimalSequenceType& data,
2510 size_t current_alignment = 0);
2511 RTPS_DllAPI void serialize(
2512 eprosima::fastcdr::Cdr& cdr) const;
2513 RTPS_DllAPI void deserialize(
2514 eprosima::fastcdr::Cdr& cdr);
2515
2516 RTPS_DllAPI bool operator==(
2517 const MinimalSequenceType& other) const;
2518
2519 RTPS_DllAPI bool consistent(
2520 const MinimalSequenceType& x,
2521 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2522
2523private:
2524
2525 CollectionTypeFlag m_collection_flag;
2526 MinimalCollectionHeader m_header;
2527 MinimalCollectionElement m_element;
2528};
2529
2530// --- Array: -----------------------------------------------------
2531/*struct CommonArrayHeader final{
2532 LBoundSeq bound_seq;
2533 };*/
2535{
2536public:
2537
2538 RTPS_DllAPI CommonArrayHeader();
2539 RTPS_DllAPI ~CommonArrayHeader();
2541 const CommonArrayHeader& x);
2543 CommonArrayHeader&& x);
2545 const CommonArrayHeader& x);
2547 CommonArrayHeader&& x);
2548
2549 RTPS_DllAPI inline void bound_seq(
2550 const LBoundSeq& _bound_seq) { m_bound_seq = _bound_seq; }
2551 RTPS_DllAPI inline void bound_seq(
2552 LBoundSeq&& _bound_seq) { m_bound_seq = std::move(_bound_seq); }
2553 RTPS_DllAPI inline const LBoundSeq& bound_seq() const { return m_bound_seq; }
2554 RTPS_DllAPI inline LBoundSeq& bound_seq() { return m_bound_seq; }
2555
2556 RTPS_DllAPI static size_t getCdrSerializedSize(
2557 const CommonArrayHeader& data,
2558 size_t current_alignment = 0);
2559 RTPS_DllAPI void serialize(
2560 eprosima::fastcdr::Cdr& cdr) const;
2561 RTPS_DllAPI void deserialize(
2562 eprosima::fastcdr::Cdr& cdr);
2563
2564 RTPS_DllAPI bool operator==(
2565 const CommonArrayHeader& other) const;
2566
2567 RTPS_DllAPI bool consistent(
2568 const CommonArrayHeader& x,
2569 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2570
2571private:
2572
2573 LBoundSeq m_bound_seq;
2574};
2575
2576/*struct CompleteArrayHeader {
2577 CommonArrayHeader common;
2578 CompleteTypeDetail detail;
2579 };*/
2581{
2582public:
2583
2584 RTPS_DllAPI CompleteArrayHeader();
2587 const CompleteArrayHeader& x);
2591 const CompleteArrayHeader& x);
2594
2595 RTPS_DllAPI inline void common(
2596 const CommonArrayHeader& _common) { m_common = _common; }
2597 RTPS_DllAPI inline void common(
2598 CommonArrayHeader&& _common) { m_common = std::move(_common); }
2599 RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }
2600 RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }
2601
2602 RTPS_DllAPI inline void detail(
2603 const CompleteTypeDetail& _detail) { m_detail = _detail; }
2604 RTPS_DllAPI inline void detail(
2605 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
2606 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
2607 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
2608
2609 RTPS_DllAPI static size_t getCdrSerializedSize(
2610 const CompleteArrayHeader& data,
2611 size_t current_alignment = 0);
2612 RTPS_DllAPI void serialize(
2613 eprosima::fastcdr::Cdr& cdr) const;
2614 RTPS_DllAPI void deserialize(
2615 eprosima::fastcdr::Cdr& cdr);
2616
2617 RTPS_DllAPI bool operator==(
2618 const CompleteArrayHeader& other) const;
2619
2620 RTPS_DllAPI bool consistent(
2621 const CompleteArrayHeader& x,
2622 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2623
2624private:
2625
2626 CommonArrayHeader m_common;
2627 CompleteTypeDetail m_detail;
2628};
2629
2630/*struct MinimalArrayHeader {
2631 CommonArrayHeader common;
2632 };*/
2634{
2635public:
2636
2637 RTPS_DllAPI MinimalArrayHeader();
2638 RTPS_DllAPI ~MinimalArrayHeader();
2640 const MinimalArrayHeader& x);
2642 MinimalArrayHeader&& x);
2644 const MinimalArrayHeader& x);
2646 MinimalArrayHeader&& x);
2647
2648 RTPS_DllAPI inline void common(
2649 const CommonArrayHeader& _common) { m_common = _common; }
2650 RTPS_DllAPI inline void common(
2651 CommonArrayHeader&& _common) { m_common = std::move(_common); }
2652 RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }
2653 RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }
2654
2655 RTPS_DllAPI static size_t getCdrSerializedSize(
2656 const MinimalArrayHeader& data,
2657 size_t current_alignment = 0);
2658 RTPS_DllAPI void serialize(
2659 eprosima::fastcdr::Cdr& cdr) const;
2660 RTPS_DllAPI void deserialize(
2661 eprosima::fastcdr::Cdr& cdr);
2662
2663 RTPS_DllAPI bool operator==(
2664 const MinimalArrayHeader& other) const;
2665
2666 RTPS_DllAPI bool consistent(
2667 const MinimalArrayHeader& x,
2668 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2669
2670private:
2671
2672 CommonArrayHeader m_common;
2673};
2674
2675/*struct CompleteArrayType {
2676 CollectionTypeFlag collection_flag;
2677 CompleteArrayHeader header;
2678 CompleteCollectionElement element;
2679 };*/
2681{
2682public:
2683
2684 RTPS_DllAPI CompleteArrayType();
2685 RTPS_DllAPI ~CompleteArrayType();
2687 const CompleteArrayType& x);
2689 CompleteArrayType&& x);
2691 const CompleteArrayType& x);
2693 CompleteArrayType&& x);
2694
2695 RTPS_DllAPI inline void collection_flag(
2696 const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2697 RTPS_DllAPI inline void collection_flag(
2698 CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2699 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2700 RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2701
2702 RTPS_DllAPI inline void header(
2703 const CompleteArrayHeader& _header) { m_header = _header; }
2704 RTPS_DllAPI inline void header(
2705 CompleteArrayHeader&& _header) { m_header = std::move(_header); }
2706 RTPS_DllAPI inline const CompleteArrayHeader& header() const { return m_header; }
2707 RTPS_DllAPI inline CompleteArrayHeader& header() { return m_header; }
2708
2709 RTPS_DllAPI inline void element(
2710 const CompleteCollectionElement& _element) { m_element = _element; }
2711 RTPS_DllAPI inline void element(
2712 CompleteCollectionElement&& _element) { m_element = std::move(_element); }
2713 RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
2714 RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
2715
2716 RTPS_DllAPI static size_t getCdrSerializedSize(
2717 const CompleteArrayType& data,
2718 size_t current_alignment = 0);
2719 RTPS_DllAPI void serialize(
2720 eprosima::fastcdr::Cdr& cdr) const;
2721 RTPS_DllAPI void deserialize(
2722 eprosima::fastcdr::Cdr& cdr);
2723
2724 RTPS_DllAPI bool operator==(
2725 const CompleteArrayType& other) const;
2726
2727 RTPS_DllAPI bool consistent(
2728 const CompleteArrayType& x,
2729 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2730
2731private:
2732
2733 CollectionTypeFlag m_collection_flag;
2734 CompleteArrayHeader m_header;
2735 CompleteCollectionElement m_element;
2736};
2737
2738/*struct MinimalArrayType final{
2739 CollectionTypeFlag collection_flag;
2740 MinimalArrayHeader header;
2741 MinimalCollectionElement element;
2742 };*/
2744{
2745public:
2746
2747 RTPS_DllAPI MinimalArrayType();
2748 RTPS_DllAPI ~MinimalArrayType();
2749 RTPS_DllAPI MinimalArrayType(
2750 const MinimalArrayType& x);
2751 RTPS_DllAPI MinimalArrayType(
2752 MinimalArrayType&& x);
2754 const MinimalArrayType& x);
2756 MinimalArrayType&& x);
2757
2758 RTPS_DllAPI inline void collection_flag(
2759 const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2760 RTPS_DllAPI inline void collection_flag(
2761 CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2762 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2763 RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2764
2765 RTPS_DllAPI inline void header(
2766 const MinimalArrayHeader& _header) { m_header = _header; }
2767 RTPS_DllAPI inline void header(
2768 MinimalArrayHeader&& _header) { m_header = std::move(_header); }
2769 RTPS_DllAPI inline const MinimalArrayHeader& header() const { return m_header; }
2770 RTPS_DllAPI inline MinimalArrayHeader& header() { return m_header; }
2771
2772 RTPS_DllAPI inline void element(
2773 const MinimalCollectionElement& _element) { m_element = _element; }
2774 RTPS_DllAPI inline void element(
2775 MinimalCollectionElement&& _element) { m_element = std::move(_element); }
2776 RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
2777 RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
2778
2779 RTPS_DllAPI static size_t getCdrSerializedSize(
2780 const MinimalArrayType& data,
2781 size_t current_alignment = 0);
2782 RTPS_DllAPI void serialize(
2783 eprosima::fastcdr::Cdr& cdr) const;
2784 RTPS_DllAPI void deserialize(
2785 eprosima::fastcdr::Cdr& cdr);
2786
2787 RTPS_DllAPI bool operator==(
2788 const MinimalArrayType& other) const;
2789
2790 RTPS_DllAPI bool consistent(
2791 const MinimalArrayType& x,
2792 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2793
2794private:
2795
2796 CollectionTypeFlag m_collection_flag;
2797 MinimalArrayHeader m_header;
2798 MinimalCollectionElement m_element;
2799};
2800
2801// --- Map: -----------------------------------------------------
2802/*struct CompleteMapType final{
2803 CollectionTypeFlag collection_flag;
2804 CompleteCollectionHeader header;
2805 CompleteCollectionElement key;
2806 CompleteCollectionElement element;
2807 };*/
2809{
2810public:
2811
2812 RTPS_DllAPI CompleteMapType();
2813 RTPS_DllAPI ~CompleteMapType();
2814 RTPS_DllAPI CompleteMapType(
2815 const CompleteMapType& x);
2816 RTPS_DllAPI CompleteMapType(
2817 CompleteMapType&& x);
2819 const CompleteMapType& x);
2821 CompleteMapType&& x);
2822
2823 RTPS_DllAPI inline void collection_flag(
2824 const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2825 RTPS_DllAPI inline void collection_flag(
2826 CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2827 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2828 RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2829
2830 RTPS_DllAPI inline void header(
2831 const CompleteCollectionHeader& _header) { m_header = _header; }
2832 RTPS_DllAPI inline void header(
2833 CompleteCollectionHeader&& _header) { m_header = std::move(_header); }
2834 RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }
2835 RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }
2836
2837 RTPS_DllAPI inline void key(
2838 const CompleteCollectionElement& _key) { m_key = _key; }
2839 RTPS_DllAPI inline void key(
2840 CompleteCollectionElement&& _key) { m_key = std::move(_key); }
2841 RTPS_DllAPI inline const CompleteCollectionElement& key() const { return m_key; }
2842 RTPS_DllAPI inline CompleteCollectionElement& key() { return m_key; }
2843
2844 RTPS_DllAPI inline void element(
2845 const CompleteCollectionElement& _element) { m_element = _element; }
2846 RTPS_DllAPI inline void element(
2847 CompleteCollectionElement&& _element) { m_element = std::move(_element); }
2848 RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
2849 RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
2850
2851 RTPS_DllAPI static size_t getCdrSerializedSize(
2852 const CompleteMapType& data,
2853 size_t current_alignment = 0);
2854 RTPS_DllAPI void serialize(
2855 eprosima::fastcdr::Cdr& cdr) const;
2856 RTPS_DllAPI void deserialize(
2857 eprosima::fastcdr::Cdr& cdr);
2858
2859 RTPS_DllAPI bool operator==(
2860 const CompleteMapType& other) const;
2861
2862 RTPS_DllAPI bool consistent(
2863 const CompleteMapType& x,
2864 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2865
2866private:
2867
2868 CollectionTypeFlag m_collection_flag;
2869 CompleteCollectionHeader m_header;
2871 CompleteCollectionElement m_element;
2872};
2873/*struct MinimalMapType final{
2874 CollectionTypeFlag collection_flag;
2875 MinimalCollectionHeader header;
2876 MinimalCollectionElement key;
2877 MinimalCollectionElement element;
2878 };*/
2880{
2881public:
2882
2883 RTPS_DllAPI MinimalMapType();
2884 RTPS_DllAPI ~MinimalMapType();
2885 RTPS_DllAPI MinimalMapType(
2886 const MinimalMapType& x);
2887 RTPS_DllAPI MinimalMapType(
2888 MinimalMapType&& x);
2890 const MinimalMapType& x);
2892 MinimalMapType&& x);
2893
2894 RTPS_DllAPI inline void collection_flag(
2895 const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2896 RTPS_DllAPI inline void collection_flag(
2897 CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2898 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2899 RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2900
2901 RTPS_DllAPI inline void header(
2902 const MinimalCollectionHeader& _header) { m_header = _header; }
2903 RTPS_DllAPI inline void header(
2904 MinimalCollectionHeader&& _header) { m_header = std::move(_header); }
2905 RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }
2906 RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }
2907
2908 RTPS_DllAPI inline void key(
2909 const MinimalCollectionElement& _key) { m_key = _key; }
2910 RTPS_DllAPI inline void key(
2911 MinimalCollectionElement&& _key) { m_key = std::move(_key); }
2912 RTPS_DllAPI inline const MinimalCollectionElement& key() const { return m_key; }
2913 RTPS_DllAPI inline MinimalCollectionElement& key() { return m_key; }
2914
2915 RTPS_DllAPI inline void element(
2916 const MinimalCollectionElement& _element) { m_element = _element; }
2917 RTPS_DllAPI inline void element(
2918 MinimalCollectionElement&& _element) { m_element = std::move(_element); }
2919 RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
2920 RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
2921
2922 RTPS_DllAPI static size_t getCdrSerializedSize(
2923 const MinimalMapType& data,
2924 size_t current_alignment = 0);
2925 RTPS_DllAPI void serialize(
2926 eprosima::fastcdr::Cdr& cdr) const;
2927 RTPS_DllAPI void deserialize(
2928 eprosima::fastcdr::Cdr& cdr);
2929
2930 RTPS_DllAPI bool operator==(
2931 const MinimalMapType& other) const;
2932
2933 RTPS_DllAPI bool consistent(
2934 const MinimalMapType& x,
2935 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2936
2937private:
2938
2939 CollectionTypeFlag m_collection_flag;
2940 MinimalCollectionHeader m_header;
2942 MinimalCollectionElement m_element;
2943};
2944
2945// --- Enumeration: ---------------------------------------------------
2946typedef uint16_t BitBound;
2947
2948// Constant in an enumerated type
2949
2950/*struct CommonEnumeratedLiteral {
2951 int32_t value;
2952 EnumeratedLiteralFlag flags;
2953 };*/
2955{
2956public:
2957
2961 const CommonEnumeratedLiteral& x);
2965 const CommonEnumeratedLiteral& x);
2968
2969 RTPS_DllAPI inline void value(
2970 const int32_t& _value) { m_value = _value; }
2971 RTPS_DllAPI inline void value(
2972 int32_t&& _value) { m_value = std::move(_value); }
2973 RTPS_DllAPI inline const int32_t& value() const { return m_value; }
2974 RTPS_DllAPI inline int32_t& value() { return m_value; }
2975
2976 RTPS_DllAPI inline void flags(
2977 const EnumeratedLiteralFlag& _flags) { m_flags = _flags; }
2978 RTPS_DllAPI inline void flags(
2979 EnumeratedLiteralFlag&& _flags) { m_flags = std::move(_flags); }
2980 RTPS_DllAPI inline const EnumeratedLiteralFlag& flags() const { return m_flags; }
2981 RTPS_DllAPI inline EnumeratedLiteralFlag& flags() { return m_flags; }
2982
2983 RTPS_DllAPI static size_t getCdrSerializedSize(
2984 const CommonEnumeratedLiteral& data,
2985 size_t current_alignment = 0);
2986 RTPS_DllAPI void serialize(
2987 eprosima::fastcdr::Cdr& cdr) const;
2988 RTPS_DllAPI void deserialize(
2989 eprosima::fastcdr::Cdr& cdr);
2990
2991 RTPS_DllAPI bool operator==(
2992 const CommonEnumeratedLiteral& other) const;
2993
2994 RTPS_DllAPI bool consistent(
2995 const CommonEnumeratedLiteral& x,
2996 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2997
2998private:
2999
3000 int32_t m_value;
3001 EnumeratedLiteralFlag m_flags;
3002};
3003
3004// Constant in an enumerated type
3005
3006/*struct CompleteEnumeratedLiteral {
3007 CommonEnumeratedLiteral common;
3008 CompleteMemberDetail detail;
3009 };*/
3011{
3012public:
3013
3017 const CompleteEnumeratedLiteral& x);
3021 const CompleteEnumeratedLiteral& x);
3024
3025 RTPS_DllAPI inline void common(
3026 const CommonEnumeratedLiteral& _common) { m_common = _common; }
3027 RTPS_DllAPI inline void common(
3028 CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }
3029 RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }
3030 RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }
3031
3032 RTPS_DllAPI inline void detail(
3033 const CompleteMemberDetail& _detail) { m_detail = _detail; }
3034 RTPS_DllAPI inline void detail(
3035 CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
3036 RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
3037 RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
3038
3039 RTPS_DllAPI static size_t getCdrSerializedSize(
3040 const CompleteEnumeratedLiteral& data,
3041 size_t current_alignment = 0);
3042 RTPS_DllAPI void serialize(
3043 eprosima::fastcdr::Cdr& cdr) const;
3044 RTPS_DllAPI void deserialize(
3045 eprosima::fastcdr::Cdr& cdr);
3046
3047 RTPS_DllAPI bool operator==(
3048 const CompleteEnumeratedLiteral& other) const;
3049
3050 RTPS_DllAPI bool consistent(
3052 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3053
3054private:
3055
3056 CommonEnumeratedLiteral m_common;
3057 CompleteMemberDetail m_detail;
3058};
3059// Ordered by EnumeratedLiteral.common.value
3060typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
3061
3062// Constant in an enumerated type
3063
3064/*struct MinimalEnumeratedLiteral {
3065 CommonEnumeratedLiteral common;
3066 MinimalMemberDetail detail;
3067 };*/
3069{
3070public:
3071
3075 const MinimalEnumeratedLiteral& x);
3079 const MinimalEnumeratedLiteral& x);
3082
3083 RTPS_DllAPI inline void common(
3084 const CommonEnumeratedLiteral& _common) { m_common = _common; }
3085 RTPS_DllAPI inline void common(
3086 CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }
3087 RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }
3088 RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }
3089
3090 RTPS_DllAPI inline void detail(
3091 const MinimalMemberDetail& _detail) { m_detail = _detail; }
3092 RTPS_DllAPI inline void detail(
3093 MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
3094 RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
3095 RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
3096
3097 RTPS_DllAPI static size_t getCdrSerializedSize(
3098 const MinimalEnumeratedLiteral& data,
3099 size_t current_alignment = 0);
3100 RTPS_DllAPI void serialize(
3101 eprosima::fastcdr::Cdr& cdr) const;
3102 RTPS_DllAPI void deserialize(
3103 eprosima::fastcdr::Cdr& cdr);
3104
3105 RTPS_DllAPI bool operator==(
3106 const MinimalEnumeratedLiteral& other) const;
3107
3108 RTPS_DllAPI bool consistent(
3109 const MinimalEnumeratedLiteral& x,
3110 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3111
3112private:
3113
3114 CommonEnumeratedLiteral m_common;
3115 MinimalMemberDetail m_detail;
3116};
3117
3118// Ordered by EnumeratedLiteral.common.value
3119typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
3120
3121/*struct CommonEnumeratedHeader final{
3122 BitBound bit_bound;
3123 };*/
3125{
3126public:
3127
3131 const CommonEnumeratedHeader& x);
3135 const CommonEnumeratedHeader& x);
3138
3139 RTPS_DllAPI inline void bit_bound(
3140 const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }
3141 RTPS_DllAPI inline void bit_bound(
3142 BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }
3143 RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }
3144 RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }
3145
3146 RTPS_DllAPI static size_t getCdrSerializedSize(
3147 const CommonEnumeratedHeader& data,
3148 size_t current_alignment = 0);
3149 RTPS_DllAPI void serialize(
3150 eprosima::fastcdr::Cdr& cdr) const;
3151 RTPS_DllAPI void deserialize(
3152 eprosima::fastcdr::Cdr& cdr);
3153
3154 RTPS_DllAPI bool operator==(
3155 const CommonEnumeratedHeader& other) const;
3156
3157 RTPS_DllAPI bool consistent(
3158 const CommonEnumeratedHeader& x,
3159 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3160
3161private:
3162
3163 BitBound m_bit_bound;
3164};
3165
3166/*struct CompleteEnumeratedHeader {
3167 CommonEnumeratedHeader common;
3168 CompleteTypeDetail detail;
3169 };*/
3171{
3172public:
3173
3177 const CompleteEnumeratedHeader& x);
3181 const CompleteEnumeratedHeader& x);
3184
3185 RTPS_DllAPI inline void common(
3186 const CommonEnumeratedHeader& _common) { m_common = _common; }
3187 RTPS_DllAPI inline void common(
3188 CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }
3189 RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }
3190 RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }
3191
3192 RTPS_DllAPI inline void detail(
3193 const CompleteTypeDetail& _detail) { m_detail = _detail; }
3194 RTPS_DllAPI inline void detail(
3195 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
3196 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
3197 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
3198
3199 RTPS_DllAPI static size_t getCdrSerializedSize(
3200 const CompleteEnumeratedHeader& data,
3201 size_t current_alignment = 0);
3202 RTPS_DllAPI void serialize(
3203 eprosima::fastcdr::Cdr& cdr) const;
3204 RTPS_DllAPI void deserialize(
3205 eprosima::fastcdr::Cdr& cdr);
3206
3207 RTPS_DllAPI bool operator==(
3208 const CompleteEnumeratedHeader& other) const;
3209
3210 RTPS_DllAPI bool consistent(
3211 const CompleteEnumeratedHeader& x,
3212 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3213
3214private:
3215
3216 CommonEnumeratedHeader m_common;
3217 CompleteTypeDetail m_detail;
3218};
3219
3220/*struct MinimalEnumeratedHeader {
3221 CommonEnumeratedHeader common;
3222 };*/
3224{
3225public:
3226
3230 const MinimalEnumeratedHeader& x);
3234 const MinimalEnumeratedHeader& x);
3237
3238 RTPS_DllAPI inline void common(
3239 const CommonEnumeratedHeader& _common) { m_common = _common; }
3240 RTPS_DllAPI inline void common(
3241 CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }
3242 RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }
3243 RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }
3244
3245 RTPS_DllAPI static size_t getCdrSerializedSize(
3246 const MinimalEnumeratedHeader& data,
3247 size_t current_alignment = 0);
3248 RTPS_DllAPI void serialize(
3249 eprosima::fastcdr::Cdr& cdr) const;
3250 RTPS_DllAPI void deserialize(
3251 eprosima::fastcdr::Cdr& cdr);
3252
3253 RTPS_DllAPI bool operator==(
3254 const MinimalEnumeratedHeader& other) const;
3255
3256 RTPS_DllAPI bool consistent(
3257 const MinimalEnumeratedHeader& x,
3258 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3259
3260private:
3261
3262 CommonEnumeratedHeader m_common;
3263};
3264
3265// Enumerated type
3266/*struct CompleteEnumeratedType final{
3267 EnumTypeFlag enum_flags; // unused
3268 CompleteEnumeratedHeader header;
3269 CompleteEnumeratedLiteralSeq literal_seq;
3270 };*/
3272{
3273public:
3274
3278 const CompleteEnumeratedType& x);
3282 const CompleteEnumeratedType& x);
3285
3286 RTPS_DllAPI inline void enum_flags(
3287 const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }
3288 RTPS_DllAPI inline void enum_flags(
3289 EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }
3290 RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }
3291 RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }
3292
3293 RTPS_DllAPI inline void header(
3294 const CompleteEnumeratedHeader& _header) { m_header = _header; }
3295 RTPS_DllAPI inline void header(
3296 CompleteEnumeratedHeader&& _header) { m_header = std::move(_header); }
3297 RTPS_DllAPI inline const CompleteEnumeratedHeader& header() const { return m_header; }
3298 RTPS_DllAPI inline CompleteEnumeratedHeader& header() { return m_header; }
3299
3300 RTPS_DllAPI inline void literal_seq(
3301 const CompleteEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }
3302 RTPS_DllAPI inline void literal_seq(
3303 CompleteEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }
3304 RTPS_DllAPI inline const CompleteEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }
3305 RTPS_DllAPI inline CompleteEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }
3306
3307 RTPS_DllAPI static size_t getCdrSerializedSize(
3308 const CompleteEnumeratedType& data,
3309 size_t current_alignment = 0);
3310 RTPS_DllAPI void serialize(
3311 eprosima::fastcdr::Cdr& cdr) const;
3312 RTPS_DllAPI void deserialize(
3313 eprosima::fastcdr::Cdr& cdr);
3314
3315 RTPS_DllAPI bool operator==(
3316 const CompleteEnumeratedType& other) const;
3317
3318 RTPS_DllAPI bool consistent(
3319 const CompleteEnumeratedType& x,
3320 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3321
3322private:
3323
3324 EnumTypeFlag m_enum_flags;
3325 CompleteEnumeratedHeader m_header;
3326 CompleteEnumeratedLiteralSeq m_literal_seq;
3327};
3328// Enumerated type
3329/*struct MinimalEnumeratedType final{
3330 EnumTypeFlag enum_flags; // unused
3331 MinimalEnumeratedHeader header;
3332 MinimalEnumeratedLiteralSeq literal_seq;
3333 };*/
3335{
3336public:
3337
3341 const MinimalEnumeratedType& x);
3345 const MinimalEnumeratedType& x);
3348
3349 RTPS_DllAPI inline void enum_flags(
3350 const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }
3351 RTPS_DllAPI inline void enum_flags(
3352 EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }
3353 RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }
3354 RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }
3355
3356 RTPS_DllAPI inline void header(
3357 const MinimalEnumeratedHeader& _header) { m_header = _header; }
3358 RTPS_DllAPI inline void header(
3359 MinimalEnumeratedHeader&& _header) { m_header = std::move(_header); }
3360 RTPS_DllAPI inline const MinimalEnumeratedHeader& header() const { return m_header; }
3361 RTPS_DllAPI inline MinimalEnumeratedHeader& header() { return m_header; }
3362
3363 RTPS_DllAPI inline void literal_seq(
3364 const MinimalEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }
3365 RTPS_DllAPI inline void literal_seq(
3366 MinimalEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }
3367 RTPS_DllAPI inline const MinimalEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }
3368 RTPS_DllAPI inline MinimalEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }
3369
3370 RTPS_DllAPI static size_t getCdrSerializedSize(
3371 const MinimalEnumeratedType& data,
3372 size_t current_alignment = 0);
3373 RTPS_DllAPI void serialize(
3374 eprosima::fastcdr::Cdr& cdr) const;
3375 RTPS_DllAPI void deserialize(
3376 eprosima::fastcdr::Cdr& cdr);
3377
3378 RTPS_DllAPI bool operator==(
3379 const MinimalEnumeratedType& other) const;
3380
3381 RTPS_DllAPI bool consistent(
3382 const MinimalEnumeratedType& x,
3383 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3384
3385private:
3386
3387 EnumTypeFlag m_enum_flags;
3388 MinimalEnumeratedHeader m_header;
3389 MinimalEnumeratedLiteralSeq m_literal_seq;
3390};
3391
3392// --- Bitmask: -------------------------------------------------------
3393// Bit in a bit mask
3394/*struct CommonBitflag final{
3395 uint16_t position;
3396 BitflagFlag flags;
3397 };*/
3398class CommonBitflag final
3399{
3400public:
3401
3402 RTPS_DllAPI CommonBitflag();
3403 RTPS_DllAPI ~CommonBitflag();
3404 RTPS_DllAPI CommonBitflag(
3405 const CommonBitflag& x);
3406 RTPS_DllAPI CommonBitflag(
3407 CommonBitflag&& x);
3409 const CommonBitflag& x);
3411 CommonBitflag&& x);
3412
3413 RTPS_DllAPI inline void position(
3414 const uint16_t& _position) { m_position = _position; }
3415 RTPS_DllAPI inline void position(
3416 uint16_t&& _position) { m_position = std::move(_position); }
3417 RTPS_DllAPI inline const uint16_t& position() const { return m_position; }
3418 RTPS_DllAPI inline uint16_t& position() { return m_position; }
3419
3420 RTPS_DllAPI inline void flags(
3421 const BitflagFlag& _flags) { m_flags = _flags; }
3422 RTPS_DllAPI inline void flags(
3423 BitflagFlag&& _flags) { m_flags = std::move(_flags); }
3424 RTPS_DllAPI inline const BitflagFlag& flags() const { return m_flags; }
3425 RTPS_DllAPI inline BitflagFlag& flags() { return m_flags; }
3426
3427 RTPS_DllAPI static size_t getCdrSerializedSize(
3428 const CommonBitflag& data,
3429 size_t current_alignment = 0);
3430 RTPS_DllAPI void serialize(
3431 eprosima::fastcdr::Cdr& cdr) const;
3432 RTPS_DllAPI void deserialize(
3433 eprosima::fastcdr::Cdr& cdr);
3434
3435 RTPS_DllAPI bool operator==(
3436 const CommonBitflag& other) const;
3437
3438 RTPS_DllAPI bool consistent(
3439 const CommonBitflag& x,
3440 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3441
3442private:
3443
3444 uint16_t m_position;
3445 BitflagFlag m_flags;
3446};
3447
3448/*struct CompleteBitflag {
3449 CommonBitflag common;
3450 CompleteMemberDetail detail;
3451 };*/
3453{
3454public:
3455
3456 RTPS_DllAPI CompleteBitflag();
3457 RTPS_DllAPI ~CompleteBitflag();
3458 RTPS_DllAPI CompleteBitflag(
3459 const CompleteBitflag& x);
3460 RTPS_DllAPI CompleteBitflag(
3461 CompleteBitflag&& x);
3463 const CompleteBitflag& x);
3465 CompleteBitflag&& x);
3466
3467 RTPS_DllAPI inline void common(
3468 const CommonBitflag& _common) { m_common = _common; }
3469 RTPS_DllAPI inline void common(
3470 CommonBitflag&& _common) { m_common = std::move(_common); }
3471 RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }
3472 RTPS_DllAPI inline CommonBitflag& common() { return m_common; }
3473
3474 RTPS_DllAPI inline void detail(
3475 const CompleteMemberDetail& _detail) { m_detail = _detail; }
3476 RTPS_DllAPI inline void detail(
3477 CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
3478 RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
3479 RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
3480
3481 RTPS_DllAPI static size_t getCdrSerializedSize(
3482 const CompleteBitflag& data,
3483 size_t current_alignment = 0);
3484 RTPS_DllAPI void serialize(
3485 eprosima::fastcdr::Cdr& cdr) const;
3486 RTPS_DllAPI void deserialize(
3487 eprosima::fastcdr::Cdr& cdr);
3488
3489 RTPS_DllAPI bool operator==(
3490 const CompleteBitflag& other) const;
3491
3492 RTPS_DllAPI bool consistent(
3493 const CompleteBitflag& x,
3494 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3495
3496private:
3497
3498 CommonBitflag m_common;
3499 CompleteMemberDetail m_detail;
3500};
3501// Ordered by Bitflag.position
3502typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
3503/*struct MinimalBitflag {
3504 CommonBitflag common;
3505 MinimalMemberDetail detail;
3506 };*/
3508{
3509public:
3510
3511 RTPS_DllAPI MinimalBitflag();
3512 RTPS_DllAPI ~MinimalBitflag();
3513 RTPS_DllAPI MinimalBitflag(
3514 const MinimalBitflag& x);
3515 RTPS_DllAPI MinimalBitflag(
3516 MinimalBitflag&& x);
3518 const MinimalBitflag& x);
3520 MinimalBitflag&& x);
3521
3522 RTPS_DllAPI inline void common(
3523 const CommonBitflag& _common) { m_common = _common; }
3524 RTPS_DllAPI inline void common(
3525 CommonBitflag&& _common) { m_common = std::move(_common); }
3526 RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }
3527 RTPS_DllAPI inline CommonBitflag& common() { return m_common; }
3528
3529 RTPS_DllAPI inline void detail(
3530 const MinimalMemberDetail& _detail) { m_detail = _detail; }
3531 RTPS_DllAPI inline void detail(
3532 MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
3533 RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
3534 RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
3535
3536 RTPS_DllAPI static size_t getCdrSerializedSize(
3537 const MinimalBitflag& data,
3538 size_t current_alignment = 0);
3539 RTPS_DllAPI void serialize(
3540 eprosima::fastcdr::Cdr& cdr) const;
3541 RTPS_DllAPI void deserialize(
3542 eprosima::fastcdr::Cdr& cdr);
3543
3544 RTPS_DllAPI bool operator==(
3545 const MinimalBitflag& other) const;
3546
3547 RTPS_DllAPI bool consistent(
3548 const MinimalBitflag& x,
3549 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3550
3551private:
3552
3553 CommonBitflag m_common;
3554 MinimalMemberDetail m_detail;
3555};
3556
3557// Ordered by Bitflag.position
3558typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
3559
3560/*struct CommonBitmaskHeader final{
3561 BitBound bit_bound;
3562 };*/
3564{
3565public:
3566
3567 RTPS_DllAPI CommonBitmaskHeader();
3570 const CommonBitmaskHeader& x);
3574 const CommonBitmaskHeader& x);
3577
3578 RTPS_DllAPI inline void bit_bound(
3579 const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }
3580 RTPS_DllAPI inline void bit_bound(
3581 BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }
3582 RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }
3583 RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }
3584
3585 RTPS_DllAPI static size_t getCdrSerializedSize(
3586 const CommonBitmaskHeader& data,
3587 size_t current_alignment = 0);
3588 RTPS_DllAPI void serialize(
3589 eprosima::fastcdr::Cdr& cdr) const;
3590 RTPS_DllAPI void deserialize(
3591 eprosima::fastcdr::Cdr& cdr);
3592
3593 RTPS_DllAPI bool operator==(
3594 const CommonBitmaskHeader& other) const;
3595
3596 RTPS_DllAPI bool consistent(
3597 const CommonBitmaskHeader& x,
3598 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3599
3600private:
3601
3602 BitBound m_bit_bound;
3603};
3605
3607/*struct CompleteBitmaskType {
3608 BitmaskTypeFlag bitmask_flags; // unused
3609 CompleteBitmaskHeader header;
3610 CompleteBitflagSeq flag_seq;
3611 };*/
3613{
3614public:
3615
3616 RTPS_DllAPI CompleteBitmaskType();
3619 const CompleteBitmaskType& x);
3623 const CompleteBitmaskType& x);
3626
3627 RTPS_DllAPI inline void bitmask_flags(
3628 const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }
3629 RTPS_DllAPI inline void bitmask_flags(
3630 BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }
3631 RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }
3632 RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }
3633
3634 RTPS_DllAPI inline void header(
3635 const CompleteBitmaskHeader& _header) { m_header = _header; }
3636 RTPS_DllAPI inline void header(
3637 CompleteBitmaskHeader&& _header) { m_header = std::move(_header); }
3638 RTPS_DllAPI inline const CompleteBitmaskHeader& header() const { return m_header; }
3639 RTPS_DllAPI inline CompleteBitmaskHeader& header() { return m_header; }
3640
3641 RTPS_DllAPI inline void flag_seq(
3642 const CompleteBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }
3643 RTPS_DllAPI inline void flag_seq(
3644 CompleteBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }
3645 RTPS_DllAPI inline const CompleteBitflagSeq& flag_seq() const { return m_flag_seq; }
3646 RTPS_DllAPI inline CompleteBitflagSeq& flag_seq() { return m_flag_seq; }
3647
3648 RTPS_DllAPI static size_t getCdrSerializedSize(
3649 const CompleteBitmaskType& data,
3650 size_t current_alignment = 0);
3651 RTPS_DllAPI void serialize(
3652 eprosima::fastcdr::Cdr& cdr) const;
3653 RTPS_DllAPI void deserialize(
3654 eprosima::fastcdr::Cdr& cdr);
3655
3656 RTPS_DllAPI bool operator==(
3657 const CompleteBitmaskType& other) const;
3658
3659 RTPS_DllAPI bool consistent(
3660 const CompleteBitmaskType& x,
3661 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3662
3663private:
3664
3665 BitmaskTypeFlag m_bitmask_flags;
3666 CompleteBitmaskHeader m_header;
3667 CompleteBitflagSeq m_flag_seq;
3668};
3669
3670/*struct MinimalBitmaskType {
3671 BitmaskTypeFlag bitmask_flags; // unused
3672 MinimalBitmaskHeader header;
3673 MinimalBitflagSeq flag_seq;
3674 };*/
3676{
3677public:
3678
3679 RTPS_DllAPI MinimalBitmaskType();
3680 RTPS_DllAPI ~MinimalBitmaskType();
3682 const MinimalBitmaskType& x);
3684 MinimalBitmaskType&& x);
3686 const MinimalBitmaskType& x);
3688 MinimalBitmaskType&& x);
3689
3690 RTPS_DllAPI inline void bitmask_flags(
3691 const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }
3692 RTPS_DllAPI inline void bitmask_flags(
3693 BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }
3694 RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }
3695 RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }
3696
3697 RTPS_DllAPI inline void header(
3698 const MinimalBitmaskHeader& _header) { m_header = _header; }
3699 RTPS_DllAPI inline void header(
3700 MinimalBitmaskHeader&& _header) { m_header = std::move(_header); }
3701 RTPS_DllAPI inline const MinimalBitmaskHeader& header() const { return m_header; }
3702 RTPS_DllAPI inline MinimalBitmaskHeader& header() { return m_header; }
3703
3704 RTPS_DllAPI inline void flag_seq(
3705 const MinimalBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }
3706 RTPS_DllAPI inline void flag_seq(
3707 MinimalBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }
3708 RTPS_DllAPI inline const MinimalBitflagSeq& flag_seq() const { return m_flag_seq; }
3709 RTPS_DllAPI inline MinimalBitflagSeq& flag_seq() { return m_flag_seq; }
3710
3711 RTPS_DllAPI static size_t getCdrSerializedSize(
3712 const MinimalBitmaskType& data,
3713 size_t current_alignment = 0);
3714 RTPS_DllAPI void serialize(
3715 eprosima::fastcdr::Cdr& cdr) const;
3716 RTPS_DllAPI void deserialize(
3717 eprosima::fastcdr::Cdr& cdr);
3718
3719 RTPS_DllAPI bool operator==(
3720 const MinimalBitmaskType& other) const;
3721
3722 RTPS_DllAPI bool consistent(
3723 const MinimalBitmaskType& x,
3724 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3725
3726private:
3727
3728 BitmaskTypeFlag m_bitmask_flags;
3729 MinimalBitmaskHeader m_header;
3730 MinimalBitflagSeq m_flag_seq;
3731};
3732
3733// --- Bitset: ---------------------------------------------------------
3734/*struct CommonBitfield final{
3735 uint16_t position;
3736 BitsetMemberFlag flags;
3737 octet bitcount;
3738 TypeKind holder_type; // Must be primitive integer type
3739 };*/
3741{
3742public:
3743
3744 RTPS_DllAPI CommonBitfield();
3745 RTPS_DllAPI ~CommonBitfield();
3746 RTPS_DllAPI CommonBitfield(
3747 const CommonBitfield& x);
3748 RTPS_DllAPI CommonBitfield(
3749 CommonBitfield&& x);
3751 const CommonBitfield& x);
3753 CommonBitfield&& x);
3754
3755 RTPS_DllAPI inline void position(
3756 const uint16_t& _position) { m_position = _position; }
3757 RTPS_DllAPI inline void position(
3758 uint16_t&& _position) { m_position = std::move(_position); }
3759 RTPS_DllAPI inline const uint16_t& position() const { return m_position; }
3760 RTPS_DllAPI inline uint16_t& position() { return m_position; }
3761
3762 RTPS_DllAPI inline void flags(
3763 const BitsetMemberFlag& _flags) { m_flags = _flags; }
3764 RTPS_DllAPI inline void flags(
3765 BitsetMemberFlag&& _flags) { m_flags = std::move(_flags); }
3766 RTPS_DllAPI inline const BitsetMemberFlag& flags() const { return m_flags; }
3767 RTPS_DllAPI inline BitsetMemberFlag& flags() { return m_flags; }
3768
3769 RTPS_DllAPI inline void bitcount(
3770 const octet& _bitcount) { m_bitcount = _bitcount; }
3771 RTPS_DllAPI inline void bitcount(
3772 octet&& _bitcount) { m_bitcount = std::move(_bitcount); }
3773 RTPS_DllAPI inline const octet& bitcount() const { return m_bitcount; }
3774 RTPS_DllAPI inline octet& bitcount() { return m_bitcount; }
3775
3776 RTPS_DllAPI inline void holder_type(
3777 const TypeKind& _holder_type) { m_holder_type = _holder_type; }
3778 RTPS_DllAPI inline void holder_type(
3779 TypeKind&& _holder_type) { m_holder_type = std::move(_holder_type); }
3780 RTPS_DllAPI inline const TypeKind& holder_type() const { return m_holder_type; }
3781 RTPS_DllAPI inline TypeKind& holder_type() { return m_holder_type; }
3782
3783 RTPS_DllAPI static size_t getCdrSerializedSize(
3784 const CommonBitfield& data,
3785 size_t current_alignment = 0);
3786 RTPS_DllAPI void serialize(
3787 eprosima::fastcdr::Cdr& cdr) const;
3788 RTPS_DllAPI void deserialize(
3789 eprosima::fastcdr::Cdr& cdr);
3790
3791 RTPS_DllAPI bool operator==(
3792 const CommonBitfield& other) const;
3793
3794 RTPS_DllAPI bool consistent(
3795 const CommonBitfield& x,
3796 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3797
3798private:
3799
3800 uint16_t m_position;
3801 BitsetMemberFlag m_flags;
3802 octet m_bitcount;
3803 TypeKind m_holder_type;
3804};
3805
3806/*struct CompleteBitfield {
3807 CommonBitfield common;
3808 CompleteMemberDetail detail;
3809 };*/
3811{
3812public:
3813
3814 RTPS_DllAPI CompleteBitfield();
3815 RTPS_DllAPI ~CompleteBitfield();
3816 RTPS_DllAPI CompleteBitfield(
3817 const CompleteBitfield& x);
3818 RTPS_DllAPI CompleteBitfield(
3819 CompleteBitfield&& x);
3821 const CompleteBitfield& x);
3823 CompleteBitfield&& x);
3824
3825 RTPS_DllAPI inline void common(
3826 const CommonBitfield& _common) { m_common = _common; }
3827 RTPS_DllAPI inline void common(
3828 CommonBitfield&& _common) { m_common = std::move(_common); }
3829 RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }
3830 RTPS_DllAPI inline CommonBitfield& common() { return m_common; }
3831
3832 RTPS_DllAPI inline void detail(
3833 const CompleteMemberDetail& _detail) { m_detail = _detail; }
3834 RTPS_DllAPI inline void detail(
3835 CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
3836 RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
3837 RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
3838
3839 RTPS_DllAPI static size_t getCdrSerializedSize(
3840 const CompleteBitfield& data,
3841 size_t current_alignment = 0);
3842 RTPS_DllAPI void serialize(
3843 eprosima::fastcdr::Cdr& cdr) const;
3844 RTPS_DllAPI void deserialize(
3845 eprosima::fastcdr::Cdr& cdr);
3846
3847 RTPS_DllAPI bool operator==(
3848 const CompleteBitfield& other) const;
3849
3850 RTPS_DllAPI bool consistent(
3851 const CompleteBitfield& x,
3852 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3853
3854private:
3855
3856 CommonBitfield m_common;
3857 CompleteMemberDetail m_detail;
3858};
3859// Ordered by Bitfield.position
3860typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
3861/*struct MinimalBitfield {
3862 CommonBitfield common;
3863 NameHash name_hash;
3864 };*/
3866{
3867public:
3868
3869 RTPS_DllAPI MinimalBitfield();
3870 RTPS_DllAPI ~MinimalBitfield();
3871 RTPS_DllAPI MinimalBitfield(
3872 const MinimalBitfield& x);
3873 RTPS_DllAPI MinimalBitfield(
3874 MinimalBitfield&& x);
3876 const MinimalBitfield& x);
3878 MinimalBitfield&& x);
3879
3880 RTPS_DllAPI inline void name_hash(
3881 const NameHash& _name_hash) { m_name_hash = _name_hash; }
3882 RTPS_DllAPI inline void name_hash(
3883 NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }
3884 RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }
3885 RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }
3886
3887 RTPS_DllAPI inline void common(
3888 const CommonBitfield& _common) { m_common = _common; }
3889 RTPS_DllAPI inline void common(
3890 CommonBitfield&& _common) { m_common = std::move(_common); }
3891 RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }
3892 RTPS_DllAPI inline CommonBitfield& common() { return m_common; }
3893
3894 RTPS_DllAPI static size_t getCdrSerializedSize(
3895 const MinimalBitfield& data,
3896 size_t current_alignment = 0);
3897 RTPS_DllAPI void serialize(
3898 eprosima::fastcdr::Cdr& cdr) const;
3899 RTPS_DllAPI void deserialize(
3900 eprosima::fastcdr::Cdr& cdr);
3901
3902 RTPS_DllAPI bool operator==(
3903 const MinimalBitfield& other) const;
3904
3905 RTPS_DllAPI bool consistent(
3906 const MinimalBitfield& x,
3907 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3908
3909private:
3910
3911 CommonBitfield m_common;
3912 NameHash m_name_hash;
3913};
3914// Ordered by Bitfield.position
3915typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
3916/*struct CompleteBitsetHeader {
3917 CompleteTypeDetail detail;
3918 };*/
3920{
3921public:
3922
3926 const CompleteBitsetHeader& x);
3930 const CompleteBitsetHeader& x);
3933
3934 RTPS_DllAPI inline void base_type(
3935 const TypeIdentifier& _base_type) { m_base_type = _base_type; }
3936 RTPS_DllAPI inline void base_type(
3937 TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
3938 RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
3939 RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
3940
3941 RTPS_DllAPI inline void detail(
3942 const CompleteTypeDetail& _detail) { m_detail = _detail; }
3943 RTPS_DllAPI inline void detail(
3944 CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
3945 RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
3946 RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
3947
3948 RTPS_DllAPI static size_t getCdrSerializedSize(
3949 const CompleteBitsetHeader& data,
3950 size_t current_alignment = 0);
3951 RTPS_DllAPI void serialize(
3952 eprosima::fastcdr::Cdr& cdr) const;
3953 RTPS_DllAPI void deserialize(
3954 eprosima::fastcdr::Cdr& cdr);
3955
3956 RTPS_DllAPI bool operator==(
3957 const CompleteBitsetHeader& other) const;
3958
3959 RTPS_DllAPI bool consistent(
3960 const CompleteBitsetHeader& x,
3961 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3962
3963private:
3964
3965 TypeIdentifier m_base_type;
3966 CompleteTypeDetail m_detail;
3967};
3968
3969/*struct MinimalBitsetHeader {
3970 // Empty. Available for future extension
3971 };*/
3973{
3974public:
3975
3976 RTPS_DllAPI MinimalBitsetHeader();
3979 const MinimalBitsetHeader& x);
3983 const MinimalBitsetHeader& x);
3986
3987 RTPS_DllAPI inline void base_type(
3988 const TypeIdentifier& _base_type) { m_base_type = _base_type; }
3989 RTPS_DllAPI inline void base_type(
3990 TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
3991 RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
3992 RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
3993
3994 RTPS_DllAPI static size_t getCdrSerializedSize(
3995 const MinimalBitsetHeader& data,
3996 size_t current_alignment = 0);
3997 RTPS_DllAPI void serialize(
3998 eprosima::fastcdr::Cdr& cdr) const;
3999 RTPS_DllAPI void deserialize(
4000 eprosima::fastcdr::Cdr& cdr);
4001
4002 RTPS_DllAPI bool operator==(
4003 const MinimalBitsetHeader& other) const;
4004
4005 RTPS_DllAPI bool consistent(
4006 const MinimalBitsetHeader& x,
4007 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4008
4009private:
4010
4011 TypeIdentifier m_base_type;
4012};
4013/*struct CompleteBitsetType {
4014 BitsetTypeFlag bitset_flags; // unused
4015 CompleteBitsetHeader header;
4016 CompleteBitfieldSeq field_seq;
4017 };*/
4019{
4020public:
4021
4022 RTPS_DllAPI CompleteBitsetType();
4023 RTPS_DllAPI ~CompleteBitsetType();
4025 const CompleteBitsetType& x);
4027 CompleteBitsetType&& x);
4029 const CompleteBitsetType& x);
4031 CompleteBitsetType&& x);
4032
4033 RTPS_DllAPI inline void bitset_flags(
4034 const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }
4035 RTPS_DllAPI inline void bitset_flags(
4036 BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }
4037 RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }
4038 RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }
4039
4040 RTPS_DllAPI inline void header(
4041 const CompleteBitsetHeader& _header) { m_header = _header; }
4042 RTPS_DllAPI inline void header(
4043 CompleteBitsetHeader&& _header) { m_header = std::move(_header); }
4044 RTPS_DllAPI inline const CompleteBitsetHeader& header() const { return m_header; }
4045 RTPS_DllAPI inline CompleteBitsetHeader& header() { return m_header; }
4046
4047 RTPS_DllAPI inline void field_seq(
4048 const CompleteBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }
4049 RTPS_DllAPI inline void field_seq(
4050 CompleteBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }
4051 RTPS_DllAPI inline const CompleteBitfieldSeq& field_seq() const { return m_field_seq; }
4052 RTPS_DllAPI inline CompleteBitfieldSeq& field_seq() { return m_field_seq; }
4053
4054 RTPS_DllAPI static size_t getCdrSerializedSize(
4055 const CompleteBitsetType& data,
4056 size_t current_alignment = 0);
4057 RTPS_DllAPI void serialize(
4058 eprosima::fastcdr::Cdr& cdr) const;
4059 RTPS_DllAPI void deserialize(
4060 eprosima::fastcdr::Cdr& cdr);
4061
4062 RTPS_DllAPI bool operator==(
4063 const CompleteBitsetType& other) const;
4064
4065 RTPS_DllAPI bool consistent(
4066 const CompleteBitsetType& x,
4067 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4068
4069private:
4070
4071 BitsetTypeFlag m_bitset_flags;
4072 CompleteBitsetHeader m_header;
4073 CompleteBitfieldSeq m_field_seq;
4074};
4075
4076/*struct MinimalBitsetType {
4077 BitsetTypeFlag bitset_flags; // unused
4078 MinimalBitsetHeader header;
4079 MinimalBitfieldSeq field_seq;
4080 };*/
4082{
4083public:
4084
4085 RTPS_DllAPI MinimalBitsetType();
4086 RTPS_DllAPI ~MinimalBitsetType();
4088 const MinimalBitsetType& x);
4090 MinimalBitsetType&& x);
4092 const MinimalBitsetType& x);
4094 MinimalBitsetType&& x);
4095
4096 RTPS_DllAPI inline void bitset_flags(
4097 const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }
4098 RTPS_DllAPI inline void bitset_flags(
4099 BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }
4100 RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }
4101 RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }
4102
4103 RTPS_DllAPI inline void header(
4104 const MinimalBitsetHeader& _header) { m_header = _header; }
4105 RTPS_DllAPI inline void header(
4106 MinimalBitsetHeader&& _header) { m_header = std::move(_header); }
4107 RTPS_DllAPI inline const MinimalBitsetHeader& header() const { return m_header; }
4108 RTPS_DllAPI inline MinimalBitsetHeader& header() { return m_header; }
4109
4110 RTPS_DllAPI inline void field_seq(
4111 const MinimalBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }
4112 RTPS_DllAPI inline void field_seq(
4113 MinimalBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }
4114 RTPS_DllAPI inline const MinimalBitfieldSeq& field_seq() const { return m_field_seq; }
4115 RTPS_DllAPI inline MinimalBitfieldSeq& field_seq() { return m_field_seq; }
4116
4117 RTPS_DllAPI static size_t getCdrSerializedSize(
4118 const MinimalBitsetType& data,
4119 size_t current_alignment = 0);
4120 RTPS_DllAPI void serialize(
4121 eprosima::fastcdr::Cdr& cdr) const;
4122 RTPS_DllAPI void deserialize(
4123 eprosima::fastcdr::Cdr& cdr);
4124
4125 RTPS_DllAPI bool operator==(
4126 const MinimalBitsetType& other) const;
4127
4128 RTPS_DllAPI bool consistent(
4129 const MinimalBitsetType& x,
4130 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4131
4132private:
4133
4134 BitsetTypeFlag m_bitset_flags;
4135 MinimalBitsetHeader m_header;
4136 MinimalBitfieldSeq m_field_seq;
4137};
4138
4139// --- Type Object: --------------------------------------------------
4140// The types associated with each case selection must have extensibility
4141// kind APPENDABLE or MUTABLE so that they can be extended in the future
4142
4143/*struct CompleteExtendedType {
4144 // Empty. Available for future extension
4145 };*/
4147{
4148public:
4149
4153 const CompleteExtendedType& x);
4157 const CompleteExtendedType& x);
4160
4161 RTPS_DllAPI static size_t getCdrSerializedSize(
4162 const CompleteExtendedType& data,
4163 size_t current_alignment = 0);
4164 RTPS_DllAPI void serialize(
4165 eprosima::fastcdr::Cdr& cdr) const;
4166 RTPS_DllAPI void deserialize(
4167 eprosima::fastcdr::Cdr& cdr);
4168
4169 RTPS_DllAPI bool operator==(
4170 const CompleteExtendedType&) const { return true; }
4171
4172 RTPS_DllAPI bool consistent(
4173 const CompleteExtendedType& x,
4174 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4175
4176private:
4177
4178};
4179
4180/*struct MinimalExtendedType {
4181 // Empty. Available for future extension
4182 };*/
4184{
4185public:
4186
4187 RTPS_DllAPI MinimalExtendedType();
4190 const MinimalExtendedType& x);
4194 const MinimalExtendedType& x);
4197
4198 RTPS_DllAPI static size_t getCdrSerializedSize(
4199 const MinimalExtendedType& data,
4200 size_t current_alignment = 0);
4201 RTPS_DllAPI void serialize(
4202 eprosima::fastcdr::Cdr& cdr) const;
4203 RTPS_DllAPI void deserialize(
4204 eprosima::fastcdr::Cdr& cdr);
4205
4206 RTPS_DllAPI bool operator==(
4207 const MinimalExtendedType&) const { return true; }
4208
4209 RTPS_DllAPI bool consistent(
4210 const MinimalExtendedType& x,
4211 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4212
4213private:
4214
4215};
4216
4218{
4219public:
4220
4221 RTPS_DllAPI CompleteTypeObject();
4222 RTPS_DllAPI ~CompleteTypeObject();
4224 const CompleteTypeObject& x);
4226 CompleteTypeObject&& x);
4228 const CompleteTypeObject& x);
4230 CompleteTypeObject&& x);
4231 RTPS_DllAPI void _d(
4232 octet __d);
4233 RTPS_DllAPI octet _d() const;
4234 RTPS_DllAPI octet& _d();
4235
4236 RTPS_DllAPI void alias_type(
4237 CompleteAliasType _alias_type);
4238 RTPS_DllAPI const CompleteAliasType& alias_type() const;
4240
4241 RTPS_DllAPI void annotation_type(
4242 CompleteAnnotationType _annotation_type);
4243 RTPS_DllAPI const CompleteAnnotationType& annotation_type() const;
4245
4246 RTPS_DllAPI void struct_type(
4247 CompleteStructType _struct_type);
4248 RTPS_DllAPI const CompleteStructType& struct_type() const;
4250
4251 RTPS_DllAPI void union_type(
4252 CompleteUnionType _union_type);
4253 RTPS_DllAPI const CompleteUnionType& union_type() const;
4255
4256 RTPS_DllAPI void bitset_type(
4257 CompleteBitsetType _bitset_type);
4258 RTPS_DllAPI const CompleteBitsetType& bitset_type() const;
4260
4261 RTPS_DllAPI void sequence_type(
4262 CompleteSequenceType _sequence_type);
4263 RTPS_DllAPI const CompleteSequenceType& sequence_type() const;
4265
4266 RTPS_DllAPI void array_type(
4267 CompleteArrayType _array_type);
4268 RTPS_DllAPI const CompleteArrayType& array_type() const;
4270
4271 RTPS_DllAPI void map_type(
4272 CompleteMapType _map_type);
4273 RTPS_DllAPI const CompleteMapType& map_type() const;
4275
4276 RTPS_DllAPI void enumerated_type(
4277 CompleteEnumeratedType _enumerated_type);
4278 RTPS_DllAPI const CompleteEnumeratedType& enumerated_type() const;
4280
4281 RTPS_DllAPI void bitmask_type(
4282 CompleteBitmaskType _bitmask_type);
4283 RTPS_DllAPI const CompleteBitmaskType& bitmask_type() const;
4285
4286 RTPS_DllAPI void extended_type(
4287 CompleteExtendedType _extended_type);
4288 RTPS_DllAPI const CompleteExtendedType& extended_type() const;
4290
4291 RTPS_DllAPI static size_t getCdrSerializedSize(
4292 const CompleteTypeObject& data,
4293 size_t current_alignment = 0);
4294 RTPS_DllAPI void serialize(
4295 eprosima::fastcdr::Cdr& cdr) const;
4296 RTPS_DllAPI void deserialize(
4297 eprosima::fastcdr::Cdr& cdr);
4298
4299 RTPS_DllAPI bool operator==(
4300 const CompleteTypeObject& other) const;
4301
4302 RTPS_DllAPI bool consistent(
4303 const CompleteTypeObject& x,
4304 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4305
4306private:
4307
4308 octet m__d;
4309
4310 CompleteAliasType m_alias_type;
4311 CompleteAnnotationType m_annotation_type;
4312 CompleteStructType m_struct_type;
4313 CompleteUnionType m_union_type;
4314 CompleteBitsetType m_bitset_type;
4315 CompleteSequenceType m_sequence_type;
4316 CompleteArrayType m_array_type;
4317 CompleteMapType m_map_type;
4318 CompleteEnumeratedType m_enumerated_type;
4319 CompleteBitmaskType m_bitmask_type;
4320 CompleteExtendedType m_extended_type;
4321};
4322
4324{
4325public:
4326
4327 RTPS_DllAPI MinimalTypeObject();
4328 RTPS_DllAPI ~MinimalTypeObject();
4330 const MinimalTypeObject& x);
4332 MinimalTypeObject&& x);
4334 const MinimalTypeObject& x);
4336 MinimalTypeObject&& x);
4337 RTPS_DllAPI void _d(
4338 octet __d);
4339 RTPS_DllAPI octet _d() const;
4340 RTPS_DllAPI octet& _d();
4341
4342 RTPS_DllAPI void alias_type(
4343 MinimalAliasType _alias_type);
4344 RTPS_DllAPI const MinimalAliasType& alias_type() const;
4346
4347 RTPS_DllAPI void annotation_type(
4348 MinimalAnnotationType _annotation_type);
4349 RTPS_DllAPI const MinimalAnnotationType& annotation_type() const;
4351
4352 RTPS_DllAPI void struct_type(
4353 MinimalStructType _struct_type);
4354 RTPS_DllAPI const MinimalStructType& struct_type() const;
4356
4357 RTPS_DllAPI void union_type(
4358 MinimalUnionType _union_type);
4359 RTPS_DllAPI const MinimalUnionType& union_type() const;
4361
4362 RTPS_DllAPI void bitset_type(
4363 MinimalBitsetType _bitset_type);
4364 RTPS_DllAPI const MinimalBitsetType& bitset_type() const;
4366
4367 RTPS_DllAPI void sequence_type(
4368 MinimalSequenceType _sequence_type);
4369 RTPS_DllAPI const MinimalSequenceType& sequence_type() const;
4371
4372 RTPS_DllAPI void array_type(
4373 MinimalArrayType _array_type);
4374 RTPS_DllAPI const MinimalArrayType& array_type() const;
4376
4377 RTPS_DllAPI void map_type(
4378 MinimalMapType _map_type);
4379 RTPS_DllAPI const MinimalMapType& map_type() const;
4380 RTPS_DllAPI MinimalMapType& map_type();
4381
4382 RTPS_DllAPI void enumerated_type(
4383 MinimalEnumeratedType _enumerated_type);
4384 RTPS_DllAPI const MinimalEnumeratedType& enumerated_type() const;
4386
4387 RTPS_DllAPI void bitmask_type(
4388 MinimalBitmaskType _bitmask_type);
4389 RTPS_DllAPI const MinimalBitmaskType& bitmask_type() const;
4391
4392 RTPS_DllAPI void extended_type(
4393 MinimalExtendedType _extended_type);
4394 RTPS_DllAPI const MinimalExtendedType& extended_type() const;
4396
4397 RTPS_DllAPI static size_t getCdrSerializedSize(
4398 const MinimalTypeObject& data,
4399 size_t current_alignment = 0);
4400 RTPS_DllAPI void serialize(
4401 eprosima::fastcdr::Cdr& cdr) const;
4402 RTPS_DllAPI void deserialize(
4403 eprosima::fastcdr::Cdr& cdr);
4404
4405 RTPS_DllAPI bool operator==(
4406 const MinimalTypeObject& other) const;
4407
4408 RTPS_DllAPI bool consistent(
4409 const MinimalTypeObject& x,
4410 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4411
4412private:
4413
4414 octet m__d;
4415
4416 MinimalAliasType m_alias_type;
4417 MinimalAnnotationType m_annotation_type;
4418 MinimalStructType m_struct_type;
4419 MinimalUnionType m_union_type;
4420 MinimalBitsetType m_bitset_type;
4421 MinimalSequenceType m_sequence_type;
4422 MinimalArrayType m_array_type;
4423 MinimalMapType m_map_type;
4424 MinimalEnumeratedType m_enumerated_type;
4425 MinimalBitmaskType m_bitmask_type;
4426 MinimalExtendedType m_extended_type;
4427};
4429{
4430public:
4431
4435 RTPS_DllAPI TypeObject();
4436
4440 RTPS_DllAPI ~TypeObject();
4441
4446 RTPS_DllAPI TypeObject(
4447 const TypeObject& x);
4448
4453 RTPS_DllAPI TypeObject(
4454 TypeObject&& x);
4455
4460 RTPS_DllAPI TypeObject& operator=(
4461 const TypeObject& x);
4462
4467 RTPS_DllAPI TypeObject& operator=(
4468 TypeObject&& x);
4469
4475 RTPS_DllAPI void _d(
4476 uint8_t __d);
4477
4482 RTPS_DllAPI uint8_t _d() const;
4483
4488 RTPS_DllAPI uint8_t& _d();
4489
4494 RTPS_DllAPI void complete(
4495 const CompleteTypeObject& _complete);
4496
4501 RTPS_DllAPI void complete(
4502 CompleteTypeObject&& _complete);
4503
4509 RTPS_DllAPI const CompleteTypeObject& complete() const;
4510
4521 RTPS_DllAPI void minimal(
4522 const MinimalTypeObject& _minimal);
4523
4528 RTPS_DllAPI void minimal(
4529 MinimalTypeObject&& _minimal);
4530
4536 RTPS_DllAPI const MinimalTypeObject& minimal() const;
4537
4544
4551 RTPS_DllAPI static size_t getCdrSerializedSize(
4552 const TypeObject& data,
4553 size_t current_alignment = 0);
4558 RTPS_DllAPI void serialize(
4559 eprosima::fastcdr::Cdr& cdr) const;
4560
4565 RTPS_DllAPI void deserialize(
4566 eprosima::fastcdr::Cdr& cdr);
4567
4568 RTPS_DllAPI bool operator==(
4569 const TypeObject& other) const;
4570
4576 RTPS_DllAPI bool consistent(
4577 const TypeObject& x,
4578 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4579
4580private:
4581
4582 uint8_t m__d;
4583
4584 CompleteTypeObject m_complete;
4585 MinimalTypeObject m_minimal;
4586};
4587
4588typedef std::vector<TypeObject> TypeObjectSeq;
4589
4590// Set of TypeObjects representing a strong component: Equivalence class
4591// for the Strong Connectivity relationship (mutual reachability between
4592// types).
4593// Ordered by fully qualified typename lexicographic order
4595
4596/*struct TypeIdentifierTypeObjectPair final {
4597 TypeIdentifier type_identifier;
4598 TypeObject type_object;
4599 };*/
4601{
4602public:
4603
4614
4615 RTPS_DllAPI inline void type_identifier(
4616 const TypeIdentifier& _type_identifier) { m_type_identifier = _type_identifier; }
4617 RTPS_DllAPI inline void type_identifier(
4618 TypeIdentifier&& _type_identifier) { m_type_identifier = std::move(_type_identifier); }
4619 RTPS_DllAPI inline const TypeIdentifier& type_identifier() const { return m_type_identifier; }
4620 RTPS_DllAPI inline TypeIdentifier& type_identifier() { return m_type_identifier; }
4621
4622 RTPS_DllAPI inline void type_object(
4623 const TypeObject& _type_object) { m_type_object = _type_object; }
4624 RTPS_DllAPI inline void type_object(
4625 TypeObject&& _type_object) { m_type_object = std::move(_type_object); }
4626 RTPS_DllAPI inline const TypeObject& type_object() const { return m_type_object; }
4627 RTPS_DllAPI inline TypeObject& type_object() { return m_type_object; }
4628
4629 RTPS_DllAPI static size_t getCdrSerializedSize(
4630 const TypeIdentifierTypeObjectPair& data,
4631 size_t current_alignment = 0);
4632 RTPS_DllAPI void serialize(
4633 eprosima::fastcdr::Cdr& cdr) const;
4634 RTPS_DllAPI void deserialize(
4635 eprosima::fastcdr::Cdr& cdr);
4636
4637private:
4638
4639 TypeIdentifier m_type_identifier;
4640 TypeObject m_type_object;
4641};
4642typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
4643
4644/*struct TypeIdentifierPair final {
4645 TypeIdentifier type_identifier1;
4646 TypeIdentifier type_identifier2;
4647 };*/
4649{
4650public:
4651
4652 RTPS_DllAPI TypeIdentifierPair();
4653 RTPS_DllAPI ~TypeIdentifierPair();
4655 const TypeIdentifierPair& x);
4657 TypeIdentifierPair&& x);
4659 const TypeIdentifierPair& x);
4661 TypeIdentifierPair&& x);
4662
4663 RTPS_DllAPI inline void type_identifier1(
4664 const TypeIdentifier& _type_identifier1) { m_type_identifier1 = _type_identifier1; }
4665 RTPS_DllAPI inline void type_identifier1(
4666 TypeIdentifier&& _type_identifier1) { m_type_identifier1 = std::move(_type_identifier1); }
4667 RTPS_DllAPI inline const TypeIdentifier& type_identifier1() const { return m_type_identifier1; }
4668 RTPS_DllAPI inline TypeIdentifier& type_identifier1() { return m_type_identifier1; }
4669
4670 RTPS_DllAPI inline void type_identifier2(
4671 const TypeIdentifier& _type_identifier2) { m_type_identifier2 = _type_identifier2; }
4672 RTPS_DllAPI inline void type_identifier2(
4673 TypeIdentifier&& _type_identifier2) { m_type_identifier2 = std::move(_type_identifier2); }
4674 RTPS_DllAPI inline const TypeIdentifier& type_identifier2() const { return m_type_identifier2; }
4675 RTPS_DllAPI inline TypeIdentifier& type_identifier2() { return m_type_identifier2; }
4676
4677 RTPS_DllAPI static size_t getCdrSerializedSize(
4678 const TypeIdentifierPair& data,
4679 size_t current_alignment = 0);
4680 RTPS_DllAPI void serialize(
4681 eprosima::fastcdr::Cdr& cdr) const;
4682 RTPS_DllAPI void deserialize(
4683 eprosima::fastcdr::Cdr& cdr);
4684
4685private:
4686
4687 TypeIdentifier m_type_identifier1;
4688 TypeIdentifier m_type_identifier2;
4689};
4690
4691typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
4692/*struct TypeIdentifierWithSize {
4693 TypeIdentifier type_id;
4694 uint32_t typeobject_serialized_size;
4695 };*/
4697{
4698public:
4699
4703 const TypeIdentifierWithSize& x);
4707 const TypeIdentifierWithSize& x);
4710
4711 RTPS_DllAPI inline void type_id(
4712 const TypeIdentifier& _type_id) { m_type_id = _type_id; }
4713 RTPS_DllAPI inline void type_id(
4714 TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
4715 RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
4716 RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
4717
4718 RTPS_DllAPI inline void typeobject_serialized_size(
4719 const uint32_t& _typeobject_serialized_size) { m_typeobject_serialized_size = _typeobject_serialized_size; }
4720 RTPS_DllAPI inline void typeobject_serialized_size(
4721 uint32_t&& _typeobject_serialized_size) {
4722 m_typeobject_serialized_size = std::move(_typeobject_serialized_size);
4723 }
4724 RTPS_DllAPI inline const uint32_t& typeobject_serialized_size() const { return m_typeobject_serialized_size; }
4725 RTPS_DllAPI inline uint32_t& typeobject_serialized_size() { return m_typeobject_serialized_size; }
4726
4727 RTPS_DllAPI static size_t getCdrSerializedSize(
4728 const TypeIdentifierWithSize& data,
4729 size_t current_alignment = 0);
4730 RTPS_DllAPI void serialize(
4731 eprosima::fastcdr::Cdr& cdr) const;
4732 RTPS_DllAPI void deserialize(
4733 eprosima::fastcdr::Cdr& cdr);
4734
4735private:
4736
4737 TypeIdentifier m_type_id;
4738 uint32_t m_typeobject_serialized_size;
4739};
4740
4741typedef std::vector<TypeIdentifierWithSize> TypeIdentifierWithSizeSeq;
4742
4743/*struct TypeIdentifierWithDependencies {
4744 TypeIdentifierWithSize typeid_with_size;
4745 // The total additional types related to minimal_type
4746 int32_t dependent_typeid_count;
4747 TypeIdentifierWithSizeSeq dependent_typeids;
4748 };*/
4750{
4751public:
4752
4763
4764 RTPS_DllAPI inline void typeid_with_size(
4765 const TypeIdentifierWithSize& _typeid_with_size) { m_typeid_with_size = _typeid_with_size; }
4766 RTPS_DllAPI inline void typeid_with_size(
4767 TypeIdentifierWithSize&& _typeid_with_size) { m_typeid_with_size = std::move(_typeid_with_size); }
4768 RTPS_DllAPI inline const TypeIdentifierWithSize& typeid_with_size() const { return m_typeid_with_size; }
4769 RTPS_DllAPI inline TypeIdentifierWithSize& typeid_with_size() { return m_typeid_with_size; }
4770
4771 RTPS_DllAPI inline void dependent_typeid_count(
4772 const int32_t& _dependent_typeid_count) { m_dependent_typeid_count = _dependent_typeid_count; }
4773 RTPS_DllAPI inline void dependent_typeid_count(
4774 int32_t&& _dependent_typeid_count) { m_dependent_typeid_count = std::move(_dependent_typeid_count); }
4775 RTPS_DllAPI inline const int32_t& dependent_typeid_count() const { return m_dependent_typeid_count; }
4776 RTPS_DllAPI inline int32_t& dependent_typeid_count() { return m_dependent_typeid_count; }
4777
4778 RTPS_DllAPI inline void dependent_typeids(
4779 const TypeIdentifierWithSizeSeq& _dependent_typeids) { m_dependent_typeids = _dependent_typeids; }
4780 RTPS_DllAPI inline void dependent_typeids(
4781 TypeIdentifierWithSizeSeq&& _dependent_typeids) { m_dependent_typeids = std::move(_dependent_typeids); }
4782 RTPS_DllAPI inline const TypeIdentifierWithSizeSeq& dependent_typeids() const { return m_dependent_typeids; }
4783 RTPS_DllAPI inline TypeIdentifierWithSizeSeq& dependent_typeids() { return m_dependent_typeids; }
4784
4785 RTPS_DllAPI static size_t getCdrSerializedSize(
4787 size_t current_alignment = 0);
4788 RTPS_DllAPI void serialize(
4789 eprosima::fastcdr::Cdr& cdr) const;
4790 RTPS_DllAPI void deserialize(
4791 eprosima::fastcdr::Cdr& cdr);
4792
4793private:
4794
4795 TypeIdentifierWithSize m_typeid_with_size;
4796 int32_t m_dependent_typeid_count;
4797 TypeIdentifierWithSizeSeq m_dependent_typeids;
4798};
4799
4800typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
4802
4803// This appears in the builtin DDS topics PublicationBuiltinTopicData
4804// and SubscriptionBuiltinTopicData
4805
4806/*struct TypeInformation {
4807 TypeIdentifierWithDependencies minimal; // @id{0x1001}
4808 TypeIdentifierWithDependencies complete; // @id{0x1002}
4809 };*/
4811{
4812public:
4813
4814 RTPS_DllAPI TypeInformation();
4815 RTPS_DllAPI ~TypeInformation();
4816 RTPS_DllAPI TypeInformation(
4817 const TypeInformation& x);
4818 RTPS_DllAPI TypeInformation(
4819 TypeInformation&& x);
4821 const TypeInformation& x);
4823 TypeInformation&& x);
4824
4825 RTPS_DllAPI inline void minimal(
4826 const TypeIdentifierWithDependencies& _minimal) { m_minimal = _minimal; }
4827 RTPS_DllAPI inline void minimal(
4828 TypeIdentifierWithDependencies&& _minimal) { m_minimal = std::move(_minimal); }
4829 RTPS_DllAPI inline const TypeIdentifierWithDependencies& minimal() const { return m_minimal; }
4830 RTPS_DllAPI inline TypeIdentifierWithDependencies& minimal() { return m_minimal; }
4831
4832 RTPS_DllAPI inline void complete(
4833 const TypeIdentifierWithDependencies& _complete) { m_complete = _complete; }
4834 RTPS_DllAPI inline void complete(
4835 TypeIdentifierWithDependencies&& _complete) { m_complete = std::move(_complete); }
4836 RTPS_DllAPI inline const TypeIdentifierWithDependencies& complete() const { return m_complete; }
4837 RTPS_DllAPI inline TypeIdentifierWithDependencies& complete() { return m_complete; }
4838
4839 RTPS_DllAPI static size_t getCdrSerializedSize(
4840 const TypeInformation& data,
4841 size_t current_alignment = 0);
4842 RTPS_DllAPI void serialize(
4843 eprosima::fastcdr::Cdr& cdr) const;
4844 RTPS_DllAPI void deserialize(
4845 eprosima::fastcdr::Cdr& cdr);
4846
4847private:
4848
4851};
4852
4853typedef std::vector<TypeInformation> TypeInformationSeq;
4855
4856} // namespace types
4857} // namespace fastrtps
4858} // namespace eprosima
4859
4860#endif // TYPES_TYPE_OBJECT_H
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition: AnnotationParameterValue.h:166
Definition: AnnotationParameterValue.h:1255
RTPS_DllAPI AppliedVerbatimAnnotation & verbatim()
Definition: TypeObject.h:350
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(AppliedBuiltinTypeAnnotations &&x)
RTPS_DllAPI AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const AppliedBuiltinTypeAnnotations &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedBuiltinTypeAnnotations &data, size_t current_alignment=0)
RTPS_DllAPI const AppliedVerbatimAnnotation & verbatim() const
Definition: TypeObject.h:349
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI void verbatim(AppliedVerbatimAnnotation &&_verbatim)
Definition: TypeObject.h:347
RTPS_DllAPI bool operator==(const AppliedBuiltinTypeAnnotations &other) const
RTPS_DllAPI void verbatim(const AppliedVerbatimAnnotation &_verbatim)
Definition: TypeObject.h:345
Definition: AnnotationParameterValue.h:1133
Definition: TypeObject.h:1695
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonAliasBody &data, size_t current_alignment=0)
RTPS_DllAPI CommonAliasBody(const CommonAliasBody &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonAliasBody & operator=(const CommonAliasBody &x)
RTPS_DllAPI CommonAliasBody(CommonAliasBody &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const AliasMemberFlag & related_flags() const
Definition: TypeObject.h:1713
RTPS_DllAPI void related_flags(AliasMemberFlag &&_related_flags)
Definition: TypeObject.h:1711
RTPS_DllAPI TypeIdentifier & related_type()
Definition: TypeObject.h:1721
RTPS_DllAPI AliasMemberFlag & related_flags()
Definition: TypeObject.h:1714
RTPS_DllAPI void related_flags(const AliasMemberFlag &_related_flags)
Definition: TypeObject.h:1709
RTPS_DllAPI bool operator==(const CommonAliasBody &other) const
RTPS_DllAPI void related_type(TypeIdentifier &&_related_type)
Definition: TypeObject.h:1718
RTPS_DllAPI void related_type(const TypeIdentifier &_related_type)
Definition: TypeObject.h:1716
RTPS_DllAPI CommonAliasBody & operator=(CommonAliasBody &&x)
RTPS_DllAPI const TypeIdentifier & related_type() const
Definition: TypeObject.h:1720
RTPS_DllAPI CommonAnnotationParameter & operator=(CommonAnnotationParameter &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonAnnotationParameter &data, size_t current_alignment=0)
RTPS_DllAPI AnnotationParameterFlag & member_flags()
Definition: TypeObject.h:1321
RTPS_DllAPI CommonAnnotationParameter(CommonAnnotationParameter &&x)
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:1325
RTPS_DllAPI void member_flags(const AnnotationParameterFlag &_member_flags)
Definition: TypeObject.h:1316
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonAnnotationParameter(const CommonAnnotationParameter &x)
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:1323
RTPS_DllAPI void member_flags(AnnotationParameterFlag &&_member_flags)
Definition: TypeObject.h:1318
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:1328
RTPS_DllAPI bool consistent(const CommonAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CommonAnnotationParameter &other) const
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition: TypeObject.h:1327
RTPS_DllAPI CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
RTPS_DllAPI const AnnotationParameterFlag & member_flags() const
Definition: TypeObject.h:1320
RTPS_DllAPI bool consistent(const CommonArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonArrayHeader & operator=(CommonArrayHeader &&x)
RTPS_DllAPI void bound_seq(const LBoundSeq &_bound_seq)
Definition: TypeObject.h:2549
RTPS_DllAPI CommonArrayHeader & operator=(const CommonArrayHeader &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonArrayHeader(const CommonArrayHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonArrayHeader &data, size_t current_alignment=0)
RTPS_DllAPI LBoundSeq & bound_seq()
Definition: TypeObject.h:2554
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const LBoundSeq & bound_seq() const
Definition: TypeObject.h:2553
RTPS_DllAPI CommonArrayHeader(CommonArrayHeader &&x)
RTPS_DllAPI void bound_seq(LBoundSeq &&_bound_seq)
Definition: TypeObject.h:2551
RTPS_DllAPI bool operator==(const CommonArrayHeader &other) const
Definition: TypeObject.h:3741
RTPS_DllAPI void bitcount(octet &&_bitcount)
Definition: TypeObject.h:3771
RTPS_DllAPI CommonBitfield(const CommonBitfield &x)
RTPS_DllAPI void holder_type(TypeKind &&_holder_type)
Definition: TypeObject.h:3778
RTPS_DllAPI octet & bitcount()
Definition: TypeObject.h:3774
RTPS_DllAPI BitsetMemberFlag & flags()
Definition: TypeObject.h:3767
RTPS_DllAPI const TypeKind & holder_type() const
Definition: TypeObject.h:3780
RTPS_DllAPI CommonBitfield(CommonBitfield &&x)
RTPS_DllAPI CommonBitfield & operator=(const CommonBitfield &x)
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:3759
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI TypeKind & holder_type()
Definition: TypeObject.h:3781
RTPS_DllAPI bool consistent(const CommonBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CommonBitfield &other) const
RTPS_DllAPI void holder_type(const TypeKind &_holder_type)
Definition: TypeObject.h:3776
RTPS_DllAPI CommonBitfield & operator=(CommonBitfield &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:3760
RTPS_DllAPI void bitcount(const octet &_bitcount)
Definition: TypeObject.h:3769
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:3757
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:3755
RTPS_DllAPI const octet & bitcount() const
Definition: TypeObject.h:3773
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitfield &data, size_t current_alignment=0)
RTPS_DllAPI const BitsetMemberFlag & flags() const
Definition: TypeObject.h:3766
RTPS_DllAPI void flags(BitsetMemberFlag &&_flags)
Definition: TypeObject.h:3764
RTPS_DllAPI void flags(const BitsetMemberFlag &_flags)
Definition: TypeObject.h:3762
Definition: TypeObject.h:3399
RTPS_DllAPI CommonBitflag(const CommonBitflag &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitflag &data, size_t current_alignment=0)
RTPS_DllAPI CommonBitflag & operator=(CommonBitflag &&x)
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:3417
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const BitflagFlag & flags() const
Definition: TypeObject.h:3424
RTPS_DllAPI BitflagFlag & flags()
Definition: TypeObject.h:3425
RTPS_DllAPI CommonBitflag(CommonBitflag &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:3418
RTPS_DllAPI void flags(BitflagFlag &&_flags)
Definition: TypeObject.h:3422
RTPS_DllAPI bool consistent(const CommonBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void flags(const BitflagFlag &_flags)
Definition: TypeObject.h:3420
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:3415
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:3413
RTPS_DllAPI bool operator==(const CommonBitflag &other) const
RTPS_DllAPI CommonBitflag & operator=(const CommonBitflag &x)
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:3578
RTPS_DllAPI CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:3583
RTPS_DllAPI bool consistent(const CommonBitmaskHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:3582
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:3580
RTPS_DllAPI CommonBitmaskHeader(const CommonBitmaskHeader &x)
RTPS_DllAPI CommonBitmaskHeader(CommonBitmaskHeader &&x)
RTPS_DllAPI CommonBitmaskHeader & operator=(CommonBitmaskHeader &&x)
RTPS_DllAPI bool operator==(const CommonBitmaskHeader &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitmaskHeader &data, size_t current_alignment=0)
RTPS_DllAPI void element_flags(const CollectionElementFlag &_element_flags)
Definition: TypeObject.h:2125
RTPS_DllAPI CommonCollectionElement(CommonCollectionElement &&x)
RTPS_DllAPI bool operator==(const CommonCollectionElement &other) const
RTPS_DllAPI TypeIdentifier & type()
Definition: TypeObject.h:2137
RTPS_DllAPI CommonCollectionElement & operator=(const CommonCollectionElement &x)
RTPS_DllAPI void type(TypeIdentifier &&_type)
Definition: TypeObject.h:2134
RTPS_DllAPI void element_flags(CollectionElementFlag &&_element_flags)
Definition: TypeObject.h:2127
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonCollectionElement(const CommonCollectionElement &x)
RTPS_DllAPI CommonCollectionElement & operator=(CommonCollectionElement &&x)
RTPS_DllAPI const TypeIdentifier & type() const
Definition: TypeObject.h:2136
RTPS_DllAPI bool consistent(const CommonCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void type(const TypeIdentifier &_type)
Definition: TypeObject.h:2132
RTPS_DllAPI const CollectionElementFlag & element_flags() const
Definition: TypeObject.h:2129
RTPS_DllAPI CollectionElementFlag & element_flags()
Definition: TypeObject.h:2130
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonCollectionElement &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const CommonCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bound(const LBound &_bound)
Definition: TypeObject.h:2277
RTPS_DllAPI void bound(LBound &&_bound)
Definition: TypeObject.h:2279
RTPS_DllAPI CommonCollectionHeader(const CommonCollectionHeader &x)
RTPS_DllAPI CommonCollectionHeader(CommonCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CommonCollectionHeader &other) const
RTPS_DllAPI CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonCollectionHeader &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const LBound & bound() const
Definition: TypeObject.h:2281
RTPS_DllAPI LBound & bound()
Definition: TypeObject.h:2282
RTPS_DllAPI CommonCollectionHeader & operator=(CommonCollectionHeader &&x)
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:926
RTPS_DllAPI UnionDiscriminatorFlag & member_flags()
Definition: TypeObject.h:922
RTPS_DllAPI bool consistent(const CommonDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CommonDiscriminatorMember &other) const
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:928
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void member_flags(const UnionDiscriminatorFlag &_member_flags)
Definition: TypeObject.h:917
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
RTPS_DllAPI const UnionDiscriminatorFlag & member_flags() const
Definition: TypeObject.h:921
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonDiscriminatorMember &data, size_t current_alignment=0)
RTPS_DllAPI CommonDiscriminatorMember & operator=(CommonDiscriminatorMember &&x)
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:924
RTPS_DllAPI CommonDiscriminatorMember(CommonDiscriminatorMember &&x)
RTPS_DllAPI CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:929
RTPS_DllAPI void member_flags(UnionDiscriminatorFlag &&_member_flags)
Definition: TypeObject.h:919
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:3139
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:3144
RTPS_DllAPI bool consistent(const CommonEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:3143
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonEnumeratedHeader & operator=(CommonEnumeratedHeader &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:3141
RTPS_DllAPI CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonEnumeratedHeader &data, size_t current_alignment=0)
RTPS_DllAPI CommonEnumeratedHeader(CommonEnumeratedHeader &&x)
RTPS_DllAPI bool operator==(const CommonEnumeratedHeader &other) const
RTPS_DllAPI void flags(const EnumeratedLiteralFlag &_flags)
Definition: TypeObject.h:2976
RTPS_DllAPI CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
RTPS_DllAPI EnumeratedLiteralFlag & flags()
Definition: TypeObject.h:2981
RTPS_DllAPI CommonEnumeratedLiteral & operator=(CommonEnumeratedLiteral &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void flags(EnumeratedLiteralFlag &&_flags)
Definition: TypeObject.h:2978
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
RTPS_DllAPI const int32_t & value() const
Definition: TypeObject.h:2973
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonEnumeratedLiteral &data, size_t current_alignment=0)
RTPS_DllAPI int32_t & value()
Definition: TypeObject.h:2974
RTPS_DllAPI const EnumeratedLiteralFlag & flags() const
Definition: TypeObject.h:2980
RTPS_DllAPI bool operator==(const CommonEnumeratedLiteral &other) const
RTPS_DllAPI void value(const int32_t &_value)
Definition: TypeObject.h:2969
RTPS_DllAPI bool consistent(const CommonEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonEnumeratedLiteral(CommonEnumeratedLiteral &&x)
RTPS_DllAPI void value(int32_t &&_value)
Definition: TypeObject.h:2971
RTPS_DllAPI void member_flags(const StructMemberFlag &_member_flags)
Definition: TypeObject.h:64
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:73
RTPS_DllAPI bool operator==(const CommonStructMember &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:71
RTPS_DllAPI StructMemberFlag & member_flags()
Definition: TypeObject.h:69
RTPS_DllAPI bool consistent(const CommonStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition: TypeObject.h:59
RTPS_DllAPI MemberId & member_id()
Definition: TypeObject.h:62
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:76
RTPS_DllAPI CommonStructMember & operator=(const CommonStructMember &x)
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition: TypeObject.h:57
RTPS_DllAPI CommonStructMember(const CommonStructMember &x)
RTPS_DllAPI CommonStructMember(CommonStructMember &&x)
RTPS_DllAPI const MemberId & member_id() const
Definition: TypeObject.h:61
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonStructMember &data, size_t current_alignment=0)
RTPS_DllAPI void member_flags(StructMemberFlag &&_member_flags)
Definition: TypeObject.h:66
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition: TypeObject.h:75
RTPS_DllAPI CommonStructMember & operator=(CommonStructMember &&x)
RTPS_DllAPI const StructMemberFlag & member_flags() const
Definition: TypeObject.h:68
RTPS_DllAPI bool operator==(const CommonUnionMember &other) const
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:747
RTPS_DllAPI void member_flags(UnionMemberFlag &&_member_flags)
Definition: TypeObject.h:740
RTPS_DllAPI UnionMemberFlag & member_flags()
Definition: TypeObject.h:743
RTPS_DllAPI CommonUnionMember & operator=(const CommonUnionMember &x)
RTPS_DllAPI const UnionMemberFlag & member_flags() const
Definition: TypeObject.h:742
RTPS_DllAPI void member_flags(const UnionMemberFlag &_member_flags)
Definition: TypeObject.h:738
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:749
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonUnionMember &data, size_t current_alignment=0)
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition: TypeObject.h:733
RTPS_DllAPI void label_seq(const UnionCaseLabelSeq &_label_seq)
Definition: TypeObject.h:752
RTPS_DllAPI MemberId & member_id()
Definition: TypeObject.h:736
RTPS_DllAPI bool consistent(const CommonUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonUnionMember(const CommonUnionMember &x)
RTPS_DllAPI UnionCaseLabelSeq & label_seq()
Definition: TypeObject.h:757
RTPS_DllAPI CommonUnionMember(CommonUnionMember &&x)
RTPS_DllAPI CommonUnionMember & operator=(CommonUnionMember &&x)
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition: TypeObject.h:731
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:745
RTPS_DllAPI const MemberId & member_id() const
Definition: TypeObject.h:735
RTPS_DllAPI void label_seq(UnionCaseLabelSeq &&_label_seq)
Definition: TypeObject.h:754
RTPS_DllAPI const UnionCaseLabelSeq & label_seq() const
Definition: TypeObject.h:756
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:750
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:1774
RTPS_DllAPI bool operator==(const CompleteAliasBody &other) const
RTPS_DllAPI CommonAliasBody & common()
Definition: TypeObject.h:1768
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:1775
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteAliasBody(const CompleteAliasBody &x)
RTPS_DllAPI const CommonAliasBody & common() const
Definition: TypeObject.h:1767
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteAliasBody & operator=(const CompleteAliasBody &x)
RTPS_DllAPI CompleteAliasBody(CompleteAliasBody &&x)
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition: TypeObject.h:1763
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition: TypeObject.h:1765
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAliasBody &data, size_t current_alignment=0)
RTPS_DllAPI CompleteAliasBody & operator=(CompleteAliasBody &&x)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:1779
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:1777
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:1770
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:1781
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:1772
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:1782
RTPS_DllAPI CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
RTPS_DllAPI CompleteAliasHeader & operator=(CompleteAliasHeader &&x)
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:1869
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteAliasHeader(CompleteAliasHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:1867
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:1871
RTPS_DllAPI bool operator==(const CompleteAliasHeader &other) const
RTPS_DllAPI CompleteAliasHeader(const CompleteAliasHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAliasHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:1872
RTPS_DllAPI const CompleteAliasHeader & header() const
Definition: TypeObject.h:1960
RTPS_DllAPI CompleteAliasType & operator=(const CompleteAliasType &x)
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition: TypeObject.h:1954
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition: TypeObject.h:1949
RTPS_DllAPI void header(CompleteAliasHeader &&_header)
Definition: TypeObject.h:1958
RTPS_DllAPI void body(CompleteAliasBody &&_body)
Definition: TypeObject.h:1965
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition: TypeObject.h:1951
RTPS_DllAPI CompleteAliasType & operator=(CompleteAliasType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void body(const CompleteAliasBody &_body)
Definition: TypeObject.h:1963
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAliasType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteAliasBody & body()
Definition: TypeObject.h:1968
RTPS_DllAPI const CompleteAliasBody & body() const
Definition: TypeObject.h:1967
RTPS_DllAPI CompleteAliasHeader & header()
Definition: TypeObject.h:1961
RTPS_DllAPI bool operator==(const CompleteAliasType &other) const
RTPS_DllAPI void header(const CompleteAliasHeader &_header)
Definition: TypeObject.h:1956
RTPS_DllAPI CompleteAliasType(CompleteAliasType &&x)
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition: TypeObject.h:1953
RTPS_DllAPI CompleteAliasType(const CompleteAliasType &x)
RTPS_DllAPI QualifiedTypeName & annotation_name()
Definition: TypeObject.h:1505
RTPS_DllAPI void annotation_name(const QualifiedTypeName &_annotation_name)
Definition: TypeObject.h:1500
RTPS_DllAPI CompleteAnnotationHeader & operator=(CompleteAnnotationHeader &&x)
RTPS_DllAPI void annotation_name(QualifiedTypeName &&_annotation_name)
Definition: TypeObject.h:1502
RTPS_DllAPI bool consistent(const CompleteAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationHeader(CompleteAnnotationHeader &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteAnnotationHeader &other) const
RTPS_DllAPI CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
RTPS_DllAPI const QualifiedTypeName & annotation_name() const
Definition: TypeObject.h:1504
RTPS_DllAPI CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAnnotationHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
RTPS_DllAPI CommonAnnotationParameter & common()
Definition: TypeObject.h:1378
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition: TypeObject.h:1392
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition: TypeObject.h:1373
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition: TypeObject.h:1387
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition: TypeObject.h:1377
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:1380
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition: TypeObject.h:1375
RTPS_DllAPI CompleteAnnotationParameter(CompleteAnnotationParameter &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:1382
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:1384
RTPS_DllAPI CompleteAnnotationParameter & operator=(CompleteAnnotationParameter &&x)
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition: TypeObject.h:1391
RTPS_DllAPI bool consistent(const CompleteAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:1385
RTPS_DllAPI CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAnnotationParameter &data, size_t current_alignment=0)
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition: TypeObject.h:1389
RTPS_DllAPI bool operator==(const CompleteAnnotationParameter &other) const
RTPS_DllAPI void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
Definition: TypeObject.h:1600
RTPS_DllAPI CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition: TypeObject.h:1584
RTPS_DllAPI CompleteAnnotationHeader & header()
Definition: TypeObject.h:1596
RTPS_DllAPI void header(CompleteAnnotationHeader &&_header)
Definition: TypeObject.h:1593
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition: TypeObject.h:1586
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool operator==(const CompleteAnnotationType &other) const
RTPS_DllAPI bool consistent(const CompleteAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteAnnotationType(const CompleteAnnotationType &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAnnotationType &data, size_t current_alignment=0)
RTPS_DllAPI const CompleteAnnotationParameterSeq & member_seq() const
Definition: TypeObject.h:1602
RTPS_DllAPI CompleteAnnotationType(CompleteAnnotationType &&x)
RTPS_DllAPI void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
Definition: TypeObject.h:1598
RTPS_DllAPI const CompleteAnnotationHeader & header() const
Definition: TypeObject.h:1595
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition: TypeObject.h:1589
RTPS_DllAPI CompleteAnnotationType & operator=(CompleteAnnotationType &&x)
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition: TypeObject.h:1588
RTPS_DllAPI void header(const CompleteAnnotationHeader &_header)
Definition: TypeObject.h:1591
RTPS_DllAPI CompleteAnnotationParameterSeq & member_seq()
Definition: TypeObject.h:1603
RTPS_DllAPI bool consistent(const CompleteArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteArrayHeader &data, size_t current_alignment=0)
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition: TypeObject.h:2597
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:2604
RTPS_DllAPI CommonArrayHeader & common()
Definition: TypeObject.h:2600
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteArrayHeader(CompleteArrayHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:2602
RTPS_DllAPI CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
RTPS_DllAPI const CommonArrayHeader & common() const
Definition: TypeObject.h:2599
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:2606
RTPS_DllAPI bool operator==(const CompleteArrayHeader &other) const
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:2607
RTPS_DllAPI void common(const CommonArrayHeader &_common)
Definition: TypeObject.h:2595
RTPS_DllAPI CompleteArrayHeader(const CompleteArrayHeader &x)
RTPS_DllAPI CompleteArrayHeader & operator=(CompleteArrayHeader &&x)
RTPS_DllAPI CompleteArrayType & operator=(const CompleteArrayType &x)
RTPS_DllAPI void header(const CompleteArrayHeader &_header)
Definition: TypeObject.h:2702
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2699
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:2709
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:2711
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteArrayType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:2714
RTPS_DllAPI void header(CompleteArrayHeader &&_header)
Definition: TypeObject.h:2704
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2695
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:2713
RTPS_DllAPI CompleteArrayType(CompleteArrayType &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteArrayType &other) const
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2697
RTPS_DllAPI CompleteArrayHeader & header()
Definition: TypeObject.h:2707
RTPS_DllAPI const CompleteArrayHeader & header() const
Definition: TypeObject.h:2706
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2700
RTPS_DllAPI CompleteArrayType & operator=(CompleteArrayType &&x)
RTPS_DllAPI bool consistent(const CompleteArrayType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteArrayType(const CompleteArrayType &x)
Definition: TypeObject.h:3811
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:3837
RTPS_DllAPI const CommonBitfield & common() const
Definition: TypeObject.h:3829
RTPS_DllAPI CommonBitfield & common()
Definition: TypeObject.h:3830
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitfield &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition: TypeObject.h:3825
RTPS_DllAPI CompleteBitfield(CompleteBitfield &&x)
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:3836
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition: TypeObject.h:3827
RTPS_DllAPI bool consistent(const CompleteBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:3832
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:3834
RTPS_DllAPI bool operator==(const CompleteBitfield &other) const
RTPS_DllAPI CompleteBitfield & operator=(const CompleteBitfield &x)
RTPS_DllAPI CompleteBitfield & operator=(CompleteBitfield &&x)
RTPS_DllAPI CompleteBitfield(const CompleteBitfield &x)
Definition: TypeObject.h:3453
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:3479
RTPS_DllAPI CompleteBitflag & operator=(CompleteBitflag &&x)
RTPS_DllAPI CommonBitflag & common()
Definition: TypeObject.h:3472
RTPS_DllAPI CompleteBitflag & operator=(const CompleteBitflag &x)
RTPS_DllAPI CompleteBitflag(CompleteBitflag &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition: TypeObject.h:3469
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:3478
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:3474
RTPS_DllAPI const CommonBitflag & common() const
Definition: TypeObject.h:3471
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:3476
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition: TypeObject.h:3467
RTPS_DllAPI bool operator==(const CompleteBitflag &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitflag &data, size_t current_alignment=0)
RTPS_DllAPI CompleteBitflag(const CompleteBitflag &x)
RTPS_DllAPI CompleteBitmaskType(const CompleteBitmaskType &x)
RTPS_DllAPI void header(const CompleteBitmaskHeader &_header)
Definition: TypeObject.h:3634
RTPS_DllAPI CompleteBitflagSeq & flag_seq()
Definition: TypeObject.h:3646
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitmaskType &data, size_t current_alignment=0)
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition: TypeObject.h:3629
RTPS_DllAPI const CompleteBitflagSeq & flag_seq() const
Definition: TypeObject.h:3645
RTPS_DllAPI void flag_seq(const CompleteBitflagSeq &_flag_seq)
Definition: TypeObject.h:3641
RTPS_DllAPI bool operator==(const CompleteBitmaskType &other) const
RTPS_DllAPI CompleteBitmaskType & operator=(CompleteBitmaskType &&x)
RTPS_DllAPI CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteBitmaskHeader & header()
Definition: TypeObject.h:3639
RTPS_DllAPI void flag_seq(CompleteBitflagSeq &&_flag_seq)
Definition: TypeObject.h:3643
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void header(CompleteBitmaskHeader &&_header)
Definition: TypeObject.h:3636
RTPS_DllAPI CompleteBitmaskType(CompleteBitmaskType &&x)
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition: TypeObject.h:3632
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition: TypeObject.h:3631
RTPS_DllAPI bool consistent(const CompleteBitmaskType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
Definition: TypeObject.h:3627
RTPS_DllAPI const CompleteBitmaskHeader & header() const
Definition: TypeObject.h:3638
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:3938
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitsetHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const CompleteBitsetHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:3943
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const CompleteBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:3941
RTPS_DllAPI CompleteBitsetHeader & operator=(CompleteBitsetHeader &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:3945
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:3939
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:3946
RTPS_DllAPI CompleteBitsetHeader(const CompleteBitsetHeader &x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:3934
RTPS_DllAPI CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
RTPS_DllAPI CompleteBitsetHeader(CompleteBitsetHeader &&x)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:3936
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition: TypeObject.h:4035
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition: TypeObject.h:4038
RTPS_DllAPI void header(const CompleteBitsetHeader &_header)
Definition: TypeObject.h:4040
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitsetType &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const CompleteBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteBitsetHeader & header() const
Definition: TypeObject.h:4044
RTPS_DllAPI CompleteBitfieldSeq & field_seq()
Definition: TypeObject.h:4052
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void header(CompleteBitsetHeader &&_header)
Definition: TypeObject.h:4042
RTPS_DllAPI CompleteBitsetType & operator=(CompleteBitsetType &&x)
RTPS_DllAPI CompleteBitsetType(const CompleteBitsetType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteBitsetType &other) const
RTPS_DllAPI const CompleteBitfieldSeq & field_seq() const
Definition: TypeObject.h:4051
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition: TypeObject.h:4033
RTPS_DllAPI CompleteBitsetType & operator=(const CompleteBitsetType &x)
RTPS_DllAPI void field_seq(CompleteBitfieldSeq &&_field_seq)
Definition: TypeObject.h:4049
RTPS_DllAPI CompleteBitsetHeader & header()
Definition: TypeObject.h:4045
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition: TypeObject.h:4037
RTPS_DllAPI CompleteBitsetType(CompleteBitsetType &&x)
RTPS_DllAPI void field_seq(const CompleteBitfieldSeq &_field_seq)
Definition: TypeObject.h:4047
RTPS_DllAPI CompleteElementDetail & detail()
Definition: TypeObject.h:2191
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteCollectionElement &data, size_t current_alignment=0)
RTPS_DllAPI CompleteCollectionElement & operator=(CompleteCollectionElement &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition: TypeObject.h:2179
RTPS_DllAPI void detail(CompleteElementDetail &&_detail)
Definition: TypeObject.h:2188
RTPS_DllAPI CompleteCollectionElement(const CompleteCollectionElement &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteElementDetail & detail() const
Definition: TypeObject.h:2190
RTPS_DllAPI const CommonCollectionElement & common() const
Definition: TypeObject.h:2183
RTPS_DllAPI CompleteCollectionElement(CompleteCollectionElement &&x)
RTPS_DllAPI void detail(const CompleteElementDetail &_detail)
Definition: TypeObject.h:2186
RTPS_DllAPI bool consistent(const CompleteCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition: TypeObject.h:2181
RTPS_DllAPI CommonCollectionElement & common()
Definition: TypeObject.h:2184
RTPS_DllAPI bool operator==(const CompleteCollectionElement &other) const
RTPS_DllAPI CompleteCollectionHeader(const CompleteCollectionHeader &x)
RTPS_DllAPI CommonCollectionHeader & common()
Definition: TypeObject.h:2328
RTPS_DllAPI bool consistent(const CompleteCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:2332
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition: TypeObject.h:2323
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition: TypeObject.h:2327
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:2330
RTPS_DllAPI CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:2334
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:2335
RTPS_DllAPI CompleteCollectionHeader & operator=(CompleteCollectionHeader &&x)
RTPS_DllAPI CompleteCollectionHeader(CompleteCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CompleteCollectionHeader &other) const
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition: TypeObject.h:2325
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteCollectionHeader &data, size_t current_alignment=0)
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition: TypeObject.h:975
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition: TypeObject.h:985
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition: TypeObject.h:977
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition: TypeObject.h:984
RTPS_DllAPI CompleteDiscriminatorMember & operator=(CompleteDiscriminatorMember &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition: TypeObject.h:980
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition: TypeObject.h:982
RTPS_DllAPI CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteDiscriminatorMember &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition: TypeObject.h:973
RTPS_DllAPI bool operator==(const CompleteDiscriminatorMember &other) const
RTPS_DllAPI CompleteDiscriminatorMember(const CompleteDiscriminatorMember &x)
RTPS_DllAPI CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:989
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition: TypeObject.h:978
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:987
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:991
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:992
RTPS_DllAPI CompleteElementDetail(const CompleteElementDetail &x)
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:2076
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:2077
RTPS_DllAPI bool operator==(const CompleteElementDetail &other) const
RTPS_DllAPI CompleteElementDetail(CompleteElementDetail &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteElementDetail & operator=(const CompleteElementDetail &x)
RTPS_DllAPI CompleteElementDetail & operator=(CompleteElementDetail &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteElementDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:2081
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteElementDetail &data, size_t current_alignment=0)
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:2079
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:2072
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:2083
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:2074
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:2084
RTPS_DllAPI CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x)
RTPS_DllAPI bool consistent(const CompleteEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteEnumeratedHeader &data, size_t current_alignment=0)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition: TypeObject.h:3190
RTPS_DllAPI CompleteEnumeratedHeader & operator=(CompleteEnumeratedHeader &&x)
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:3194
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:3192
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition: TypeObject.h:3189
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:3196
RTPS_DllAPI bool operator==(const CompleteEnumeratedHeader &other) const
RTPS_DllAPI CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:3197
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition: TypeObject.h:3185
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition: TypeObject.h:3187
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:3037
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition: TypeObject.h:3027
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteEnumeratedLiteral &data, size_t current_alignment=0)
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition: TypeObject.h:3030
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const CompleteEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:3036
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI CompleteEnumeratedLiteral & operator=(CompleteEnumeratedLiteral &&x)
RTPS_DllAPI CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x)
RTPS_DllAPI CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:3032
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:3034
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition: TypeObject.h:3025
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition: TypeObject.h:3029
RTPS_DllAPI bool operator==(const CompleteEnumeratedLiteral &other) const
RTPS_DllAPI bool consistent(const CompleteEnumeratedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteEnumeratedType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteEnumeratedType(const CompleteEnumeratedType &x)
RTPS_DllAPI CompleteEnumeratedHeader & header()
Definition: TypeObject.h:3298
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition: TypeObject.h:3286
RTPS_DllAPI CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition: TypeObject.h:3288
RTPS_DllAPI CompleteEnumeratedType(CompleteEnumeratedType &&x)
RTPS_DllAPI CompleteEnumeratedLiteralSeq & literal_seq()
Definition: TypeObject.h:3305
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition: TypeObject.h:3291
RTPS_DllAPI const CompleteEnumeratedHeader & header() const
Definition: TypeObject.h:3297
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition: TypeObject.h:3290
RTPS_DllAPI void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
Definition: TypeObject.h:3302
RTPS_DllAPI const CompleteEnumeratedLiteralSeq & literal_seq() const
Definition: TypeObject.h:3304
RTPS_DllAPI CompleteEnumeratedType & operator=(CompleteEnumeratedType &&x)
RTPS_DllAPI void header(CompleteEnumeratedHeader &&_header)
Definition: TypeObject.h:3295
RTPS_DllAPI bool operator==(const CompleteEnumeratedType &other) const
RTPS_DllAPI void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
Definition: TypeObject.h:3300
RTPS_DllAPI void header(const CompleteEnumeratedHeader &_header)
Definition: TypeObject.h:3293
RTPS_DllAPI CompleteExtendedType(const CompleteExtendedType &x)
RTPS_DllAPI bool consistent(const CompleteExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteExtendedType & operator=(CompleteExtendedType &&x)
RTPS_DllAPI CompleteExtendedType(CompleteExtendedType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteExtendedType &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const CompleteExtendedType &) const
Definition: TypeObject.h:4169
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteExtendedType & operator=(const CompleteExtendedType &x)
Definition: TypeObject.h:2809
RTPS_DllAPI bool consistent(const CompleteMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteMapType & operator=(CompleteMapType &&x)
RTPS_DllAPI bool operator==(const CompleteMapType &other) const
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2827
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:2844
RTPS_DllAPI void key(const CompleteCollectionElement &_key)
Definition: TypeObject.h:2837
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition: TypeObject.h:2830
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:2846
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition: TypeObject.h:2834
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:2849
RTPS_DllAPI CompleteCollectionElement & key()
Definition: TypeObject.h:2842
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2823
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition: TypeObject.h:2832
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteMapType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteMapType & operator=(const CompleteMapType &x)
RTPS_DllAPI void key(CompleteCollectionElement &&_key)
Definition: TypeObject.h:2839
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:2848
RTPS_DllAPI const CompleteCollectionElement & key() const
Definition: TypeObject.h:2841
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteCollectionHeader & header()
Definition: TypeObject.h:2835
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2825
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2828
RTPS_DllAPI CompleteMapType(const CompleteMapType &x)
RTPS_DllAPI CompleteMapType(CompleteMapType &&x)
RTPS_DllAPI CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:132
RTPS_DllAPI bool consistent(const CompleteMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteMemberDetail & operator=(CompleteMemberDetail &&x)
RTPS_DllAPI bool operator==(const CompleteMemberDetail &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteMemberDetail &data, size_t current_alignment=0)
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:133
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:121
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteMemberDetail(const CompleteMemberDetail &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:123
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:125
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:126
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:137
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:135
RTPS_DllAPI CompleteMemberDetail(CompleteMemberDetail &&x)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:128
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:139
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:130
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:140
RTPS_DllAPI CompleteSequenceType & operator=(CompleteSequenceType &&x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2428
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:2438
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition: TypeObject.h:2431
RTPS_DllAPI CompleteSequenceType & operator=(const CompleteSequenceType &x)
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:2440
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition: TypeObject.h:2435
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:2443
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2424
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition: TypeObject.h:2433
RTPS_DllAPI bool consistent(const CompleteSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:2442
RTPS_DllAPI CompleteSequenceType(const CompleteSequenceType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteSequenceType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteCollectionHeader & header()
Definition: TypeObject.h:2436
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2426
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2429
RTPS_DllAPI bool operator==(const CompleteSequenceType &other) const
RTPS_DllAPI CompleteSequenceType(CompleteSequenceType &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteStructHeader &data, size_t current_alignment=0)
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:494
RTPS_DllAPI bool operator==(const CompleteStructHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:499
RTPS_DllAPI CompleteStructHeader & operator=(const CompleteStructHeader &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:497
RTPS_DllAPI CompleteStructHeader(const CompleteStructHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:501
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:495
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:502
RTPS_DllAPI bool consistent(const CompleteStructHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:490
RTPS_DllAPI CompleteStructHeader(CompleteStructHeader &&x)
RTPS_DllAPI CompleteStructHeader & operator=(CompleteStructHeader &&x)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:492
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteStructMember &data, size_t current_alignment=0)
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:243
RTPS_DllAPI CompleteStructMember(CompleteStructMember &&x)
RTPS_DllAPI bool operator==(const CompleteStructMember &other) const
RTPS_DllAPI CompleteStructMember & operator=(CompleteStructMember &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteStructMember(const CompleteStructMember &x)
RTPS_DllAPI const CommonStructMember & common() const
Definition: TypeObject.h:235
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:242
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition: TypeObject.h:231
RTPS_DllAPI CommonStructMember & common()
Definition: TypeObject.h:236
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:238
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:240
RTPS_DllAPI CompleteStructMember & operator=(const CompleteStructMember &x)
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition: TypeObject.h:233
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition: TypeObject.h:600
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition: TypeObject.h:602
RTPS_DllAPI void header(const CompleteStructHeader &_header)
Definition: TypeObject.h:605
RTPS_DllAPI CompleteStructMemberSeq & member_seq()
Definition: TypeObject.h:617
RTPS_DllAPI CompleteStructType(CompleteStructType &&x)
RTPS_DllAPI const CompleteStructMemberSeq & member_seq() const
Definition: TypeObject.h:616
RTPS_DllAPI CompleteStructType(const CompleteStructType &x)
RTPS_DllAPI CompleteStructType & operator=(const CompleteStructType &x)
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition: TypeObject.h:598
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteStructHeader & header() const
Definition: TypeObject.h:609
RTPS_DllAPI void member_seq(const CompleteStructMemberSeq &_member_seq)
Definition: TypeObject.h:612
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition: TypeObject.h:603
RTPS_DllAPI void header(CompleteStructHeader &&_header)
Definition: TypeObject.h:607
RTPS_DllAPI CompleteStructHeader & header()
Definition: TypeObject.h:610
RTPS_DllAPI void member_seq(CompleteStructMemberSeq &&_member_seq)
Definition: TypeObject.h:614
RTPS_DllAPI CompleteStructType & operator=(CompleteStructType &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteStructType &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const CompleteStructType &other) const
RTPS_DllAPI CompleteTypeDetail(const CompleteTypeDetail &x)
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition: TypeObject.h:434
RTPS_DllAPI const QualifiedTypeName & type_name() const
Definition: TypeObject.h:447
RTPS_DllAPI QualifiedTypeName & type_name()
Definition: TypeObject.h:448
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition: TypeObject.h:433
RTPS_DllAPI CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
RTPS_DllAPI CompleteTypeDetail(CompleteTypeDetail &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition: TypeObject.h:429
RTPS_DllAPI bool consistent(const CompleteTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteTypeDetail &data, size_t current_alignment=0)
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition: TypeObject.h:431
RTPS_DllAPI CompleteTypeDetail & operator=(CompleteTypeDetail &&x)
RTPS_DllAPI void type_name(const QualifiedTypeName &_type_name)
Definition: TypeObject.h:443
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:438
RTPS_DllAPI bool operator==(const CompleteTypeDetail &other) const
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:436
RTPS_DllAPI void type_name(QualifiedTypeName &&_type_name)
Definition: TypeObject.h:445
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:440
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:441
RTPS_DllAPI void annotation_type(CompleteAnnotationType _annotation_type)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteTypeObject &data, size_t current_alignment=0)
RTPS_DllAPI const CompleteSequenceType & sequence_type() const
RTPS_DllAPI void union_type(CompleteUnionType _union_type)
RTPS_DllAPI CompleteUnionType & union_type()
RTPS_DllAPI void struct_type(CompleteStructType _struct_type)
RTPS_DllAPI bool consistent(const CompleteTypeObject &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteTypeObject & operator=(CompleteTypeObject &&x)
RTPS_DllAPI void array_type(CompleteArrayType _array_type)
RTPS_DllAPI const CompleteAnnotationType & annotation_type() const
RTPS_DllAPI void alias_type(CompleteAliasType _alias_type)
RTPS_DllAPI CompleteSequenceType & sequence_type()
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteUnionType & union_type() const
RTPS_DllAPI CompleteExtendedType & extended_type()
RTPS_DllAPI const CompleteExtendedType & extended_type() const
RTPS_DllAPI CompleteEnumeratedType & enumerated_type()
RTPS_DllAPI const CompleteBitsetType & bitset_type() const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteStructType & struct_type()
RTPS_DllAPI const CompleteMapType & map_type() const
RTPS_DllAPI bool operator==(const CompleteTypeObject &other) const
RTPS_DllAPI void map_type(CompleteMapType _map_type)
RTPS_DllAPI CompleteTypeObject & operator=(const CompleteTypeObject &x)
RTPS_DllAPI const CompleteArrayType & array_type() const
RTPS_DllAPI void enumerated_type(CompleteEnumeratedType _enumerated_type)
RTPS_DllAPI CompleteArrayType & array_type()
RTPS_DllAPI const CompleteAliasType & alias_type() const
RTPS_DllAPI void bitset_type(CompleteBitsetType _bitset_type)
RTPS_DllAPI void bitmask_type(CompleteBitmaskType _bitmask_type)
RTPS_DllAPI void sequence_type(CompleteSequenceType _sequence_type)
RTPS_DllAPI CompleteTypeObject(CompleteTypeObject &&x)
RTPS_DllAPI const CompleteEnumeratedType & enumerated_type() const
RTPS_DllAPI CompleteAliasType & alias_type()
RTPS_DllAPI CompleteMapType & map_type()
RTPS_DllAPI const CompleteBitmaskType & bitmask_type() const
RTPS_DllAPI CompleteAnnotationType & annotation_type()
RTPS_DllAPI void extended_type(CompleteExtendedType _extended_type)
RTPS_DllAPI const CompleteStructType & struct_type() const
RTPS_DllAPI CompleteBitsetType & bitset_type()
RTPS_DllAPI CompleteTypeObject(const CompleteTypeObject &x)
RTPS_DllAPI CompleteBitmaskType & bitmask_type()
RTPS_DllAPI CompleteUnionHeader & operator=(CompleteUnionHeader &&x)
RTPS_DllAPI bool operator==(const CompleteUnionHeader &other) const
RTPS_DllAPI CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
RTPS_DllAPI CompleteUnionHeader(CompleteUnionHeader &&x)
RTPS_DllAPI CompleteUnionHeader(const CompleteUnionHeader &x)
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:1082
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:1080
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:1084
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteUnionHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const CompleteUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:1085
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:814
RTPS_DllAPI CompleteUnionMember(const CompleteUnionMember &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteUnionMember &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition: TypeObject.h:802
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition: TypeObject.h:804
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const CompleteUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:813
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CommonUnionMember & common() const
Definition: TypeObject.h:806
RTPS_DllAPI CompleteUnionMember & operator=(const CompleteUnionMember &x)
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:809
RTPS_DllAPI CompleteUnionMember(CompleteUnionMember &&x)
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:811
RTPS_DllAPI CompleteUnionMember & operator=(CompleteUnionMember &&x)
RTPS_DllAPI bool operator==(const CompleteUnionMember &other) const
RTPS_DllAPI CommonUnionMember & common()
Definition: TypeObject.h:807
RTPS_DllAPI CompleteDiscriminatorMember & discriminator()
Definition: TypeObject.h:1192
RTPS_DllAPI void discriminator(const CompleteDiscriminatorMember &_discriminator)
Definition: TypeObject.h:1187
RTPS_DllAPI const CompleteUnionMemberSeq & member_seq() const
Definition: TypeObject.h:1198
RTPS_DllAPI bool consistent(const CompleteUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteUnionType & operator=(const CompleteUnionType &x)
RTPS_DllAPI void member_seq(CompleteUnionMemberSeq &&_member_seq)
Definition: TypeObject.h:1196
RTPS_DllAPI bool operator==(const CompleteUnionType &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteUnionHeader & header() const
Definition: TypeObject.h:1184
RTPS_DllAPI CompleteUnionType(const CompleteUnionType &x)
RTPS_DllAPI CompleteUnionType & operator=(CompleteUnionType &&x)
RTPS_DllAPI void header(const CompleteUnionHeader &_header)
Definition: TypeObject.h:1180
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteDiscriminatorMember & discriminator() const
Definition: TypeObject.h:1191
RTPS_DllAPI CompleteUnionHeader & header()
Definition: TypeObject.h:1185
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition: TypeObject.h:1173
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition: TypeObject.h:1177
RTPS_DllAPI void member_seq(const CompleteUnionMemberSeq &_member_seq)
Definition: TypeObject.h:1194
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteUnionType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteUnionType(CompleteUnionType &&x)
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition: TypeObject.h:1178
RTPS_DllAPI CompleteUnionMemberSeq & member_seq()
Definition: TypeObject.h:1199
RTPS_DllAPI void discriminator(CompleteDiscriminatorMember &&_discriminator)
Definition: TypeObject.h:1189
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition: TypeObject.h:1175
RTPS_DllAPI void header(CompleteUnionHeader &&_header)
Definition: TypeObject.h:1182
Definition: TypesBase.h:323
Definition: TypeObject.h:1809
RTPS_DllAPI MinimalAliasBody & operator=(const MinimalAliasBody &x)
RTPS_DllAPI bool operator==(const MinimalAliasBody &other) const
RTPS_DllAPI MinimalAliasBody(const MinimalAliasBody &x)
RTPS_DllAPI CommonAliasBody & common()
Definition: TypeObject.h:1828
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalAliasBody & operator=(MinimalAliasBody &&x)
RTPS_DllAPI const CommonAliasBody & common() const
Definition: TypeObject.h:1827
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition: TypeObject.h:1823
RTPS_DllAPI MinimalAliasBody(MinimalAliasBody &&x)
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition: TypeObject.h:1825
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAliasBody &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAliasHeader & operator=(MinimalAliasHeader &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalAliasHeader(MinimalAliasHeader &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
RTPS_DllAPI bool operator==(const MinimalAliasHeader &) const
Definition: TypeObject.h:1919
RTPS_DllAPI MinimalAliasHeader(const MinimalAliasHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAliasHeader &data, size_t current_alignment=0)
Definition: TypeObject.h:1996
RTPS_DllAPI void header(const MinimalAliasHeader &_header)
Definition: TypeObject.h:2017
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition: TypeObject.h:2015
RTPS_DllAPI bool operator==(const MinimalAliasType &other) const
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition: TypeObject.h:2010
RTPS_DllAPI MinimalAliasType & operator=(MinimalAliasType &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAliasType &data, size_t current_alignment=0)
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition: TypeObject.h:2012
RTPS_DllAPI MinimalAliasType(const MinimalAliasType &x)
RTPS_DllAPI void body(const MinimalAliasBody &_body)
Definition: TypeObject.h:2024
RTPS_DllAPI void header(MinimalAliasHeader &&_header)
Definition: TypeObject.h:2019
RTPS_DllAPI const MinimalAliasBody & body() const
Definition: TypeObject.h:2028
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const MinimalAliasHeader & header() const
Definition: TypeObject.h:2021
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalAliasType(MinimalAliasType &&x)
RTPS_DllAPI void body(MinimalAliasBody &&_body)
Definition: TypeObject.h:2026
RTPS_DllAPI MinimalAliasHeader & header()
Definition: TypeObject.h:2022
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition: TypeObject.h:2014
RTPS_DllAPI MinimalAliasType & operator=(const MinimalAliasType &x)
RTPS_DllAPI MinimalAliasBody & body()
Definition: TypeObject.h:2029
RTPS_DllAPI MinimalAnnotationHeader & operator=(MinimalAnnotationHeader &&x)
RTPS_DllAPI MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
RTPS_DllAPI MinimalAnnotationHeader(MinimalAnnotationHeader &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAnnotationHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalAnnotationHeader &) const
Definition: TypeObject.h:1553
RTPS_DllAPI bool consistent(const MinimalAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonAnnotationParameter & common()
Definition: TypeObject.h:1442
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition: TypeObject.h:1456
RTPS_DllAPI bool consistent(const MinimalAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition: TypeObject.h:1437
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition: TypeObject.h:1451
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition: TypeObject.h:1441
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:1444
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition: TypeObject.h:1439
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:1446
RTPS_DllAPI MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:1448
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAnnotationParameter &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAnnotationParameter(MinimalAnnotationParameter &&x)
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition: TypeObject.h:1455
RTPS_DllAPI bool operator==(const MinimalAnnotationParameter &other) const
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:1449
RTPS_DllAPI MinimalAnnotationParameter & operator=(MinimalAnnotationParameter &&x)
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition: TypeObject.h:1453
RTPS_DllAPI MinimalAnnotationType(MinimalAnnotationType &&x)
RTPS_DllAPI const MinimalAnnotationParameterSeq & member_seq() const
Definition: TypeObject.h:1664
RTPS_DllAPI void header(const MinimalAnnotationHeader &_header)
Definition: TypeObject.h:1653
RTPS_DllAPI void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
Definition: TypeObject.h:1660
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition: TypeObject.h:1646
RTPS_DllAPI MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
RTPS_DllAPI void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
Definition: TypeObject.h:1662
RTPS_DllAPI const MinimalAnnotationHeader & header() const
Definition: TypeObject.h:1657
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition: TypeObject.h:1648
RTPS_DllAPI void header(MinimalAnnotationHeader &&_header)
Definition: TypeObject.h:1655
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalAnnotationHeader & header()
Definition: TypeObject.h:1658
RTPS_DllAPI bool consistent(const MinimalAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalAnnotationParameterSeq & member_seq()
Definition: TypeObject.h:1665
RTPS_DllAPI MinimalAnnotationType(const MinimalAnnotationType &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAnnotationType &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAnnotationType & operator=(MinimalAnnotationType &&x)
RTPS_DllAPI bool operator==(const MinimalAnnotationType &other) const
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition: TypeObject.h:1651
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition: TypeObject.h:1650
RTPS_DllAPI MinimalArrayHeader(MinimalArrayHeader &&x)
RTPS_DllAPI MinimalArrayHeader & operator=(MinimalArrayHeader &&x)
RTPS_DllAPI MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition: TypeObject.h:2650
RTPS_DllAPI CommonArrayHeader & common()
Definition: TypeObject.h:2653
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CommonArrayHeader & common() const
Definition: TypeObject.h:2652
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const MinimalArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const MinimalArrayHeader &other) const
RTPS_DllAPI void common(const CommonArrayHeader &_common)
Definition: TypeObject.h:2648
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalArrayHeader &data, size_t current_alignment=0)
RTPS_DllAPI MinimalArrayHeader(const MinimalArrayHeader &x)
Definition: TypeObject.h:2744
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalArrayType &data, size_t current_alignment=0)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2762
RTPS_DllAPI MinimalArrayHeader & header()
Definition: TypeObject.h:2770
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:2776
RTPS_DllAPI void header(const MinimalArrayHeader &_header)
Definition: TypeObject.h:2765
RTPS_DllAPI bool consistent(const MinimalArrayType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2758
RTPS_DllAPI MinimalArrayType(MinimalArrayType &&x)
RTPS_DllAPI void header(MinimalArrayHeader &&_header)
Definition: TypeObject.h:2767
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalArrayType(const MinimalArrayType &x)
RTPS_DllAPI bool operator==(const MinimalArrayType &other) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:2772
RTPS_DllAPI MinimalArrayType & operator=(const MinimalArrayType &x)
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2760
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2763
RTPS_DllAPI MinimalArrayType & operator=(MinimalArrayType &&x)
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:2777
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:2774
RTPS_DllAPI const MinimalArrayHeader & header() const
Definition: TypeObject.h:2769
Definition: TypeObject.h:3866
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitfield &data, size_t current_alignment=0)
RTPS_DllAPI MinimalBitfield(MinimalBitfield &&x)
RTPS_DllAPI const CommonBitfield & common() const
Definition: TypeObject.h:3891
RTPS_DllAPI CommonBitfield & common()
Definition: TypeObject.h:3892
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition: TypeObject.h:3887
RTPS_DllAPI MinimalBitfield & operator=(const MinimalBitfield &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition: TypeObject.h:3889
RTPS_DllAPI bool operator==(const MinimalBitfield &other) const
RTPS_DllAPI MinimalBitfield(const MinimalBitfield &x)
RTPS_DllAPI void name_hash(const NameHash &_name_hash)
Definition: TypeObject.h:3880
RTPS_DllAPI const NameHash & name_hash() const
Definition: TypeObject.h:3884
RTPS_DllAPI MinimalBitfield & operator=(MinimalBitfield &&x)
RTPS_DllAPI bool consistent(const MinimalBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI NameHash & name_hash()
Definition: TypeObject.h:3885
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition: TypeObject.h:3882
Definition: TypeObject.h:3508
RTPS_DllAPI MinimalBitflag(const MinimalBitflag &x)
RTPS_DllAPI MinimalBitflag & operator=(MinimalBitflag &&x)
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:3533
RTPS_DllAPI MinimalBitflag & operator=(const MinimalBitflag &x)
RTPS_DllAPI CommonBitflag & common()
Definition: TypeObject.h:3527
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition: TypeObject.h:3524
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:3534
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:3531
RTPS_DllAPI bool operator==(const MinimalBitflag &other) const
RTPS_DllAPI bool consistent(const MinimalBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CommonBitflag & common() const
Definition: TypeObject.h:3526
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitflag &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition: TypeObject.h:3522
RTPS_DllAPI MinimalBitflag(MinimalBitflag &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:3529
RTPS_DllAPI MinimalBitmaskHeader & header()
Definition: TypeObject.h:3702
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition: TypeObject.h:3692
RTPS_DllAPI void flag_seq(MinimalBitflagSeq &&_flag_seq)
Definition: TypeObject.h:3706
RTPS_DllAPI MinimalBitmaskType(MinimalBitmaskType &&x)
RTPS_DllAPI const MinimalBitflagSeq & flag_seq() const
Definition: TypeObject.h:3708
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void header(const MinimalBitmaskHeader &_header)
Definition: TypeObject.h:3697
RTPS_DllAPI bool operator==(const MinimalBitmaskType &other) const
RTPS_DllAPI bool consistent(const MinimalBitmaskType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
RTPS_DllAPI MinimalBitflagSeq & flag_seq()
Definition: TypeObject.h:3709
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition: TypeObject.h:3695
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition: TypeObject.h:3694
RTPS_DllAPI void flag_seq(const MinimalBitflagSeq &_flag_seq)
Definition: TypeObject.h:3704
RTPS_DllAPI MinimalBitmaskType(const MinimalBitmaskType &x)
RTPS_DllAPI const MinimalBitmaskHeader & header() const
Definition: TypeObject.h:3701
RTPS_DllAPI MinimalBitmaskType & operator=(MinimalBitmaskType &&x)
RTPS_DllAPI void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
Definition: TypeObject.h:3690
RTPS_DllAPI void header(MinimalBitmaskHeader &&_header)
Definition: TypeObject.h:3699
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitmaskType &data, size_t current_alignment=0)
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:3991
RTPS_DllAPI MinimalBitsetHeader(MinimalBitsetHeader &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool operator==(const MinimalBitsetHeader &other) const
RTPS_DllAPI MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
RTPS_DllAPI MinimalBitsetHeader(const MinimalBitsetHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:3992
RTPS_DllAPI bool consistent(const MinimalBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalBitsetHeader & operator=(MinimalBitsetHeader &&x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:3987
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitsetHeader &data, size_t current_alignment=0)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:3989
RTPS_DllAPI bool consistent(const MinimalBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition: TypeObject.h:4098
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition: TypeObject.h:4101
RTPS_DllAPI bool operator==(const MinimalBitsetType &other) const
RTPS_DllAPI void header(MinimalBitsetHeader &&_header)
Definition: TypeObject.h:4105
RTPS_DllAPI void field_seq(MinimalBitfieldSeq &&_field_seq)
Definition: TypeObject.h:4112
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalBitsetType & operator=(const MinimalBitsetType &x)
RTPS_DllAPI MinimalBitfieldSeq & field_seq()
Definition: TypeObject.h:4115
RTPS_DllAPI void header(const MinimalBitsetHeader &_header)
Definition: TypeObject.h:4103
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitsetType &data, size_t current_alignment=0)
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition: TypeObject.h:4096
RTPS_DllAPI MinimalBitsetType & operator=(MinimalBitsetType &&x)
RTPS_DllAPI void field_seq(const MinimalBitfieldSeq &_field_seq)
Definition: TypeObject.h:4110
RTPS_DllAPI MinimalBitsetType(const MinimalBitsetType &x)
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition: TypeObject.h:4100
RTPS_DllAPI MinimalBitsetType(MinimalBitsetType &&x)
RTPS_DllAPI MinimalBitsetHeader & header()
Definition: TypeObject.h:4108
RTPS_DllAPI const MinimalBitfieldSeq & field_seq() const
Definition: TypeObject.h:4114
RTPS_DllAPI const MinimalBitsetHeader & header() const
Definition: TypeObject.h:4107
RTPS_DllAPI MinimalCollectionElement(const MinimalCollectionElement &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalCollectionElement &data, size_t current_alignment=0)
RTPS_DllAPI MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition: TypeObject.h:2232
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CommonCollectionElement & common() const
Definition: TypeObject.h:2236
RTPS_DllAPI bool operator==(const MinimalCollectionElement &other) const
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition: TypeObject.h:2234
RTPS_DllAPI MinimalCollectionElement & operator=(MinimalCollectionElement &&x)
RTPS_DllAPI MinimalCollectionElement(MinimalCollectionElement &&x)
RTPS_DllAPI bool consistent(const MinimalCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonCollectionElement & common()
Definition: TypeObject.h:2237
RTPS_DllAPI CommonCollectionHeader & common()
Definition: TypeObject.h:2381
RTPS_DllAPI bool consistent(const MinimalCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalCollectionHeader &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition: TypeObject.h:2376
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalCollectionHeader & operator=(MinimalCollectionHeader &&x)
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition: TypeObject.h:2380
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalCollectionHeader(MinimalCollectionHeader &&x)
RTPS_DllAPI MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
RTPS_DllAPI MinimalCollectionHeader(const MinimalCollectionHeader &x)
RTPS_DllAPI bool operator==(const MinimalCollectionHeader &other) const
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition: TypeObject.h:2378
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition: TypeObject.h:1037
RTPS_DllAPI MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x)
RTPS_DllAPI MinimalDiscriminatorMember & operator=(MinimalDiscriminatorMember &&x)
RTPS_DllAPI bool consistent(const MinimalDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalDiscriminatorMember &data, size_t current_alignment=0)
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition: TypeObject.h:1039
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalDiscriminatorMember &other) const
RTPS_DllAPI MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition: TypeObject.h:1035
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition: TypeObject.h:1040
RTPS_DllAPI bool consistent(const MinimalEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition: TypeObject.h:3243
RTPS_DllAPI MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalEnumeratedHeader &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalEnumeratedHeader &other) const
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition: TypeObject.h:3242
RTPS_DllAPI MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
RTPS_DllAPI MinimalEnumeratedHeader & operator=(MinimalEnumeratedHeader &&x)
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition: TypeObject.h:3238
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition: TypeObject.h:3240
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:3094
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition: TypeObject.h:3085
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition: TypeObject.h:3088
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalEnumeratedLiteral &data, size_t current_alignment=0)
RTPS_DllAPI MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const MinimalEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:3095
RTPS_DllAPI MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:3092
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition: TypeObject.h:3083
RTPS_DllAPI bool operator==(const MinimalEnumeratedLiteral &other) const
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition: TypeObject.h:3087
RTPS_DllAPI MinimalEnumeratedLiteral & operator=(MinimalEnumeratedLiteral &&x)
RTPS_DllAPI MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:3090
RTPS_DllAPI MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
RTPS_DllAPI bool consistent(const MinimalEnumeratedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalEnumeratedLiteralSeq & literal_seq() const
Definition: TypeObject.h:3367
RTPS_DllAPI MinimalEnumeratedHeader & header()
Definition: TypeObject.h:3361
RTPS_DllAPI void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
Definition: TypeObject.h:3363
RTPS_DllAPI bool operator==(const MinimalEnumeratedType &other) const
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition: TypeObject.h:3349
RTPS_DllAPI MinimalEnumeratedLiteralSeq & literal_seq()
Definition: TypeObject.h:3368
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalEnumeratedType &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition: TypeObject.h:3351
RTPS_DllAPI MinimalEnumeratedType(MinimalEnumeratedType &&x)
RTPS_DllAPI MinimalEnumeratedType & operator=(MinimalEnumeratedType &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalEnumeratedType(const MinimalEnumeratedType &x)
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition: TypeObject.h:3354
RTPS_DllAPI void header(const MinimalEnumeratedHeader &_header)
Definition: TypeObject.h:3356
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition: TypeObject.h:3353
RTPS_DllAPI void header(MinimalEnumeratedHeader &&_header)
Definition: TypeObject.h:3358
RTPS_DllAPI void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
Definition: TypeObject.h:3365
RTPS_DllAPI const MinimalEnumeratedHeader & header() const
Definition: TypeObject.h:3360
RTPS_DllAPI MinimalExtendedType & operator=(MinimalExtendedType &&x)
RTPS_DllAPI MinimalExtendedType & operator=(const MinimalExtendedType &x)
RTPS_DllAPI MinimalExtendedType(MinimalExtendedType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalExtendedType(const MinimalExtendedType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalExtendedType &) const
Definition: TypeObject.h:4206
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalExtendedType &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const MinimalExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
Definition: TypeObject.h:2880
RTPS_DllAPI MinimalMapType & operator=(const MinimalMapType &x)
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition: TypeObject.h:2905
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2898
RTPS_DllAPI MinimalCollectionElement & key()
Definition: TypeObject.h:2913
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:2919
RTPS_DllAPI void key(MinimalCollectionElement &&_key)
Definition: TypeObject.h:2910
RTPS_DllAPI void key(const MinimalCollectionElement &_key)
Definition: TypeObject.h:2908
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2894
RTPS_DllAPI const MinimalCollectionElement & key() const
Definition: TypeObject.h:2912
RTPS_DllAPI MinimalMapType & operator=(MinimalMapType &&x)
RTPS_DllAPI MinimalMapType(MinimalMapType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalCollectionHeader & header()
Definition: TypeObject.h:2906
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:2915
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalMapType &data, size_t current_alignment=0)
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2896
RTPS_DllAPI bool operator==(const MinimalMapType &other) const
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition: TypeObject.h:2903
RTPS_DllAPI MinimalMapType(const MinimalMapType &x)
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2899
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:2920
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:2917
RTPS_DllAPI bool consistent(const MinimalMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition: TypeObject.h:2901
RTPS_DllAPI MinimalMemberDetail & operator=(MinimalMemberDetail &&x)
RTPS_DllAPI bool operator==(const MinimalMemberDetail &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalMemberDetail(MinimalMemberDetail &&x)
RTPS_DllAPI MinimalMemberDetail(const MinimalMemberDetail &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void name_hash(const NameHash &_name_hash)
Definition: TypeObject.h:184
RTPS_DllAPI MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
RTPS_DllAPI const NameHash & name_hash() const
Definition: TypeObject.h:188
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalMemberDetail &data, size_t current_alignment=0)
RTPS_DllAPI NameHash & name_hash()
Definition: TypeObject.h:189
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition: TypeObject.h:186
RTPS_DllAPI bool consistent(const MinimalMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition: TypeObject.h:2498
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2491
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:2505
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2487
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalSequenceType &data, size_t current_alignment=0)
RTPS_DllAPI MinimalSequenceType & operator=(const MinimalSequenceType &x)
RTPS_DllAPI MinimalCollectionHeader & header()
Definition: TypeObject.h:2499
RTPS_DllAPI MinimalSequenceType(const MinimalSequenceType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:2501
RTPS_DllAPI bool consistent(const MinimalSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2489
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition: TypeObject.h:2496
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2492
RTPS_DllAPI bool operator==(const MinimalSequenceType &other) const
RTPS_DllAPI MinimalSequenceType(MinimalSequenceType &&x)
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:2506
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:2503
RTPS_DllAPI MinimalSequenceType & operator=(MinimalSequenceType &&x)
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition: TypeObject.h:2494
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:547
RTPS_DllAPI bool consistent(const MinimalStructHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition: TypeObject.h:550
RTPS_DllAPI MinimalStructHeader(MinimalStructHeader &&x)
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition: TypeObject.h:552
RTPS_DllAPI MinimalTypeDetail & detail()
Definition: TypeObject.h:555
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalStructHeader(const MinimalStructHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalStructHeader & operator=(MinimalStructHeader &&x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:548
RTPS_DllAPI MinimalStructHeader & operator=(const MinimalStructHeader &x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:543
RTPS_DllAPI bool operator==(const MinimalStructHeader &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalStructHeader &data, size_t current_alignment=0)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:545
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition: TypeObject.h:554
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:300
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalStructMember &data, size_t current_alignment=0)
RTPS_DllAPI MinimalStructMember & operator=(MinimalStructMember &&x)
RTPS_DllAPI bool consistent(const MinimalStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalStructMember & operator=(const MinimalStructMember &x)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:301
RTPS_DllAPI const CommonStructMember & common() const
Definition: TypeObject.h:293
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition: TypeObject.h:289
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:298
RTPS_DllAPI MinimalStructMember(MinimalStructMember &&x)
RTPS_DllAPI CommonStructMember & common()
Definition: TypeObject.h:294
RTPS_DllAPI MinimalStructMember(const MinimalStructMember &x)
RTPS_DllAPI bool operator==(const MinimalStructMember &other) const
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition: TypeObject.h:291
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:296
RTPS_DllAPI MinimalStructMemberSeq & member_seq()
Definition: TypeObject.h:680
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition: TypeObject.h:663
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition: TypeObject.h:665
RTPS_DllAPI MinimalStructType(MinimalStructType &&x)
RTPS_DllAPI MinimalStructType & operator=(MinimalStructType &&x)
RTPS_DllAPI void member_seq(const MinimalStructMemberSeq &_member_seq)
Definition: TypeObject.h:675
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition: TypeObject.h:661
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void header(const MinimalStructHeader &_header)
Definition: TypeObject.h:668
RTPS_DllAPI void header(MinimalStructHeader &&_header)
Definition: TypeObject.h:670
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalStructType &data, size_t current_alignment=0)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const MinimalStructHeader & header() const
Definition: TypeObject.h:672
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition: TypeObject.h:666
RTPS_DllAPI void member_seq(MinimalStructMemberSeq &&_member_seq)
Definition: TypeObject.h:677
RTPS_DllAPI bool operator==(const MinimalStructType &other) const
RTPS_DllAPI MinimalStructType(const MinimalStructType &x)
RTPS_DllAPI MinimalStructType & operator=(const MinimalStructType &x)
RTPS_DllAPI MinimalStructHeader & header()
Definition: TypeObject.h:673
RTPS_DllAPI const MinimalStructMemberSeq & member_seq() const
Definition: TypeObject.h:679
RTPS_DllAPI bool consistent(const MinimalStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalTypeDetail(const MinimalTypeDetail &x)
RTPS_DllAPI MinimalTypeDetail(MinimalTypeDetail &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalTypeDetail &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalTypeDetail &) const
Definition: TypeObject.h:398
RTPS_DllAPI bool consistent(const MinimalTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalTypeDetail & operator=(MinimalTypeDetail &&x)
RTPS_DllAPI const MinimalAnnotationType & annotation_type() const
RTPS_DllAPI void union_type(MinimalUnionType _union_type)
RTPS_DllAPI void annotation_type(MinimalAnnotationType _annotation_type)
RTPS_DllAPI MinimalArrayType & array_type()
RTPS_DllAPI void extended_type(MinimalExtendedType _extended_type)
RTPS_DllAPI bool operator==(const MinimalTypeObject &other) const
RTPS_DllAPI MinimalTypeObject(const MinimalTypeObject &x)
RTPS_DllAPI bool consistent(const MinimalTypeObject &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalUnionType & union_type()
RTPS_DllAPI const MinimalEnumeratedType & enumerated_type() const
RTPS_DllAPI const MinimalExtendedType & extended_type() const
RTPS_DllAPI void bitset_type(MinimalBitsetType _bitset_type)
RTPS_DllAPI void sequence_type(MinimalSequenceType _sequence_type)
RTPS_DllAPI void enumerated_type(MinimalEnumeratedType _enumerated_type)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void bitmask_type(MinimalBitmaskType _bitmask_type)
RTPS_DllAPI const MinimalUnionType & union_type() const
RTPS_DllAPI void array_type(MinimalArrayType _array_type)
RTPS_DllAPI const MinimalArrayType & array_type() const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalEnumeratedType & enumerated_type()
RTPS_DllAPI void map_type(MinimalMapType _map_type)
RTPS_DllAPI MinimalAliasType & alias_type()
RTPS_DllAPI MinimalTypeObject & operator=(const MinimalTypeObject &x)
RTPS_DllAPI MinimalStructType & struct_type()
RTPS_DllAPI void struct_type(MinimalStructType _struct_type)
RTPS_DllAPI const MinimalStructType & struct_type() const
RTPS_DllAPI const MinimalBitsetType & bitset_type() const
RTPS_DllAPI MinimalBitmaskType & bitmask_type()
RTPS_DllAPI MinimalExtendedType & extended_type()
RTPS_DllAPI MinimalBitsetType & bitset_type()
RTPS_DllAPI const MinimalBitmaskType & bitmask_type() const
RTPS_DllAPI void alias_type(MinimalAliasType _alias_type)
RTPS_DllAPI const MinimalSequenceType & sequence_type() const
RTPS_DllAPI MinimalMapType & map_type()
RTPS_DllAPI MinimalTypeObject & operator=(MinimalTypeObject &&x)
RTPS_DllAPI MinimalTypeObject(MinimalTypeObject &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalTypeObject &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAnnotationType & annotation_type()
RTPS_DllAPI MinimalSequenceType & sequence_type()
RTPS_DllAPI const MinimalAliasType & alias_type() const
RTPS_DllAPI const MinimalMapType & map_type() const
RTPS_DllAPI MinimalUnionHeader(MinimalUnionHeader &&x)
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition: TypeObject.h:1125
RTPS_DllAPI MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition: TypeObject.h:1127
RTPS_DllAPI MinimalTypeDetail & detail()
Definition: TypeObject.h:1130
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalUnionHeader & operator=(MinimalUnionHeader &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const MinimalUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalUnionHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalUnionHeader &other) const
RTPS_DllAPI MinimalUnionHeader(const MinimalUnionHeader &x)
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition: TypeObject.h:1129
RTPS_DllAPI bool consistent(const MinimalUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:871
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition: TypeObject.h:860
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition: TypeObject.h:862
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:872
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:869
RTPS_DllAPI const CommonUnionMember & common() const
Definition: TypeObject.h:864
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalUnionMember &data, size_t current_alignment=0)
RTPS_DllAPI MinimalUnionMember(MinimalUnionMember &&x)
RTPS_DllAPI MinimalUnionMember & operator=(const MinimalUnionMember &x)
RTPS_DllAPI bool operator==(const MinimalUnionMember &other) const
RTPS_DllAPI MinimalUnionMember & operator=(MinimalUnionMember &&x)
RTPS_DllAPI MinimalUnionMember(const MinimalUnionMember &x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:867
RTPS_DllAPI CommonUnionMember & common()
Definition: TypeObject.h:865
Definition: TypeObject.h:1231
RTPS_DllAPI void member_seq(const MinimalUnionMemberSeq &_member_seq)
Definition: TypeObject.h:1266
RTPS_DllAPI bool consistent(const MinimalUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void discriminator(const MinimalDiscriminatorMember &_discriminator)
Definition: TypeObject.h:1259
RTPS_DllAPI const MinimalUnionHeader & header() const
Definition: TypeObject.h:1256
RTPS_DllAPI const MinimalDiscriminatorMember & discriminator() const
Definition: TypeObject.h:1263
RTPS_DllAPI void discriminator(MinimalDiscriminatorMember &&_discriminator)
Definition: TypeObject.h:1261
RTPS_DllAPI MinimalUnionType(const MinimalUnionType &x)
RTPS_DllAPI bool operator==(const MinimalUnionType &other) const
RTPS_DllAPI const MinimalUnionMemberSeq & member_seq() const
Definition: TypeObject.h:1270
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalUnionType(MinimalUnionType &&x)
RTPS_DllAPI MinimalUnionHeader & header()
Definition: TypeObject.h:1257
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalUnionType &data, size_t current_alignment=0)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalDiscriminatorMember & discriminator()
Definition: TypeObject.h:1264
RTPS_DllAPI MinimalUnionType & operator=(MinimalUnionType &&x)
RTPS_DllAPI MinimalUnionType & operator=(const MinimalUnionType &x)
RTPS_DllAPI MinimalUnionMemberSeq & member_seq()
Definition: TypeObject.h:1271
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition: TypeObject.h:1245
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition: TypeObject.h:1249
RTPS_DllAPI void member_seq(MinimalUnionMemberSeq &&_member_seq)
Definition: TypeObject.h:1268
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition: TypeObject.h:1250
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition: TypeObject.h:1247
RTPS_DllAPI void header(MinimalUnionHeader &&_header)
Definition: TypeObject.h:1254
RTPS_DllAPI void header(const MinimalUnionHeader &_header)
Definition: TypeObject.h:1252
Definition: TypesBase.h:477
Definition: TypeIdentifier.h:81
RTPS_DllAPI TypeIdentifierPair(TypeIdentifierPair &&x)
RTPS_DllAPI const TypeIdentifier & type_identifier2() const
Definition: TypeObject.h:4674
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierPair &data, size_t current_alignment=0)
RTPS_DllAPI const TypeIdentifier & type_identifier1() const
Definition: TypeObject.h:4667
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void type_identifier1(TypeIdentifier &&_type_identifier1)
Definition: TypeObject.h:4665
RTPS_DllAPI void type_identifier2(TypeIdentifier &&_type_identifier2)
Definition: TypeObject.h:4672
RTPS_DllAPI TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
RTPS_DllAPI void type_identifier1(const TypeIdentifier &_type_identifier1)
Definition: TypeObject.h:4663
RTPS_DllAPI TypeIdentifierPair(const TypeIdentifierPair &x)
RTPS_DllAPI void type_identifier2(const TypeIdentifier &_type_identifier2)
Definition: TypeObject.h:4670
RTPS_DllAPI TypeIdentifierPair & operator=(TypeIdentifierPair &&x)
RTPS_DllAPI TypeIdentifier & type_identifier1()
Definition: TypeObject.h:4668
RTPS_DllAPI TypeIdentifier & type_identifier2()
Definition: TypeObject.h:4675
RTPS_DllAPI TypeObject & type_object()
Definition: TypeObject.h:4627
RTPS_DllAPI void type_object(TypeObject &&_type_object)
Definition: TypeObject.h:4624
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierTypeObjectPair &data, size_t current_alignment=0)
RTPS_DllAPI TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x)
RTPS_DllAPI TypeIdentifier & type_identifier()
Definition: TypeObject.h:4620
RTPS_DllAPI const TypeIdentifier & type_identifier() const
Definition: TypeObject.h:4619
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void type_identifier(const TypeIdentifier &_type_identifier)
Definition: TypeObject.h:4615
RTPS_DllAPI TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI void type_identifier(TypeIdentifier &&_type_identifier)
Definition: TypeObject.h:4617
RTPS_DllAPI TypeIdentifierTypeObjectPair & operator=(TypeIdentifierTypeObjectPair &&x)
RTPS_DllAPI void type_object(const TypeObject &_type_object)
Definition: TypeObject.h:4622
RTPS_DllAPI TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI const TypeObject & type_object() const
Definition: TypeObject.h:4626
RTPS_DllAPI const int32_t & dependent_typeid_count() const
Definition: TypeObject.h:4775
RTPS_DllAPI TypeIdentifierWithDependencies & operator=(TypeIdentifierWithDependencies &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierWithDependencies &data, size_t current_alignment=0)
RTPS_DllAPI TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeid_with_size(const TypeIdentifierWithSize &_typeid_with_size)
Definition: TypeObject.h:4764
RTPS_DllAPI const TypeIdentifierWithSizeSeq & dependent_typeids() const
Definition: TypeObject.h:4782
RTPS_DllAPI int32_t & dependent_typeid_count()
Definition: TypeObject.h:4776
RTPS_DllAPI void typeid_with_size(TypeIdentifierWithSize &&_typeid_with_size)
Definition: TypeObject.h:4766
RTPS_DllAPI void dependent_typeids(const TypeIdentifierWithSizeSeq &_dependent_typeids)
Definition: TypeObject.h:4778
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI TypeIdentifierWithSizeSeq & dependent_typeids()
Definition: TypeObject.h:4783
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void dependent_typeid_count(int32_t &&_dependent_typeid_count)
Definition: TypeObject.h:4773
RTPS_DllAPI const TypeIdentifierWithSize & typeid_with_size() const
Definition: TypeObject.h:4768
RTPS_DllAPI TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x)
RTPS_DllAPI void dependent_typeid_count(const int32_t &_dependent_typeid_count)
Definition: TypeObject.h:4771
RTPS_DllAPI TypeIdentifierWithSize & typeid_with_size()
Definition: TypeObject.h:4769
RTPS_DllAPI void dependent_typeids(TypeIdentifierWithSizeSeq &&_dependent_typeids)
Definition: TypeObject.h:4780
RTPS_DllAPI TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeobject_serialized_size(uint32_t &&_typeobject_serialized_size)
Definition: TypeObject.h:4720
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:4713
RTPS_DllAPI TypeIdentifierWithSize & operator=(const TypeIdentifierWithSize &x)
RTPS_DllAPI const uint32_t & typeobject_serialized_size() const
Definition: TypeObject.h:4724
RTPS_DllAPI TypeIdentifierWithSize(const TypeIdentifierWithSize &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierWithSize &data, size_t current_alignment=0)
RTPS_DllAPI TypeIdentifierWithSize & operator=(TypeIdentifierWithSize &&x)
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:4715
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI uint32_t & typeobject_serialized_size()
Definition: TypeObject.h:4725
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:4711
RTPS_DllAPI TypeIdentifierWithSize(TypeIdentifierWithSize &&x)
RTPS_DllAPI void typeobject_serialized_size(const uint32_t &_typeobject_serialized_size)
Definition: TypeObject.h:4718
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:4716
Definition: TypeObject.h:4811
RTPS_DllAPI const TypeIdentifierWithDependencies & minimal() const
Definition: TypeObject.h:4829
RTPS_DllAPI void complete(TypeIdentifierWithDependencies &&_complete)
Definition: TypeObject.h:4834
RTPS_DllAPI TypeIdentifierWithDependencies & minimal()
Definition: TypeObject.h:4830
RTPS_DllAPI void complete(const TypeIdentifierWithDependencies &_complete)
Definition: TypeObject.h:4832
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const TypeIdentifierWithDependencies & complete() const
Definition: TypeObject.h:4836
RTPS_DllAPI TypeIdentifierWithDependencies & complete()
Definition: TypeObject.h:4837
RTPS_DllAPI TypeInformation & operator=(TypeInformation &&x)
RTPS_DllAPI void minimal(TypeIdentifierWithDependencies &&_minimal)
Definition: TypeObject.h:4827
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeInformation(TypeInformation &&x)
RTPS_DllAPI TypeInformation & operator=(const TypeInformation &x)
RTPS_DllAPI void minimal(const TypeIdentifierWithDependencies &_minimal)
Definition: TypeObject.h:4825
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeInformation &data, size_t current_alignment=0)
RTPS_DllAPI TypeInformation(const TypeInformation &x)
Definition: TypeObject.h:4429
RTPS_DllAPI void minimal(MinimalTypeObject &&_minimal)
This function moves the value in member minimal.
RTPS_DllAPI void _d(uint8_t __d)
This function sets the discriminator value.
RTPS_DllAPI uint8_t & _d()
This function returns a reference to the discriminator.
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeObject &data, size_t current_alignment=0)
This function returns the serialized size of a data depending on the buffer alignment.
RTPS_DllAPI TypeObject()
Default constructor.
RTPS_DllAPI TypeObject & operator=(const TypeObject &x)
Copy assignment.
RTPS_DllAPI void complete(CompleteTypeObject &&_complete)
This function moves the value in member complete.
RTPS_DllAPI const CompleteTypeObject & complete() const
This function returns a constant reference to member complete.
RTPS_DllAPI TypeObject(TypeObject &&x)
Move constructor.
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
This function deserializes an object using CDR serialization.
RTPS_DllAPI bool consistent(const TypeObject &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
This function check type consistency enforcement with the given TypeObject x.
RTPS_DllAPI void complete(const CompleteTypeObject &_complete)
This function copies the value in member complete.
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
This function serializes an object using CDR serialization.
RTPS_DllAPI TypeObject(const TypeObject &x)
Copy constructor.
RTPS_DllAPI const MinimalTypeObject & minimal() const
This function returns a constant reference to member minimal.
RTPS_DllAPI ~TypeObject()
Default destructor.
RTPS_DllAPI TypeObject & operator=(TypeObject &&x)
Move assignment.
RTPS_DllAPI MinimalTypeObject & minimal()
This function returns a reference to member minimal.
RTPS_DllAPI uint8_t _d() const
This function returns the value of the discriminator.
RTPS_DllAPI CompleteTypeObject & complete()
This function returns a reference to member complete.
RTPS_DllAPI void minimal(const MinimalTypeObject &_minimal)
This function copies the value in member minimal.
RTPS_DllAPI bool operator==(const TypeObject &other) const
std::vector< MinimalBitflag > MinimalBitflagSeq
Definition: TypeObject.h:3558
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition: TypeObject.h:3915
uint32_t MemberId
Definition: TypesBase.h:272
TypeObjectSeq StronglyConnectedComponent
Definition: TypeObject.h:4594
std::vector< TypeObject > TypeObjectSeq
Definition: TypeObject.h:4588
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition: TypeObject.h:3606
std::vector< int32_t > UnionCaseLabelSeq
Definition: TypeObject.h:708
std::vector< CompleteBitfield > CompleteBitfieldSeq
Definition: TypeObject.h:3860
uint32_t LBound
Definition: TypesBase.h:281
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition: TypeObject.h:1481
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition: TypeObject.h:896
std::string MemberName
Definition: TypesBase.h:165
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition: TypeObject.h:3604
std::vector< TypeIdentifierWithSize > TypeIdentifierWithSizeSeq
Definition: TypeObject.h:4741
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition: TypeObject.h:325
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition: TypeObject.h:4800
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition: TypeObject.h:3119
std::vector< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition: TypeObject.h:1416
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition: TypeObject.h:4642
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition: TypeObject.h:3502
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition: TypeObject.h:267
std::vector< TypeInformation > TypeInformationSeq
Definition: TypeObject.h:4853
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition: TypeObject.h:3060
std::string QualifiedTypeName
Definition: TypesBase.h:170
uint16_t BitBound
Definition: TypeObject.h:2946
std::vector< CompleteUnionMember > CompleteUnionMemberSeq
Definition: TypeObject.h:838
std::vector< LBound > LBoundSeq
Definition: TypesBase.h:282
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition: AnnotationParameterValue.h:1124
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition: TypeObject.h:4691
octet TypeKind
Definition: TypesBase.h:119
std::array< uint8_t, 4 > NameHash
Definition: TypesBase.h:178
eProsima namespace.
Definition: LibrarySettingsAttributes.h:23