Fast RTPS  Version 2.14.1
Fast RTPS
Loading...
Searching...
No Matches
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 <array>
19#include <cstdint>
20
21#include <fastrtps/types/AnnotationParameterValue.h>
22#include <fastrtps/types/TypeIdentifier.h>
23#include <fastrtps/types/TypeObjectHashId.h>
24#include <fastrtps/types/TypesBase.h>
25
26namespace eprosima {
27namespace fastcdr {
28class Cdr;
29} // namespace fastcdr
30} // namespace eprosima
31
32// The types in this file shall be serialized with XCDR encoding version 2
33namespace eprosima {
34namespace fastrtps {
35
36namespace types {
37
38/*struct CommonStructMember final {
39 MemberId member_id;
40 StructMemberFlag member_flags;
41 TypeIdentifier member_type_id;
42 };*/
44{
45public:
46
47 RTPS_DllAPI CommonStructMember();
48 RTPS_DllAPI ~CommonStructMember();
49 RTPS_DllAPI CommonStructMember(
50 const CommonStructMember& x);
51 RTPS_DllAPI CommonStructMember(
54 const CommonStructMember& x);
57
58 RTPS_DllAPI inline void member_id(
59 const MemberId& _member_id)
60 {
61 m_member_id = _member_id;
62 }
63
64 RTPS_DllAPI inline void member_id(
65 MemberId&& _member_id)
66 {
67 m_member_id = std::move(_member_id);
68 }
69
70 RTPS_DllAPI inline const MemberId& member_id() const
71 {
72 return m_member_id;
73 }
74
75 RTPS_DllAPI inline MemberId& member_id()
76 {
77 return m_member_id;
78 }
79
80 RTPS_DllAPI inline void member_flags(
81 const StructMemberFlag& _member_flags)
82 {
83 m_member_flags = _member_flags;
84 }
85
86 RTPS_DllAPI inline void member_flags(
87 StructMemberFlag&& _member_flags)
88 {
89 m_member_flags = std::move(_member_flags);
90 }
91
92 RTPS_DllAPI inline const StructMemberFlag& member_flags() const
93 {
94 return m_member_flags;
95 }
96
97 RTPS_DllAPI inline StructMemberFlag& member_flags()
98 {
99 return m_member_flags;
100 }
101
102 RTPS_DllAPI inline void member_type_id(
103 const TypeIdentifier& _member_type_id)
104 {
105 m_member_type_id = _member_type_id;
106 }
107
108 RTPS_DllAPI inline void member_type_id(
109 TypeIdentifier&& _member_type_id)
110 {
111 m_member_type_id = std::move(_member_type_id);
112 }
113
114 RTPS_DllAPI inline const TypeIdentifier& member_type_id() const
115 {
116 return m_member_type_id;
117 }
118
119 RTPS_DllAPI inline TypeIdentifier& member_type_id()
120 {
121 return m_member_type_id;
122 }
123
124#ifndef DOXYGEN_SHOULD_SKIP_THIS
125 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonStructMember::getCdrSerializedSize()",
126 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
127 RTPS_DllAPI static size_t getCdrSerializedSize(
128 const CommonStructMember& data,
129 size_t current_alignment = 0);
130 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonStructMember::serialize()",
131 "In favor of version using eprosima::fastcdr::serialize.")
132 RTPS_DllAPI void serialize(
133 eprosima::fastcdr::Cdr& cdr) const;
134 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonStructMember::deserialize()",
135 "In favor of version using eprosima::fastcdr::deserialize.")
136 RTPS_DllAPI void deserialize(
137 eprosima::fastcdr::Cdr& cdr);
138#endif // DOXYGEN_SHOULD_SKIP_THIS
139
140 RTPS_DllAPI bool operator ==(
141 const CommonStructMember& other) const;
142
143 RTPS_DllAPI bool consistent(
144 const CommonStructMember& x,
145 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
146
147private:
148
149 MemberId m_member_id;
150 StructMemberFlag m_member_flags;
151 TypeIdentifier m_member_type_id;
152};
153
154// COMPLETE Details for a member of an aggregate type
155/*struct CompleteMemberDetail final{
156 MemberName name;
157 AppliedBuiltinMemberAnnotations ann_builtin; // Optional
158 AppliedAnnotationSeq ann_custom; // Optional
159 };*/
161{
162public:
163
164 RTPS_DllAPI CompleteMemberDetail();
167 const CompleteMemberDetail& x);
171 const CompleteMemberDetail& x);
174
175 RTPS_DllAPI inline void name(
176 const MemberName& _name)
177 {
178 m_name = _name;
179 }
180
181 RTPS_DllAPI inline void name(
182 MemberName&& _name)
183 {
184 m_name = std::move(_name);
185 }
186
187 RTPS_DllAPI inline const MemberName& name() const
188 {
189 return m_name;
190 }
191
192 RTPS_DllAPI inline MemberName& name()
193 {
194 return m_name;
195 }
196
197 RTPS_DllAPI inline void ann_builtin(
198 const AppliedBuiltinMemberAnnotations& _ann_builtin)
199 {
200 m_ann_builtin = _ann_builtin;
201 }
202
203 RTPS_DllAPI inline void ann_builtin(
204 AppliedBuiltinMemberAnnotations&& _ann_builtin)
205 {
206 m_ann_builtin = std::move(_ann_builtin);
207 }
208
209 RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const
210 {
211 return m_ann_builtin;
212 }
213
215 {
216 return m_ann_builtin;
217 }
218
219 RTPS_DllAPI inline void ann_custom(
220 const AppliedAnnotationSeq& _ann_custom)
221 {
222 m_ann_custom = _ann_custom;
223 }
224
225 RTPS_DllAPI inline void ann_custom(
226 AppliedAnnotationSeq&& _ann_custom)
227 {
228 m_ann_custom = std::move(_ann_custom);
229 }
230
231 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
232 {
233 return m_ann_custom;
234 }
235
236 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
237 {
238 return m_ann_custom;
239 }
240
241#ifndef DOXYGEN_SHOULD_SKIP_THIS
242 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMemberDetail::getCdrSerializedSize()",
243 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
244 RTPS_DllAPI static size_t getCdrSerializedSize(
245 const CompleteMemberDetail& data,
246 size_t current_alignment = 0);
247 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMemberDetail::serialize()",
248 "In favor of version using eprosima::fastcdr::serialize.")
249 RTPS_DllAPI void serialize(
250 eprosima::fastcdr::Cdr& cdr) const;
251 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMemberDetail::deserialize()",
252 "In favor of version using eprosima::fastcdr::deserialize.")
253 RTPS_DllAPI void deserialize(
254 eprosima::fastcdr::Cdr& cdr);
255#endif // DOXYGEN_SHOULD_SKIP_THIS
256
257 RTPS_DllAPI bool operator ==(
258 const CompleteMemberDetail& other) const;
259
260 RTPS_DllAPI bool consistent(
261 const CompleteMemberDetail& x,
262 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
263
264private:
265
266 MemberName m_name;
268 AppliedAnnotationSeq m_ann_custom;
269};
270
271// MINIMAL Details for a member of an aggregate type
272/*struct MinimalMemberDetail final{
273 NameHash name_hash;
274 };*/
275
277{
278public:
279
280 RTPS_DllAPI MinimalMemberDetail();
281 RTPS_DllAPI ~MinimalMemberDetail();
283 const MinimalMemberDetail& x);
287 const MinimalMemberDetail& x);
290
291 RTPS_DllAPI inline void name_hash(
292 const NameHash& _name_hash)
293 {
294 m_name_hash = _name_hash;
295 }
296
297 RTPS_DllAPI inline void name_hash(
298 NameHash&& _name_hash)
299 {
300 m_name_hash = std::move(_name_hash);
301 }
302
303 RTPS_DllAPI inline const NameHash& name_hash() const
304 {
305 return m_name_hash;
306 }
307
308 RTPS_DllAPI inline NameHash& name_hash()
309 {
310 return m_name_hash;
311 }
312
313#ifndef DOXYGEN_SHOULD_SKIP_THIS
314 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMemberDetail::getCdrSerializedSize()",
315 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
316 RTPS_DllAPI static size_t getCdrSerializedSize(
317 const MinimalMemberDetail& data,
318 size_t current_alignment = 0);
319 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMemberDetail::serialize()",
320 "In favor of version using eprosima::fastcdr::serialize.")
321 RTPS_DllAPI void serialize(
322 eprosima::fastcdr::Cdr& cdr) const;
323 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMemberDetail::deserialize()",
324 "In favor of version using eprosima::fastcdr::deserialize.")
325 RTPS_DllAPI void deserialize(
326 eprosima::fastcdr::Cdr& cdr);
327#endif // DOXYGEN_SHOULD_SKIP_THIS
328
329 RTPS_DllAPI bool operator ==(
330 const MinimalMemberDetail& other) const;
331
332 RTPS_DllAPI bool consistent(
333 const MinimalMemberDetail& x,
334 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
335
336private:
337
338 NameHash m_name_hash;
339};
340
341// Member of an aggregate type
342/*struct CompleteStructMember {
343 CommonStructMember common;
344 CompleteMemberDetail detail;
345 };*/
347{
348public:
349
350 RTPS_DllAPI CompleteStructMember();
353 const CompleteStructMember& x);
357 const CompleteStructMember& x);
360
361 RTPS_DllAPI inline void common(
362 const CommonStructMember& _common)
363 {
364 m_common = _common;
365 }
366
367 RTPS_DllAPI inline void common(
368 CommonStructMember&& _common)
369 {
370 m_common = std::move(_common);
371 }
372
373 RTPS_DllAPI inline const CommonStructMember& common() const
374 {
375 return m_common;
376 }
377
378 RTPS_DllAPI inline CommonStructMember& common()
379 {
380 return m_common;
381 }
382
383 RTPS_DllAPI inline void detail(
384 const CompleteMemberDetail& _detail)
385 {
386 m_detail = _detail;
387 }
388
389 RTPS_DllAPI inline void detail(
390 CompleteMemberDetail&& _detail)
391 {
392 m_detail = std::move(_detail);
393 }
394
395 RTPS_DllAPI inline const CompleteMemberDetail& detail() const
396 {
397 return m_detail;
398 }
399
400 RTPS_DllAPI inline CompleteMemberDetail& detail()
401 {
402 return m_detail;
403 }
404
405#ifndef DOXYGEN_SHOULD_SKIP_THIS
406 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructMember::getCdrSerializedSize()",
407 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
408 RTPS_DllAPI static size_t getCdrSerializedSize(
409 const CompleteStructMember& data,
410 size_t current_alignment = 0);
411 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructMember::serialize()",
412 "In favor of version using eprosima::fastcdr::serialize.")
413 RTPS_DllAPI void serialize(
414 eprosima::fastcdr::Cdr& cdr) const;
415 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructMember::deserialize()",
416 "In favor of version using eprosima::fastcdr::deserialize.")
417 RTPS_DllAPI void deserialize(
418 eprosima::fastcdr::Cdr& cdr);
419#endif // DOXYGEN_SHOULD_SKIP_THIS
420
421 RTPS_DllAPI bool operator ==(
422 const CompleteStructMember& other) const;
423
424 RTPS_DllAPI bool consistent(
425 const CompleteStructMember& x,
426 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
427
428private:
429
430 CommonStructMember m_common;
431 CompleteMemberDetail m_detail;
432};
433
434// Ordered by the member_index
435typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
436
437// Member of an aggregate type
438/*struct MinimalStructMember {
439 CommonStructMember common;
440 MinimalMemberDetail detail;
441 };*/
443{
444public:
445
446 RTPS_DllAPI MinimalStructMember();
447 RTPS_DllAPI ~MinimalStructMember();
449 const MinimalStructMember& x);
453 const MinimalStructMember& x);
456
457 RTPS_DllAPI inline void common(
458 const CommonStructMember& _common)
459 {
460 m_common = _common;
461 }
462
463 RTPS_DllAPI inline void common(
464 CommonStructMember&& _common)
465 {
466 m_common = std::move(_common);
467 }
468
469 RTPS_DllAPI inline const CommonStructMember& common() const
470 {
471 return m_common;
472 }
473
474 RTPS_DllAPI inline CommonStructMember& common()
475 {
476 return m_common;
477 }
478
479 RTPS_DllAPI inline void detail(
480 const MinimalMemberDetail& _detail)
481 {
482 m_detail = _detail;
483 }
484
485 RTPS_DllAPI inline void detail(
486 MinimalMemberDetail&& _detail)
487 {
488 m_detail = std::move(_detail);
489 }
490
491 RTPS_DllAPI inline const MinimalMemberDetail& detail() const
492 {
493 return m_detail;
494 }
495
496 RTPS_DllAPI inline MinimalMemberDetail& detail()
497 {
498 return m_detail;
499 }
500
501#ifndef DOXYGEN_SHOULD_SKIP_THIS
502 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructMember::getCdrSerializedSize()",
503 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
504 RTPS_DllAPI static size_t getCdrSerializedSize(
505 const MinimalStructMember& data,
506 size_t current_alignment = 0);
507 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructMember::serialize()",
508 "In favor of version using eprosima::fastcdr::serialize.")
509 RTPS_DllAPI void serialize(
510 eprosima::fastcdr::Cdr& cdr) const;
511 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructMember::deserialize()",
512 "In favor of version using eprosima::fastcdr::deserialize.")
513 RTPS_DllAPI void deserialize(
514 eprosima::fastcdr::Cdr& cdr);
515#endif // DOXYGEN_SHOULD_SKIP_THIS
516
517 RTPS_DllAPI bool operator ==(
518 const MinimalStructMember& other) const;
519
520 RTPS_DllAPI bool consistent(
521 const MinimalStructMember& x,
522 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
523
524private:
525
526 CommonStructMember m_common;
527 MinimalMemberDetail m_detail;
528};
529
530// Ordered by common.member_id
531typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
532
533/*struct AppliedBuiltinTypeAnnotations {
534 AppliedVerbatimAnnotation verbatim; // verbatim(...) // optional
535 };*/
537{
538public:
539
550
551 RTPS_DllAPI inline void verbatim(
552 const AppliedVerbatimAnnotation& _verbatim)
553 {
554 m_verbatim = _verbatim;
555 }
556
557 RTPS_DllAPI inline void verbatim(
558 AppliedVerbatimAnnotation&& _verbatim)
559 {
560 m_verbatim = std::move(_verbatim);
561 }
562
563 RTPS_DllAPI inline const AppliedVerbatimAnnotation& verbatim() const
564 {
565 return m_verbatim;
566 }
567
569 {
570 return m_verbatim;
571 }
572
573#ifndef DOXYGEN_SHOULD_SKIP_THIS
574 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::getCdrSerializedSize()",
575 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
576 RTPS_DllAPI static size_t getCdrSerializedSize(
578 size_t current_alignment = 0);
579 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::serialize()",
580 "In favor of version using eprosima::fastcdr::serialize.")
581 RTPS_DllAPI void serialize(
582 eprosima::fastcdr::Cdr& cdr) const;
583 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::AppliedBuiltinTypeAnnotations::deserialize()",
584 "In favor of version using eprosima::fastcdr::deserialize.")
585 RTPS_DllAPI void deserialize(
586 eprosima::fastcdr::Cdr& cdr);
587#endif // DOXYGEN_SHOULD_SKIP_THIS
588
589 RTPS_DllAPI bool operator ==(
590 const AppliedBuiltinTypeAnnotations& other) const;
591
592 RTPS_DllAPI bool consistent(
594 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
595
596private:
597
598 AppliedVerbatimAnnotation m_verbatim;
599};
600
601/*struct MinimalTypeDetail final{
602 // Empty. Available for future extension
603 };*/
605{
606public:
607
608 RTPS_DllAPI MinimalTypeDetail();
609 RTPS_DllAPI ~MinimalTypeDetail();
610 RTPS_DllAPI MinimalTypeDetail(
611 const MinimalTypeDetail& x);
612 RTPS_DllAPI MinimalTypeDetail(
615 const MinimalTypeDetail& x);
618
619#ifndef DOXYGEN_SHOULD_SKIP_THIS
620 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeDetail::getCdrSerializedSize()",
621 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
622 RTPS_DllAPI static size_t getCdrSerializedSize(
623 const MinimalTypeDetail& data,
624 size_t current_alignment = 0);
625 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeDetail::serialize()",
626 "In favor of version using eprosima::fastcdr::serialize.")
627 RTPS_DllAPI void serialize(
628 eprosima::fastcdr::Cdr& cdr) const;
629 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeDetail::deserialize()",
630 "In favor of version using eprosima::fastcdr::deserialize.")
631 RTPS_DllAPI void deserialize(
632 eprosima::fastcdr::Cdr& cdr);
633#endif // DOXYGEN_SHOULD_SKIP_THIS
634
635 RTPS_DllAPI bool operator ==(
636 const MinimalTypeDetail&) const
637 {
638 return true;
639 }
640
641 RTPS_DllAPI bool consistent(
642 const MinimalTypeDetail& x,
643 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
644
645private:
646
647};
648
649/*struct CompleteTypeDetail final{
650 AppliedBuiltinTypeAnnotations ann_builtin; // optional
651 AppliedAnnotationSeq ann_custom; // optional
652 QualifiedTypeName type_name;
653 };*/
655{
656public:
657
658 RTPS_DllAPI CompleteTypeDetail();
659 RTPS_DllAPI ~CompleteTypeDetail();
661 const CompleteTypeDetail& x);
665 const CompleteTypeDetail& x);
668
669 RTPS_DllAPI inline void ann_builtin(
670 const AppliedBuiltinTypeAnnotations& _ann_builtin)
671 {
672 m_ann_builtin = _ann_builtin;
673 }
674
675 RTPS_DllAPI inline void ann_builtin(
676 AppliedBuiltinTypeAnnotations&& _ann_builtin)
677 {
678 m_ann_builtin = std::move(_ann_builtin);
679 }
680
681 RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const
682 {
683 return m_ann_builtin;
684 }
685
687 {
688 return m_ann_builtin;
689 }
690
691 RTPS_DllAPI inline void ann_custom(
692 const AppliedAnnotationSeq& _ann_custom)
693 {
694 m_ann_custom = _ann_custom;
695 }
696
697 RTPS_DllAPI inline void ann_custom(
698 AppliedAnnotationSeq&& _ann_custom)
699 {
700 m_ann_custom = std::move(_ann_custom);
701 }
702
703 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
704 {
705 return m_ann_custom;
706 }
707
708 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
709 {
710 return m_ann_custom;
711 }
712
713 RTPS_DllAPI inline void type_name(
714 const QualifiedTypeName& _type_name)
715 {
716 m_type_name = _type_name;
717 }
718
719 RTPS_DllAPI inline void type_name(
720 QualifiedTypeName&& _type_name)
721 {
722 m_type_name = std::move(_type_name);
723 }
724
725 RTPS_DllAPI inline const QualifiedTypeName& type_name() const
726 {
727 return m_type_name;
728 }
729
730 RTPS_DllAPI inline QualifiedTypeName& type_name()
731 {
732 return m_type_name;
733 }
734
735#ifndef DOXYGEN_SHOULD_SKIP_THIS
736 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeDetail::getCdrSerializedSize()",
737 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
738 RTPS_DllAPI static size_t getCdrSerializedSize(
739 const CompleteTypeDetail& data,
740 size_t current_alignment = 0);
741 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeDetail::serialize()",
742 "In favor of version using eprosima::fastcdr::serialize.")
743 RTPS_DllAPI void serialize(
744 eprosima::fastcdr::Cdr& cdr) const;
745 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeDetail::deserialize()",
746 "In favor of version using eprosima::fastcdr::deserialize.")
747 RTPS_DllAPI void deserialize(
748 eprosima::fastcdr::Cdr& cdr);
749#endif // DOXYGEN_SHOULD_SKIP_THIS
750
751 RTPS_DllAPI bool operator ==(
752 const CompleteTypeDetail& other) const;
753
754 RTPS_DllAPI bool consistent(
755 const CompleteTypeDetail& x,
756 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
757
758private:
759
760 AppliedBuiltinTypeAnnotations m_ann_builtin;
761 AppliedAnnotationSeq m_ann_custom;
762 QualifiedTypeName m_type_name;
763};
764/*struct CompleteStructHeader {
765 TypeIdentifier base_type;
766 CompleteTypeDetail detail;
767 };*/
769{
770public:
771
772 RTPS_DllAPI CompleteStructHeader();
775 const CompleteStructHeader& x);
779 const CompleteStructHeader& x);
782
783 RTPS_DllAPI inline void base_type(
784 const TypeIdentifier& _base_type)
785 {
786 m_base_type = _base_type;
787 }
788
789 RTPS_DllAPI inline void base_type(
790 TypeIdentifier&& _base_type)
791 {
792 m_base_type = std::move(_base_type);
793 }
794
795 RTPS_DllAPI inline const TypeIdentifier& base_type() const
796 {
797 return m_base_type;
798 }
799
800 RTPS_DllAPI inline TypeIdentifier& base_type()
801 {
802 return m_base_type;
803 }
804
805 RTPS_DllAPI inline void detail(
806 const CompleteTypeDetail& _detail)
807 {
808 m_detail = _detail;
809 }
810
811 RTPS_DllAPI inline void detail(
812 CompleteTypeDetail&& _detail)
813 {
814 m_detail = std::move(_detail);
815 }
816
817 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
818 {
819 return m_detail;
820 }
821
822 RTPS_DllAPI inline CompleteTypeDetail& detail()
823 {
824 return m_detail;
825 }
826
827#ifndef DOXYGEN_SHOULD_SKIP_THIS
828 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructHeader::getCdrSerializedSize()",
829 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
830 RTPS_DllAPI static size_t getCdrSerializedSize(
831 const CompleteStructHeader& data,
832 size_t current_alignment = 0);
833 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructHeader::serialize()",
834 "In favor of version using eprosima::fastcdr::serialize.")
835 RTPS_DllAPI void serialize(
836 eprosima::fastcdr::Cdr& cdr) const;
837 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructHeader::deserialize()",
838 "In favor of version using eprosima::fastcdr::deserialize.")
839 RTPS_DllAPI void deserialize(
840 eprosima::fastcdr::Cdr& cdr);
841#endif // DOXYGEN_SHOULD_SKIP_THIS
842
843 RTPS_DllAPI bool operator ==(
844 const CompleteStructHeader& other) const;
845
846 RTPS_DllAPI bool consistent(
847 const CompleteStructHeader& x,
848 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
849
850private:
851
852 TypeIdentifier m_base_type;
853 CompleteTypeDetail m_detail;
854};
855/*struct MinimalStructHeader {
856 TypeIdentifier base_type;
857 MinimalTypeDetail detail;
858 };*/
860{
861public:
862
863 RTPS_DllAPI MinimalStructHeader();
864 RTPS_DllAPI ~MinimalStructHeader();
866 const MinimalStructHeader& x);
870 const MinimalStructHeader& x);
873
874 RTPS_DllAPI inline void base_type(
875 const TypeIdentifier& _base_type)
876 {
877 m_base_type = _base_type;
878 }
879
880 RTPS_DllAPI inline void base_type(
881 TypeIdentifier&& _base_type)
882 {
883 m_base_type = std::move(_base_type);
884 }
885
886 RTPS_DllAPI inline const TypeIdentifier& base_type() const
887 {
888 return m_base_type;
889 }
890
891 RTPS_DllAPI inline TypeIdentifier& base_type()
892 {
893 return m_base_type;
894 }
895
896 RTPS_DllAPI inline void detail(
897 const MinimalTypeDetail& _detail)
898 {
899 m_detail = _detail;
900 }
901
902 RTPS_DllAPI inline void detail(
903 MinimalTypeDetail&& _detail)
904 {
905 m_detail = std::move(_detail);
906 }
907
908 RTPS_DllAPI inline const MinimalTypeDetail& detail() const
909 {
910 return m_detail;
911 }
912
913 RTPS_DllAPI inline MinimalTypeDetail& detail()
914 {
915 return m_detail;
916 }
917
918#ifndef DOXYGEN_SHOULD_SKIP_THIS
919 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructHeader::getCdrSerializedSize()",
920 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
921 RTPS_DllAPI static size_t getCdrSerializedSize(
922 const MinimalStructHeader& data,
923 size_t current_alignment = 0);
924 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructHeader::serialize()",
925 "In favor of version using eprosima::fastcdr::serialize.")
926 RTPS_DllAPI void serialize(
927 eprosima::fastcdr::Cdr& cdr) const;
928 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructHeader::deserialize()",
929 "In favor of version using eprosima::fastcdr::deserialize.")
930 RTPS_DllAPI void deserialize(
931 eprosima::fastcdr::Cdr& cdr);
932#endif // DOXYGEN_SHOULD_SKIP_THIS
933
934 RTPS_DllAPI bool operator ==(
935 const MinimalStructHeader& other) const;
936
937 RTPS_DllAPI bool consistent(
938 const MinimalStructHeader& x,
939 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
940
941private:
942
943 TypeIdentifier m_base_type;
944 MinimalTypeDetail m_detail;
945};
946
947/*struct CompleteStructType final{
948 StructTypeFlag struct_flags;
949 CompleteStructHeader header;
950 CompleteStructMemberSeq member_seq;
951 };*/
953{
954public:
955
956 RTPS_DllAPI CompleteStructType();
957 RTPS_DllAPI ~CompleteStructType();
959 const CompleteStructType& x);
963 const CompleteStructType& x);
966
967 RTPS_DllAPI inline void struct_flags(
968 const StructTypeFlag& _struct_flags)
969 {
970 m_struct_flags = _struct_flags;
971 }
972
973 RTPS_DllAPI inline void struct_flags(
974 StructTypeFlag&& _struct_flags)
975 {
976 m_struct_flags = std::move(_struct_flags);
977 }
978
979 RTPS_DllAPI inline const StructTypeFlag& struct_flags() const
980 {
981 return m_struct_flags;
982 }
983
984 RTPS_DllAPI inline StructTypeFlag& struct_flags()
985 {
986 return m_struct_flags;
987 }
988
989 RTPS_DllAPI inline void header(
990 const CompleteStructHeader& _header)
991 {
992 m_header = _header;
993 }
994
995 RTPS_DllAPI inline void header(
996 CompleteStructHeader&& _header)
997 {
998 m_header = std::move(_header);
999 }
1000
1001 RTPS_DllAPI inline const CompleteStructHeader& header() const
1002 {
1003 return m_header;
1004 }
1005
1006 RTPS_DllAPI inline CompleteStructHeader& header()
1007 {
1008 return m_header;
1009 }
1010
1011 RTPS_DllAPI inline void member_seq(
1012 const CompleteStructMemberSeq& _member_seq)
1013 {
1014 m_member_seq = _member_seq;
1015 }
1016
1017 RTPS_DllAPI inline void member_seq(
1018 CompleteStructMemberSeq&& _member_seq)
1019 {
1020 m_member_seq = std::move(_member_seq);
1021 }
1022
1023 RTPS_DllAPI inline const CompleteStructMemberSeq& member_seq() const
1024 {
1025 return m_member_seq;
1026 }
1027
1029 {
1030 return m_member_seq;
1031 }
1032
1033#ifndef DOXYGEN_SHOULD_SKIP_THIS
1034 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructType::getCdrSerializedSize()",
1035 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1036 RTPS_DllAPI static size_t getCdrSerializedSize(
1037 const CompleteStructType& data,
1038 size_t current_alignment = 0);
1039 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructType::serialize()",
1040 "In favor of version using eprosima::fastcdr::serialize.")
1041 RTPS_DllAPI void serialize(
1042 eprosima::fastcdr::Cdr& cdr) const;
1043 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteStructType::deserialize()",
1044 "In favor of version using eprosima::fastcdr::deserialize.")
1045 RTPS_DllAPI void deserialize(
1046 eprosima::fastcdr::Cdr& cdr);
1047#endif // DOXYGEN_SHOULD_SKIP_THIS
1048
1049 RTPS_DllAPI bool operator ==(
1050 const CompleteStructType& other) const;
1051
1052 RTPS_DllAPI bool consistent(
1053 const CompleteStructType& x,
1054 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1055
1056private:
1057
1058 StructTypeFlag m_struct_flags;
1059 CompleteStructHeader m_header;
1060 CompleteStructMemberSeq m_member_seq;
1061};
1062
1063/*struct MinimalStructType final{
1064 StructTypeFlag struct_flags;
1065 MinimalStructHeader header;
1066 MinimalStructMemberSeq member_seq;
1067 };*/
1069{
1070public:
1071
1072 RTPS_DllAPI MinimalStructType();
1073 RTPS_DllAPI ~MinimalStructType();
1075 const MinimalStructType& x);
1077 MinimalStructType&& x);
1079 const MinimalStructType& x);
1081 MinimalStructType&& x);
1082
1083 RTPS_DllAPI inline void struct_flags(
1084 const StructTypeFlag& _struct_flags)
1085 {
1086 m_struct_flags = _struct_flags;
1087 }
1088
1089 RTPS_DllAPI inline void struct_flags(
1090 StructTypeFlag&& _struct_flags)
1091 {
1092 m_struct_flags = std::move(_struct_flags);
1093 }
1094
1095 RTPS_DllAPI inline const StructTypeFlag& struct_flags() const
1096 {
1097 return m_struct_flags;
1098 }
1099
1100 RTPS_DllAPI inline StructTypeFlag& struct_flags()
1101 {
1102 return m_struct_flags;
1103 }
1104
1105 RTPS_DllAPI inline void header(
1106 const MinimalStructHeader& _header)
1107 {
1108 m_header = _header;
1109 }
1110
1111 RTPS_DllAPI inline void header(
1112 MinimalStructHeader&& _header)
1113 {
1114 m_header = std::move(_header);
1115 }
1116
1117 RTPS_DllAPI inline const MinimalStructHeader& header() const
1118 {
1119 return m_header;
1120 }
1121
1122 RTPS_DllAPI inline MinimalStructHeader& header()
1123 {
1124 return m_header;
1125 }
1126
1127 RTPS_DllAPI inline void member_seq(
1128 const MinimalStructMemberSeq& _member_seq)
1129 {
1130 m_member_seq = _member_seq;
1131 }
1132
1133 RTPS_DllAPI inline void member_seq(
1134 MinimalStructMemberSeq&& _member_seq)
1135 {
1136 m_member_seq = std::move(_member_seq);
1137 }
1138
1139 RTPS_DllAPI inline const MinimalStructMemberSeq& member_seq() const
1140 {
1141 return m_member_seq;
1142 }
1143
1145 {
1146 return m_member_seq;
1147 }
1148
1149#ifndef DOXYGEN_SHOULD_SKIP_THIS
1150 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructType::getCdrSerializedSize()",
1151 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1152 RTPS_DllAPI static size_t getCdrSerializedSize(
1153 const MinimalStructType& data,
1154 size_t current_alignment = 0);
1155 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructType::serialize()",
1156 "In favor of version using eprosima::fastcdr::serialize.")
1157 RTPS_DllAPI void serialize(
1158 eprosima::fastcdr::Cdr& cdr) const;
1159 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalStructType::deserialize()",
1160 "In favor of version using eprosima::fastcdr::deserialize.")
1161 RTPS_DllAPI void deserialize(
1162 eprosima::fastcdr::Cdr& cdr);
1163#endif // DOXYGEN_SHOULD_SKIP_THIS
1164
1165 RTPS_DllAPI bool operator ==(
1166 const MinimalStructType& other) const;
1167
1168 RTPS_DllAPI bool consistent(
1169 const MinimalStructType& x,
1170 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1171
1172private:
1173
1174 StructTypeFlag m_struct_flags;
1175 MinimalStructHeader m_header;
1176 MinimalStructMemberSeq m_member_seq;
1177};
1178
1179// --- Union: ---------------------------------------------------------
1180
1181// Case labels that apply to a member of a union type
1182// Ordered by their values
1183typedef std::vector<int32_t> UnionCaseLabelSeq;
1184
1185/*struct CommonUnionMember final{
1186 MemberId member_id;
1187 UnionMemberFlag member_flags;
1188 TypeIdentifier type_id;
1189 UnionCaseLabelSeq label_seq;
1190 };*/
1192{
1193public:
1194
1195 RTPS_DllAPI CommonUnionMember();
1196 RTPS_DllAPI ~CommonUnionMember();
1198 const CommonUnionMember& x);
1200 CommonUnionMember&& x);
1202 const CommonUnionMember& x);
1204 CommonUnionMember&& x);
1205
1206 RTPS_DllAPI inline void member_id(
1207 const MemberId& _member_id)
1208 {
1209 m_member_id = _member_id;
1210 }
1211
1212 RTPS_DllAPI inline void member_id(
1213 MemberId&& _member_id)
1214 {
1215 m_member_id = std::move(_member_id);
1216 }
1217
1218 RTPS_DllAPI inline const MemberId& member_id() const
1219 {
1220 return m_member_id;
1221 }
1222
1223 RTPS_DllAPI inline MemberId& member_id()
1224 {
1225 return m_member_id;
1226 }
1227
1228 RTPS_DllAPI inline void member_flags(
1229 const UnionMemberFlag& _member_flags)
1230 {
1231 m_member_flags = _member_flags;
1232 }
1233
1234 RTPS_DllAPI inline void member_flags(
1235 UnionMemberFlag&& _member_flags)
1236 {
1237 m_member_flags = std::move(_member_flags);
1238 }
1239
1240 RTPS_DllAPI inline const UnionMemberFlag& member_flags() const
1241 {
1242 return m_member_flags;
1243 }
1244
1245 RTPS_DllAPI inline UnionMemberFlag& member_flags()
1246 {
1247 return m_member_flags;
1248 }
1249
1250 RTPS_DllAPI inline void type_id(
1251 const TypeIdentifier& _type_id)
1252 {
1253 m_type_id = _type_id;
1254 }
1255
1256 RTPS_DllAPI inline void type_id(
1257 TypeIdentifier&& _type_id)
1258 {
1259 m_type_id = std::move(_type_id);
1260 }
1261
1262 RTPS_DllAPI inline const TypeIdentifier& type_id() const
1263 {
1264 return m_type_id;
1265 }
1266
1267 RTPS_DllAPI inline TypeIdentifier& type_id()
1268 {
1269 return m_type_id;
1270 }
1271
1272 RTPS_DllAPI inline void label_seq(
1273 const UnionCaseLabelSeq& _label_seq)
1274 {
1275 m_label_seq = _label_seq;
1276 }
1277
1278 RTPS_DllAPI inline void label_seq(
1279 UnionCaseLabelSeq&& _label_seq)
1280 {
1281 m_label_seq = std::move(_label_seq);
1282 }
1283
1284 RTPS_DllAPI inline const UnionCaseLabelSeq& label_seq() const
1285 {
1286 return m_label_seq;
1287 }
1288
1289 RTPS_DllAPI inline UnionCaseLabelSeq& label_seq()
1290 {
1291 return m_label_seq;
1292 }
1293
1294#ifndef DOXYGEN_SHOULD_SKIP_THIS
1295 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonUnionMember::getCdrSerializedSize()",
1296 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1297 RTPS_DllAPI static size_t getCdrSerializedSize(
1298 const CommonUnionMember& data,
1299 size_t current_alignment = 0);
1300 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonUnionMember::serialize()",
1301 "In favor of version using eprosima::fastcdr::serialize.")
1302 RTPS_DllAPI void serialize(
1303 eprosima::fastcdr::Cdr& cdr) const;
1304 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonUnionMember::deserialize()",
1305 "In favor of version using eprosima::fastcdr::deserialize.")
1306 RTPS_DllAPI void deserialize(
1307 eprosima::fastcdr::Cdr& cdr);
1308#endif // DOXYGEN_SHOULD_SKIP_THIS
1309
1310 RTPS_DllAPI bool operator ==(
1311 const CommonUnionMember& other) const;
1312
1313 RTPS_DllAPI bool consistent(
1314 const CommonUnionMember& x,
1315 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1316
1317private:
1318
1319 MemberId m_member_id;
1320 UnionMemberFlag m_member_flags;
1321 TypeIdentifier m_type_id;
1322 UnionCaseLabelSeq m_label_seq;
1323};
1324
1325// Member of a union type
1326/*struct CompleteUnionMember {
1327 CommonUnionMember common;
1328 CompleteMemberDetail detail;
1329 };*/
1331{
1332public:
1333
1334 RTPS_DllAPI CompleteUnionMember();
1337 const CompleteUnionMember& x);
1341 const CompleteUnionMember& x);
1344
1345 RTPS_DllAPI inline void common(
1346 const CommonUnionMember& _common)
1347 {
1348 m_common = _common;
1349 }
1350
1351 RTPS_DllAPI inline void common(
1352 CommonUnionMember&& _common)
1353 {
1354 m_common = std::move(_common);
1355 }
1356
1357 RTPS_DllAPI inline const CommonUnionMember& common() const
1358 {
1359 return m_common;
1360 }
1361
1362 RTPS_DllAPI inline CommonUnionMember& common()
1363 {
1364 return m_common;
1365 }
1366
1367 RTPS_DllAPI inline void detail(
1368 const CompleteMemberDetail& _detail)
1369 {
1370 m_detail = _detail;
1371 }
1372
1373 RTPS_DllAPI inline void detail(
1374 CompleteMemberDetail&& _detail)
1375 {
1376 m_detail = std::move(_detail);
1377 }
1378
1379 RTPS_DllAPI inline const CompleteMemberDetail& detail() const
1380 {
1381 return m_detail;
1382 }
1383
1384 RTPS_DllAPI inline CompleteMemberDetail& detail()
1385 {
1386 return m_detail;
1387 }
1388
1389#ifndef DOXYGEN_SHOULD_SKIP_THIS
1390 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionMember::getCdrSerializedSize()",
1391 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1392 RTPS_DllAPI static size_t getCdrSerializedSize(
1393 const CompleteUnionMember& data,
1394 size_t current_alignment = 0);
1395 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionMember::serialize()",
1396 "In favor of version using eprosima::fastcdr::serialize.")
1397 RTPS_DllAPI void serialize(
1398 eprosima::fastcdr::Cdr& cdr) const;
1399 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionMember::deserialize()",
1400 "In favor of version using eprosima::fastcdr::deserialize.")
1401 RTPS_DllAPI void deserialize(
1402 eprosima::fastcdr::Cdr& cdr);
1403#endif // DOXYGEN_SHOULD_SKIP_THIS
1404
1405 RTPS_DllAPI bool operator ==(
1406 const CompleteUnionMember& other) const;
1407
1408 RTPS_DllAPI bool consistent(
1409 const CompleteUnionMember& x,
1410 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1411
1412private:
1413
1414 CommonUnionMember m_common;
1415 CompleteMemberDetail m_detail;
1416};
1417
1418// Ordered by member_index
1419typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
1420
1421// Member of a union type
1422/*struct MinimalUnionMember {
1423 CommonUnionMember common;
1424 MinimalMemberDetail detail;
1425 };*/
1427{
1428public:
1429
1430 RTPS_DllAPI MinimalUnionMember();
1431 RTPS_DllAPI ~MinimalUnionMember();
1433 const MinimalUnionMember& x);
1435 MinimalUnionMember&& x);
1437 const MinimalUnionMember& x);
1439 MinimalUnionMember&& x);
1440
1441 RTPS_DllAPI inline void common(
1442 const CommonUnionMember& _common)
1443 {
1444 m_common = _common;
1445 }
1446
1447 RTPS_DllAPI inline void common(
1448 CommonUnionMember&& _common)
1449 {
1450 m_common = std::move(_common);
1451 }
1452
1453 RTPS_DllAPI inline const CommonUnionMember& common() const
1454 {
1455 return m_common;
1456 }
1457
1458 RTPS_DllAPI inline CommonUnionMember& common()
1459 {
1460 return m_common;
1461 }
1462
1463 RTPS_DllAPI inline void detail(
1464 const MinimalMemberDetail& _detail)
1465 {
1466 m_detail = _detail;
1467 }
1468
1469 RTPS_DllAPI inline void detail(
1470 MinimalMemberDetail&& _detail)
1471 {
1472 m_detail = std::move(_detail);
1473 }
1474
1475 RTPS_DllAPI inline const MinimalMemberDetail& detail() const
1476 {
1477 return m_detail;
1478 }
1479
1480 RTPS_DllAPI inline MinimalMemberDetail& detail()
1481 {
1482 return m_detail;
1483 }
1484
1485#ifndef DOXYGEN_SHOULD_SKIP_THIS
1486 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionMember::getCdrSerializedSize()",
1487 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1488 RTPS_DllAPI static size_t getCdrSerializedSize(
1489 const MinimalUnionMember& data,
1490 size_t current_alignment = 0);
1491 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionMember::serialize()",
1492 "In favor of version using eprosima::fastcdr::serialize.")
1493 RTPS_DllAPI void serialize(
1494 eprosima::fastcdr::Cdr& cdr) const;
1495 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionMember::deserialize()",
1496 "In favor of version using eprosima::fastcdr::deserialize.")
1497 RTPS_DllAPI void deserialize(
1498 eprosima::fastcdr::Cdr& cdr);
1499#endif // DOXYGEN_SHOULD_SKIP_THIS
1500
1501 RTPS_DllAPI bool operator ==(
1502 const MinimalUnionMember& other) const;
1503
1504 RTPS_DllAPI bool consistent(
1505 const MinimalUnionMember& x,
1506 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1507
1508private:
1509
1510 CommonUnionMember m_common;
1511 MinimalMemberDetail m_detail;
1512};
1513
1514// Ordered by MinimalUnionMember.common.member_id
1515typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
1516
1517/*struct CommonDiscriminatorMember final{
1518 UnionDiscriminatorFlag member_flags;
1519 TypeIdentifier type_id;
1520 };*/
1522{
1523public:
1524
1528 const CommonDiscriminatorMember& x);
1532 const CommonDiscriminatorMember& x);
1535
1536 RTPS_DllAPI inline void member_flags(
1537 const UnionDiscriminatorFlag& _member_flags)
1538 {
1539 m_member_flags = _member_flags;
1540 }
1541
1542 RTPS_DllAPI inline void member_flags(
1543 UnionDiscriminatorFlag&& _member_flags)
1544 {
1545 m_member_flags = std::move(_member_flags);
1546 }
1547
1548 RTPS_DllAPI inline const UnionDiscriminatorFlag& member_flags() const
1549 {
1550 return m_member_flags;
1551 }
1552
1554 {
1555 return m_member_flags;
1556 }
1557
1558 RTPS_DllAPI inline void type_id(
1559 const TypeIdentifier& _type_id)
1560 {
1561 m_type_id = _type_id;
1562 }
1563
1564 RTPS_DllAPI inline void type_id(
1565 TypeIdentifier&& _type_id)
1566 {
1567 m_type_id = std::move(_type_id);
1568 }
1569
1570 RTPS_DllAPI inline const TypeIdentifier& type_id() const
1571 {
1572 return m_type_id;
1573 }
1574
1575 RTPS_DllAPI inline TypeIdentifier& type_id()
1576 {
1577 return m_type_id;
1578 }
1579
1580#ifndef DOXYGEN_SHOULD_SKIP_THIS
1581 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonDiscriminatorMember::getCdrSerializedSize()",
1582 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1583 RTPS_DllAPI static size_t getCdrSerializedSize(
1584 const CommonDiscriminatorMember& data,
1585 size_t current_alignment = 0);
1586 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonDiscriminatorMember::serialize()",
1587 "In favor of version using eprosima::fastcdr::serialize.")
1588 RTPS_DllAPI void serialize(
1589 eprosima::fastcdr::Cdr& cdr) const;
1590 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonDiscriminatorMember::deserialize()",
1591 "In favor of version using eprosima::fastcdr::deserialize.")
1592 RTPS_DllAPI void deserialize(
1593 eprosima::fastcdr::Cdr& cdr);
1594#endif // DOXYGEN_SHOULD_SKIP_THIS
1595
1596 RTPS_DllAPI bool operator ==(
1597 const CommonDiscriminatorMember& other) const;
1598
1599 RTPS_DllAPI bool consistent(
1601 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1602
1603private:
1604
1605 UnionDiscriminatorFlag m_member_flags;
1606 TypeIdentifier m_type_id;
1607};
1608
1609// Member of a union type
1610/*struct CompleteDiscriminatorMember {
1611 CommonDiscriminatorMember common;
1612 AppliedBuiltinTypeAnnotations ann_builtin; // Optional
1613 AppliedAnnotationSeq ann_custom; // Optional
1614 };*/
1616{
1617public:
1618
1629
1630 RTPS_DllAPI inline void common(
1631 const CommonDiscriminatorMember& _common)
1632 {
1633 m_common = _common;
1634 }
1635
1636 RTPS_DllAPI inline void common(
1637 CommonDiscriminatorMember&& _common)
1638 {
1639 m_common = std::move(_common);
1640 }
1641
1642 RTPS_DllAPI inline const CommonDiscriminatorMember& common() const
1643 {
1644 return m_common;
1645 }
1646
1647 RTPS_DllAPI inline CommonDiscriminatorMember& common()
1648 {
1649 return m_common;
1650 }
1651
1652 RTPS_DllAPI inline void ann_builtin(
1653 const AppliedBuiltinTypeAnnotations& _ann_builtin)
1654 {
1655 m_ann_builtin = _ann_builtin;
1656 }
1657
1658 RTPS_DllAPI inline void ann_builtin(
1659 AppliedBuiltinTypeAnnotations&& _ann_builtin)
1660 {
1661 m_ann_builtin = std::move(_ann_builtin);
1662 }
1663
1664 RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const
1665 {
1666 return m_ann_builtin;
1667 }
1668
1670 {
1671 return m_ann_builtin;
1672 }
1673
1674 RTPS_DllAPI inline void ann_custom(
1675 const AppliedAnnotationSeq& _ann_custom)
1676 {
1677 m_ann_custom = _ann_custom;
1678 }
1679
1680 RTPS_DllAPI inline void ann_custom(
1681 AppliedAnnotationSeq&& _ann_custom)
1682 {
1683 m_ann_custom = std::move(_ann_custom);
1684 }
1685
1686 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
1687 {
1688 return m_ann_custom;
1689 }
1690
1691 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
1692 {
1693 return m_ann_custom;
1694 }
1695
1696#ifndef DOXYGEN_SHOULD_SKIP_THIS
1697 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteDiscriminatorMember::getCdrSerializedSize()",
1698 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1699 RTPS_DllAPI static size_t getCdrSerializedSize(
1700 const CompleteDiscriminatorMember& data,
1701 size_t current_alignment = 0);
1702 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteDiscriminatorMember::serialize()",
1703 "In favor of version using eprosima::fastcdr::serialize.")
1704 RTPS_DllAPI void serialize(
1705 eprosima::fastcdr::Cdr& cdr) const;
1706 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteDiscriminatorMember::deserialize()",
1707 "In favor of version using eprosima::fastcdr::deserialize.")
1708 RTPS_DllAPI void deserialize(
1709 eprosima::fastcdr::Cdr& cdr);
1710#endif // DOXYGEN_SHOULD_SKIP_THIS
1711
1712 RTPS_DllAPI bool operator ==(
1713 const CompleteDiscriminatorMember& other) const;
1714
1715 RTPS_DllAPI bool consistent(
1717 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1718
1719private:
1720
1722 AppliedBuiltinTypeAnnotations m_ann_builtin;
1723 AppliedAnnotationSeq m_ann_custom;
1724};
1725
1726// Member of a union type
1727/*struct MinimalDiscriminatorMember {
1728 CommonDiscriminatorMember common;
1729 };*/
1731{
1732public:
1733
1744
1745 RTPS_DllAPI inline void common(
1746 const CommonDiscriminatorMember& _common)
1747 {
1748 m_common = _common;
1749 }
1750
1751 RTPS_DllAPI inline void common(
1752 CommonDiscriminatorMember&& _common)
1753 {
1754 m_common = std::move(_common);
1755 }
1756
1757 RTPS_DllAPI inline const CommonDiscriminatorMember& common() const
1758 {
1759 return m_common;
1760 }
1761
1762 RTPS_DllAPI inline CommonDiscriminatorMember& common()
1763 {
1764 return m_common;
1765 }
1766
1767#ifndef DOXYGEN_SHOULD_SKIP_THIS
1768 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalDiscriminatorMember::getCdrSerializedSize()",
1769 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1770 RTPS_DllAPI static size_t getCdrSerializedSize(
1771 const MinimalDiscriminatorMember& data,
1772 size_t current_alignment = 0);
1773 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalDiscriminatorMember::serialize()",
1774 "In favor of version using eprosima::fastcdr::serialize.")
1775 RTPS_DllAPI void serialize(
1776 eprosima::fastcdr::Cdr& cdr) const;
1777 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalDiscriminatorMember::deserialize()",
1778 "In favor of version using eprosima::fastcdr::deserialize.")
1779 RTPS_DllAPI void deserialize(
1780 eprosima::fastcdr::Cdr& cdr);
1781#endif // DOXYGEN_SHOULD_SKIP_THIS
1782
1783 RTPS_DllAPI bool operator ==(
1784 const MinimalDiscriminatorMember& other) const;
1785
1786 RTPS_DllAPI bool consistent(
1788 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1789
1790private:
1791
1793};
1794
1795/*struct CompleteUnionHeader {
1796 CompleteTypeDetail detail;
1797 };*/
1799{
1800public:
1801
1802 RTPS_DllAPI CompleteUnionHeader();
1805 const CompleteUnionHeader& x);
1809 const CompleteUnionHeader& x);
1812
1813 RTPS_DllAPI inline void detail(
1814 const CompleteTypeDetail& _detail)
1815 {
1816 m_detail = _detail;
1817 }
1818
1819 RTPS_DllAPI inline void detail(
1820 CompleteTypeDetail&& _detail)
1821 {
1822 m_detail = std::move(_detail);
1823 }
1824
1825 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
1826 {
1827 return m_detail;
1828 }
1829
1830 RTPS_DllAPI inline CompleteTypeDetail& detail()
1831 {
1832 return m_detail;
1833 }
1834
1835#ifndef DOXYGEN_SHOULD_SKIP_THIS
1836 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionHeader::getCdrSerializedSize()",
1837 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1838 RTPS_DllAPI static size_t getCdrSerializedSize(
1839 const CompleteUnionHeader& data,
1840 size_t current_alignment = 0);
1841 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionHeader::serialize()",
1842 "In favor of version using eprosima::fastcdr::serialize.")
1843 RTPS_DllAPI void serialize(
1844 eprosima::fastcdr::Cdr& cdr) const;
1845 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionHeader::deserialize()",
1846 "In favor of version using eprosima::fastcdr::deserialize.")
1847 RTPS_DllAPI void deserialize(
1848 eprosima::fastcdr::Cdr& cdr);
1849#endif // DOXYGEN_SHOULD_SKIP_THIS
1850
1851 RTPS_DllAPI bool operator ==(
1852 const CompleteUnionHeader& other) const;
1853
1854 RTPS_DllAPI bool consistent(
1855 const CompleteUnionHeader& x,
1856 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1857
1858private:
1859
1860 CompleteTypeDetail m_detail;
1861};
1862
1863/*struct MinimalUnionHeader {
1864 MinimalTypeDetail detail;
1865 };*/
1867{
1868public:
1869
1870 RTPS_DllAPI MinimalUnionHeader();
1871 RTPS_DllAPI ~MinimalUnionHeader();
1873 const MinimalUnionHeader& x);
1875 MinimalUnionHeader&& x);
1877 const MinimalUnionHeader& x);
1879 MinimalUnionHeader&& x);
1880
1881 RTPS_DllAPI inline void detail(
1882 const MinimalTypeDetail& _detail)
1883 {
1884 m_detail = _detail;
1885 }
1886
1887 RTPS_DllAPI inline void detail(
1888 MinimalTypeDetail&& _detail)
1889 {
1890 m_detail = std::move(_detail);
1891 }
1892
1893 RTPS_DllAPI inline const MinimalTypeDetail& detail() const
1894 {
1895 return m_detail;
1896 }
1897
1898 RTPS_DllAPI inline MinimalTypeDetail& detail()
1899 {
1900 return m_detail;
1901 }
1902
1903#ifndef DOXYGEN_SHOULD_SKIP_THIS
1904 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionHeader::getCdrSerializedSize()",
1905 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
1906 RTPS_DllAPI static size_t getCdrSerializedSize(
1907 const MinimalUnionHeader& data,
1908 size_t current_alignment = 0);
1909 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionHeader::serialize()",
1910 "In favor of version using eprosima::fastcdr::serialize.")
1911 RTPS_DllAPI void serialize(
1912 eprosima::fastcdr::Cdr& cdr) const;
1913 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionHeader::deserialize()",
1914 "In favor of version using eprosima::fastcdr::deserialize.")
1915 RTPS_DllAPI void deserialize(
1916 eprosima::fastcdr::Cdr& cdr);
1917#endif // DOXYGEN_SHOULD_SKIP_THIS
1918
1919 RTPS_DllAPI bool operator ==(
1920 const MinimalUnionHeader& other) const;
1921
1922 RTPS_DllAPI bool consistent(
1923 const MinimalUnionHeader& x,
1924 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1925
1926private:
1927
1928 MinimalTypeDetail m_detail;
1929};
1930
1931/*struct CompleteUnionType final{
1932 UnionTypeFlag union_flags;
1933 CompleteUnionHeader header;
1934 CompleteDiscriminatorMember discriminator;
1935 CompleteUnionMemberSeq member_seq;
1936 };*/
1938{
1939public:
1940
1941 RTPS_DllAPI CompleteUnionType();
1942 RTPS_DllAPI ~CompleteUnionType();
1944 const CompleteUnionType& x);
1946 CompleteUnionType&& x);
1948 const CompleteUnionType& x);
1950 CompleteUnionType&& x);
1951
1952 RTPS_DllAPI inline void union_flags(
1953 const UnionTypeFlag& _union_flags)
1954 {
1955 m_union_flags = _union_flags;
1956 }
1957
1958 RTPS_DllAPI inline void union_flags(
1959 UnionTypeFlag&& _union_flags)
1960 {
1961 m_union_flags = std::move(_union_flags);
1962 }
1963
1964 RTPS_DllAPI inline const UnionTypeFlag& union_flags() const
1965 {
1966 return m_union_flags;
1967 }
1968
1969 RTPS_DllAPI inline UnionTypeFlag& union_flags()
1970 {
1971 return m_union_flags;
1972 }
1973
1974 RTPS_DllAPI inline void header(
1975 const CompleteUnionHeader& _header)
1976 {
1977 m_header = _header;
1978 }
1979
1980 RTPS_DllAPI inline void header(
1981 CompleteUnionHeader&& _header)
1982 {
1983 m_header = std::move(_header);
1984 }
1985
1986 RTPS_DllAPI inline const CompleteUnionHeader& header() const
1987 {
1988 return m_header;
1989 }
1990
1991 RTPS_DllAPI inline CompleteUnionHeader& header()
1992 {
1993 return m_header;
1994 }
1995
1996 RTPS_DllAPI inline void discriminator(
1997 const CompleteDiscriminatorMember& _discriminator)
1998 {
1999 m_discriminator = _discriminator;
2000 }
2001
2002 RTPS_DllAPI inline void discriminator(
2003 CompleteDiscriminatorMember&& _discriminator)
2004 {
2005 m_discriminator = std::move(_discriminator);
2006 }
2007
2008 RTPS_DllAPI inline const CompleteDiscriminatorMember& discriminator() const
2009 {
2010 return m_discriminator;
2011 }
2012
2014 {
2015 return m_discriminator;
2016 }
2017
2018 RTPS_DllAPI inline void member_seq(
2019 const CompleteUnionMemberSeq& _member_seq)
2020 {
2021 m_member_seq = _member_seq;
2022 }
2023
2024 RTPS_DllAPI inline void member_seq(
2025 CompleteUnionMemberSeq&& _member_seq)
2026 {
2027 m_member_seq = std::move(_member_seq);
2028 }
2029
2030 RTPS_DllAPI inline const CompleteUnionMemberSeq& member_seq() const
2031 {
2032 return m_member_seq;
2033 }
2034
2036 {
2037 return m_member_seq;
2038 }
2039
2040#ifndef DOXYGEN_SHOULD_SKIP_THIS
2041 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionType::getCdrSerializedSize()",
2042 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2043 RTPS_DllAPI static size_t getCdrSerializedSize(
2044 const CompleteUnionType& data,
2045 size_t current_alignment = 0);
2046 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionType::serialize()",
2047 "In favor of version using eprosima::fastcdr::serialize.")
2048 RTPS_DllAPI void serialize(
2049 eprosima::fastcdr::Cdr& cdr) const;
2050 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteUnionType::deserialize()",
2051 "In favor of version using eprosima::fastcdr::deserialize.")
2052 RTPS_DllAPI void deserialize(
2053 eprosima::fastcdr::Cdr& cdr);
2054#endif // DOXYGEN_SHOULD_SKIP_THIS
2055
2056 RTPS_DllAPI bool operator ==(
2057 const CompleteUnionType& other) const;
2058
2059 RTPS_DllAPI bool consistent(
2060 const CompleteUnionType& x,
2061 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2062
2063private:
2064
2065 UnionTypeFlag m_union_flags;
2066 CompleteUnionHeader m_header;
2067 CompleteDiscriminatorMember m_discriminator;
2068 CompleteUnionMemberSeq m_member_seq;
2069};
2070
2071/*struct MinimalUnionType final{
2072 UnionTypeFlag union_flags;
2073 MinimalUnionHeader header;
2074 MinimalDiscriminatorMember discriminator;
2075 MinimalUnionMemberSeq member_seq;
2076 };*/
2078{
2079public:
2080
2081 RTPS_DllAPI MinimalUnionType();
2082 RTPS_DllAPI ~MinimalUnionType();
2083 RTPS_DllAPI MinimalUnionType(
2084 const MinimalUnionType& x);
2085 RTPS_DllAPI MinimalUnionType(
2086 MinimalUnionType&& x);
2088 const MinimalUnionType& x);
2090 MinimalUnionType&& x);
2091
2092 RTPS_DllAPI inline void union_flags(
2093 const UnionTypeFlag& _union_flags)
2094 {
2095 m_union_flags = _union_flags;
2096 }
2097
2098 RTPS_DllAPI inline void union_flags(
2099 UnionTypeFlag&& _union_flags)
2100 {
2101 m_union_flags = std::move(_union_flags);
2102 }
2103
2104 RTPS_DllAPI inline const UnionTypeFlag& union_flags() const
2105 {
2106 return m_union_flags;
2107 }
2108
2109 RTPS_DllAPI inline UnionTypeFlag& union_flags()
2110 {
2111 return m_union_flags;
2112 }
2113
2114 RTPS_DllAPI inline void header(
2115 const MinimalUnionHeader& _header)
2116 {
2117 m_header = _header;
2118 }
2119
2120 RTPS_DllAPI inline void header(
2121 MinimalUnionHeader&& _header)
2122 {
2123 m_header = std::move(_header);
2124 }
2125
2126 RTPS_DllAPI inline const MinimalUnionHeader& header() const
2127 {
2128 return m_header;
2129 }
2130
2131 RTPS_DllAPI inline MinimalUnionHeader& header()
2132 {
2133 return m_header;
2134 }
2135
2136 RTPS_DllAPI inline void discriminator(
2137 const MinimalDiscriminatorMember& _discriminator)
2138 {
2139 m_discriminator = _discriminator;
2140 }
2141
2142 RTPS_DllAPI inline void discriminator(
2143 MinimalDiscriminatorMember&& _discriminator)
2144 {
2145 m_discriminator = std::move(_discriminator);
2146 }
2147
2148 RTPS_DllAPI inline const MinimalDiscriminatorMember& discriminator() const
2149 {
2150 return m_discriminator;
2151 }
2152
2154 {
2155 return m_discriminator;
2156 }
2157
2158 RTPS_DllAPI inline void member_seq(
2159 const MinimalUnionMemberSeq& _member_seq)
2160 {
2161 m_member_seq = _member_seq;
2162 }
2163
2164 RTPS_DllAPI inline void member_seq(
2165 MinimalUnionMemberSeq&& _member_seq)
2166 {
2167 m_member_seq = std::move(_member_seq);
2168 }
2169
2170 RTPS_DllAPI inline const MinimalUnionMemberSeq& member_seq() const
2171 {
2172 return m_member_seq;
2173 }
2174
2175 RTPS_DllAPI inline MinimalUnionMemberSeq& member_seq()
2176 {
2177 return m_member_seq;
2178 }
2179
2180#ifndef DOXYGEN_SHOULD_SKIP_THIS
2181 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionType::getCdrSerializedSize()",
2182 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2183 RTPS_DllAPI static size_t getCdrSerializedSize(
2184 const MinimalUnionType& data,
2185 size_t current_alignment = 0);
2186 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionType::serialize()",
2187 "In favor of version using eprosima::fastcdr::serialize.")
2188 RTPS_DllAPI void serialize(
2189 eprosima::fastcdr::Cdr& cdr) const;
2190 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalUnionType::deserialize()",
2191 "In favor of version using eprosima::fastcdr::deserialize.")
2192 RTPS_DllAPI void deserialize(
2193 eprosima::fastcdr::Cdr& cdr);
2194#endif // DOXYGEN_SHOULD_SKIP_THIS
2195
2196 RTPS_DllAPI bool operator ==(
2197 const MinimalUnionType& other) const;
2198
2199 RTPS_DllAPI bool consistent(
2200 const MinimalUnionType& x,
2201 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2202
2203private:
2204
2205 UnionTypeFlag m_union_flags;
2206 MinimalUnionHeader m_header;
2207 MinimalDiscriminatorMember m_discriminator;
2208 MinimalUnionMemberSeq m_member_seq;
2209};
2210
2211// --- Annotation: ---------------------------------------------------
2212/*struct CommonAnnotationParameter final{
2213 AnnotationParameterFlag member_flags;
2214 TypeIdentifier member_type_id;
2215 };*/
2217{
2218public:
2219
2223 const CommonAnnotationParameter& x);
2227 const CommonAnnotationParameter& x);
2230
2231 RTPS_DllAPI inline void member_flags(
2232 const AnnotationParameterFlag& _member_flags)
2233 {
2234 m_member_flags = _member_flags;
2235 }
2236
2237 RTPS_DllAPI inline void member_flags(
2238 AnnotationParameterFlag&& _member_flags)
2239 {
2240 m_member_flags = std::move(_member_flags);
2241 }
2242
2243 RTPS_DllAPI inline const AnnotationParameterFlag& member_flags() const
2244 {
2245 return m_member_flags;
2246 }
2247
2249 {
2250 return m_member_flags;
2251 }
2252
2253 RTPS_DllAPI inline void member_type_id(
2254 const TypeIdentifier& _member_type_id)
2255 {
2256 m_member_type_id = _member_type_id;
2257 }
2258
2259 RTPS_DllAPI inline void member_type_id(
2260 TypeIdentifier&& _member_type_id)
2261 {
2262 m_member_type_id = std::move(_member_type_id);
2263 }
2264
2265 RTPS_DllAPI inline const TypeIdentifier& member_type_id() const
2266 {
2267 return m_member_type_id;
2268 }
2269
2270 RTPS_DllAPI inline TypeIdentifier& member_type_id()
2271 {
2272 return m_member_type_id;
2273 }
2274
2275#ifndef DOXYGEN_SHOULD_SKIP_THIS
2276 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAnnotationParameter::getCdrSerializedSize()",
2277 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2278 RTPS_DllAPI static size_t getCdrSerializedSize(
2279 const CommonAnnotationParameter& data,
2280 size_t current_alignment = 0);
2281 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAnnotationParameter::serialize()",
2282 "In favor of version using eprosima::fastcdr::serialize.")
2283 RTPS_DllAPI void serialize(
2284 eprosima::fastcdr::Cdr& cdr) const;
2285 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAnnotationParameter::deserialize()",
2286 "In favor of version using eprosima::fastcdr::deserialize.")
2287 RTPS_DllAPI void deserialize(
2288 eprosima::fastcdr::Cdr& cdr);
2289#endif // DOXYGEN_SHOULD_SKIP_THIS
2290
2291 RTPS_DllAPI bool operator ==(
2292 const CommonAnnotationParameter& other) const;
2293
2294 RTPS_DllAPI bool consistent(
2296 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2297
2298private:
2299
2300 AnnotationParameterFlag m_member_flags;
2301 TypeIdentifier m_member_type_id;
2302};
2303
2304// Member of an annotation type
2305
2306/*struct CompleteAnnotationParameter {
2307 CommonAnnotationParameter common;
2308 MemberName name;
2309 AnnotationParameterValue default_value;
2310 };*/
2312{
2313public:
2314
2325
2326 RTPS_DllAPI inline void common(
2327 const CommonAnnotationParameter& _common)
2328 {
2329 m_common = _common;
2330 }
2331
2332 RTPS_DllAPI inline void common(
2333 CommonAnnotationParameter&& _common)
2334 {
2335 m_common = std::move(_common);
2336 }
2337
2338 RTPS_DllAPI inline const CommonAnnotationParameter& common() const
2339 {
2340 return m_common;
2341 }
2342
2343 RTPS_DllAPI inline CommonAnnotationParameter& common()
2344 {
2345 return m_common;
2346 }
2347
2348 RTPS_DllAPI inline void name(
2349 const MemberName& _name)
2350 {
2351 m_name = _name;
2352 }
2353
2354 RTPS_DllAPI inline void name(
2355 MemberName&& _name)
2356 {
2357 m_name = std::move(_name);
2358 }
2359
2360 RTPS_DllAPI inline const MemberName& name() const
2361 {
2362 return m_name;
2363 }
2364
2365 RTPS_DllAPI inline MemberName& name()
2366 {
2367 return m_name;
2368 }
2369
2370 RTPS_DllAPI inline void default_value(
2371 const AnnotationParameterValue& _default_value)
2372 {
2373 m_default_value = _default_value;
2374 }
2375
2376 RTPS_DllAPI inline void default_value(
2377 AnnotationParameterValue&& _default_value)
2378 {
2379 m_default_value = std::move(_default_value);
2380 }
2381
2382 RTPS_DllAPI inline const AnnotationParameterValue& default_value() const
2383 {
2384 return m_default_value;
2385 }
2386
2388 {
2389 return m_default_value;
2390 }
2391
2392#ifndef DOXYGEN_SHOULD_SKIP_THIS
2393 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationParameter::getCdrSerializedSize()",
2394 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2395 RTPS_DllAPI static size_t getCdrSerializedSize(
2396 const CompleteAnnotationParameter& data,
2397 size_t current_alignment = 0);
2398 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationParameter::serialize()",
2399 "In favor of version using eprosima::fastcdr::serialize.")
2400 RTPS_DllAPI void serialize(
2401 eprosima::fastcdr::Cdr& cdr) const;
2402 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationParameter::deserialize()",
2403 "In favor of version using eprosima::fastcdr::deserialize.")
2404 RTPS_DllAPI void deserialize(
2405 eprosima::fastcdr::Cdr& cdr);
2406#endif // DOXYGEN_SHOULD_SKIP_THIS
2407
2408 RTPS_DllAPI bool operator ==(
2409 const CompleteAnnotationParameter& other) const;
2410
2411 RTPS_DllAPI bool consistent(
2413 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2414
2415private:
2416
2418 MemberName m_name;
2419 AnnotationParameterValue m_default_value;
2420};
2421// Ordered by CompleteAnnotationParameter.name
2422typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
2423/*struct MinimalAnnotationParameter {
2424 CommonAnnotationParameter common;
2425 NameHash name_hash;
2426 AnnotationParameterValue default_value;
2427 };*/
2429{
2430public:
2431
2442
2443 RTPS_DllAPI inline void common(
2444 const CommonAnnotationParameter& _common)
2445 {
2446 m_common = _common;
2447 }
2448
2449 RTPS_DllAPI inline void common(
2450 CommonAnnotationParameter&& _common)
2451 {
2452 m_common = std::move(_common);
2453 }
2454
2455 RTPS_DllAPI inline const CommonAnnotationParameter& common() const
2456 {
2457 return m_common;
2458 }
2459
2460 RTPS_DllAPI inline CommonAnnotationParameter& common()
2461 {
2462 return m_common;
2463 }
2464
2465 RTPS_DllAPI inline void name(
2466 const MemberName& _name)
2467 {
2468 m_name = _name;
2469 }
2470
2471 RTPS_DllAPI inline void name(
2472 MemberName&& _name)
2473 {
2474 m_name = std::move(_name);
2475 }
2476
2477 RTPS_DllAPI inline const MemberName& name() const
2478 {
2479 return m_name;
2480 }
2481
2482 RTPS_DllAPI inline MemberName& name()
2483 {
2484 return m_name;
2485 }
2486
2487 RTPS_DllAPI inline void default_value(
2488 const AnnotationParameterValue& _default_value)
2489 {
2490 m_default_value = _default_value;
2491 }
2492
2493 RTPS_DllAPI inline void default_value(
2494 AnnotationParameterValue&& _default_value)
2495 {
2496 m_default_value = std::move(_default_value);
2497 }
2498
2499 RTPS_DllAPI inline const AnnotationParameterValue& default_value() const
2500 {
2501 return m_default_value;
2502 }
2503
2505 {
2506 return m_default_value;
2507 }
2508
2509#ifndef DOXYGEN_SHOULD_SKIP_THIS
2510 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationParameter::getCdrSerializedSize()",
2511 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2512 RTPS_DllAPI static size_t getCdrSerializedSize(
2513 const MinimalAnnotationParameter& data,
2514 size_t current_alignment = 0);
2515 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationParameter::serialize()",
2516 "In favor of version using eprosima::fastcdr::serialize.")
2517 RTPS_DllAPI void serialize(
2518 eprosima::fastcdr::Cdr& cdr) const;
2519 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationParameter::deserialize()",
2520 "In favor of version using eprosima::fastcdr::deserialize.")
2521 RTPS_DllAPI void deserialize(
2522 eprosima::fastcdr::Cdr& cdr);
2523#endif // DOXYGEN_SHOULD_SKIP_THIS
2524
2525 RTPS_DllAPI bool operator ==(
2526 const MinimalAnnotationParameter& other) const;
2527
2528 RTPS_DllAPI bool consistent(
2530 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2531
2532private:
2533
2535 MemberName m_name;
2536 AnnotationParameterValue m_default_value;
2537};
2538
2539// Ordered by MinimalAnnotationParameter.name_hash
2540typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
2541/*struct CompleteAnnotationHeader {
2542 QualifiedTypeName annotation_name;
2543 };*/
2545{
2546public:
2547
2551 const CompleteAnnotationHeader& x);
2555 const CompleteAnnotationHeader& x);
2558
2559 RTPS_DllAPI inline void annotation_name(
2560 const QualifiedTypeName& _annotation_name)
2561 {
2562 m_annotation_name = _annotation_name;
2563 }
2564
2565 RTPS_DllAPI inline void annotation_name(
2566 QualifiedTypeName&& _annotation_name)
2567 {
2568 m_annotation_name = std::move(_annotation_name);
2569 }
2570
2571 RTPS_DllAPI inline const QualifiedTypeName& annotation_name() const
2572 {
2573 return m_annotation_name;
2574 }
2575
2577 {
2578 return m_annotation_name;
2579 }
2580
2581#ifndef DOXYGEN_SHOULD_SKIP_THIS
2582 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationHeader::getCdrSerializedSize()",
2583 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2584 RTPS_DllAPI static size_t getCdrSerializedSize(
2585 const CompleteAnnotationHeader& data,
2586 size_t current_alignment = 0);
2587 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationHeader::serialize()",
2588 "In favor of version using eprosima::fastcdr::serialize.")
2589 RTPS_DllAPI void serialize(
2590 eprosima::fastcdr::Cdr& cdr) const;
2591 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationHeader::deserialize()",
2592 "In favor of version using eprosima::fastcdr::deserialize.")
2593 RTPS_DllAPI void deserialize(
2594 eprosima::fastcdr::Cdr& cdr);
2595#endif // DOXYGEN_SHOULD_SKIP_THIS
2596
2597 RTPS_DllAPI bool operator ==(
2598 const CompleteAnnotationHeader& other) const;
2599
2600 RTPS_DllAPI bool consistent(
2601 const CompleteAnnotationHeader& x,
2602 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2603
2604private:
2605
2606 QualifiedTypeName m_annotation_name;
2607};
2608
2609/*struct MinimalAnnotationHeader {
2610 // Empty. Available for future extension
2611 };*/
2613{
2614public:
2615
2619 const MinimalAnnotationHeader& x);
2623 const MinimalAnnotationHeader& x);
2626
2627#ifndef DOXYGEN_SHOULD_SKIP_THIS
2628 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationHeader::getCdrSerializedSize()",
2629 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2630 RTPS_DllAPI static size_t getCdrSerializedSize(
2631 const MinimalAnnotationHeader& data,
2632 size_t current_alignment = 0);
2633 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationHeader::serialize()",
2634 "In favor of version using eprosima::fastcdr::serialize.")
2635 RTPS_DllAPI void serialize(
2636 eprosima::fastcdr::Cdr& cdr) const;
2637 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationHeader::deserialize()",
2638 "In favor of version using eprosima::fastcdr::deserialize.")
2639 RTPS_DllAPI void deserialize(
2640 eprosima::fastcdr::Cdr& cdr);
2641#endif // DOXYGEN_SHOULD_SKIP_THIS
2642
2643 RTPS_DllAPI bool operator ==(
2644 const MinimalAnnotationHeader&) const
2645 {
2646 return true;
2647 }
2648
2649 RTPS_DllAPI bool consistent(
2650 const MinimalAnnotationHeader& x,
2651 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2652
2653private:
2654
2655};
2656
2657/*struct CompleteAnnotationType final{
2658 AnnotationTypeFlag annotation_flag;
2659 CompleteAnnotationHeader header;
2660 CompleteAnnotationParameterSeq member_seq;
2661 };*/
2663{
2664public:
2665
2669 const CompleteAnnotationType& x);
2673 const CompleteAnnotationType& x);
2676
2677 RTPS_DllAPI inline void annotation_flag(
2678 const AnnotationTypeFlag& _annotation_flag)
2679 {
2680 m_annotation_flag = _annotation_flag;
2681 }
2682
2683 RTPS_DllAPI inline void annotation_flag(
2684 AnnotationTypeFlag&& _annotation_flag)
2685 {
2686 m_annotation_flag = std::move(_annotation_flag);
2687 }
2688
2689 RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const
2690 {
2691 return m_annotation_flag;
2692 }
2693
2695 {
2696 return m_annotation_flag;
2697 }
2698
2699 RTPS_DllAPI inline void header(
2700 const CompleteAnnotationHeader& _header)
2701 {
2702 m_header = _header;
2703 }
2704
2705 RTPS_DllAPI inline void header(
2706 CompleteAnnotationHeader&& _header)
2707 {
2708 m_header = std::move(_header);
2709 }
2710
2711 RTPS_DllAPI inline const CompleteAnnotationHeader& header() const
2712 {
2713 return m_header;
2714 }
2715
2716 RTPS_DllAPI inline CompleteAnnotationHeader& header()
2717 {
2718 return m_header;
2719 }
2720
2721 RTPS_DllAPI inline void member_seq(
2722 const CompleteAnnotationParameterSeq& _member_seq)
2723 {
2724 m_member_seq = _member_seq;
2725 }
2726
2727 RTPS_DllAPI inline void member_seq(
2728 CompleteAnnotationParameterSeq&& _member_seq)
2729 {
2730 m_member_seq = std::move(_member_seq);
2731 }
2732
2733 RTPS_DllAPI inline const CompleteAnnotationParameterSeq& member_seq() const
2734 {
2735 return m_member_seq;
2736 }
2737
2739 {
2740 return m_member_seq;
2741 }
2742
2743#ifndef DOXYGEN_SHOULD_SKIP_THIS
2744 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationType::getCdrSerializedSize()",
2745 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2746 RTPS_DllAPI static size_t getCdrSerializedSize(
2747 const CompleteAnnotationType& data,
2748 size_t current_alignment = 0);
2749 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationType::serialize()",
2750 "In favor of version using eprosima::fastcdr::serialize.")
2751 RTPS_DllAPI void serialize(
2752 eprosima::fastcdr::Cdr& cdr) const;
2753 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAnnotationType::deserialize()",
2754 "In favor of version using eprosima::fastcdr::deserialize.")
2755 RTPS_DllAPI void deserialize(
2756 eprosima::fastcdr::Cdr& cdr);
2757#endif // DOXYGEN_SHOULD_SKIP_THIS
2758
2759 RTPS_DllAPI bool operator ==(
2760 const CompleteAnnotationType& other) const;
2761
2762 RTPS_DllAPI bool consistent(
2763 const CompleteAnnotationType& x,
2764 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2765
2766private:
2767
2768 AnnotationTypeFlag m_annotation_flag;
2769 CompleteAnnotationHeader m_header;
2770 CompleteAnnotationParameterSeq m_member_seq;
2771};
2772/*struct MinimalAnnotationType final{
2773 AnnotationTypeFlag annotation_flag;
2774 MinimalAnnotationHeader header;
2775 MinimalAnnotationParameterSeq member_seq;
2776 };*/
2778{
2779public:
2780
2784 const MinimalAnnotationType& x);
2788 const MinimalAnnotationType& x);
2791
2792 RTPS_DllAPI inline void annotation_flag(
2793 const AnnotationTypeFlag& _annotation_flag)
2794 {
2795 m_annotation_flag = _annotation_flag;
2796 }
2797
2798 RTPS_DllAPI inline void annotation_flag(
2799 AnnotationTypeFlag&& _annotation_flag)
2800 {
2801 m_annotation_flag = std::move(_annotation_flag);
2802 }
2803
2804 RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const
2805 {
2806 return m_annotation_flag;
2807 }
2808
2810 {
2811 return m_annotation_flag;
2812 }
2813
2814 RTPS_DllAPI inline void header(
2815 const MinimalAnnotationHeader& _header)
2816 {
2817 m_header = _header;
2818 }
2819
2820 RTPS_DllAPI inline void header(
2821 MinimalAnnotationHeader&& _header)
2822 {
2823 m_header = std::move(_header);
2824 }
2825
2826 RTPS_DllAPI inline const MinimalAnnotationHeader& header() const
2827 {
2828 return m_header;
2829 }
2830
2831 RTPS_DllAPI inline MinimalAnnotationHeader& header()
2832 {
2833 return m_header;
2834 }
2835
2836 RTPS_DllAPI inline void member_seq(
2837 const MinimalAnnotationParameterSeq& _member_seq)
2838 {
2839 m_member_seq = _member_seq;
2840 }
2841
2842 RTPS_DllAPI inline void member_seq(
2843 MinimalAnnotationParameterSeq&& _member_seq)
2844 {
2845 m_member_seq = std::move(_member_seq);
2846 }
2847
2848 RTPS_DllAPI inline const MinimalAnnotationParameterSeq& member_seq() const
2849 {
2850 return m_member_seq;
2851 }
2852
2854 {
2855 return m_member_seq;
2856 }
2857
2858#ifndef DOXYGEN_SHOULD_SKIP_THIS
2859 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationType::getCdrSerializedSize()",
2860 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2861 RTPS_DllAPI static size_t getCdrSerializedSize(
2862 const MinimalAnnotationType& data,
2863 size_t current_alignment = 0);
2864 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationType::serialize()",
2865 "In favor of version using eprosima::fastcdr::serialize.")
2866 RTPS_DllAPI void serialize(
2867 eprosima::fastcdr::Cdr& cdr) const;
2868 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAnnotationType::deserialize()",
2869 "In favor of version using eprosima::fastcdr::deserialize.")
2870 RTPS_DllAPI void deserialize(
2871 eprosima::fastcdr::Cdr& cdr);
2872#endif // DOXYGEN_SHOULD_SKIP_THIS
2873
2874 RTPS_DllAPI bool operator ==(
2875 const MinimalAnnotationType& other) const;
2876
2877 RTPS_DllAPI bool consistent(
2878 const MinimalAnnotationType& x,
2879 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2880
2881private:
2882
2883 AnnotationTypeFlag m_annotation_flag;
2884 MinimalAnnotationHeader m_header;
2885 MinimalAnnotationParameterSeq m_member_seq;
2886};
2887
2888// --- Alias: ---------------------------------------------------------
2889/*struct CommonAliasBody final{
2890 AliasMemberFlag related_flags;
2891 TypeIdentifier related_type;
2892 };*/
2894{
2895public:
2896
2897 RTPS_DllAPI CommonAliasBody();
2898 RTPS_DllAPI ~CommonAliasBody();
2899 RTPS_DllAPI CommonAliasBody(
2900 const CommonAliasBody& x);
2901 RTPS_DllAPI CommonAliasBody(
2902 CommonAliasBody&& x);
2904 const CommonAliasBody& x);
2906 CommonAliasBody&& x);
2907
2908 RTPS_DllAPI inline void related_flags(
2909 const AliasMemberFlag& _related_flags)
2910 {
2911 m_related_flags = _related_flags;
2912 }
2913
2914 RTPS_DllAPI inline void related_flags(
2915 AliasMemberFlag&& _related_flags)
2916 {
2917 m_related_flags = std::move(_related_flags);
2918 }
2919
2920 RTPS_DllAPI inline const AliasMemberFlag& related_flags() const
2921 {
2922 return m_related_flags;
2923 }
2924
2925 RTPS_DllAPI inline AliasMemberFlag& related_flags()
2926 {
2927 return m_related_flags;
2928 }
2929
2930 RTPS_DllAPI inline void related_type(
2931 const TypeIdentifier& _related_type)
2932 {
2933 m_related_type = _related_type;
2934 }
2935
2936 RTPS_DllAPI inline void related_type(
2937 TypeIdentifier&& _related_type)
2938 {
2939 m_related_type = std::move(_related_type);
2940 }
2941
2942 RTPS_DllAPI inline const TypeIdentifier& related_type() const
2943 {
2944 return m_related_type;
2945 }
2946
2947 RTPS_DllAPI inline TypeIdentifier& related_type()
2948 {
2949 return m_related_type;
2950 }
2951
2952#ifndef DOXYGEN_SHOULD_SKIP_THIS
2953 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAliasBody::getCdrSerializedSize()",
2954 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
2955 RTPS_DllAPI static size_t getCdrSerializedSize(
2956 const CommonAliasBody& data,
2957 size_t current_alignment = 0);
2958 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAliasBody::serialize()",
2959 "In favor of version using eprosima::fastcdr::serialize.")
2960 RTPS_DllAPI void serialize(
2961 eprosima::fastcdr::Cdr& cdr) const;
2962 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonAliasBody::deserialize()",
2963 "In favor of version using eprosima::fastcdr::deserialize.")
2964 RTPS_DllAPI void deserialize(
2965 eprosima::fastcdr::Cdr& cdr);
2966#endif // DOXYGEN_SHOULD_SKIP_THIS
2967
2968 RTPS_DllAPI bool operator ==(
2969 const CommonAliasBody& other) const;
2970
2971 // RTPS_DllAPI bool consistent(const CommonAliasBody &x,
2972 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2973
2974private:
2975
2976 AliasMemberFlag m_related_flags;
2977 TypeIdentifier m_related_type;
2978};
2979
2980/*struct CompleteAliasBody {
2981 CommonAliasBody common;
2982 AppliedBuiltinMemberAnnotations ann_builtin; // Optional
2983 AppliedAnnotationSeq ann_custom; // Optional
2984 };*/
2986{
2987public:
2988
2989 RTPS_DllAPI CompleteAliasBody();
2990 RTPS_DllAPI ~CompleteAliasBody();
2992 const CompleteAliasBody& x);
2994 CompleteAliasBody&& x);
2996 const CompleteAliasBody& x);
2998 CompleteAliasBody&& x);
2999
3000 RTPS_DllAPI inline void common(
3001 const CommonAliasBody& _common)
3002 {
3003 m_common = _common;
3004 }
3005
3006 RTPS_DllAPI inline void common(
3007 CommonAliasBody&& _common)
3008 {
3009 m_common = std::move(_common);
3010 }
3011
3012 RTPS_DllAPI inline const CommonAliasBody& common() const
3013 {
3014 return m_common;
3015 }
3016
3017 RTPS_DllAPI inline CommonAliasBody& common()
3018 {
3019 return m_common;
3020 }
3021
3022 RTPS_DllAPI inline void ann_builtin(
3023 const AppliedBuiltinMemberAnnotations& _ann_builtin)
3024 {
3025 m_ann_builtin = _ann_builtin;
3026 }
3027
3028 RTPS_DllAPI inline void ann_builtin(
3029 AppliedBuiltinMemberAnnotations&& _ann_builtin)
3030 {
3031 m_ann_builtin = std::move(_ann_builtin);
3032 }
3033
3034 RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const
3035 {
3036 return m_ann_builtin;
3037 }
3038
3040 {
3041 return m_ann_builtin;
3042 }
3043
3044 RTPS_DllAPI inline void ann_custom(
3045 const AppliedAnnotationSeq& _ann_custom)
3046 {
3047 m_ann_custom = _ann_custom;
3048 }
3049
3050 RTPS_DllAPI inline void ann_custom(
3051 AppliedAnnotationSeq&& _ann_custom)
3052 {
3053 m_ann_custom = std::move(_ann_custom);
3054 }
3055
3056 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
3057 {
3058 return m_ann_custom;
3059 }
3060
3061 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
3062 {
3063 return m_ann_custom;
3064 }
3065
3066#ifndef DOXYGEN_SHOULD_SKIP_THIS
3067 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasBody::getCdrSerializedSize()",
3068 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3069 RTPS_DllAPI static size_t getCdrSerializedSize(
3070 const CompleteAliasBody& data,
3071 size_t current_alignment = 0);
3072 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasBody::serialize()",
3073 "In favor of version using eprosima::fastcdr::serialize.")
3074 RTPS_DllAPI void serialize(
3075 eprosima::fastcdr::Cdr& cdr) const;
3076 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasBody::deserialize()",
3077 "In favor of version using eprosima::fastcdr::deserialize.")
3078 RTPS_DllAPI void deserialize(
3079 eprosima::fastcdr::Cdr& cdr);
3080#endif // DOXYGEN_SHOULD_SKIP_THIS
3081
3082 RTPS_DllAPI bool operator ==(
3083 const CompleteAliasBody& other) const;
3084
3085 // RTPS_DllAPI bool consistent(const CompleteAliasBody &x,
3086 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3087
3088private:
3089
3090 CommonAliasBody m_common;
3091 AppliedBuiltinMemberAnnotations m_ann_builtin;
3092 AppliedAnnotationSeq m_ann_custom;
3093};
3094
3095/*struct MinimalAliasBody {
3096 CommonAliasBody common;
3097 };*/
3099{
3100public:
3101
3102 RTPS_DllAPI MinimalAliasBody();
3103 RTPS_DllAPI ~MinimalAliasBody();
3104 RTPS_DllAPI MinimalAliasBody(
3105 const MinimalAliasBody& x);
3106 RTPS_DllAPI MinimalAliasBody(
3107 MinimalAliasBody&& x);
3109 const MinimalAliasBody& x);
3111 MinimalAliasBody&& x);
3112
3113 RTPS_DllAPI inline void common(
3114 const CommonAliasBody& _common)
3115 {
3116 m_common = _common;
3117 }
3118
3119 RTPS_DllAPI inline void common(
3120 CommonAliasBody&& _common)
3121 {
3122 m_common = std::move(_common);
3123 }
3124
3125 RTPS_DllAPI inline const CommonAliasBody& common() const
3126 {
3127 return m_common;
3128 }
3129
3130 RTPS_DllAPI inline CommonAliasBody& common()
3131 {
3132 return m_common;
3133 }
3134
3135#ifndef DOXYGEN_SHOULD_SKIP_THIS
3136 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasBody::getCdrSerializedSize()",
3137 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3138 RTPS_DllAPI static size_t getCdrSerializedSize(
3139 const MinimalAliasBody& data,
3140 size_t current_alignment = 0);
3141 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasBody::serialize()",
3142 "In favor of version using eprosima::fastcdr::serialize.")
3143 RTPS_DllAPI void serialize(
3144 eprosima::fastcdr::Cdr& cdr) const;
3145 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasBody::deserialize()",
3146 "In favor of version using eprosima::fastcdr::deserialize.")
3147 RTPS_DllAPI void deserialize(
3148 eprosima::fastcdr::Cdr& cdr);
3149#endif // DOXYGEN_SHOULD_SKIP_THIS
3150
3151 RTPS_DllAPI bool operator ==(
3152 const MinimalAliasBody& other) const;
3153
3154 // RTPS_DllAPI bool consistent(const MinimalAliasBody &x,
3155 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3156
3157private:
3158
3159 CommonAliasBody m_common;
3160};
3161
3162/*struct CompleteAliasHeader {
3163 CompleteTypeDetail detail;
3164 };*/
3166{
3167public:
3168
3169 RTPS_DllAPI CompleteAliasHeader();
3172 const CompleteAliasHeader& x);
3176 const CompleteAliasHeader& x);
3179
3180 RTPS_DllAPI inline void detail(
3181 const CompleteTypeDetail& _detail)
3182 {
3183 m_detail = _detail;
3184 }
3185
3186 RTPS_DllAPI inline void detail(
3187 CompleteTypeDetail&& _detail)
3188 {
3189 m_detail = std::move(_detail);
3190 }
3191
3192 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
3193 {
3194 return m_detail;
3195 }
3196
3197 RTPS_DllAPI inline CompleteTypeDetail& detail()
3198 {
3199 return m_detail;
3200 }
3201
3202#ifndef DOXYGEN_SHOULD_SKIP_THIS
3203 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasHeader::getCdrSerializedSize()",
3204 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3205 RTPS_DllAPI static size_t getCdrSerializedSize(
3206 const CompleteAliasHeader& data,
3207 size_t current_alignment = 0);
3208 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasHeader::serialize()",
3209 "In favor of version using eprosima::fastcdr::serialize.")
3210 RTPS_DllAPI void serialize(
3211 eprosima::fastcdr::Cdr& cdr) const;
3212 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasHeader::deserialize()",
3213 "In favor of version using eprosima::fastcdr::deserialize.")
3214 RTPS_DllAPI void deserialize(
3215 eprosima::fastcdr::Cdr& cdr);
3216#endif // DOXYGEN_SHOULD_SKIP_THIS
3217
3218 RTPS_DllAPI bool operator ==(
3219 const CompleteAliasHeader& other) const;
3220
3221 // RTPS_DllAPI bool consistent(const CompleteAliasHeader &x,
3222 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3223
3224private:
3225
3226 CompleteTypeDetail m_detail;
3227};
3228
3229/*struct MinimalAliasHeader {
3230 // Empty. Available for future extension
3231 };*/
3233{
3234public:
3235
3236 RTPS_DllAPI MinimalAliasHeader();
3237 RTPS_DllAPI ~MinimalAliasHeader();
3239 const MinimalAliasHeader& x);
3241 MinimalAliasHeader&& x);
3243 const MinimalAliasHeader& x);
3245 MinimalAliasHeader&& x);
3246
3247#ifndef DOXYGEN_SHOULD_SKIP_THIS
3248 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasHeader::getCdrSerializedSize()",
3249 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3250 RTPS_DllAPI static size_t getCdrSerializedSize(
3251 const MinimalAliasHeader& data,
3252 size_t current_alignment = 0);
3253 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasHeader::serialize()",
3254 "In favor of version using eprosima::fastcdr::serialize.")
3255 RTPS_DllAPI void serialize(
3256 eprosima::fastcdr::Cdr& cdr) const;
3257 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasHeader::deserialize()",
3258 "In favor of version using eprosima::fastcdr::deserialize.")
3259 RTPS_DllAPI void deserialize(
3260 eprosima::fastcdr::Cdr& cdr);
3261#endif // DOXYGEN_SHOULD_SKIP_THIS
3262
3263 RTPS_DllAPI bool operator ==(
3264 const MinimalAliasHeader&) const
3265 {
3266 return true;
3267 }
3268
3269 // RTPS_DllAPI bool consistent(const MinimalAliasHeader &x,
3270 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3271
3272private:
3273
3274};
3275
3276/*struct CompleteAliasType final{
3277 AliasTypeFlag alias_flags;
3278 CompleteAliasHeader header;
3279 CompleteAliasBody body;
3280 };*/
3282{
3283public:
3284
3285 RTPS_DllAPI CompleteAliasType();
3286 RTPS_DllAPI ~CompleteAliasType();
3288 const CompleteAliasType& x);
3290 CompleteAliasType&& x);
3292 const CompleteAliasType& x);
3294 CompleteAliasType&& x);
3295
3296 RTPS_DllAPI inline void alias_flags(
3297 const AliasTypeFlag& _alias_flags)
3298 {
3299 m_alias_flags = _alias_flags;
3300 }
3301
3302 RTPS_DllAPI inline void alias_flags(
3303 AliasTypeFlag&& _alias_flags)
3304 {
3305 m_alias_flags = std::move(_alias_flags);
3306 }
3307
3308 RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const
3309 {
3310 return m_alias_flags;
3311 }
3312
3313 RTPS_DllAPI inline AliasTypeFlag& alias_flags()
3314 {
3315 return m_alias_flags;
3316 }
3317
3318 RTPS_DllAPI inline void header(
3319 const CompleteAliasHeader& _header)
3320 {
3321 m_header = _header;
3322 }
3323
3324 RTPS_DllAPI inline void header(
3325 CompleteAliasHeader&& _header)
3326 {
3327 m_header = std::move(_header);
3328 }
3329
3330 RTPS_DllAPI inline const CompleteAliasHeader& header() const
3331 {
3332 return m_header;
3333 }
3334
3335 RTPS_DllAPI inline CompleteAliasHeader& header()
3336 {
3337 return m_header;
3338 }
3339
3340 RTPS_DllAPI inline void body(
3341 const CompleteAliasBody& _body)
3342 {
3343 m_body = _body;
3344 }
3345
3346 RTPS_DllAPI inline void body(
3347 CompleteAliasBody&& _body)
3348 {
3349 m_body = std::move(_body);
3350 }
3351
3352 RTPS_DllAPI inline const CompleteAliasBody& body() const
3353 {
3354 return m_body;
3355 }
3356
3357 RTPS_DllAPI inline CompleteAliasBody& body()
3358 {
3359 return m_body;
3360 }
3361
3362#ifndef DOXYGEN_SHOULD_SKIP_THIS
3363 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasType::getCdrSerializedSize()",
3364 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3365 RTPS_DllAPI static size_t getCdrSerializedSize(
3366 const CompleteAliasType& data,
3367 size_t current_alignment = 0);
3368 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasType::serialize()",
3369 "In favor of version using eprosima::fastcdr::serialize.")
3370 RTPS_DllAPI void serialize(
3371 eprosima::fastcdr::Cdr& cdr) const;
3372 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteAliasType::deserialize()",
3373 "In favor of version using eprosima::fastcdr::deserialize.")
3374 RTPS_DllAPI void deserialize(
3375 eprosima::fastcdr::Cdr& cdr);
3376#endif // DOXYGEN_SHOULD_SKIP_THIS
3377
3378 RTPS_DllAPI bool operator ==(
3379 const CompleteAliasType& other) const;
3380
3381 // RTPS_DllAPI bool consistent(const CompleteAliasType &x,
3382 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3383
3384private:
3385
3386 AliasTypeFlag m_alias_flags;
3387 CompleteAliasHeader m_header;
3388 CompleteAliasBody m_body;
3389};
3390/*struct MinimalAliasType final{
3391 AliasTypeFlag alias_flags;
3392 MinimalAliasHeader header;
3393 MinimalAliasBody body;
3394 };*/
3396{
3397public:
3398
3399 RTPS_DllAPI MinimalAliasType();
3400 RTPS_DllAPI ~MinimalAliasType();
3401 RTPS_DllAPI MinimalAliasType(
3402 const MinimalAliasType& x);
3403 RTPS_DllAPI MinimalAliasType(
3404 MinimalAliasType&& x);
3406 const MinimalAliasType& x);
3408 MinimalAliasType&& x);
3409
3410 RTPS_DllAPI inline void alias_flags(
3411 const AliasTypeFlag& _alias_flags)
3412 {
3413 m_alias_flags = _alias_flags;
3414 }
3415
3416 RTPS_DllAPI inline void alias_flags(
3417 AliasTypeFlag&& _alias_flags)
3418 {
3419 m_alias_flags = std::move(_alias_flags);
3420 }
3421
3422 RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const
3423 {
3424 return m_alias_flags;
3425 }
3426
3427 RTPS_DllAPI inline AliasTypeFlag& alias_flags()
3428 {
3429 return m_alias_flags;
3430 }
3431
3432 RTPS_DllAPI inline void header(
3433 const MinimalAliasHeader& _header)
3434 {
3435 m_header = _header;
3436 }
3437
3438 RTPS_DllAPI inline void header(
3439 MinimalAliasHeader&& _header)
3440 {
3441 m_header = std::move(_header);
3442 }
3443
3444 RTPS_DllAPI inline const MinimalAliasHeader& header() const
3445 {
3446 return m_header;
3447 }
3448
3449 RTPS_DllAPI inline MinimalAliasHeader& header()
3450 {
3451 return m_header;
3452 }
3453
3454 RTPS_DllAPI inline void body(
3455 const MinimalAliasBody& _body)
3456 {
3457 m_body = _body;
3458 }
3459
3460 RTPS_DllAPI inline void body(
3461 MinimalAliasBody&& _body)
3462 {
3463 m_body = std::move(_body);
3464 }
3465
3466 RTPS_DllAPI inline const MinimalAliasBody& body() const
3467 {
3468 return m_body;
3469 }
3470
3471 RTPS_DllAPI inline MinimalAliasBody& body()
3472 {
3473 return m_body;
3474 }
3475
3476#ifndef DOXYGEN_SHOULD_SKIP_THIS
3477 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasType::getCdrSerializedSize()",
3478 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3479 RTPS_DllAPI static size_t getCdrSerializedSize(
3480 const MinimalAliasType& data,
3481 size_t current_alignment = 0);
3482 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasType::serialize()",
3483 "In favor of version using eprosima::fastcdr::serialize.")
3484 RTPS_DllAPI void serialize(
3485 eprosima::fastcdr::Cdr& cdr) const;
3486 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalAliasType::deserialize()",
3487 "In favor of version using eprosima::fastcdr::deserialize.")
3488 RTPS_DllAPI void deserialize(
3489 eprosima::fastcdr::Cdr& cdr);
3490#endif // DOXYGEN_SHOULD_SKIP_THIS
3491
3492 RTPS_DllAPI bool operator ==(
3493 const MinimalAliasType& other) const;
3494
3495 // RTPS_DllAPI bool consistent(const MinimalAliasType &x,
3496 // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3497
3498private:
3499
3500 AliasTypeFlag m_alias_flags;
3501 MinimalAliasHeader m_header;
3502 MinimalAliasBody m_body;
3503};
3504
3505// --- Collections: ---------------------------------------------------
3506/*struct CompleteElementDetail final{
3507 AppliedBuiltinMemberAnnotations ann_builtin; // Optional
3508 AppliedAnnotationSeq ann_custom; // Optional
3509 };*/
3511{
3512public:
3513
3517 const CompleteElementDetail& x);
3521 const CompleteElementDetail& x);
3524
3525 RTPS_DllAPI inline void ann_builtin(
3526 const AppliedBuiltinMemberAnnotations& _ann_builtin)
3527 {
3528 m_ann_builtin = _ann_builtin;
3529 }
3530
3531 RTPS_DllAPI inline void ann_builtin(
3532 AppliedBuiltinMemberAnnotations&& _ann_builtin)
3533 {
3534 m_ann_builtin = std::move(_ann_builtin);
3535 }
3536
3537 RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const
3538 {
3539 return m_ann_builtin;
3540 }
3541
3543 {
3544 return m_ann_builtin;
3545 }
3546
3547 RTPS_DllAPI inline void ann_custom(
3548 const AppliedAnnotationSeq& _ann_custom)
3549 {
3550 m_ann_custom = _ann_custom;
3551 }
3552
3553 RTPS_DllAPI inline void ann_custom(
3554 AppliedAnnotationSeq&& _ann_custom)
3555 {
3556 m_ann_custom = std::move(_ann_custom);
3557 }
3558
3559 RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const
3560 {
3561 return m_ann_custom;
3562 }
3563
3564 RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom()
3565 {
3566 return m_ann_custom;
3567 }
3568
3569#ifndef DOXYGEN_SHOULD_SKIP_THIS
3570 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteElementDetail::getCdrSerializedSize()",
3571 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3572 RTPS_DllAPI static size_t getCdrSerializedSize(
3573 const CompleteElementDetail& data,
3574 size_t current_alignment = 0);
3575 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteElementDetail::serialize()",
3576 "In favor of version using eprosima::fastcdr::serialize.")
3577 RTPS_DllAPI void serialize(
3578 eprosima::fastcdr::Cdr& cdr) const;
3579 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteElementDetail::deserialize()",
3580 "In favor of version using eprosima::fastcdr::deserialize.")
3581 RTPS_DllAPI void deserialize(
3582 eprosima::fastcdr::Cdr& cdr);
3583#endif // DOXYGEN_SHOULD_SKIP_THIS
3584
3585 RTPS_DllAPI bool operator ==(
3586 const CompleteElementDetail& other) const;
3587
3588 RTPS_DllAPI bool consistent(
3589 const CompleteElementDetail& x,
3590 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3591
3592private:
3593
3594 AppliedBuiltinMemberAnnotations m_ann_builtin;
3595 AppliedAnnotationSeq m_ann_custom;
3596};
3597/*struct CommonCollectionElement final{
3598 CollectionElementFlag element_flags;
3599 TypeIdentifier type;
3600 };*/
3602{
3603public:
3604
3608 const CommonCollectionElement& x);
3612 const CommonCollectionElement& x);
3615
3616 RTPS_DllAPI inline void element_flags(
3617 const CollectionElementFlag& _element_flags)
3618 {
3619 m_element_flags = _element_flags;
3620 }
3621
3622 RTPS_DllAPI inline void element_flags(
3623 CollectionElementFlag&& _element_flags)
3624 {
3625 m_element_flags = std::move(_element_flags);
3626 }
3627
3628 RTPS_DllAPI inline const CollectionElementFlag& element_flags() const
3629 {
3630 return m_element_flags;
3631 }
3632
3634 {
3635 return m_element_flags;
3636 }
3637
3638 RTPS_DllAPI inline void type(
3639 const TypeIdentifier& _type)
3640 {
3641 m_type = _type;
3642 }
3643
3644 RTPS_DllAPI inline void type(
3645 TypeIdentifier&& _type)
3646 {
3647 m_type = std::move(_type);
3648 }
3649
3650 RTPS_DllAPI inline const TypeIdentifier& type() const
3651 {
3652 return m_type;
3653 }
3654
3655 RTPS_DllAPI inline TypeIdentifier& type()
3656 {
3657 return m_type;
3658 }
3659
3660#ifndef DOXYGEN_SHOULD_SKIP_THIS
3661 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionElement::getCdrSerializedSize()",
3662 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3663 RTPS_DllAPI static size_t getCdrSerializedSize(
3664 const CommonCollectionElement& data,
3665 size_t current_alignment = 0);
3666 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionElement::serialize()",
3667 "In favor of version using eprosima::fastcdr::serialize.")
3668 RTPS_DllAPI void serialize(
3669 eprosima::fastcdr::Cdr& cdr) const;
3670 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionElement::deserialize()",
3671 "In favor of version using eprosima::fastcdr::deserialize.")
3672 RTPS_DllAPI void deserialize(
3673 eprosima::fastcdr::Cdr& cdr);
3674#endif // DOXYGEN_SHOULD_SKIP_THIS
3675
3676 RTPS_DllAPI bool operator ==(
3677 const CommonCollectionElement& other) const;
3678
3679 RTPS_DllAPI bool consistent(
3680 const CommonCollectionElement& x,
3681 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3682
3683private:
3684
3685 CollectionElementFlag m_element_flags;
3686 TypeIdentifier m_type;
3687};
3688
3689/*struct CompleteCollectionElement {
3690 CommonCollectionElement common;
3691 CompleteElementDetail detail;
3692 };*/
3694{
3695public:
3696
3700 const CompleteCollectionElement& x);
3704 const CompleteCollectionElement& x);
3707
3708 RTPS_DllAPI inline void common(
3709 const CommonCollectionElement& _common)
3710 {
3711 m_common = _common;
3712 }
3713
3714 RTPS_DllAPI inline void common(
3715 CommonCollectionElement&& _common)
3716 {
3717 m_common = std::move(_common);
3718 }
3719
3720 RTPS_DllAPI inline const CommonCollectionElement& common() const
3721 {
3722 return m_common;
3723 }
3724
3725 RTPS_DllAPI inline CommonCollectionElement& common()
3726 {
3727 return m_common;
3728 }
3729
3730 RTPS_DllAPI inline void detail(
3731 const CompleteElementDetail& _detail)
3732 {
3733 m_detail = _detail;
3734 }
3735
3736 RTPS_DllAPI inline void detail(
3737 CompleteElementDetail&& _detail)
3738 {
3739 m_detail = std::move(_detail);
3740 }
3741
3742 RTPS_DllAPI inline const CompleteElementDetail& detail() const
3743 {
3744 return m_detail;
3745 }
3746
3747 RTPS_DllAPI inline CompleteElementDetail& detail()
3748 {
3749 return m_detail;
3750 }
3751
3752#ifndef DOXYGEN_SHOULD_SKIP_THIS
3753 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionElement::getCdrSerializedSize()",
3754 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3755 RTPS_DllAPI static size_t getCdrSerializedSize(
3756 const CompleteCollectionElement& data,
3757 size_t current_alignment = 0);
3758 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionElement::serialize()",
3759 "In favor of version using eprosima::fastcdr::serialize.")
3760 RTPS_DllAPI void serialize(
3761 eprosima::fastcdr::Cdr& cdr) const;
3762 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionElement::deserialize()",
3763 "In favor of version using eprosima::fastcdr::deserialize.")
3764 RTPS_DllAPI void deserialize(
3765 eprosima::fastcdr::Cdr& cdr);
3766#endif // DOXYGEN_SHOULD_SKIP_THIS
3767
3768 RTPS_DllAPI bool operator ==(
3769 const CompleteCollectionElement& other) const;
3770
3771 RTPS_DllAPI bool consistent(
3773 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3774
3775private:
3776
3777 CommonCollectionElement m_common;
3778 CompleteElementDetail m_detail;
3779};
3780
3781/*struct MinimalCollectionElement {
3782 CommonCollectionElement common;
3783 };*/
3785{
3786public:
3787
3791 const MinimalCollectionElement& x);
3795 const MinimalCollectionElement& x);
3798
3799 RTPS_DllAPI inline void common(
3800 const CommonCollectionElement& _common)
3801 {
3802 m_common = _common;
3803 }
3804
3805 RTPS_DllAPI inline void common(
3806 CommonCollectionElement&& _common)
3807 {
3808 m_common = std::move(_common);
3809 }
3810
3811 RTPS_DllAPI inline const CommonCollectionElement& common() const
3812 {
3813 return m_common;
3814 }
3815
3816 RTPS_DllAPI inline CommonCollectionElement& common()
3817 {
3818 return m_common;
3819 }
3820
3821#ifndef DOXYGEN_SHOULD_SKIP_THIS
3822 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionElement::getCdrSerializedSize()",
3823 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3824 RTPS_DllAPI static size_t getCdrSerializedSize(
3825 const MinimalCollectionElement& data,
3826 size_t current_alignment = 0);
3827 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionElement::serialize()",
3828 "In favor of version using eprosima::fastcdr::serialize.")
3829 RTPS_DllAPI void serialize(
3830 eprosima::fastcdr::Cdr& cdr) const;
3831 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionElement::deserialize()",
3832 "In favor of version using eprosima::fastcdr::deserialize.")
3833 RTPS_DllAPI void deserialize(
3834 eprosima::fastcdr::Cdr& cdr);
3835#endif // DOXYGEN_SHOULD_SKIP_THIS
3836
3837 RTPS_DllAPI bool operator ==(
3838 const MinimalCollectionElement& other) const;
3839
3840 RTPS_DllAPI bool consistent(
3841 const MinimalCollectionElement& x,
3842 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3843
3844private:
3845
3846 CommonCollectionElement m_common;
3847};
3848
3849/*struct CommonCollectionHeader final{
3850 LBound bound;
3851 };*/
3853{
3854public:
3855
3859 const CommonCollectionHeader& x);
3863 const CommonCollectionHeader& x);
3866
3867 RTPS_DllAPI inline void bound(
3868 const LBound& _bound)
3869 {
3870 m_bound = _bound;
3871 }
3872
3873 RTPS_DllAPI inline void bound(
3874 LBound&& _bound)
3875 {
3876 m_bound = std::move(_bound);
3877 }
3878
3879 RTPS_DllAPI inline const LBound& bound() const
3880 {
3881 return m_bound;
3882 }
3883
3884 RTPS_DllAPI inline LBound& bound()
3885 {
3886 return m_bound;
3887 }
3888
3889#ifndef DOXYGEN_SHOULD_SKIP_THIS
3890 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionHeader::getCdrSerializedSize()",
3891 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3892 RTPS_DllAPI static size_t getCdrSerializedSize(
3893 const CommonCollectionHeader& data,
3894 size_t current_alignment = 0);
3895 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionHeader::serialize()",
3896 "In favor of version using eprosima::fastcdr::serialize.")
3897 RTPS_DllAPI void serialize(
3898 eprosima::fastcdr::Cdr& cdr) const;
3899 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonCollectionHeader::deserialize()",
3900 "In favor of version using eprosima::fastcdr::deserialize.")
3901 RTPS_DllAPI void deserialize(
3902 eprosima::fastcdr::Cdr& cdr);
3903#endif // DOXYGEN_SHOULD_SKIP_THIS
3904
3905 RTPS_DllAPI bool operator ==(
3906 const CommonCollectionHeader& other) const;
3907
3908 RTPS_DllAPI bool consistent(
3909 const CommonCollectionHeader& x,
3910 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3911
3912private:
3913
3914 LBound m_bound;
3915};
3916
3917/*struct CompleteCollectionHeader {
3918 CommonCollectionHeader common;
3919 CompleteTypeDetail detail; // Optional // not present for anonymous
3920 };*/
3922{
3923public:
3924
3928 const CompleteCollectionHeader& x);
3932 const CompleteCollectionHeader& x);
3935
3936 RTPS_DllAPI inline void common(
3937 const CommonCollectionHeader& _common)
3938 {
3939 m_common = _common;
3940 }
3941
3942 RTPS_DllAPI inline void common(
3943 CommonCollectionHeader&& _common)
3944 {
3945 m_common = std::move(_common);
3946 }
3947
3948 RTPS_DllAPI inline const CommonCollectionHeader& common() const
3949 {
3950 return m_common;
3951 }
3952
3953 RTPS_DllAPI inline CommonCollectionHeader& common()
3954 {
3955 return m_common;
3956 }
3957
3958 RTPS_DllAPI inline void detail(
3959 const CompleteTypeDetail& _detail)
3960 {
3961 m_detail = _detail;
3962 }
3963
3964 RTPS_DllAPI inline void detail(
3965 CompleteTypeDetail&& _detail)
3966 {
3967 m_detail = std::move(_detail);
3968 }
3969
3970 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
3971 {
3972 return m_detail;
3973 }
3974
3975 RTPS_DllAPI inline CompleteTypeDetail& detail()
3976 {
3977 return m_detail;
3978 }
3979
3980#ifndef DOXYGEN_SHOULD_SKIP_THIS
3981 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionHeader::getCdrSerializedSize()",
3982 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
3983 RTPS_DllAPI static size_t getCdrSerializedSize(
3984 const CompleteCollectionHeader& data,
3985 size_t current_alignment = 0);
3986 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionHeader::serialize()",
3987 "In favor of version using eprosima::fastcdr::serialize.")
3988 RTPS_DllAPI void serialize(
3989 eprosima::fastcdr::Cdr& cdr) const;
3990 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteCollectionHeader::deserialize()",
3991 "In favor of version using eprosima::fastcdr::deserialize.")
3992 RTPS_DllAPI void deserialize(
3993 eprosima::fastcdr::Cdr& cdr);
3994#endif // DOXYGEN_SHOULD_SKIP_THIS
3995
3996 RTPS_DllAPI bool operator ==(
3997 const CompleteCollectionHeader& other) const;
3998
3999 RTPS_DllAPI bool consistent(
4000 const CompleteCollectionHeader& x,
4001 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4002
4003private:
4004
4005 CommonCollectionHeader m_common;
4006 CompleteTypeDetail m_detail;
4007};
4008
4009/*struct MinimalCollectionHeader {
4010 CommonCollectionHeader common;
4011 };*/
4013{
4014public:
4015
4019 const MinimalCollectionHeader& x);
4023 const MinimalCollectionHeader& x);
4026
4027 RTPS_DllAPI inline void common(
4028 const CommonCollectionHeader& _common)
4029 {
4030 m_common = _common;
4031 }
4032
4033 RTPS_DllAPI inline void common(
4034 CommonCollectionHeader&& _common)
4035 {
4036 m_common = std::move(_common);
4037 }
4038
4039 RTPS_DllAPI inline const CommonCollectionHeader& common() const
4040 {
4041 return m_common;
4042 }
4043
4044 RTPS_DllAPI inline CommonCollectionHeader& common()
4045 {
4046 return m_common;
4047 }
4048
4049#ifndef DOXYGEN_SHOULD_SKIP_THIS
4050 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionHeader::getCdrSerializedSize()",
4051 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4052 RTPS_DllAPI static size_t getCdrSerializedSize(
4053 const MinimalCollectionHeader& data,
4054 size_t current_alignment = 0);
4055 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionHeader::serialize()",
4056 "In favor of version using eprosima::fastcdr::serialize.")
4057 RTPS_DllAPI void serialize(
4058 eprosima::fastcdr::Cdr& cdr) const;
4059 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalCollectionHeader::deserialize()",
4060 "In favor of version using eprosima::fastcdr::deserialize.")
4061 RTPS_DllAPI void deserialize(
4062 eprosima::fastcdr::Cdr& cdr);
4063#endif // DOXYGEN_SHOULD_SKIP_THIS
4064
4065 RTPS_DllAPI bool operator ==(
4066 const MinimalCollectionHeader& other) const;
4067
4068 RTPS_DllAPI bool consistent(
4069 const MinimalCollectionHeader& x,
4070 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4071
4072private:
4073
4074 CommonCollectionHeader m_common;
4075};
4076
4077// --- Sequence: -----------------------------------------------------
4078/*struct CompleteSequenceType final{
4079 CollectionTypeFlag collection_flag;
4080 CompleteCollectionHeader header;
4081 CompleteCollectionElement element;
4082 };*/
4084{
4085public:
4086
4090 const CompleteSequenceType& x);
4094 const CompleteSequenceType& x);
4097
4098 RTPS_DllAPI inline void collection_flag(
4099 const CollectionTypeFlag& _collection_flag)
4100 {
4101 m_collection_flag = _collection_flag;
4102 }
4103
4104 RTPS_DllAPI inline void collection_flag(
4105 CollectionTypeFlag&& _collection_flag)
4106 {
4107 m_collection_flag = std::move(_collection_flag);
4108 }
4109
4110 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4111 {
4112 return m_collection_flag;
4113 }
4114
4116 {
4117 return m_collection_flag;
4118 }
4119
4120 RTPS_DllAPI inline void header(
4121 const CompleteCollectionHeader& _header)
4122 {
4123 m_header = _header;
4124 }
4125
4126 RTPS_DllAPI inline void header(
4127 CompleteCollectionHeader&& _header)
4128 {
4129 m_header = std::move(_header);
4130 }
4131
4132 RTPS_DllAPI inline const CompleteCollectionHeader& header() const
4133 {
4134 return m_header;
4135 }
4136
4137 RTPS_DllAPI inline CompleteCollectionHeader& header()
4138 {
4139 return m_header;
4140 }
4141
4142 RTPS_DllAPI inline void element(
4143 const CompleteCollectionElement& _element)
4144 {
4145 m_element = _element;
4146 }
4147
4148 RTPS_DllAPI inline void element(
4149 CompleteCollectionElement&& _element)
4150 {
4151 m_element = std::move(_element);
4152 }
4153
4154 RTPS_DllAPI inline const CompleteCollectionElement& element() const
4155 {
4156 return m_element;
4157 }
4158
4160 {
4161 return m_element;
4162 }
4163
4164#ifndef DOXYGEN_SHOULD_SKIP_THIS
4165 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteSequenceType::getCdrSerializedSize()",
4166 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4167 RTPS_DllAPI static size_t getCdrSerializedSize(
4168 const CompleteSequenceType& data,
4169 size_t current_alignment = 0);
4170 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteSequenceType::serialize()",
4171 "In favor of version using eprosima::fastcdr::serialize.")
4172 RTPS_DllAPI void serialize(
4173 eprosima::fastcdr::Cdr& cdr) const;
4174 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteSequenceType::deserialize()",
4175 "In favor of version using eprosima::fastcdr::deserialize.")
4176 RTPS_DllAPI void deserialize(
4177 eprosima::fastcdr::Cdr& cdr);
4178#endif // DOXYGEN_SHOULD_SKIP_THIS
4179
4180 RTPS_DllAPI bool operator ==(
4181 const CompleteSequenceType& other) const;
4182
4183 RTPS_DllAPI bool consistent(
4184 const CompleteSequenceType& x,
4185 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4186
4187private:
4188
4189 CollectionTypeFlag m_collection_flag;
4190 CompleteCollectionHeader m_header;
4191 CompleteCollectionElement m_element;
4192};
4193
4194/*struct MinimalSequenceType final{
4195 CollectionTypeFlag collection_flag;
4196 MinimalCollectionHeader header;
4197 MinimalCollectionElement element;
4198 };*/
4200{
4201public:
4202
4203 RTPS_DllAPI MinimalSequenceType();
4206 const MinimalSequenceType& x);
4210 const MinimalSequenceType& x);
4213
4214 RTPS_DllAPI inline void collection_flag(
4215 const CollectionTypeFlag& _collection_flag)
4216 {
4217 m_collection_flag = _collection_flag;
4218 }
4219
4220 RTPS_DllAPI inline void collection_flag(
4221 CollectionTypeFlag&& _collection_flag)
4222 {
4223 m_collection_flag = std::move(_collection_flag);
4224 }
4225
4226 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4227 {
4228 return m_collection_flag;
4229 }
4230
4232 {
4233 return m_collection_flag;
4234 }
4235
4236 RTPS_DllAPI inline void header(
4237 const MinimalCollectionHeader& _header)
4238 {
4239 m_header = _header;
4240 }
4241
4242 RTPS_DllAPI inline void header(
4243 MinimalCollectionHeader&& _header)
4244 {
4245 m_header = std::move(_header);
4246 }
4247
4248 RTPS_DllAPI inline const MinimalCollectionHeader& header() const
4249 {
4250 return m_header;
4251 }
4252
4253 RTPS_DllAPI inline MinimalCollectionHeader& header()
4254 {
4255 return m_header;
4256 }
4257
4258 RTPS_DllAPI inline void element(
4259 const MinimalCollectionElement& _element)
4260 {
4261 m_element = _element;
4262 }
4263
4264 RTPS_DllAPI inline void element(
4265 MinimalCollectionElement&& _element)
4266 {
4267 m_element = std::move(_element);
4268 }
4269
4270 RTPS_DllAPI inline const MinimalCollectionElement& element() const
4271 {
4272 return m_element;
4273 }
4274
4275 RTPS_DllAPI inline MinimalCollectionElement& element()
4276 {
4277 return m_element;
4278 }
4279
4280#ifndef DOXYGEN_SHOULD_SKIP_THIS
4281 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalSequenceType::getCdrSerializedSize()",
4282 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4283 RTPS_DllAPI static size_t getCdrSerializedSize(
4284 const MinimalSequenceType& data,
4285 size_t current_alignment = 0);
4286 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalSequenceType::serialize()",
4287 "In favor of version using eprosima::fastcdr::serialize.")
4288 RTPS_DllAPI void serialize(
4289 eprosima::fastcdr::Cdr& cdr) const;
4290 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalSequenceType::deserialize()",
4291 "In favor of version using eprosima::fastcdr::deserialize.")
4292 RTPS_DllAPI void deserialize(
4293 eprosima::fastcdr::Cdr& cdr);
4294#endif // DOXYGEN_SHOULD_SKIP_THIS
4295
4296 RTPS_DllAPI bool operator ==(
4297 const MinimalSequenceType& other) const;
4298
4299 RTPS_DllAPI bool consistent(
4300 const MinimalSequenceType& x,
4301 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4302
4303private:
4304
4305 CollectionTypeFlag m_collection_flag;
4306 MinimalCollectionHeader m_header;
4307 MinimalCollectionElement m_element;
4308};
4309
4310// --- Array: -----------------------------------------------------
4311/*struct CommonArrayHeader final{
4312 LBoundSeq bound_seq;
4313 };*/
4315{
4316public:
4317
4318 RTPS_DllAPI CommonArrayHeader();
4319 RTPS_DllAPI ~CommonArrayHeader();
4321 const CommonArrayHeader& x);
4323 CommonArrayHeader&& x);
4325 const CommonArrayHeader& x);
4327 CommonArrayHeader&& x);
4328
4329 RTPS_DllAPI inline void bound_seq(
4330 const LBoundSeq& _bound_seq)
4331 {
4332 m_bound_seq = _bound_seq;
4333 }
4334
4335 RTPS_DllAPI inline void bound_seq(
4336 LBoundSeq&& _bound_seq)
4337 {
4338 m_bound_seq = std::move(_bound_seq);
4339 }
4340
4341 RTPS_DllAPI inline const LBoundSeq& bound_seq() const
4342 {
4343 return m_bound_seq;
4344 }
4345
4346 RTPS_DllAPI inline LBoundSeq& bound_seq()
4347 {
4348 return m_bound_seq;
4349 }
4350
4351#ifndef DOXYGEN_SHOULD_SKIP_THIS
4352 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonArrayHeader::getCdrSerializedSize()",
4353 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4354 RTPS_DllAPI static size_t getCdrSerializedSize(
4355 const CommonArrayHeader& data,
4356 size_t current_alignment = 0);
4357 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonArrayHeader::serialize()",
4358 "In favor of version using eprosima::fastcdr::serialize.")
4359 RTPS_DllAPI void serialize(
4360 eprosima::fastcdr::Cdr& cdr) const;
4361 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonArrayHeader::deserialize()",
4362 "In favor of version using eprosima::fastcdr::deserialize.")
4363 RTPS_DllAPI void deserialize(
4364 eprosima::fastcdr::Cdr& cdr);
4365#endif // DOXYGEN_SHOULD_SKIP_THIS
4366
4367 RTPS_DllAPI bool operator ==(
4368 const CommonArrayHeader& other) const;
4369
4370 RTPS_DllAPI bool consistent(
4371 const CommonArrayHeader& x,
4372 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4373
4374private:
4375
4376 LBoundSeq m_bound_seq;
4377};
4378
4379/*struct CompleteArrayHeader {
4380 CommonArrayHeader common;
4381 CompleteTypeDetail detail;
4382 };*/
4384{
4385public:
4386
4387 RTPS_DllAPI CompleteArrayHeader();
4390 const CompleteArrayHeader& x);
4394 const CompleteArrayHeader& x);
4397
4398 RTPS_DllAPI inline void common(
4399 const CommonArrayHeader& _common)
4400 {
4401 m_common = _common;
4402 }
4403
4404 RTPS_DllAPI inline void common(
4405 CommonArrayHeader&& _common)
4406 {
4407 m_common = std::move(_common);
4408 }
4409
4410 RTPS_DllAPI inline const CommonArrayHeader& common() const
4411 {
4412 return m_common;
4413 }
4414
4415 RTPS_DllAPI inline CommonArrayHeader& common()
4416 {
4417 return m_common;
4418 }
4419
4420 RTPS_DllAPI inline void detail(
4421 const CompleteTypeDetail& _detail)
4422 {
4423 m_detail = _detail;
4424 }
4425
4426 RTPS_DllAPI inline void detail(
4427 CompleteTypeDetail&& _detail)
4428 {
4429 m_detail = std::move(_detail);
4430 }
4431
4432 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
4433 {
4434 return m_detail;
4435 }
4436
4437 RTPS_DllAPI inline CompleteTypeDetail& detail()
4438 {
4439 return m_detail;
4440 }
4441
4442#ifndef DOXYGEN_SHOULD_SKIP_THIS
4443 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayHeader::getCdrSerializedSize()",
4444 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4445 RTPS_DllAPI static size_t getCdrSerializedSize(
4446 const CompleteArrayHeader& data,
4447 size_t current_alignment = 0);
4448 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayHeader::serialize()",
4449 "In favor of version using eprosima::fastcdr::serialize.")
4450 RTPS_DllAPI void serialize(
4451 eprosima::fastcdr::Cdr& cdr) const;
4452 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayHeader::deserialize()",
4453 "In favor of version using eprosima::fastcdr::deserialize.")
4454 RTPS_DllAPI void deserialize(
4455 eprosima::fastcdr::Cdr& cdr);
4456#endif // DOXYGEN_SHOULD_SKIP_THIS
4457
4458 RTPS_DllAPI bool operator ==(
4459 const CompleteArrayHeader& other) const;
4460
4461 RTPS_DllAPI bool consistent(
4462 const CompleteArrayHeader& x,
4463 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4464
4465private:
4466
4467 CommonArrayHeader m_common;
4468 CompleteTypeDetail m_detail;
4469};
4470
4471/*struct MinimalArrayHeader {
4472 CommonArrayHeader common;
4473 };*/
4475{
4476public:
4477
4478 RTPS_DllAPI MinimalArrayHeader();
4479 RTPS_DllAPI ~MinimalArrayHeader();
4481 const MinimalArrayHeader& x);
4483 MinimalArrayHeader&& x);
4485 const MinimalArrayHeader& x);
4487 MinimalArrayHeader&& x);
4488
4489 RTPS_DllAPI inline void common(
4490 const CommonArrayHeader& _common)
4491 {
4492 m_common = _common;
4493 }
4494
4495 RTPS_DllAPI inline void common(
4496 CommonArrayHeader&& _common)
4497 {
4498 m_common = std::move(_common);
4499 }
4500
4501 RTPS_DllAPI inline const CommonArrayHeader& common() const
4502 {
4503 return m_common;
4504 }
4505
4506 RTPS_DllAPI inline CommonArrayHeader& common()
4507 {
4508 return m_common;
4509 }
4510
4511#ifndef DOXYGEN_SHOULD_SKIP_THIS
4512 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayHeader::getCdrSerializedSize()",
4513 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4514 RTPS_DllAPI static size_t getCdrSerializedSize(
4515 const MinimalArrayHeader& data,
4516 size_t current_alignment = 0);
4517 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayHeader::serialize()",
4518 "In favor of version using eprosima::fastcdr::serialize.")
4519 RTPS_DllAPI void serialize(
4520 eprosima::fastcdr::Cdr& cdr) const;
4521 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayHeader::deserialize()",
4522 "In favor of version using eprosima::fastcdr::deserialize.")
4523 RTPS_DllAPI void deserialize(
4524 eprosima::fastcdr::Cdr& cdr);
4525#endif // DOXYGEN_SHOULD_SKIP_THIS
4526
4527 RTPS_DllAPI bool operator ==(
4528 const MinimalArrayHeader& other) const;
4529
4530 RTPS_DllAPI bool consistent(
4531 const MinimalArrayHeader& x,
4532 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4533
4534private:
4535
4536 CommonArrayHeader m_common;
4537};
4538
4539/*struct CompleteArrayType {
4540 CollectionTypeFlag collection_flag;
4541 CompleteArrayHeader header;
4542 CompleteCollectionElement element;
4543 };*/
4545{
4546public:
4547
4548 RTPS_DllAPI CompleteArrayType();
4549 RTPS_DllAPI ~CompleteArrayType();
4551 const CompleteArrayType& x);
4553 CompleteArrayType&& x);
4555 const CompleteArrayType& x);
4557 CompleteArrayType&& x);
4558
4559 RTPS_DllAPI inline void collection_flag(
4560 const CollectionTypeFlag& _collection_flag)
4561 {
4562 m_collection_flag = _collection_flag;
4563 }
4564
4565 RTPS_DllAPI inline void collection_flag(
4566 CollectionTypeFlag&& _collection_flag)
4567 {
4568 m_collection_flag = std::move(_collection_flag);
4569 }
4570
4571 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4572 {
4573 return m_collection_flag;
4574 }
4575
4577 {
4578 return m_collection_flag;
4579 }
4580
4581 RTPS_DllAPI inline void header(
4582 const CompleteArrayHeader& _header)
4583 {
4584 m_header = _header;
4585 }
4586
4587 RTPS_DllAPI inline void header(
4588 CompleteArrayHeader&& _header)
4589 {
4590 m_header = std::move(_header);
4591 }
4592
4593 RTPS_DllAPI inline const CompleteArrayHeader& header() const
4594 {
4595 return m_header;
4596 }
4597
4598 RTPS_DllAPI inline CompleteArrayHeader& header()
4599 {
4600 return m_header;
4601 }
4602
4603 RTPS_DllAPI inline void element(
4604 const CompleteCollectionElement& _element)
4605 {
4606 m_element = _element;
4607 }
4608
4609 RTPS_DllAPI inline void element(
4610 CompleteCollectionElement&& _element)
4611 {
4612 m_element = std::move(_element);
4613 }
4614
4615 RTPS_DllAPI inline const CompleteCollectionElement& element() const
4616 {
4617 return m_element;
4618 }
4619
4621 {
4622 return m_element;
4623 }
4624
4625#ifndef DOXYGEN_SHOULD_SKIP_THIS
4626 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayType::getCdrSerializedSize()",
4627 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4628 RTPS_DllAPI static size_t getCdrSerializedSize(
4629 const CompleteArrayType& data,
4630 size_t current_alignment = 0);
4631 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayType::serialize()",
4632 "In favor of version using eprosima::fastcdr::serialize.")
4633 RTPS_DllAPI void serialize(
4634 eprosima::fastcdr::Cdr& cdr) const;
4635 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteArrayType::deserialize()",
4636 "In favor of version using eprosima::fastcdr::deserialize.")
4637 RTPS_DllAPI void deserialize(
4638 eprosima::fastcdr::Cdr& cdr);
4639#endif // DOXYGEN_SHOULD_SKIP_THIS
4640
4641 RTPS_DllAPI bool operator ==(
4642 const CompleteArrayType& other) const;
4643
4644 RTPS_DllAPI bool consistent(
4645 const CompleteArrayType& x,
4646 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4647
4648private:
4649
4650 CollectionTypeFlag m_collection_flag;
4651 CompleteArrayHeader m_header;
4652 CompleteCollectionElement m_element;
4653};
4654
4655/*struct MinimalArrayType final{
4656 CollectionTypeFlag collection_flag;
4657 MinimalArrayHeader header;
4658 MinimalCollectionElement element;
4659 };*/
4661{
4662public:
4663
4664 RTPS_DllAPI MinimalArrayType();
4665 RTPS_DllAPI ~MinimalArrayType();
4666 RTPS_DllAPI MinimalArrayType(
4667 const MinimalArrayType& x);
4668 RTPS_DllAPI MinimalArrayType(
4669 MinimalArrayType&& x);
4671 const MinimalArrayType& x);
4673 MinimalArrayType&& x);
4674
4675 RTPS_DllAPI inline void collection_flag(
4676 const CollectionTypeFlag& _collection_flag)
4677 {
4678 m_collection_flag = _collection_flag;
4679 }
4680
4681 RTPS_DllAPI inline void collection_flag(
4682 CollectionTypeFlag&& _collection_flag)
4683 {
4684 m_collection_flag = std::move(_collection_flag);
4685 }
4686
4687 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4688 {
4689 return m_collection_flag;
4690 }
4691
4693 {
4694 return m_collection_flag;
4695 }
4696
4697 RTPS_DllAPI inline void header(
4698 const MinimalArrayHeader& _header)
4699 {
4700 m_header = _header;
4701 }
4702
4703 RTPS_DllAPI inline void header(
4704 MinimalArrayHeader&& _header)
4705 {
4706 m_header = std::move(_header);
4707 }
4708
4709 RTPS_DllAPI inline const MinimalArrayHeader& header() const
4710 {
4711 return m_header;
4712 }
4713
4714 RTPS_DllAPI inline MinimalArrayHeader& header()
4715 {
4716 return m_header;
4717 }
4718
4719 RTPS_DllAPI inline void element(
4720 const MinimalCollectionElement& _element)
4721 {
4722 m_element = _element;
4723 }
4724
4725 RTPS_DllAPI inline void element(
4726 MinimalCollectionElement&& _element)
4727 {
4728 m_element = std::move(_element);
4729 }
4730
4731 RTPS_DllAPI inline const MinimalCollectionElement& element() const
4732 {
4733 return m_element;
4734 }
4735
4736 RTPS_DllAPI inline MinimalCollectionElement& element()
4737 {
4738 return m_element;
4739 }
4740
4741#ifndef DOXYGEN_SHOULD_SKIP_THIS
4742 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayType::getCdrSerializedSize()",
4743 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4744 RTPS_DllAPI static size_t getCdrSerializedSize(
4745 const MinimalArrayType& data,
4746 size_t current_alignment = 0);
4747 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayType::serialize()",
4748 "In favor of version using eprosima::fastcdr::serialize.")
4749 RTPS_DllAPI void serialize(
4750 eprosima::fastcdr::Cdr& cdr) const;
4751 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalArrayType::deserialize()",
4752 "In favor of version using eprosima::fastcdr::deserialize.")
4753 RTPS_DllAPI void deserialize(
4754 eprosima::fastcdr::Cdr& cdr);
4755#endif // DOXYGEN_SHOULD_SKIP_THIS
4756
4757 RTPS_DllAPI bool operator ==(
4758 const MinimalArrayType& other) const;
4759
4760 RTPS_DllAPI bool consistent(
4761 const MinimalArrayType& x,
4762 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4763
4764private:
4765
4766 CollectionTypeFlag m_collection_flag;
4767 MinimalArrayHeader m_header;
4768 MinimalCollectionElement m_element;
4769};
4770
4771// --- Map: -----------------------------------------------------
4772/*struct CompleteMapType final{
4773 CollectionTypeFlag collection_flag;
4774 CompleteCollectionHeader header;
4775 CompleteCollectionElement key;
4776 CompleteCollectionElement element;
4777 };*/
4779{
4780public:
4781
4782 RTPS_DllAPI CompleteMapType();
4783 RTPS_DllAPI ~CompleteMapType();
4784 RTPS_DllAPI CompleteMapType(
4785 const CompleteMapType& x);
4786 RTPS_DllAPI CompleteMapType(
4787 CompleteMapType&& x);
4789 const CompleteMapType& x);
4791 CompleteMapType&& x);
4792
4793 RTPS_DllAPI inline void collection_flag(
4794 const CollectionTypeFlag& _collection_flag)
4795 {
4796 m_collection_flag = _collection_flag;
4797 }
4798
4799 RTPS_DllAPI inline void collection_flag(
4800 CollectionTypeFlag&& _collection_flag)
4801 {
4802 m_collection_flag = std::move(_collection_flag);
4803 }
4804
4805 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4806 {
4807 return m_collection_flag;
4808 }
4809
4811 {
4812 return m_collection_flag;
4813 }
4814
4815 RTPS_DllAPI inline void header(
4816 const CompleteCollectionHeader& _header)
4817 {
4818 m_header = _header;
4819 }
4820
4821 RTPS_DllAPI inline void header(
4822 CompleteCollectionHeader&& _header)
4823 {
4824 m_header = std::move(_header);
4825 }
4826
4827 RTPS_DllAPI inline const CompleteCollectionHeader& header() const
4828 {
4829 return m_header;
4830 }
4831
4832 RTPS_DllAPI inline CompleteCollectionHeader& header()
4833 {
4834 return m_header;
4835 }
4836
4837 RTPS_DllAPI inline void key(
4838 const CompleteCollectionElement& _key)
4839 {
4840 m_key = _key;
4841 }
4842
4843 RTPS_DllAPI inline void key(
4845 {
4846 m_key = std::move(_key);
4847 }
4848
4849 RTPS_DllAPI inline const CompleteCollectionElement& key() const
4850 {
4851 return m_key;
4852 }
4853
4854 RTPS_DllAPI inline CompleteCollectionElement& key()
4855 {
4856 return m_key;
4857 }
4858
4859 RTPS_DllAPI inline void element(
4860 const CompleteCollectionElement& _element)
4861 {
4862 m_element = _element;
4863 }
4864
4865 RTPS_DllAPI inline void element(
4866 CompleteCollectionElement&& _element)
4867 {
4868 m_element = std::move(_element);
4869 }
4870
4871 RTPS_DllAPI inline const CompleteCollectionElement& element() const
4872 {
4873 return m_element;
4874 }
4875
4877 {
4878 return m_element;
4879 }
4880
4881#ifndef DOXYGEN_SHOULD_SKIP_THIS
4882 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMapType::getCdrSerializedSize()",
4883 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
4884 RTPS_DllAPI static size_t getCdrSerializedSize(
4885 const CompleteMapType& data,
4886 size_t current_alignment = 0);
4887 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMapType::serialize()",
4888 "In favor of version using eprosima::fastcdr::serialize.")
4889 RTPS_DllAPI void serialize(
4890 eprosima::fastcdr::Cdr& cdr) const;
4891 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteMapType::deserialize()",
4892 "In favor of version using eprosima::fastcdr::deserialize.")
4893 RTPS_DllAPI void deserialize(
4894 eprosima::fastcdr::Cdr& cdr);
4895#endif // DOXYGEN_SHOULD_SKIP_THIS
4896
4897 RTPS_DllAPI bool operator ==(
4898 const CompleteMapType& other) const;
4899
4900 RTPS_DllAPI bool consistent(
4901 const CompleteMapType& x,
4902 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4903
4904private:
4905
4906 CollectionTypeFlag m_collection_flag;
4907 CompleteCollectionHeader m_header;
4909 CompleteCollectionElement m_element;
4910};
4911/*struct MinimalMapType final{
4912 CollectionTypeFlag collection_flag;
4913 MinimalCollectionHeader header;
4914 MinimalCollectionElement key;
4915 MinimalCollectionElement element;
4916 };*/
4918{
4919public:
4920
4921 RTPS_DllAPI MinimalMapType();
4922 RTPS_DllAPI ~MinimalMapType();
4923 RTPS_DllAPI MinimalMapType(
4924 const MinimalMapType& x);
4925 RTPS_DllAPI MinimalMapType(
4926 MinimalMapType&& x);
4928 const MinimalMapType& x);
4930 MinimalMapType&& x);
4931
4932 RTPS_DllAPI inline void collection_flag(
4933 const CollectionTypeFlag& _collection_flag)
4934 {
4935 m_collection_flag = _collection_flag;
4936 }
4937
4938 RTPS_DllAPI inline void collection_flag(
4939 CollectionTypeFlag&& _collection_flag)
4940 {
4941 m_collection_flag = std::move(_collection_flag);
4942 }
4943
4944 RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const
4945 {
4946 return m_collection_flag;
4947 }
4948
4950 {
4951 return m_collection_flag;
4952 }
4953
4954 RTPS_DllAPI inline void header(
4955 const MinimalCollectionHeader& _header)
4956 {
4957 m_header = _header;
4958 }
4959
4960 RTPS_DllAPI inline void header(
4961 MinimalCollectionHeader&& _header)
4962 {
4963 m_header = std::move(_header);
4964 }
4965
4966 RTPS_DllAPI inline const MinimalCollectionHeader& header() const
4967 {
4968 return m_header;
4969 }
4970
4971 RTPS_DllAPI inline MinimalCollectionHeader& header()
4972 {
4973 return m_header;
4974 }
4975
4976 RTPS_DllAPI inline void key(
4977 const MinimalCollectionElement& _key)
4978 {
4979 m_key = _key;
4980 }
4981
4982 RTPS_DllAPI inline void key(
4984 {
4985 m_key = std::move(_key);
4986 }
4987
4988 RTPS_DllAPI inline const MinimalCollectionElement& key() const
4989 {
4990 return m_key;
4991 }
4992
4993 RTPS_DllAPI inline MinimalCollectionElement& key()
4994 {
4995 return m_key;
4996 }
4997
4998 RTPS_DllAPI inline void element(
4999 const MinimalCollectionElement& _element)
5000 {
5001 m_element = _element;
5002 }
5003
5004 RTPS_DllAPI inline void element(
5005 MinimalCollectionElement&& _element)
5006 {
5007 m_element = std::move(_element);
5008 }
5009
5010 RTPS_DllAPI inline const MinimalCollectionElement& element() const
5011 {
5012 return m_element;
5013 }
5014
5015 RTPS_DllAPI inline MinimalCollectionElement& element()
5016 {
5017 return m_element;
5018 }
5019
5020#ifndef DOXYGEN_SHOULD_SKIP_THIS
5021 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMapType::getCdrSerializedSize()",
5022 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5023 RTPS_DllAPI static size_t getCdrSerializedSize(
5024 const MinimalMapType& data,
5025 size_t current_alignment = 0);
5026 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMapType::serialize()",
5027 "In favor of version using eprosima::fastcdr::serialize.")
5028 RTPS_DllAPI void serialize(
5029 eprosima::fastcdr::Cdr& cdr) const;
5030 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalMapType::deserialize()",
5031 "In favor of version using eprosima::fastcdr::deserialize.")
5032 RTPS_DllAPI void deserialize(
5033 eprosima::fastcdr::Cdr& cdr);
5034#endif // DOXYGEN_SHOULD_SKIP_THIS
5035
5036 RTPS_DllAPI bool operator ==(
5037 const MinimalMapType& other) const;
5038
5039 RTPS_DllAPI bool consistent(
5040 const MinimalMapType& x,
5041 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5042
5043private:
5044
5045 CollectionTypeFlag m_collection_flag;
5046 MinimalCollectionHeader m_header;
5048 MinimalCollectionElement m_element;
5049};
5050
5051// --- Enumeration: ---------------------------------------------------
5052typedef uint16_t BitBound;
5053
5054// Constant in an enumerated type
5055
5056/*struct CommonEnumeratedLiteral {
5057 int32_t value;
5058 EnumeratedLiteralFlag flags;
5059 };*/
5061{
5062public:
5063
5067 const CommonEnumeratedLiteral& x);
5071 const CommonEnumeratedLiteral& x);
5074
5075 RTPS_DllAPI inline void value(
5076 const int32_t& _value)
5077 {
5078 m_value = _value;
5079 }
5080
5081 RTPS_DllAPI inline void value(
5082 int32_t&& _value)
5083 {
5084 m_value = std::move(_value);
5085 }
5086
5087 RTPS_DllAPI inline const int32_t& value() const
5088 {
5089 return m_value;
5090 }
5091
5092 RTPS_DllAPI inline int32_t& value()
5093 {
5094 return m_value;
5095 }
5096
5097 RTPS_DllAPI inline void flags(
5098 const EnumeratedLiteralFlag& _flags)
5099 {
5100 m_flags = _flags;
5101 }
5102
5103 RTPS_DllAPI inline void flags(
5104 EnumeratedLiteralFlag&& _flags)
5105 {
5106 m_flags = std::move(_flags);
5107 }
5108
5109 RTPS_DllAPI inline const EnumeratedLiteralFlag& flags() const
5110 {
5111 return m_flags;
5112 }
5113
5114 RTPS_DllAPI inline EnumeratedLiteralFlag& flags()
5115 {
5116 return m_flags;
5117 }
5118
5119#ifndef DOXYGEN_SHOULD_SKIP_THIS
5120 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedLiteral::getCdrSerializedSize()",
5121 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5122 RTPS_DllAPI static size_t getCdrSerializedSize(
5123 const CommonEnumeratedLiteral& data,
5124 size_t current_alignment = 0);
5125 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedLiteral::serialize()",
5126 "In favor of version using eprosima::fastcdr::serialize.")
5127 RTPS_DllAPI void serialize(
5128 eprosima::fastcdr::Cdr& cdr) const;
5129 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedLiteral::deserialize()",
5130 "In favor of version using eprosima::fastcdr::deserialize.")
5131 RTPS_DllAPI void deserialize(
5132 eprosima::fastcdr::Cdr& cdr);
5133#endif // DOXYGEN_SHOULD_SKIP_THIS
5134
5135 RTPS_DllAPI bool operator ==(
5136 const CommonEnumeratedLiteral& other) const;
5137
5138 RTPS_DllAPI bool consistent(
5139 const CommonEnumeratedLiteral& x,
5140 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5141
5142private:
5143
5144 int32_t m_value;
5145 EnumeratedLiteralFlag m_flags;
5146};
5147
5148// Constant in an enumerated type
5149
5150/*struct CompleteEnumeratedLiteral {
5151 CommonEnumeratedLiteral common;
5152 CompleteMemberDetail detail;
5153 };*/
5155{
5156public:
5157
5161 const CompleteEnumeratedLiteral& x);
5165 const CompleteEnumeratedLiteral& x);
5168
5169 RTPS_DllAPI inline void common(
5170 const CommonEnumeratedLiteral& _common)
5171 {
5172 m_common = _common;
5173 }
5174
5175 RTPS_DllAPI inline void common(
5176 CommonEnumeratedLiteral&& _common)
5177 {
5178 m_common = std::move(_common);
5179 }
5180
5181 RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const
5182 {
5183 return m_common;
5184 }
5185
5186 RTPS_DllAPI inline CommonEnumeratedLiteral& common()
5187 {
5188 return m_common;
5189 }
5190
5191 RTPS_DllAPI inline void detail(
5192 const CompleteMemberDetail& _detail)
5193 {
5194 m_detail = _detail;
5195 }
5196
5197 RTPS_DllAPI inline void detail(
5198 CompleteMemberDetail&& _detail)
5199 {
5200 m_detail = std::move(_detail);
5201 }
5202
5203 RTPS_DllAPI inline const CompleteMemberDetail& detail() const
5204 {
5205 return m_detail;
5206 }
5207
5208 RTPS_DllAPI inline CompleteMemberDetail& detail()
5209 {
5210 return m_detail;
5211 }
5212
5213#ifndef DOXYGEN_SHOULD_SKIP_THIS
5214 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedLiteral::getCdrSerializedSize()",
5215 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5216 RTPS_DllAPI static size_t getCdrSerializedSize(
5217 const CompleteEnumeratedLiteral& data,
5218 size_t current_alignment = 0);
5219 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedLiteral::serialize()",
5220 "In favor of version using eprosima::fastcdr::serialize.")
5221 RTPS_DllAPI void serialize(
5222 eprosima::fastcdr::Cdr& cdr) const;
5223 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedLiteral::deserialize()",
5224 "In favor of version using eprosima::fastcdr::deserialize.")
5225 RTPS_DllAPI void deserialize(
5226 eprosima::fastcdr::Cdr& cdr);
5227#endif // DOXYGEN_SHOULD_SKIP_THIS
5228
5229 RTPS_DllAPI bool operator ==(
5230 const CompleteEnumeratedLiteral& other) const;
5231
5232 RTPS_DllAPI bool consistent(
5234 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5235
5236private:
5237
5238 CommonEnumeratedLiteral m_common;
5239 CompleteMemberDetail m_detail;
5240};
5241// Ordered by EnumeratedLiteral.common.value
5242typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
5243
5244// Constant in an enumerated type
5245
5246/*struct MinimalEnumeratedLiteral {
5247 CommonEnumeratedLiteral common;
5248 MinimalMemberDetail detail;
5249 };*/
5251{
5252public:
5253
5257 const MinimalEnumeratedLiteral& x);
5261 const MinimalEnumeratedLiteral& x);
5264
5265 RTPS_DllAPI inline void common(
5266 const CommonEnumeratedLiteral& _common)
5267 {
5268 m_common = _common;
5269 }
5270
5271 RTPS_DllAPI inline void common(
5272 CommonEnumeratedLiteral&& _common)
5273 {
5274 m_common = std::move(_common);
5275 }
5276
5277 RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const
5278 {
5279 return m_common;
5280 }
5281
5282 RTPS_DllAPI inline CommonEnumeratedLiteral& common()
5283 {
5284 return m_common;
5285 }
5286
5287 RTPS_DllAPI inline void detail(
5288 const MinimalMemberDetail& _detail)
5289 {
5290 m_detail = _detail;
5291 }
5292
5293 RTPS_DllAPI inline void detail(
5294 MinimalMemberDetail&& _detail)
5295 {
5296 m_detail = std::move(_detail);
5297 }
5298
5299 RTPS_DllAPI inline const MinimalMemberDetail& detail() const
5300 {
5301 return m_detail;
5302 }
5303
5304 RTPS_DllAPI inline MinimalMemberDetail& detail()
5305 {
5306 return m_detail;
5307 }
5308
5309#ifndef DOXYGEN_SHOULD_SKIP_THIS
5310 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedLiteral::getCdrSerializedSize()",
5311 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5312 RTPS_DllAPI static size_t getCdrSerializedSize(
5313 const MinimalEnumeratedLiteral& data,
5314 size_t current_alignment = 0);
5315 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedLiteral::serialize()",
5316 "In favor of version using eprosima::fastcdr::serialize.")
5317 RTPS_DllAPI void serialize(
5318 eprosima::fastcdr::Cdr& cdr) const;
5319 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedLiteral::deserialize()",
5320 "In favor of version using eprosima::fastcdr::deserialize.")
5321 RTPS_DllAPI void deserialize(
5322 eprosima::fastcdr::Cdr& cdr);
5323#endif // DOXYGEN_SHOULD_SKIP_THIS
5324
5325 RTPS_DllAPI bool operator ==(
5326 const MinimalEnumeratedLiteral& other) const;
5327
5328 RTPS_DllAPI bool consistent(
5329 const MinimalEnumeratedLiteral& x,
5330 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5331
5332private:
5333
5334 CommonEnumeratedLiteral m_common;
5335 MinimalMemberDetail m_detail;
5336};
5337
5338// Ordered by EnumeratedLiteral.common.value
5339typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
5340
5341/*struct CommonEnumeratedHeader final{
5342 BitBound bit_bound;
5343 };*/
5345{
5346public:
5347
5351 const CommonEnumeratedHeader& x);
5355 const CommonEnumeratedHeader& x);
5358
5359 RTPS_DllAPI inline void bit_bound(
5360 const BitBound& _bit_bound)
5361 {
5362 m_bit_bound = _bit_bound;
5363 }
5364
5365 RTPS_DllAPI inline void bit_bound(
5366 BitBound&& _bit_bound)
5367 {
5368 m_bit_bound = std::move(_bit_bound);
5369 }
5370
5371 RTPS_DllAPI inline const BitBound& bit_bound() const
5372 {
5373 return m_bit_bound;
5374 }
5375
5376 RTPS_DllAPI inline BitBound& bit_bound()
5377 {
5378 return m_bit_bound;
5379 }
5380
5381#ifndef DOXYGEN_SHOULD_SKIP_THIS
5382 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedHeader::getCdrSerializedSize()",
5383 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5384 RTPS_DllAPI static size_t getCdrSerializedSize(
5385 const CommonEnumeratedHeader& data,
5386 size_t current_alignment = 0);
5387 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedHeader::serialize()",
5388 "In favor of version using eprosima::fastcdr::serialize.")
5389 RTPS_DllAPI void serialize(
5390 eprosima::fastcdr::Cdr& cdr) const;
5391 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonEnumeratedHeader::deserialize()",
5392 "In favor of version using eprosima::fastcdr::deserialize.")
5393 RTPS_DllAPI void deserialize(
5394 eprosima::fastcdr::Cdr& cdr);
5395#endif // DOXYGEN_SHOULD_SKIP_THIS
5396
5397 RTPS_DllAPI bool operator ==(
5398 const CommonEnumeratedHeader& other) const;
5399
5400 RTPS_DllAPI bool consistent(
5401 const CommonEnumeratedHeader& x,
5402 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5403
5404private:
5405
5406 BitBound m_bit_bound;
5407};
5408
5409/*struct CompleteEnumeratedHeader {
5410 CommonEnumeratedHeader common;
5411 CompleteTypeDetail detail;
5412 };*/
5414{
5415public:
5416
5420 const CompleteEnumeratedHeader& x);
5424 const CompleteEnumeratedHeader& x);
5427
5428 RTPS_DllAPI inline void common(
5429 const CommonEnumeratedHeader& _common)
5430 {
5431 m_common = _common;
5432 }
5433
5434 RTPS_DllAPI inline void common(
5435 CommonEnumeratedHeader&& _common)
5436 {
5437 m_common = std::move(_common);
5438 }
5439
5440 RTPS_DllAPI inline const CommonEnumeratedHeader& common() const
5441 {
5442 return m_common;
5443 }
5444
5445 RTPS_DllAPI inline CommonEnumeratedHeader& common()
5446 {
5447 return m_common;
5448 }
5449
5450 RTPS_DllAPI inline void detail(
5451 const CompleteTypeDetail& _detail)
5452 {
5453 m_detail = _detail;
5454 }
5455
5456 RTPS_DllAPI inline void detail(
5457 CompleteTypeDetail&& _detail)
5458 {
5459 m_detail = std::move(_detail);
5460 }
5461
5462 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
5463 {
5464 return m_detail;
5465 }
5466
5467 RTPS_DllAPI inline CompleteTypeDetail& detail()
5468 {
5469 return m_detail;
5470 }
5471
5472#ifndef DOXYGEN_SHOULD_SKIP_THIS
5473 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedHeader::getCdrSerializedSize()",
5474 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5475 RTPS_DllAPI static size_t getCdrSerializedSize(
5476 const CompleteEnumeratedHeader& data,
5477 size_t current_alignment = 0);
5478 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedHeader::serialize()",
5479 "In favor of version using eprosima::fastcdr::serialize.")
5480 RTPS_DllAPI void serialize(
5481 eprosima::fastcdr::Cdr& cdr) const;
5482 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedHeader::deserialize()",
5483 "In favor of version using eprosima::fastcdr::deserialize.")
5484 RTPS_DllAPI void deserialize(
5485 eprosima::fastcdr::Cdr& cdr);
5486#endif // DOXYGEN_SHOULD_SKIP_THIS
5487
5488 RTPS_DllAPI bool operator ==(
5489 const CompleteEnumeratedHeader& other) const;
5490
5491 RTPS_DllAPI bool consistent(
5492 const CompleteEnumeratedHeader& x,
5493 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5494
5495private:
5496
5497 CommonEnumeratedHeader m_common;
5498 CompleteTypeDetail m_detail;
5499};
5500
5501/*struct MinimalEnumeratedHeader {
5502 CommonEnumeratedHeader common;
5503 };*/
5505{
5506public:
5507
5511 const MinimalEnumeratedHeader& x);
5515 const MinimalEnumeratedHeader& x);
5518
5519 RTPS_DllAPI inline void common(
5520 const CommonEnumeratedHeader& _common)
5521 {
5522 m_common = _common;
5523 }
5524
5525 RTPS_DllAPI inline void common(
5526 CommonEnumeratedHeader&& _common)
5527 {
5528 m_common = std::move(_common);
5529 }
5530
5531 RTPS_DllAPI inline const CommonEnumeratedHeader& common() const
5532 {
5533 return m_common;
5534 }
5535
5536 RTPS_DllAPI inline CommonEnumeratedHeader& common()
5537 {
5538 return m_common;
5539 }
5540
5541#ifndef DOXYGEN_SHOULD_SKIP_THIS
5542 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedHeader::getCdrSerializedSize()",
5543 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5544 RTPS_DllAPI static size_t getCdrSerializedSize(
5545 const MinimalEnumeratedHeader& data,
5546 size_t current_alignment = 0);
5547 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedHeader::serialize()",
5548 "In favor of version using eprosima::fastcdr::serialize.")
5549 RTPS_DllAPI void serialize(
5550 eprosima::fastcdr::Cdr& cdr) const;
5551 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedHeader::deserialize()",
5552 "In favor of version using eprosima::fastcdr::deserialize.")
5553 RTPS_DllAPI void deserialize(
5554 eprosima::fastcdr::Cdr& cdr);
5555#endif // DOXYGEN_SHOULD_SKIP_THIS
5556
5557 RTPS_DllAPI bool operator ==(
5558 const MinimalEnumeratedHeader& other) const;
5559
5560 RTPS_DllAPI bool consistent(
5561 const MinimalEnumeratedHeader& x,
5562 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5563
5564private:
5565
5566 CommonEnumeratedHeader m_common;
5567};
5568
5569// Enumerated type
5570/*struct CompleteEnumeratedType final{
5571 EnumTypeFlag enum_flags; // unused
5572 CompleteEnumeratedHeader header;
5573 CompleteEnumeratedLiteralSeq literal_seq;
5574 };*/
5576{
5577public:
5578
5582 const CompleteEnumeratedType& x);
5586 const CompleteEnumeratedType& x);
5589
5590 RTPS_DllAPI inline void enum_flags(
5591 const EnumTypeFlag& _enum_flags)
5592 {
5593 m_enum_flags = _enum_flags;
5594 }
5595
5596 RTPS_DllAPI inline void enum_flags(
5597 EnumTypeFlag&& _enum_flags)
5598 {
5599 m_enum_flags = std::move(_enum_flags);
5600 }
5601
5602 RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const
5603 {
5604 return m_enum_flags;
5605 }
5606
5607 RTPS_DllAPI inline EnumTypeFlag& enum_flags()
5608 {
5609 return m_enum_flags;
5610 }
5611
5612 RTPS_DllAPI inline void header(
5613 const CompleteEnumeratedHeader& _header)
5614 {
5615 m_header = _header;
5616 }
5617
5618 RTPS_DllAPI inline void header(
5619 CompleteEnumeratedHeader&& _header)
5620 {
5621 m_header = std::move(_header);
5622 }
5623
5624 RTPS_DllAPI inline const CompleteEnumeratedHeader& header() const
5625 {
5626 return m_header;
5627 }
5628
5629 RTPS_DllAPI inline CompleteEnumeratedHeader& header()
5630 {
5631 return m_header;
5632 }
5633
5634 RTPS_DllAPI inline void literal_seq(
5635 const CompleteEnumeratedLiteralSeq& _literal_seq)
5636 {
5637 m_literal_seq = _literal_seq;
5638 }
5639
5640 RTPS_DllAPI inline void literal_seq(
5641 CompleteEnumeratedLiteralSeq&& _literal_seq)
5642 {
5643 m_literal_seq = std::move(_literal_seq);
5644 }
5645
5646 RTPS_DllAPI inline const CompleteEnumeratedLiteralSeq& literal_seq() const
5647 {
5648 return m_literal_seq;
5649 }
5650
5652 {
5653 return m_literal_seq;
5654 }
5655
5656#ifndef DOXYGEN_SHOULD_SKIP_THIS
5657 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedType::getCdrSerializedSize()",
5658 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5659 RTPS_DllAPI static size_t getCdrSerializedSize(
5660 const CompleteEnumeratedType& data,
5661 size_t current_alignment = 0);
5662 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedType::serialize()",
5663 "In favor of version using eprosima::fastcdr::serialize.")
5664 RTPS_DllAPI void serialize(
5665 eprosima::fastcdr::Cdr& cdr) const;
5666 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteEnumeratedType::deserialize()",
5667 "In favor of version using eprosima::fastcdr::deserialize.")
5668 RTPS_DllAPI void deserialize(
5669 eprosima::fastcdr::Cdr& cdr);
5670#endif // DOXYGEN_SHOULD_SKIP_THIS
5671
5672 RTPS_DllAPI bool operator ==(
5673 const CompleteEnumeratedType& other) const;
5674
5675 RTPS_DllAPI bool consistent(
5676 const CompleteEnumeratedType& x,
5677 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5678
5679private:
5680
5681 EnumTypeFlag m_enum_flags;
5682 CompleteEnumeratedHeader m_header;
5683 CompleteEnumeratedLiteralSeq m_literal_seq;
5684};
5685// Enumerated type
5686/*struct MinimalEnumeratedType final{
5687 EnumTypeFlag enum_flags; // unused
5688 MinimalEnumeratedHeader header;
5689 MinimalEnumeratedLiteralSeq literal_seq;
5690 };*/
5692{
5693public:
5694
5698 const MinimalEnumeratedType& x);
5702 const MinimalEnumeratedType& x);
5705
5706 RTPS_DllAPI inline void enum_flags(
5707 const EnumTypeFlag& _enum_flags)
5708 {
5709 m_enum_flags = _enum_flags;
5710 }
5711
5712 RTPS_DllAPI inline void enum_flags(
5713 EnumTypeFlag&& _enum_flags)
5714 {
5715 m_enum_flags = std::move(_enum_flags);
5716 }
5717
5718 RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const
5719 {
5720 return m_enum_flags;
5721 }
5722
5723 RTPS_DllAPI inline EnumTypeFlag& enum_flags()
5724 {
5725 return m_enum_flags;
5726 }
5727
5728 RTPS_DllAPI inline void header(
5729 const MinimalEnumeratedHeader& _header)
5730 {
5731 m_header = _header;
5732 }
5733
5734 RTPS_DllAPI inline void header(
5735 MinimalEnumeratedHeader&& _header)
5736 {
5737 m_header = std::move(_header);
5738 }
5739
5740 RTPS_DllAPI inline const MinimalEnumeratedHeader& header() const
5741 {
5742 return m_header;
5743 }
5744
5745 RTPS_DllAPI inline MinimalEnumeratedHeader& header()
5746 {
5747 return m_header;
5748 }
5749
5750 RTPS_DllAPI inline void literal_seq(
5751 const MinimalEnumeratedLiteralSeq& _literal_seq)
5752 {
5753 m_literal_seq = _literal_seq;
5754 }
5755
5756 RTPS_DllAPI inline void literal_seq(
5757 MinimalEnumeratedLiteralSeq&& _literal_seq)
5758 {
5759 m_literal_seq = std::move(_literal_seq);
5760 }
5761
5762 RTPS_DllAPI inline const MinimalEnumeratedLiteralSeq& literal_seq() const
5763 {
5764 return m_literal_seq;
5765 }
5766
5768 {
5769 return m_literal_seq;
5770 }
5771
5772#ifndef DOXYGEN_SHOULD_SKIP_THIS
5773 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedType::getCdrSerializedSize()",
5774 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5775 RTPS_DllAPI static size_t getCdrSerializedSize(
5776 const MinimalEnumeratedType& data,
5777 size_t current_alignment = 0);
5778 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedType::serialize()",
5779 "In favor of version using eprosima::fastcdr::serialize.")
5780 RTPS_DllAPI void serialize(
5781 eprosima::fastcdr::Cdr& cdr) const;
5782 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalEnumeratedType::deserialize()",
5783 "In favor of version using eprosima::fastcdr::deserialize.")
5784 RTPS_DllAPI void deserialize(
5785 eprosima::fastcdr::Cdr& cdr);
5786#endif // DOXYGEN_SHOULD_SKIP_THIS
5787
5788 RTPS_DllAPI bool operator ==(
5789 const MinimalEnumeratedType& other) const;
5790
5791 RTPS_DllAPI bool consistent(
5792 const MinimalEnumeratedType& x,
5793 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5794
5795private:
5796
5797 EnumTypeFlag m_enum_flags;
5798 MinimalEnumeratedHeader m_header;
5799 MinimalEnumeratedLiteralSeq m_literal_seq;
5800};
5801
5802// --- Bitmask: -------------------------------------------------------
5803// Bit in a bit mask
5804/*struct CommonBitflag final{
5805 uint16_t position;
5806 BitflagFlag flags;
5807 };*/
5808class CommonBitflag final
5809{
5810public:
5811
5812 RTPS_DllAPI CommonBitflag();
5813 RTPS_DllAPI ~CommonBitflag();
5814 RTPS_DllAPI CommonBitflag(
5815 const CommonBitflag& x);
5816 RTPS_DllAPI CommonBitflag(
5817 CommonBitflag&& x);
5819 const CommonBitflag& x);
5821 CommonBitflag&& x);
5822
5823 RTPS_DllAPI inline void position(
5824 const uint16_t& _position)
5825 {
5826 m_position = _position;
5827 }
5828
5829 RTPS_DllAPI inline void position(
5830 uint16_t&& _position)
5831 {
5832 m_position = std::move(_position);
5833 }
5834
5835 RTPS_DllAPI inline const uint16_t& position() const
5836 {
5837 return m_position;
5838 }
5839
5840 RTPS_DllAPI inline uint16_t& position()
5841 {
5842 return m_position;
5843 }
5844
5845 RTPS_DllAPI inline void flags(
5846 const BitflagFlag& _flags)
5847 {
5848 m_flags = _flags;
5849 }
5850
5851 RTPS_DllAPI inline void flags(
5852 BitflagFlag&& _flags)
5853 {
5854 m_flags = std::move(_flags);
5855 }
5856
5857 RTPS_DllAPI inline const BitflagFlag& flags() const
5858 {
5859 return m_flags;
5860 }
5861
5862 RTPS_DllAPI inline BitflagFlag& flags()
5863 {
5864 return m_flags;
5865 }
5866
5867#ifndef DOXYGEN_SHOULD_SKIP_THIS
5868 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitflag::getCdrSerializedSize()",
5869 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5870 RTPS_DllAPI static size_t getCdrSerializedSize(
5871 const CommonBitflag& data,
5872 size_t current_alignment = 0);
5873 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitflag::serialize()",
5874 "In favor of version using eprosima::fastcdr::serialize.")
5875 RTPS_DllAPI void serialize(
5876 eprosima::fastcdr::Cdr& cdr) const;
5877 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitflag::deserialize()",
5878 "In favor of version using eprosima::fastcdr::deserialize.")
5879 RTPS_DllAPI void deserialize(
5880 eprosima::fastcdr::Cdr& cdr);
5881#endif // DOXYGEN_SHOULD_SKIP_THIS
5882
5883 RTPS_DllAPI bool operator ==(
5884 const CommonBitflag& other) const;
5885
5886 RTPS_DllAPI bool consistent(
5887 const CommonBitflag& x,
5888 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5889
5890private:
5891
5892 uint16_t m_position;
5893 BitflagFlag m_flags;
5894};
5895
5896/*struct CompleteBitflag {
5897 CommonBitflag common;
5898 CompleteMemberDetail detail;
5899 };*/
5901{
5902public:
5903
5904 RTPS_DllAPI CompleteBitflag();
5905 RTPS_DllAPI ~CompleteBitflag();
5906 RTPS_DllAPI CompleteBitflag(
5907 const CompleteBitflag& x);
5908 RTPS_DllAPI CompleteBitflag(
5909 CompleteBitflag&& x);
5911 const CompleteBitflag& x);
5913 CompleteBitflag&& x);
5914
5915 RTPS_DllAPI inline void common(
5916 const CommonBitflag& _common)
5917 {
5918 m_common = _common;
5919 }
5920
5921 RTPS_DllAPI inline void common(
5922 CommonBitflag&& _common)
5923 {
5924 m_common = std::move(_common);
5925 }
5926
5927 RTPS_DllAPI inline const CommonBitflag& common() const
5928 {
5929 return m_common;
5930 }
5931
5932 RTPS_DllAPI inline CommonBitflag& common()
5933 {
5934 return m_common;
5935 }
5936
5937 RTPS_DllAPI inline void detail(
5938 const CompleteMemberDetail& _detail)
5939 {
5940 m_detail = _detail;
5941 }
5942
5943 RTPS_DllAPI inline void detail(
5944 CompleteMemberDetail&& _detail)
5945 {
5946 m_detail = std::move(_detail);
5947 }
5948
5949 RTPS_DllAPI inline const CompleteMemberDetail& detail() const
5950 {
5951 return m_detail;
5952 }
5953
5954 RTPS_DllAPI inline CompleteMemberDetail& detail()
5955 {
5956 return m_detail;
5957 }
5958
5959#ifndef DOXYGEN_SHOULD_SKIP_THIS
5960 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitflag::getCdrSerializedSize()",
5961 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
5962 RTPS_DllAPI static size_t getCdrSerializedSize(
5963 const CompleteBitflag& data,
5964 size_t current_alignment = 0);
5965 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitflag::serialize()",
5966 "In favor of version using eprosima::fastcdr::serialize.")
5967 RTPS_DllAPI void serialize(
5968 eprosima::fastcdr::Cdr& cdr) const;
5969 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitflag::deserialize()",
5970 "In favor of version using eprosima::fastcdr::deserialize.")
5971 RTPS_DllAPI void deserialize(
5972 eprosima::fastcdr::Cdr& cdr);
5973#endif // DOXYGEN_SHOULD_SKIP_THIS
5974
5975 RTPS_DllAPI bool operator ==(
5976 const CompleteBitflag& other) const;
5977
5978 RTPS_DllAPI bool consistent(
5979 const CompleteBitflag& x,
5980 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
5981
5982private:
5983
5984 CommonBitflag m_common;
5985 CompleteMemberDetail m_detail;
5986};
5987// Ordered by Bitflag.position
5988typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
5989/*struct MinimalBitflag {
5990 CommonBitflag common;
5991 MinimalMemberDetail detail;
5992 };*/
5994{
5995public:
5996
5997 RTPS_DllAPI MinimalBitflag();
5998 RTPS_DllAPI ~MinimalBitflag();
5999 RTPS_DllAPI MinimalBitflag(
6000 const MinimalBitflag& x);
6001 RTPS_DllAPI MinimalBitflag(
6002 MinimalBitflag&& x);
6004 const MinimalBitflag& x);
6006 MinimalBitflag&& x);
6007
6008 RTPS_DllAPI inline void common(
6009 const CommonBitflag& _common)
6010 {
6011 m_common = _common;
6012 }
6013
6014 RTPS_DllAPI inline void common(
6015 CommonBitflag&& _common)
6016 {
6017 m_common = std::move(_common);
6018 }
6019
6020 RTPS_DllAPI inline const CommonBitflag& common() const
6021 {
6022 return m_common;
6023 }
6024
6025 RTPS_DllAPI inline CommonBitflag& common()
6026 {
6027 return m_common;
6028 }
6029
6030 RTPS_DllAPI inline void detail(
6031 const MinimalMemberDetail& _detail)
6032 {
6033 m_detail = _detail;
6034 }
6035
6036 RTPS_DllAPI inline void detail(
6037 MinimalMemberDetail&& _detail)
6038 {
6039 m_detail = std::move(_detail);
6040 }
6041
6042 RTPS_DllAPI inline const MinimalMemberDetail& detail() const
6043 {
6044 return m_detail;
6045 }
6046
6047 RTPS_DllAPI inline MinimalMemberDetail& detail()
6048 {
6049 return m_detail;
6050 }
6051
6052#ifndef DOXYGEN_SHOULD_SKIP_THIS
6053 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitflag::getCdrSerializedSize()",
6054 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6055 RTPS_DllAPI static size_t getCdrSerializedSize(
6056 const MinimalBitflag& data,
6057 size_t current_alignment = 0);
6058 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitflag::serialize()",
6059 "In favor of version using eprosima::fastcdr::serialize.")
6060 RTPS_DllAPI void serialize(
6061 eprosima::fastcdr::Cdr& cdr) const;
6062 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitflag::deserialize()",
6063 "In favor of version using eprosima::fastcdr::deserialize.")
6064 RTPS_DllAPI void deserialize(
6065 eprosima::fastcdr::Cdr& cdr);
6066#endif // DOXYGEN_SHOULD_SKIP_THIS
6067
6068 RTPS_DllAPI bool operator ==(
6069 const MinimalBitflag& other) const;
6070
6071 RTPS_DllAPI bool consistent(
6072 const MinimalBitflag& x,
6073 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6074
6075private:
6076
6077 CommonBitflag m_common;
6078 MinimalMemberDetail m_detail;
6079};
6080
6081// Ordered by Bitflag.position
6082typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
6083
6084/*struct CommonBitmaskHeader final{
6085 BitBound bit_bound;
6086 };*/
6088{
6089public:
6090
6091 RTPS_DllAPI CommonBitmaskHeader();
6094 const CommonBitmaskHeader& x);
6098 const CommonBitmaskHeader& x);
6101
6102 RTPS_DllAPI inline void bit_bound(
6103 const BitBound& _bit_bound)
6104 {
6105 m_bit_bound = _bit_bound;
6106 }
6107
6108 RTPS_DllAPI inline void bit_bound(
6109 BitBound&& _bit_bound)
6110 {
6111 m_bit_bound = std::move(_bit_bound);
6112 }
6113
6114 RTPS_DllAPI inline const BitBound& bit_bound() const
6115 {
6116 return m_bit_bound;
6117 }
6118
6119 RTPS_DllAPI inline BitBound& bit_bound()
6120 {
6121 return m_bit_bound;
6122 }
6123
6124#ifndef DOXYGEN_SHOULD_SKIP_THIS
6125 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitmaskHeader::getCdrSerializedSize()",
6126 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6127 RTPS_DllAPI static size_t getCdrSerializedSize(
6128 const CommonBitmaskHeader& data,
6129 size_t current_alignment = 0);
6130 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitmaskHeader::serialize()",
6131 "In favor of version using eprosima::fastcdr::serialize.")
6132 RTPS_DllAPI void serialize(
6133 eprosima::fastcdr::Cdr& cdr) const;
6134 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitmaskHeader::deserialize()",
6135 "In favor of version using eprosima::fastcdr::deserialize.")
6136 RTPS_DllAPI void deserialize(
6137 eprosima::fastcdr::Cdr& cdr);
6138#endif // DOXYGEN_SHOULD_SKIP_THIS
6139
6140 RTPS_DllAPI bool operator ==(
6141 const CommonBitmaskHeader& other) const;
6142
6143 RTPS_DllAPI bool consistent(
6144 const CommonBitmaskHeader& x,
6145 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6146
6147private:
6148
6149 BitBound m_bit_bound;
6150};
6152
6154/*struct CompleteBitmaskType {
6155 BitmaskTypeFlag bitmask_flags; // unused
6156 CompleteBitmaskHeader header;
6157 CompleteBitflagSeq flag_seq;
6158 };*/
6160{
6161public:
6162
6163 RTPS_DllAPI CompleteBitmaskType();
6166 const CompleteBitmaskType& x);
6170 const CompleteBitmaskType& x);
6173
6174 RTPS_DllAPI inline void bitmask_flags(
6175 const BitmaskTypeFlag& _bitmask_flags)
6176 {
6177 m_bitmask_flags = _bitmask_flags;
6178 }
6179
6180 RTPS_DllAPI inline void bitmask_flags(
6181 BitmaskTypeFlag&& _bitmask_flags)
6182 {
6183 m_bitmask_flags = std::move(_bitmask_flags);
6184 }
6185
6186 RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const
6187 {
6188 return m_bitmask_flags;
6189 }
6190
6191 RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags()
6192 {
6193 return m_bitmask_flags;
6194 }
6195
6196 RTPS_DllAPI inline void header(
6197 const CompleteBitmaskHeader& _header)
6198 {
6199 m_header = _header;
6200 }
6201
6202 RTPS_DllAPI inline void header(
6203 CompleteBitmaskHeader&& _header)
6204 {
6205 m_header = std::move(_header);
6206 }
6207
6208 RTPS_DllAPI inline const CompleteBitmaskHeader& header() const
6209 {
6210 return m_header;
6211 }
6212
6213 RTPS_DllAPI inline CompleteBitmaskHeader& header()
6214 {
6215 return m_header;
6216 }
6217
6218 RTPS_DllAPI inline void flag_seq(
6219 const CompleteBitflagSeq& _flag_seq)
6220 {
6221 m_flag_seq = _flag_seq;
6222 }
6223
6224 RTPS_DllAPI inline void flag_seq(
6225 CompleteBitflagSeq&& _flag_seq)
6226 {
6227 m_flag_seq = std::move(_flag_seq);
6228 }
6229
6230 RTPS_DllAPI inline const CompleteBitflagSeq& flag_seq() const
6231 {
6232 return m_flag_seq;
6233 }
6234
6235 RTPS_DllAPI inline CompleteBitflagSeq& flag_seq()
6236 {
6237 return m_flag_seq;
6238 }
6239
6240#ifndef DOXYGEN_SHOULD_SKIP_THIS
6241 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitmaskType::getCdrSerializedSize()",
6242 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6243 RTPS_DllAPI static size_t getCdrSerializedSize(
6244 const CompleteBitmaskType& data,
6245 size_t current_alignment = 0);
6246 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitmaskType::serialize()",
6247 "In favor of version using eprosima::fastcdr::serialize.")
6248 RTPS_DllAPI void serialize(
6249 eprosima::fastcdr::Cdr& cdr) const;
6250 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitmaskType::deserialize()",
6251 "In favor of version using eprosima::fastcdr::deserialize.")
6252 RTPS_DllAPI void deserialize(
6253 eprosima::fastcdr::Cdr& cdr);
6254#endif // DOXYGEN_SHOULD_SKIP_THIS
6255
6256 RTPS_DllAPI bool operator ==(
6257 const CompleteBitmaskType& other) const;
6258
6259 RTPS_DllAPI bool consistent(
6260 const CompleteBitmaskType& x,
6261 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6262
6263private:
6264
6265 BitmaskTypeFlag m_bitmask_flags;
6266 CompleteBitmaskHeader m_header;
6267 CompleteBitflagSeq m_flag_seq;
6268};
6269
6270/*struct MinimalBitmaskType {
6271 BitmaskTypeFlag bitmask_flags; // unused
6272 MinimalBitmaskHeader header;
6273 MinimalBitflagSeq flag_seq;
6274 };*/
6276{
6277public:
6278
6279 RTPS_DllAPI MinimalBitmaskType();
6280 RTPS_DllAPI ~MinimalBitmaskType();
6282 const MinimalBitmaskType& x);
6284 MinimalBitmaskType&& x);
6286 const MinimalBitmaskType& x);
6288 MinimalBitmaskType&& x);
6289
6290 RTPS_DllAPI inline void bitmask_flags(
6291 const BitmaskTypeFlag& _bitmask_flags)
6292 {
6293 m_bitmask_flags = _bitmask_flags;
6294 }
6295
6296 RTPS_DllAPI inline void bitmask_flags(
6297 BitmaskTypeFlag&& _bitmask_flags)
6298 {
6299 m_bitmask_flags = std::move(_bitmask_flags);
6300 }
6301
6302 RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const
6303 {
6304 return m_bitmask_flags;
6305 }
6306
6307 RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags()
6308 {
6309 return m_bitmask_flags;
6310 }
6311
6312 RTPS_DllAPI inline void header(
6313 const MinimalBitmaskHeader& _header)
6314 {
6315 m_header = _header;
6316 }
6317
6318 RTPS_DllAPI inline void header(
6319 MinimalBitmaskHeader&& _header)
6320 {
6321 m_header = std::move(_header);
6322 }
6323
6324 RTPS_DllAPI inline const MinimalBitmaskHeader& header() const
6325 {
6326 return m_header;
6327 }
6328
6329 RTPS_DllAPI inline MinimalBitmaskHeader& header()
6330 {
6331 return m_header;
6332 }
6333
6334 RTPS_DllAPI inline void flag_seq(
6335 const MinimalBitflagSeq& _flag_seq)
6336 {
6337 m_flag_seq = _flag_seq;
6338 }
6339
6340 RTPS_DllAPI inline void flag_seq(
6341 MinimalBitflagSeq&& _flag_seq)
6342 {
6343 m_flag_seq = std::move(_flag_seq);
6344 }
6345
6346 RTPS_DllAPI inline const MinimalBitflagSeq& flag_seq() const
6347 {
6348 return m_flag_seq;
6349 }
6350
6351 RTPS_DllAPI inline MinimalBitflagSeq& flag_seq()
6352 {
6353 return m_flag_seq;
6354 }
6355
6356#ifndef DOXYGEN_SHOULD_SKIP_THIS
6357 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitmaskType::getCdrSerializedSize()",
6358 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6359 RTPS_DllAPI static size_t getCdrSerializedSize(
6360 const MinimalBitmaskType& data,
6361 size_t current_alignment = 0);
6362 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitmaskType::serialize()",
6363 "In favor of version using eprosima::fastcdr::serialize.")
6364 RTPS_DllAPI void serialize(
6365 eprosima::fastcdr::Cdr& cdr) const;
6366 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitmaskType::deserialize()",
6367 "In favor of version using eprosima::fastcdr::deserialize.")
6368 RTPS_DllAPI void deserialize(
6369 eprosima::fastcdr::Cdr& cdr);
6370#endif // DOXYGEN_SHOULD_SKIP_THIS
6371
6372 RTPS_DllAPI bool operator ==(
6373 const MinimalBitmaskType& other) const;
6374
6375 RTPS_DllAPI bool consistent(
6376 const MinimalBitmaskType& x,
6377 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6378
6379private:
6380
6381 BitmaskTypeFlag m_bitmask_flags;
6382 MinimalBitmaskHeader m_header;
6383 MinimalBitflagSeq m_flag_seq;
6384};
6385
6386// --- Bitset: ---------------------------------------------------------
6387/*struct CommonBitfield final{
6388 uint16_t position;
6389 BitsetMemberFlag flags;
6390 octet bitcount;
6391 TypeKind holder_type; // Must be primitive integer type
6392 };*/
6394{
6395public:
6396
6397 RTPS_DllAPI CommonBitfield();
6398 RTPS_DllAPI ~CommonBitfield();
6399 RTPS_DllAPI CommonBitfield(
6400 const CommonBitfield& x);
6401 RTPS_DllAPI CommonBitfield(
6402 CommonBitfield&& x);
6404 const CommonBitfield& x);
6406 CommonBitfield&& x);
6407
6408 RTPS_DllAPI inline void position(
6409 const uint16_t& _position)
6410 {
6411 m_position = _position;
6412 }
6413
6414 RTPS_DllAPI inline void position(
6415 uint16_t&& _position)
6416 {
6417 m_position = std::move(_position);
6418 }
6419
6420 RTPS_DllAPI inline const uint16_t& position() const
6421 {
6422 return m_position;
6423 }
6424
6425 RTPS_DllAPI inline uint16_t& position()
6426 {
6427 return m_position;
6428 }
6429
6430 RTPS_DllAPI inline void flags(
6431 const BitsetMemberFlag& _flags)
6432 {
6433 m_flags = _flags;
6434 }
6435
6436 RTPS_DllAPI inline void flags(
6437 BitsetMemberFlag&& _flags)
6438 {
6439 m_flags = std::move(_flags);
6440 }
6441
6442 RTPS_DllAPI inline const BitsetMemberFlag& flags() const
6443 {
6444 return m_flags;
6445 }
6446
6447 RTPS_DllAPI inline BitsetMemberFlag& flags()
6448 {
6449 return m_flags;
6450 }
6451
6452 RTPS_DllAPI inline void bitcount(
6453 const octet& _bitcount)
6454 {
6455 m_bitcount = _bitcount;
6456 }
6457
6458 RTPS_DllAPI inline void bitcount(
6459 octet&& _bitcount)
6460 {
6461 m_bitcount = std::move(_bitcount);
6462 }
6463
6464 RTPS_DllAPI inline const octet& bitcount() const
6465 {
6466 return m_bitcount;
6467 }
6468
6469 RTPS_DllAPI inline octet& bitcount()
6470 {
6471 return m_bitcount;
6472 }
6473
6474 RTPS_DllAPI inline void holder_type(
6475 const TypeKind& _holder_type)
6476 {
6477 m_holder_type = _holder_type;
6478 }
6479
6480 RTPS_DllAPI inline void holder_type(
6481 TypeKind&& _holder_type)
6482 {
6483 m_holder_type = std::move(_holder_type);
6484 }
6485
6486 RTPS_DllAPI inline const TypeKind& holder_type() const
6487 {
6488 return m_holder_type;
6489 }
6490
6491 RTPS_DllAPI inline TypeKind& holder_type()
6492 {
6493 return m_holder_type;
6494 }
6495
6496#ifndef DOXYGEN_SHOULD_SKIP_THIS
6497 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitfield::getCdrSerializedSize()",
6498 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6499 RTPS_DllAPI static size_t getCdrSerializedSize(
6500 const CommonBitfield& data,
6501 size_t current_alignment = 0);
6502 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitfield::serialize()",
6503 "In favor of version using eprosima::fastcdr::serialize.")
6504 RTPS_DllAPI void serialize(
6505 eprosima::fastcdr::Cdr& cdr) const;
6506 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CommonBitfield::deserialize()",
6507 "In favor of version using eprosima::fastcdr::deserialize.")
6508 RTPS_DllAPI void deserialize(
6509 eprosima::fastcdr::Cdr& cdr);
6510#endif // DOXYGEN_SHOULD_SKIP_THIS
6511
6512 RTPS_DllAPI bool operator ==(
6513 const CommonBitfield& other) const;
6514
6515 RTPS_DllAPI bool consistent(
6516 const CommonBitfield& x,
6517 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6518
6519private:
6520
6521 uint16_t m_position;
6522 BitsetMemberFlag m_flags;
6523 octet m_bitcount;
6524 TypeKind m_holder_type;
6525};
6526
6527/*struct CompleteBitfield {
6528 CommonBitfield common;
6529 CompleteMemberDetail detail;
6530 };*/
6532{
6533public:
6534
6535 RTPS_DllAPI CompleteBitfield();
6536 RTPS_DllAPI ~CompleteBitfield();
6537 RTPS_DllAPI CompleteBitfield(
6538 const CompleteBitfield& x);
6539 RTPS_DllAPI CompleteBitfield(
6540 CompleteBitfield&& x);
6542 const CompleteBitfield& x);
6544 CompleteBitfield&& x);
6545
6546 RTPS_DllAPI inline void common(
6547 const CommonBitfield& _common)
6548 {
6549 m_common = _common;
6550 }
6551
6552 RTPS_DllAPI inline void common(
6553 CommonBitfield&& _common)
6554 {
6555 m_common = std::move(_common);
6556 }
6557
6558 RTPS_DllAPI inline const CommonBitfield& common() const
6559 {
6560 return m_common;
6561 }
6562
6563 RTPS_DllAPI inline CommonBitfield& common()
6564 {
6565 return m_common;
6566 }
6567
6568 RTPS_DllAPI inline void detail(
6569 const CompleteMemberDetail& _detail)
6570 {
6571 m_detail = _detail;
6572 }
6573
6574 RTPS_DllAPI inline void detail(
6575 CompleteMemberDetail&& _detail)
6576 {
6577 m_detail = std::move(_detail);
6578 }
6579
6580 RTPS_DllAPI inline const CompleteMemberDetail& detail() const
6581 {
6582 return m_detail;
6583 }
6584
6585 RTPS_DllAPI inline CompleteMemberDetail& detail()
6586 {
6587 return m_detail;
6588 }
6589
6590#ifndef DOXYGEN_SHOULD_SKIP_THIS
6591 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitfield::getCdrSerializedSize()",
6592 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6593 RTPS_DllAPI static size_t getCdrSerializedSize(
6594 const CompleteBitfield& data,
6595 size_t current_alignment = 0);
6596 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitfield::serialize()",
6597 "In favor of version using eprosima::fastcdr::serialize.")
6598 RTPS_DllAPI void serialize(
6599 eprosima::fastcdr::Cdr& cdr) const;
6600 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitfielddeserialize()",
6601 "In favor of version using eprosima::fastcdr::deserialize.")
6602 RTPS_DllAPI void deserialize(
6603 eprosima::fastcdr::Cdr& cdr);
6604#endif // DOXYGEN_SHOULD_SKIP_THIS
6605
6606 RTPS_DllAPI bool operator ==(
6607 const CompleteBitfield& other) const;
6608
6609 RTPS_DllAPI bool consistent(
6610 const CompleteBitfield& x,
6611 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6612
6613private:
6614
6615 CommonBitfield m_common;
6616 CompleteMemberDetail m_detail;
6617};
6618// Ordered by Bitfield.position
6619typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
6620/*struct MinimalBitfield {
6621 CommonBitfield common;
6622 NameHash name_hash;
6623 };*/
6625{
6626public:
6627
6628 RTPS_DllAPI MinimalBitfield();
6629 RTPS_DllAPI ~MinimalBitfield();
6630 RTPS_DllAPI MinimalBitfield(
6631 const MinimalBitfield& x);
6632 RTPS_DllAPI MinimalBitfield(
6633 MinimalBitfield&& x);
6635 const MinimalBitfield& x);
6637 MinimalBitfield&& x);
6638
6639 RTPS_DllAPI inline void name_hash(
6640 const NameHash& _name_hash)
6641 {
6642 m_name_hash = _name_hash;
6643 }
6644
6645 RTPS_DllAPI inline void name_hash(
6646 NameHash&& _name_hash)
6647 {
6648 m_name_hash = std::move(_name_hash);
6649 }
6650
6651 RTPS_DllAPI inline const NameHash& name_hash() const
6652 {
6653 return m_name_hash;
6654 }
6655
6656 RTPS_DllAPI inline NameHash& name_hash()
6657 {
6658 return m_name_hash;
6659 }
6660
6661 RTPS_DllAPI inline void common(
6662 const CommonBitfield& _common)
6663 {
6664 m_common = _common;
6665 }
6666
6667 RTPS_DllAPI inline void common(
6668 CommonBitfield&& _common)
6669 {
6670 m_common = std::move(_common);
6671 }
6672
6673 RTPS_DllAPI inline const CommonBitfield& common() const
6674 {
6675 return m_common;
6676 }
6677
6678 RTPS_DllAPI inline CommonBitfield& common()
6679 {
6680 return m_common;
6681 }
6682
6683#ifndef DOXYGEN_SHOULD_SKIP_THIS
6684 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitfield::getCdrSerializedSize()",
6685 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6686 RTPS_DllAPI static size_t getCdrSerializedSize(
6687 const MinimalBitfield& data,
6688 size_t current_alignment = 0);
6689 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitfield::serialize()",
6690 "In favor of version using eprosima::fastcdr::serialize.")
6691 RTPS_DllAPI void serialize(
6692 eprosima::fastcdr::Cdr& cdr) const;
6693 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitfield::deserialize()",
6694 "In favor of version using eprosima::fastcdr::deserialize.")
6695 RTPS_DllAPI void deserialize(
6696 eprosima::fastcdr::Cdr& cdr);
6697#endif // DOXYGEN_SHOULD_SKIP_THIS
6698
6699 RTPS_DllAPI bool operator ==(
6700 const MinimalBitfield& other) const;
6701
6702 RTPS_DllAPI bool consistent(
6703 const MinimalBitfield& x,
6704 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6705
6706private:
6707
6708 CommonBitfield m_common;
6709 NameHash m_name_hash;
6710};
6711// Ordered by Bitfield.position
6712typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
6713/*struct CompleteBitsetHeader {
6714 CompleteTypeDetail detail;
6715 };*/
6717{
6718public:
6719
6723 const CompleteBitsetHeader& x);
6727 const CompleteBitsetHeader& x);
6730
6731 RTPS_DllAPI inline void base_type(
6732 const TypeIdentifier& _base_type)
6733 {
6734 m_base_type = _base_type;
6735 }
6736
6737 RTPS_DllAPI inline void base_type(
6738 TypeIdentifier&& _base_type)
6739 {
6740 m_base_type = std::move(_base_type);
6741 }
6742
6743 RTPS_DllAPI inline const TypeIdentifier& base_type() const
6744 {
6745 return m_base_type;
6746 }
6747
6748 RTPS_DllAPI inline TypeIdentifier& base_type()
6749 {
6750 return m_base_type;
6751 }
6752
6753 RTPS_DllAPI inline void detail(
6754 const CompleteTypeDetail& _detail)
6755 {
6756 m_detail = _detail;
6757 }
6758
6759 RTPS_DllAPI inline void detail(
6760 CompleteTypeDetail&& _detail)
6761 {
6762 m_detail = std::move(_detail);
6763 }
6764
6765 RTPS_DllAPI inline const CompleteTypeDetail& detail() const
6766 {
6767 return m_detail;
6768 }
6769
6770 RTPS_DllAPI inline CompleteTypeDetail& detail()
6771 {
6772 return m_detail;
6773 }
6774
6775#ifndef DOXYGEN_SHOULD_SKIP_THIS
6776 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetHeader::getCdrSerializedSize()",
6777 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6778 RTPS_DllAPI static size_t getCdrSerializedSize(
6779 const CompleteBitsetHeader& data,
6780 size_t current_alignment = 0);
6781 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetHeader::serialize()",
6782 "In favor of version using eprosima::fastcdr::serialize.")
6783 RTPS_DllAPI void serialize(
6784 eprosima::fastcdr::Cdr& cdr) const;
6785 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetHeader::deserialize()",
6786 "In favor of version using eprosima::fastcdr::deserialize.")
6787 RTPS_DllAPI void deserialize(
6788 eprosima::fastcdr::Cdr& cdr);
6789#endif // DOXYGEN_SHOULD_SKIP_THIS
6790
6791 RTPS_DllAPI bool operator ==(
6792 const CompleteBitsetHeader& other) const;
6793
6794 RTPS_DllAPI bool consistent(
6795 const CompleteBitsetHeader& x,
6796 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6797
6798private:
6799
6800 TypeIdentifier m_base_type;
6801 CompleteTypeDetail m_detail;
6802};
6803
6804/*struct MinimalBitsetHeader {
6805 // Empty. Available for future extension
6806 };*/
6808{
6809public:
6810
6811 RTPS_DllAPI MinimalBitsetHeader();
6814 const MinimalBitsetHeader& x);
6818 const MinimalBitsetHeader& x);
6821
6822 RTPS_DllAPI inline void base_type(
6823 const TypeIdentifier& _base_type)
6824 {
6825 m_base_type = _base_type;
6826 }
6827
6828 RTPS_DllAPI inline void base_type(
6829 TypeIdentifier&& _base_type)
6830 {
6831 m_base_type = std::move(_base_type);
6832 }
6833
6834 RTPS_DllAPI inline const TypeIdentifier& base_type() const
6835 {
6836 return m_base_type;
6837 }
6838
6839 RTPS_DllAPI inline TypeIdentifier& base_type()
6840 {
6841 return m_base_type;
6842 }
6843
6844#ifndef DOXYGEN_SHOULD_SKIP_THIS
6845 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetHeader::getCdrSerializedSize()",
6846 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6847 RTPS_DllAPI static size_t getCdrSerializedSize(
6848 const MinimalBitsetHeader& data,
6849 size_t current_alignment = 0);
6850 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetHeader::serialize()",
6851 "In favor of version using eprosima::fastcdr::serialize.")
6852 RTPS_DllAPI void serialize(
6853 eprosima::fastcdr::Cdr& cdr) const;
6854 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetHeader::deserialize()",
6855 "In favor of version using eprosima::fastcdr::deserialize.")
6856 RTPS_DllAPI void deserialize(
6857 eprosima::fastcdr::Cdr& cdr);
6858#endif // DOXYGEN_SHOULD_SKIP_THIS
6859
6860 RTPS_DllAPI bool operator ==(
6861 const MinimalBitsetHeader& other) const;
6862
6863 RTPS_DllAPI bool consistent(
6864 const MinimalBitsetHeader& x,
6865 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6866
6867private:
6868
6869 TypeIdentifier m_base_type;
6870};
6871/*struct CompleteBitsetType {
6872 BitsetTypeFlag bitset_flags; // unused
6873 CompleteBitsetHeader header;
6874 CompleteBitfieldSeq field_seq;
6875 };*/
6877{
6878public:
6879
6880 RTPS_DllAPI CompleteBitsetType();
6881 RTPS_DllAPI ~CompleteBitsetType();
6883 const CompleteBitsetType& x);
6885 CompleteBitsetType&& x);
6887 const CompleteBitsetType& x);
6889 CompleteBitsetType&& x);
6890
6891 RTPS_DllAPI inline void bitset_flags(
6892 const BitsetTypeFlag& _bitset_flags)
6893 {
6894 m_bitset_flags = _bitset_flags;
6895 }
6896
6897 RTPS_DllAPI inline void bitset_flags(
6898 BitsetTypeFlag&& _bitset_flags)
6899 {
6900 m_bitset_flags = std::move(_bitset_flags);
6901 }
6902
6903 RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const
6904 {
6905 return m_bitset_flags;
6906 }
6907
6908 RTPS_DllAPI inline BitsetTypeFlag& bitset_flags()
6909 {
6910 return m_bitset_flags;
6911 }
6912
6913 RTPS_DllAPI inline void header(
6914 const CompleteBitsetHeader& _header)
6915 {
6916 m_header = _header;
6917 }
6918
6919 RTPS_DllAPI inline void header(
6920 CompleteBitsetHeader&& _header)
6921 {
6922 m_header = std::move(_header);
6923 }
6924
6925 RTPS_DllAPI inline const CompleteBitsetHeader& header() const
6926 {
6927 return m_header;
6928 }
6929
6930 RTPS_DllAPI inline CompleteBitsetHeader& header()
6931 {
6932 return m_header;
6933 }
6934
6935 RTPS_DllAPI inline void field_seq(
6936 const CompleteBitfieldSeq& _field_seq)
6937 {
6938 m_field_seq = _field_seq;
6939 }
6940
6941 RTPS_DllAPI inline void field_seq(
6942 CompleteBitfieldSeq&& _field_seq)
6943 {
6944 m_field_seq = std::move(_field_seq);
6945 }
6946
6947 RTPS_DllAPI inline const CompleteBitfieldSeq& field_seq() const
6948 {
6949 return m_field_seq;
6950 }
6951
6952 RTPS_DllAPI inline CompleteBitfieldSeq& field_seq()
6953 {
6954 return m_field_seq;
6955 }
6956
6957#ifndef DOXYGEN_SHOULD_SKIP_THIS
6958 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetType::getCdrSerializedSize()",
6959 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
6960 RTPS_DllAPI static size_t getCdrSerializedSize(
6961 const CompleteBitsetType& data,
6962 size_t current_alignment = 0);
6963 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetType::serialize()",
6964 "In favor of version using eprosima::fastcdr::serialize.")
6965 RTPS_DllAPI void serialize(
6966 eprosima::fastcdr::Cdr& cdr) const;
6967 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteBitsetType::deserialize()",
6968 "In favor of version using eprosima::fastcdr::deserialize.")
6969 RTPS_DllAPI void deserialize(
6970 eprosima::fastcdr::Cdr& cdr);
6971#endif // DOXYGEN_SHOULD_SKIP_THIS
6972
6973 RTPS_DllAPI bool operator ==(
6974 const CompleteBitsetType& other) const;
6975
6976 RTPS_DllAPI bool consistent(
6977 const CompleteBitsetType& x,
6978 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
6979
6980private:
6981
6982 BitsetTypeFlag m_bitset_flags;
6983 CompleteBitsetHeader m_header;
6984 CompleteBitfieldSeq m_field_seq;
6985};
6986
6987/*struct MinimalBitsetType {
6988 BitsetTypeFlag bitset_flags; // unused
6989 MinimalBitsetHeader header;
6990 MinimalBitfieldSeq field_seq;
6991 };*/
6993{
6994public:
6995
6996 RTPS_DllAPI MinimalBitsetType();
6997 RTPS_DllAPI ~MinimalBitsetType();
6999 const MinimalBitsetType& x);
7001 MinimalBitsetType&& x);
7003 const MinimalBitsetType& x);
7005 MinimalBitsetType&& x);
7006
7007 RTPS_DllAPI inline void bitset_flags(
7008 const BitsetTypeFlag& _bitset_flags)
7009 {
7010 m_bitset_flags = _bitset_flags;
7011 }
7012
7013 RTPS_DllAPI inline void bitset_flags(
7014 BitsetTypeFlag&& _bitset_flags)
7015 {
7016 m_bitset_flags = std::move(_bitset_flags);
7017 }
7018
7019 RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const
7020 {
7021 return m_bitset_flags;
7022 }
7023
7024 RTPS_DllAPI inline BitsetTypeFlag& bitset_flags()
7025 {
7026 return m_bitset_flags;
7027 }
7028
7029 RTPS_DllAPI inline void header(
7030 const MinimalBitsetHeader& _header)
7031 {
7032 m_header = _header;
7033 }
7034
7035 RTPS_DllAPI inline void header(
7036 MinimalBitsetHeader&& _header)
7037 {
7038 m_header = std::move(_header);
7039 }
7040
7041 RTPS_DllAPI inline const MinimalBitsetHeader& header() const
7042 {
7043 return m_header;
7044 }
7045
7046 RTPS_DllAPI inline MinimalBitsetHeader& header()
7047 {
7048 return m_header;
7049 }
7050
7051 RTPS_DllAPI inline void field_seq(
7052 const MinimalBitfieldSeq& _field_seq)
7053 {
7054 m_field_seq = _field_seq;
7055 }
7056
7057 RTPS_DllAPI inline void field_seq(
7058 MinimalBitfieldSeq&& _field_seq)
7059 {
7060 m_field_seq = std::move(_field_seq);
7061 }
7062
7063 RTPS_DllAPI inline const MinimalBitfieldSeq& field_seq() const
7064 {
7065 return m_field_seq;
7066 }
7067
7068 RTPS_DllAPI inline MinimalBitfieldSeq& field_seq()
7069 {
7070 return m_field_seq;
7071 }
7072
7073#ifndef DOXYGEN_SHOULD_SKIP_THIS
7074 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetType::getCdrSerializedSize()",
7075 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7076 RTPS_DllAPI static size_t getCdrSerializedSize(
7077 const MinimalBitsetType& data,
7078 size_t current_alignment = 0);
7079 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetType::serialize()",
7080 "In favor of version using eprosima::fastcdr::serialize.")
7081 RTPS_DllAPI void serialize(
7082 eprosima::fastcdr::Cdr& cdr) const;
7083 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalBitsetType::deserialize()",
7084 "In favor of version using eprosima::fastcdr::deserialize.")
7085 RTPS_DllAPI void deserialize(
7086 eprosima::fastcdr::Cdr& cdr);
7087#endif // DOXYGEN_SHOULD_SKIP_THIS
7088
7089 RTPS_DllAPI bool operator ==(
7090 const MinimalBitsetType& other) const;
7091
7092 RTPS_DllAPI bool consistent(
7093 const MinimalBitsetType& x,
7094 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7095
7096private:
7097
7098 BitsetTypeFlag m_bitset_flags;
7099 MinimalBitsetHeader m_header;
7100 MinimalBitfieldSeq m_field_seq;
7101};
7102
7103// --- Type Object: --------------------------------------------------
7104// The types associated with each case selection must have extensibility
7105// kind APPENDABLE or MUTABLE so that they can be extended in the future
7106
7107/*struct CompleteExtendedType {
7108 // Empty. Available for future extension
7109 };*/
7111{
7112public:
7113
7117 const CompleteExtendedType& x);
7121 const CompleteExtendedType& x);
7124
7125#ifndef DOXYGEN_SHOULD_SKIP_THIS
7126 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteExtendedType::getCdrSerializedSize()",
7127 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7128 RTPS_DllAPI static size_t getCdrSerializedSize(
7129 const CompleteExtendedType& data,
7130 size_t current_alignment = 0);
7131 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteExtendedType::serialize()",
7132 "In favor of version using eprosima::fastcdr::serialize.")
7133 RTPS_DllAPI void serialize(
7134 eprosima::fastcdr::Cdr& cdr) const;
7135 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteExtendedType::deserialize()",
7136 "In favor of version using eprosima::fastcdr::deserialize.")
7137 RTPS_DllAPI void deserialize(
7138 eprosima::fastcdr::Cdr& cdr);
7139#endif // DOXYGEN_SHOULD_SKIP_THIS
7140
7141 RTPS_DllAPI bool operator ==(
7142 const CompleteExtendedType&) const
7143 {
7144 return true;
7145 }
7146
7147 RTPS_DllAPI bool consistent(
7148 const CompleteExtendedType& x,
7149 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7150
7151private:
7152
7153};
7154
7155/*struct MinimalExtendedType {
7156 // Empty. Available for future extension
7157 };*/
7159{
7160public:
7161
7162 RTPS_DllAPI MinimalExtendedType();
7165 const MinimalExtendedType& x);
7169 const MinimalExtendedType& x);
7172
7173#ifndef DOXYGEN_SHOULD_SKIP_THIS
7174 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalExtendedType::getCdrSerializedSize()",
7175 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7176 RTPS_DllAPI static size_t getCdrSerializedSize(
7177 const MinimalExtendedType& data,
7178 size_t current_alignment = 0);
7179 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalExtendedType::serialize()",
7180 "In favor of version using eprosima::fastcdr::serialize.")
7181 RTPS_DllAPI void serialize(
7182 eprosima::fastcdr::Cdr& cdr) const;
7183 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalExtendedType::deserialize()",
7184 "In favor of version using eprosima::fastcdr::deserialize.")
7185 RTPS_DllAPI void deserialize(
7186 eprosima::fastcdr::Cdr& cdr);
7187#endif // DOXYGEN_SHOULD_SKIP_THIS
7188
7189 RTPS_DllAPI bool operator ==(
7190 const MinimalExtendedType&) const
7191 {
7192 return true;
7193 }
7194
7195 RTPS_DllAPI bool consistent(
7196 const MinimalExtendedType& x,
7197 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7198
7199private:
7200
7201};
7202
7204{
7205public:
7206
7207 RTPS_DllAPI CompleteTypeObject();
7208 RTPS_DllAPI ~CompleteTypeObject();
7210 const CompleteTypeObject& x);
7212 CompleteTypeObject&& x);
7214 const CompleteTypeObject& x);
7216 CompleteTypeObject&& x);
7217 RTPS_DllAPI void _d(
7218 octet __d);
7219 RTPS_DllAPI octet _d() const;
7220 RTPS_DllAPI octet& _d();
7221
7222 RTPS_DllAPI void alias_type(
7223 CompleteAliasType _alias_type);
7224 RTPS_DllAPI const CompleteAliasType& alias_type() const;
7226
7227 RTPS_DllAPI void annotation_type(
7228 CompleteAnnotationType _annotation_type);
7229 RTPS_DllAPI const CompleteAnnotationType& annotation_type() const;
7231
7232 RTPS_DllAPI void struct_type(
7233 CompleteStructType _struct_type);
7234 RTPS_DllAPI const CompleteStructType& struct_type() const;
7236
7237 RTPS_DllAPI void union_type(
7238 CompleteUnionType _union_type);
7239 RTPS_DllAPI const CompleteUnionType& union_type() const;
7241
7242 RTPS_DllAPI void bitset_type(
7243 CompleteBitsetType _bitset_type);
7244 RTPS_DllAPI const CompleteBitsetType& bitset_type() const;
7246
7247 RTPS_DllAPI void sequence_type(
7248 CompleteSequenceType _sequence_type);
7249 RTPS_DllAPI const CompleteSequenceType& sequence_type() const;
7251
7252 RTPS_DllAPI void array_type(
7253 CompleteArrayType _array_type);
7254 RTPS_DllAPI const CompleteArrayType& array_type() const;
7256
7257 RTPS_DllAPI void map_type(
7258 CompleteMapType _map_type);
7259 RTPS_DllAPI const CompleteMapType& map_type() const;
7261
7262 RTPS_DllAPI void enumerated_type(
7263 CompleteEnumeratedType _enumerated_type);
7264 RTPS_DllAPI const CompleteEnumeratedType& enumerated_type() const;
7266
7267 RTPS_DllAPI void bitmask_type(
7268 CompleteBitmaskType _bitmask_type);
7269 RTPS_DllAPI const CompleteBitmaskType& bitmask_type() const;
7271
7272 RTPS_DllAPI void extended_type(
7273 CompleteExtendedType _extended_type);
7274 RTPS_DllAPI const CompleteExtendedType& extended_type() const;
7276
7277#ifndef DOXYGEN_SHOULD_SKIP_THIS
7278 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeObject::getCdrSerializedSize()",
7279 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7280 RTPS_DllAPI static size_t getCdrSerializedSize(
7281 const CompleteTypeObject& data,
7282 size_t current_alignment = 0);
7283 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeObject::serialize()",
7284 "In favor of version using eprosima::fastcdr::serialize.")
7285 RTPS_DllAPI void serialize(
7286 eprosima::fastcdr::Cdr& cdr) const;
7287 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::CompleteTypeObject::deserialize()",
7288 "In favor of version using eprosima::fastcdr::deserialize.")
7289 RTPS_DllAPI void deserialize(
7290 eprosima::fastcdr::Cdr& cdr);
7291#endif // DOXYGEN_SHOULD_SKIP_THIS
7292
7293 RTPS_DllAPI bool operator ==(
7294 const CompleteTypeObject& other) const;
7295
7296 RTPS_DllAPI bool consistent(
7297 const CompleteTypeObject& x,
7298 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7299
7300private:
7301
7302 octet m__d;
7303
7304 CompleteAliasType m_alias_type;
7305 CompleteAnnotationType m_annotation_type;
7306 CompleteStructType m_struct_type;
7307 CompleteUnionType m_union_type;
7308 CompleteBitsetType m_bitset_type;
7309 CompleteSequenceType m_sequence_type;
7310 CompleteArrayType m_array_type;
7311 CompleteMapType m_map_type;
7312 CompleteEnumeratedType m_enumerated_type;
7313 CompleteBitmaskType m_bitmask_type;
7314 CompleteExtendedType m_extended_type;
7315};
7316
7318{
7319public:
7320
7321 RTPS_DllAPI MinimalTypeObject();
7322 RTPS_DllAPI ~MinimalTypeObject();
7324 const MinimalTypeObject& x);
7326 MinimalTypeObject&& x);
7328 const MinimalTypeObject& x);
7330 MinimalTypeObject&& x);
7331 RTPS_DllAPI void _d(
7332 octet __d);
7333 RTPS_DllAPI octet _d() const;
7334 RTPS_DllAPI octet& _d();
7335
7336 RTPS_DllAPI void alias_type(
7337 MinimalAliasType _alias_type);
7338 RTPS_DllAPI const MinimalAliasType& alias_type() const;
7340
7341 RTPS_DllAPI void annotation_type(
7342 MinimalAnnotationType _annotation_type);
7343 RTPS_DllAPI const MinimalAnnotationType& annotation_type() const;
7345
7346 RTPS_DllAPI void struct_type(
7347 MinimalStructType _struct_type);
7348 RTPS_DllAPI const MinimalStructType& struct_type() const;
7350
7351 RTPS_DllAPI void union_type(
7352 MinimalUnionType _union_type);
7353 RTPS_DllAPI const MinimalUnionType& union_type() const;
7355
7356 RTPS_DllAPI void bitset_type(
7357 MinimalBitsetType _bitset_type);
7358 RTPS_DllAPI const MinimalBitsetType& bitset_type() const;
7360
7361 RTPS_DllAPI void sequence_type(
7362 MinimalSequenceType _sequence_type);
7363 RTPS_DllAPI const MinimalSequenceType& sequence_type() const;
7365
7366 RTPS_DllAPI void array_type(
7367 MinimalArrayType _array_type);
7368 RTPS_DllAPI const MinimalArrayType& array_type() const;
7370
7371 RTPS_DllAPI void map_type(
7372 MinimalMapType _map_type);
7373 RTPS_DllAPI const MinimalMapType& map_type() const;
7374 RTPS_DllAPI MinimalMapType& map_type();
7375
7376 RTPS_DllAPI void enumerated_type(
7377 MinimalEnumeratedType _enumerated_type);
7378 RTPS_DllAPI const MinimalEnumeratedType& enumerated_type() const;
7380
7381 RTPS_DllAPI void bitmask_type(
7382 MinimalBitmaskType _bitmask_type);
7383 RTPS_DllAPI const MinimalBitmaskType& bitmask_type() const;
7385
7386 RTPS_DllAPI void extended_type(
7387 MinimalExtendedType _extended_type);
7388 RTPS_DllAPI const MinimalExtendedType& extended_type() const;
7390
7391#ifndef DOXYGEN_SHOULD_SKIP_THIS
7392 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeObject::getCdrSerializedSize()",
7393 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7394 RTPS_DllAPI static size_t getCdrSerializedSize(
7395 const MinimalTypeObject& data,
7396 size_t current_alignment = 0);
7397 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeObject::serialize()",
7398 "In favor of version using eprosima::fastcdr::serialize.")
7399 RTPS_DllAPI void serialize(
7400 eprosima::fastcdr::Cdr& cdr) const;
7401 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::MinimalTypeObject::deserialize()",
7402 "In favor of version using eprosima::fastcdr::deserialize.")
7403 RTPS_DllAPI void deserialize(
7404 eprosima::fastcdr::Cdr& cdr);
7405#endif // DOXYGEN_SHOULD_SKIP_THIS
7406
7407 RTPS_DllAPI bool operator ==(
7408 const MinimalTypeObject& other) const;
7409
7410 RTPS_DllAPI bool consistent(
7411 const MinimalTypeObject& x,
7412 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7413
7414private:
7415
7416 octet m__d;
7417
7418 MinimalAliasType m_alias_type;
7419 MinimalAnnotationType m_annotation_type;
7420 MinimalStructType m_struct_type;
7421 MinimalUnionType m_union_type;
7422 MinimalBitsetType m_bitset_type;
7423 MinimalSequenceType m_sequence_type;
7424 MinimalArrayType m_array_type;
7425 MinimalMapType m_map_type;
7426 MinimalEnumeratedType m_enumerated_type;
7427 MinimalBitmaskType m_bitmask_type;
7428 MinimalExtendedType m_extended_type;
7429};
7431{
7432public:
7433
7437 RTPS_DllAPI TypeObject();
7438
7442 RTPS_DllAPI ~TypeObject();
7443
7448 RTPS_DllAPI TypeObject(
7449 const TypeObject& x);
7450
7455 RTPS_DllAPI TypeObject(
7456 TypeObject&& x);
7457
7463 const TypeObject& x);
7464
7470 TypeObject&& x);
7471
7477 RTPS_DllAPI void _d(
7478 uint8_t __d);
7479
7484 RTPS_DllAPI uint8_t _d() const;
7485
7490 RTPS_DllAPI uint8_t& _d();
7491
7496 RTPS_DllAPI void complete(
7497 const CompleteTypeObject& _complete);
7498
7503 RTPS_DllAPI void complete(
7504 CompleteTypeObject&& _complete);
7505
7511 RTPS_DllAPI const CompleteTypeObject& complete() const;
7512
7523 RTPS_DllAPI void minimal(
7524 const MinimalTypeObject& _minimal);
7525
7530 RTPS_DllAPI void minimal(
7531 MinimalTypeObject&& _minimal);
7532
7538 RTPS_DllAPI const MinimalTypeObject& minimal() const;
7539
7546
7547#ifndef DOXYGEN_SHOULD_SKIP_THIS
7554 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeObject::getCdrSerializedSize()",
7555 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7556 RTPS_DllAPI static size_t getCdrSerializedSize(
7557 const TypeObject& data,
7558 size_t current_alignment = 0);
7563 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeObject::serialize()",
7564 "In favor of version using eprosima::fastcdr::serialize.")
7565 RTPS_DllAPI void serialize(
7566 eprosima::fastcdr::Cdr& cdr) const;
7567
7572 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeObject::deserialize()",
7573 "In favor of version using eprosima::fastcdr::deserialize.")
7574 RTPS_DllAPI void deserialize(
7575 eprosima::fastcdr::Cdr& cdr);
7576#endif // DOXYGEN_SHOULD_SKIP_THIS
7577
7578 RTPS_DllAPI bool operator ==(
7579 const TypeObject& other) const;
7580
7586 RTPS_DllAPI bool consistent(
7587 const TypeObject& x,
7588 const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
7589
7590private:
7591
7592 uint8_t m__d;
7593
7594 CompleteTypeObject m_complete;
7595 MinimalTypeObject m_minimal;
7596};
7597
7598typedef std::vector<TypeObject> TypeObjectSeq;
7599
7600// Set of TypeObjects representing a strong component: Equivalence class
7601// for the Strong Connectivity relationship (mutual reachability between
7602// types).
7603// Ordered by fully qualified typename lexicographic order
7605
7606/*struct TypeIdentifierTypeObjectPair final {
7607 TypeIdentifier type_identifier;
7608 TypeObject type_object;
7609 };*/
7611{
7612public:
7613
7624
7625 RTPS_DllAPI inline void type_identifier(
7626 const TypeIdentifier& _type_identifier)
7627 {
7628 m_type_identifier = _type_identifier;
7629 }
7630
7631 RTPS_DllAPI inline void type_identifier(
7632 TypeIdentifier&& _type_identifier)
7633 {
7634 m_type_identifier = std::move(_type_identifier);
7635 }
7636
7637 RTPS_DllAPI inline const TypeIdentifier& type_identifier() const
7638 {
7639 return m_type_identifier;
7640 }
7641
7642 RTPS_DllAPI inline TypeIdentifier& type_identifier()
7643 {
7644 return m_type_identifier;
7645 }
7646
7647 RTPS_DllAPI inline void type_object(
7648 const TypeObject& _type_object)
7649 {
7650 m_type_object = _type_object;
7651 }
7652
7653 RTPS_DllAPI inline void type_object(
7654 TypeObject&& _type_object)
7655 {
7656 m_type_object = std::move(_type_object);
7657 }
7658
7659 RTPS_DllAPI inline const TypeObject& type_object() const
7660 {
7661 return m_type_object;
7662 }
7663
7664 RTPS_DllAPI inline TypeObject& type_object()
7665 {
7666 return m_type_object;
7667 }
7668
7669#ifndef DOXYGEN_SHOULD_SKIP_THIS
7670 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierTypeObjectPair::getCdrSerializedSize()",
7671 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7672 RTPS_DllAPI static size_t getCdrSerializedSize(
7673 const TypeIdentifierTypeObjectPair& data,
7674 size_t current_alignment = 0);
7675 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierTypeObjectPair::serialize()",
7676 "In favor of version using eprosima::fastcdr::serialize.")
7677 RTPS_DllAPI void serialize(
7678 eprosima::fastcdr::Cdr& cdr) const;
7679 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierTypeObjectPair::deserialize()",
7680 "In favor of version using eprosima::fastcdr::deserialize.")
7681 RTPS_DllAPI void deserialize(
7682 eprosima::fastcdr::Cdr& cdr);
7683#endif // DOXYGEN_SHOULD_SKIP_THIS
7684
7685private:
7686
7687 TypeIdentifier m_type_identifier;
7688 TypeObject m_type_object;
7689};
7690typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
7691
7692/*struct TypeIdentifierPair final {
7693 TypeIdentifier type_identifier1;
7694 TypeIdentifier type_identifier2;
7695 };*/
7697{
7698public:
7699
7700 RTPS_DllAPI TypeIdentifierPair();
7701 RTPS_DllAPI ~TypeIdentifierPair();
7703 const TypeIdentifierPair& x);
7705 TypeIdentifierPair&& x);
7707 const TypeIdentifierPair& x);
7709 TypeIdentifierPair&& x);
7710
7711 RTPS_DllAPI inline void type_identifier1(
7712 const TypeIdentifier& _type_identifier1)
7713 {
7714 m_type_identifier1 = _type_identifier1;
7715 }
7716
7717 RTPS_DllAPI inline void type_identifier1(
7718 TypeIdentifier&& _type_identifier1)
7719 {
7720 m_type_identifier1 = std::move(_type_identifier1);
7721 }
7722
7723 RTPS_DllAPI inline const TypeIdentifier& type_identifier1() const
7724 {
7725 return m_type_identifier1;
7726 }
7727
7728 RTPS_DllAPI inline TypeIdentifier& type_identifier1()
7729 {
7730 return m_type_identifier1;
7731 }
7732
7733 RTPS_DllAPI inline void type_identifier2(
7734 const TypeIdentifier& _type_identifier2)
7735 {
7736 m_type_identifier2 = _type_identifier2;
7737 }
7738
7739 RTPS_DllAPI inline void type_identifier2(
7740 TypeIdentifier&& _type_identifier2)
7741 {
7742 m_type_identifier2 = std::move(_type_identifier2);
7743 }
7744
7745 RTPS_DllAPI inline const TypeIdentifier& type_identifier2() const
7746 {
7747 return m_type_identifier2;
7748 }
7749
7750 RTPS_DllAPI inline TypeIdentifier& type_identifier2()
7751 {
7752 return m_type_identifier2;
7753 }
7754
7755#ifndef DOXYGEN_SHOULD_SKIP_THIS
7756 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierPair::getCdrSerializedSize()",
7757 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7758 RTPS_DllAPI static size_t getCdrSerializedSize(
7759 const TypeIdentifierPair& data,
7760 size_t current_alignment = 0);
7761 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierPair::serialize()",
7762 "In favor of version using eprosima::fastcdr::serialize.")
7763 RTPS_DllAPI void serialize(
7764 eprosima::fastcdr::Cdr& cdr) const;
7765 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierPair::deserialize()",
7766 "In favor of version using eprosima::fastcdr::deserialize.")
7767 RTPS_DllAPI void deserialize(
7768 eprosima::fastcdr::Cdr& cdr);
7769#endif // DOXYGEN_SHOULD_SKIP_THIS
7770
7771private:
7772
7773 TypeIdentifier m_type_identifier1;
7774 TypeIdentifier m_type_identifier2;
7775};
7776
7777typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
7778/*struct TypeIdentifierWithSize {
7779 TypeIdentifier type_id;
7780 uint32_t typeobject_serialized_size;
7781 };*/
7783{
7784public:
7785
7789 const TypeIdentifierWithSize& x);
7793 const TypeIdentifierWithSize& x);
7796
7797 RTPS_DllAPI inline void type_id(
7798 const TypeIdentifier& _type_id)
7799 {
7800 m_type_id = _type_id;
7801 }
7802
7803 RTPS_DllAPI inline void type_id(
7804 TypeIdentifier&& _type_id)
7805 {
7806 m_type_id = std::move(_type_id);
7807 }
7808
7809 RTPS_DllAPI inline const TypeIdentifier& type_id() const
7810 {
7811 return m_type_id;
7812 }
7813
7814 RTPS_DllAPI inline TypeIdentifier& type_id()
7815 {
7816 return m_type_id;
7817 }
7818
7819 RTPS_DllAPI inline void typeobject_serialized_size(
7820 const uint32_t& _typeobject_serialized_size)
7821 {
7822 m_typeobject_serialized_size = _typeobject_serialized_size;
7823 }
7824
7825 RTPS_DllAPI inline void typeobject_serialized_size(
7826 uint32_t&& _typeobject_serialized_size)
7827 {
7828 m_typeobject_serialized_size = std::move(_typeobject_serialized_size);
7829 }
7830
7831 RTPS_DllAPI inline const uint32_t& typeobject_serialized_size() const
7832 {
7833 return m_typeobject_serialized_size;
7834 }
7835
7836 RTPS_DllAPI inline uint32_t& typeobject_serialized_size()
7837 {
7838 return m_typeobject_serialized_size;
7839 }
7840
7841#ifndef DOXYGEN_SHOULD_SKIP_THIS
7842 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithSize::getCdrSerializedSize()",
7843 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7844 RTPS_DllAPI static size_t getCdrSerializedSize(
7845 const TypeIdentifierWithSize& data,
7846 size_t current_alignment = 0);
7847 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithSize::serialize()",
7848 "In favor of version using eprosima::fastcdr::serialize.")
7849 RTPS_DllAPI void serialize(
7850 eprosima::fastcdr::Cdr& cdr) const;
7851 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithSize::deserialize()",
7852 "In favor of version using eprosima::fastcdr::deserialize.")
7853 RTPS_DllAPI void deserialize(
7854 eprosima::fastcdr::Cdr& cdr);
7855#endif // DOXYGEN_SHOULD_SKIP_THIS
7856
7857private:
7858
7859 TypeIdentifier m_type_id;
7860 uint32_t m_typeobject_serialized_size;
7861};
7862
7863typedef std::vector<TypeIdentifierWithSize> TypeIdentifierWithSizeSeq;
7864
7865/*struct TypeIdentifierWithDependencies {
7866 TypeIdentifierWithSize typeid_with_size;
7867 // The total additional types related to minimal_type
7868 int32_t dependent_typeid_count;
7869 TypeIdentifierWithSizeSeq dependent_typeids;
7870 };*/
7872{
7873public:
7874
7885
7886 RTPS_DllAPI inline void typeid_with_size(
7887 const TypeIdentifierWithSize& _typeid_with_size)
7888 {
7889 m_typeid_with_size = _typeid_with_size;
7890 }
7891
7892 RTPS_DllAPI inline void typeid_with_size(
7893 TypeIdentifierWithSize&& _typeid_with_size)
7894 {
7895 m_typeid_with_size = std::move(_typeid_with_size);
7896 }
7897
7898 RTPS_DllAPI inline const TypeIdentifierWithSize& typeid_with_size() const
7899 {
7900 return m_typeid_with_size;
7901 }
7902
7904 {
7905 return m_typeid_with_size;
7906 }
7907
7908 RTPS_DllAPI inline void dependent_typeid_count(
7909 const int32_t& _dependent_typeid_count)
7910 {
7911 m_dependent_typeid_count = _dependent_typeid_count;
7912 }
7913
7914 RTPS_DllAPI inline void dependent_typeid_count(
7915 int32_t&& _dependent_typeid_count)
7916 {
7917 m_dependent_typeid_count = std::move(_dependent_typeid_count);
7918 }
7919
7920 RTPS_DllAPI inline const int32_t& dependent_typeid_count() const
7921 {
7922 return m_dependent_typeid_count;
7923 }
7924
7925 RTPS_DllAPI inline int32_t& dependent_typeid_count()
7926 {
7927 return m_dependent_typeid_count;
7928 }
7929
7930 RTPS_DllAPI inline void dependent_typeids(
7931 const TypeIdentifierWithSizeSeq& _dependent_typeids)
7932 {
7933 m_dependent_typeids = _dependent_typeids;
7934 }
7935
7936 RTPS_DllAPI inline void dependent_typeids(
7937 TypeIdentifierWithSizeSeq&& _dependent_typeids)
7938 {
7939 m_dependent_typeids = std::move(_dependent_typeids);
7940 }
7941
7942 RTPS_DllAPI inline const TypeIdentifierWithSizeSeq& dependent_typeids() const
7943 {
7944 return m_dependent_typeids;
7945 }
7946
7948 {
7949 return m_dependent_typeids;
7950 }
7951
7952#ifndef DOXYGEN_SHOULD_SKIP_THIS
7953 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithDependencies::getCdrSerializedSize()",
7954 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
7955 RTPS_DllAPI static size_t getCdrSerializedSize(
7957 size_t current_alignment = 0);
7958 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithDependencies::serialize()",
7959 "In favor of version using eprosima::fastcdr::serialize.")
7960 RTPS_DllAPI void serialize(
7961 eprosima::fastcdr::Cdr& cdr) const;
7962 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeIdentifierWithDependencies::deserialize()",
7963 "In favor of version using eprosima::fastcdr::deserialize.")
7964 RTPS_DllAPI void deserialize(
7965 eprosima::fastcdr::Cdr& cdr);
7966#endif // DOXYGEN_SHOULD_SKIP_THIS
7967
7968private:
7969
7970 TypeIdentifierWithSize m_typeid_with_size;
7971 int32_t m_dependent_typeid_count;
7972 TypeIdentifierWithSizeSeq m_dependent_typeids;
7973};
7974
7975typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
7977
7978// This appears in the builtin DDS topics PublicationBuiltinTopicData
7979// and SubscriptionBuiltinTopicData
7980
7981/*struct TypeInformation {
7982 TypeIdentifierWithDependencies minimal; // @id{0x1001}
7983 TypeIdentifierWithDependencies complete; // @id{0x1002}
7984 };*/
7986{
7987public:
7988
7989 RTPS_DllAPI TypeInformation();
7990 RTPS_DllAPI ~TypeInformation();
7991 RTPS_DllAPI TypeInformation(
7992 const TypeInformation& x);
7993 RTPS_DllAPI TypeInformation(
7994 TypeInformation&& x);
7996 const TypeInformation& x);
7998 TypeInformation&& x);
7999
8000 RTPS_DllAPI inline void minimal(
8001 const TypeIdentifierWithDependencies& _minimal)
8002 {
8003 m_minimal = _minimal;
8004 }
8005
8006 RTPS_DllAPI inline void minimal(
8008 {
8009 m_minimal = std::move(_minimal);
8010 }
8011
8012 RTPS_DllAPI inline const TypeIdentifierWithDependencies& minimal() const
8013 {
8014 return m_minimal;
8015 }
8016
8018 {
8019 return m_minimal;
8020 }
8021
8022 RTPS_DllAPI inline void complete(
8023 const TypeIdentifierWithDependencies& _complete)
8024 {
8025 m_complete = _complete;
8026 }
8027
8028 RTPS_DllAPI inline void complete(
8030 {
8031 m_complete = std::move(_complete);
8032 }
8033
8034 RTPS_DllAPI inline const TypeIdentifierWithDependencies& complete() const
8035 {
8036 return m_complete;
8037 }
8038
8040 {
8041 return m_complete;
8042 }
8043
8044#ifndef DOXYGEN_SHOULD_SKIP_THIS
8045 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeInformation::getCdrSerializedSize()",
8046 "In favor of version using eprosima::fastcdr::calculate_serialized_size.")
8047 RTPS_DllAPI static size_t getCdrSerializedSize(
8048 const TypeInformation& data,
8049 size_t current_alignment = 0);
8050
8051 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeInformation::serialize()",
8052 "In favor of version using eprosima::fastcdr::serialize.")
8053 RTPS_DllAPI void serialize(
8054 eprosima::fastcdr::Cdr& cdr) const;
8055
8056 FASTDDS_SER_METHOD_DEPRECATED(3, "eprosima::fastrtps::types::TypeInformation::deserialize()",
8057 "In favor of version using eprosima::fastcdr::deserialize.")
8058 RTPS_DllAPI void deserialize(
8059 eprosima::fastcdr::Cdr& cdr);
8060#endif // DOXYGEN_SHOULD_SKIP_THIS
8061
8062private:
8063
8066};
8067
8068typedef std::vector<TypeInformation> TypeInformationSeq;
8070
8071} // namespace types
8072} // namespace fastrtps
8073} // namespace eprosima
8074
8075#endif // TYPES_TYPE_OBJECT_H
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition AnnotationParameterValue.h:173
Definition AnnotationParameterValue.h:1289
RTPS_DllAPI AppliedVerbatimAnnotation & verbatim()
Definition TypeObject.h:568
RTPS_DllAPI AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI bool consistent(const AppliedBuiltinTypeAnnotations &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x)
RTPS_DllAPI const AppliedVerbatimAnnotation & verbatim() const
Definition TypeObject.h:563
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI void verbatim(AppliedVerbatimAnnotation &&_verbatim)
Definition TypeObject.h:557
RTPS_DllAPI bool operator==(const AppliedBuiltinTypeAnnotations &other) const
RTPS_DllAPI void verbatim(const AppliedVerbatimAnnotation &_verbatim)
Definition TypeObject.h:551
Definition AnnotationParameterValue.h:1159
Definition TypeObject.h:2894
RTPS_DllAPI CommonAliasBody(const CommonAliasBody &x)
RTPS_DllAPI CommonAliasBody & operator=(const CommonAliasBody &x)
RTPS_DllAPI CommonAliasBody(CommonAliasBody &&x)
RTPS_DllAPI const AliasMemberFlag & related_flags() const
Definition TypeObject.h:2920
RTPS_DllAPI void related_flags(AliasMemberFlag &&_related_flags)
Definition TypeObject.h:2914
RTPS_DllAPI TypeIdentifier & related_type()
Definition TypeObject.h:2947
RTPS_DllAPI AliasMemberFlag & related_flags()
Definition TypeObject.h:2925
RTPS_DllAPI void related_flags(const AliasMemberFlag &_related_flags)
Definition TypeObject.h:2908
RTPS_DllAPI bool operator==(const CommonAliasBody &other) const
RTPS_DllAPI void related_type(TypeIdentifier &&_related_type)
Definition TypeObject.h:2936
RTPS_DllAPI void related_type(const TypeIdentifier &_related_type)
Definition TypeObject.h:2930
RTPS_DllAPI const TypeIdentifier & related_type() const
Definition TypeObject.h:2942
RTPS_DllAPI AnnotationParameterFlag & member_flags()
Definition TypeObject.h:2248
RTPS_DllAPI CommonAnnotationParameter(CommonAnnotationParameter &&x)
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition TypeObject.h:2259
RTPS_DllAPI void member_flags(const AnnotationParameterFlag &_member_flags)
Definition TypeObject.h:2231
RTPS_DllAPI CommonAnnotationParameter(const CommonAnnotationParameter &x)
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition TypeObject.h:2253
RTPS_DllAPI void member_flags(AnnotationParameterFlag &&_member_flags)
Definition TypeObject.h:2237
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition TypeObject.h:2270
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:2265
RTPS_DllAPI CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
RTPS_DllAPI const AnnotationParameterFlag & member_flags() const
Definition TypeObject.h:2243
RTPS_DllAPI bool consistent(const CommonArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bound_seq(const LBoundSeq &_bound_seq)
Definition TypeObject.h:4329
RTPS_DllAPI CommonArrayHeader & operator=(const CommonArrayHeader &x)
RTPS_DllAPI CommonArrayHeader(const CommonArrayHeader &x)
RTPS_DllAPI LBoundSeq & bound_seq()
Definition TypeObject.h:4346
RTPS_DllAPI const LBoundSeq & bound_seq() const
Definition TypeObject.h:4341
RTPS_DllAPI CommonArrayHeader(CommonArrayHeader &&x)
RTPS_DllAPI void bound_seq(LBoundSeq &&_bound_seq)
Definition TypeObject.h:4335
RTPS_DllAPI bool operator==(const CommonArrayHeader &other) const
Definition TypeObject.h:6394
RTPS_DllAPI void bitcount(octet &&_bitcount)
Definition TypeObject.h:6458
RTPS_DllAPI CommonBitfield(const CommonBitfield &x)
RTPS_DllAPI void holder_type(TypeKind &&_holder_type)
Definition TypeObject.h:6480
RTPS_DllAPI octet & bitcount()
Definition TypeObject.h:6469
RTPS_DllAPI BitsetMemberFlag & flags()
Definition TypeObject.h:6447
RTPS_DllAPI const TypeKind & holder_type() const
Definition TypeObject.h:6486
RTPS_DllAPI CommonBitfield(CommonBitfield &&x)
RTPS_DllAPI CommonBitfield & operator=(const CommonBitfield &x)
RTPS_DllAPI const uint16_t & position() const
Definition TypeObject.h:6420
RTPS_DllAPI TypeKind & holder_type()
Definition TypeObject.h:6491
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:6474
RTPS_DllAPI uint16_t & position()
Definition TypeObject.h:6425
RTPS_DllAPI void bitcount(const octet &_bitcount)
Definition TypeObject.h:6452
RTPS_DllAPI void position(uint16_t &&_position)
Definition TypeObject.h:6414
RTPS_DllAPI void position(const uint16_t &_position)
Definition TypeObject.h:6408
RTPS_DllAPI const octet & bitcount() const
Definition TypeObject.h:6464
RTPS_DllAPI const BitsetMemberFlag & flags() const
Definition TypeObject.h:6442
RTPS_DllAPI void flags(BitsetMemberFlag &&_flags)
Definition TypeObject.h:6436
RTPS_DllAPI void flags(const BitsetMemberFlag &_flags)
Definition TypeObject.h:6430
Definition TypeObject.h:5809
RTPS_DllAPI CommonBitflag(const CommonBitflag &x)
RTPS_DllAPI const uint16_t & position() const
Definition TypeObject.h:5835
RTPS_DllAPI const BitflagFlag & flags() const
Definition TypeObject.h:5857
RTPS_DllAPI BitflagFlag & flags()
Definition TypeObject.h:5862
RTPS_DllAPI CommonBitflag(CommonBitflag &&x)
RTPS_DllAPI uint16_t & position()
Definition TypeObject.h:5840
RTPS_DllAPI void flags(BitflagFlag &&_flags)
Definition TypeObject.h:5851
RTPS_DllAPI bool consistent(const CommonBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void flags(const BitflagFlag &_flags)
Definition TypeObject.h:5845
RTPS_DllAPI void position(uint16_t &&_position)
Definition TypeObject.h:5829
RTPS_DllAPI void position(const uint16_t &_position)
Definition TypeObject.h:5823
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:6102
RTPS_DllAPI CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
RTPS_DllAPI BitBound & bit_bound()
Definition TypeObject.h:6119
RTPS_DllAPI bool consistent(const CommonBitmaskHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const BitBound & bit_bound() const
Definition TypeObject.h:6114
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition TypeObject.h:6108
RTPS_DllAPI CommonBitmaskHeader(const CommonBitmaskHeader &x)
RTPS_DllAPI CommonBitmaskHeader(CommonBitmaskHeader &&x)
RTPS_DllAPI bool operator==(const CommonBitmaskHeader &other) const
RTPS_DllAPI void element_flags(const CollectionElementFlag &_element_flags)
Definition TypeObject.h:3616
RTPS_DllAPI CommonCollectionElement(CommonCollectionElement &&x)
RTPS_DllAPI bool operator==(const CommonCollectionElement &other) const
RTPS_DllAPI TypeIdentifier & type()
Definition TypeObject.h:3655
RTPS_DllAPI CommonCollectionElement & operator=(const CommonCollectionElement &x)
RTPS_DllAPI void type(TypeIdentifier &&_type)
Definition TypeObject.h:3644
RTPS_DllAPI void element_flags(CollectionElementFlag &&_element_flags)
Definition TypeObject.h:3622
RTPS_DllAPI CommonCollectionElement(const CommonCollectionElement &x)
RTPS_DllAPI const TypeIdentifier & type() const
Definition TypeObject.h:3650
RTPS_DllAPI bool consistent(const CommonCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void type(const TypeIdentifier &_type)
Definition TypeObject.h:3638
RTPS_DllAPI const CollectionElementFlag & element_flags() const
Definition TypeObject.h:3628
RTPS_DllAPI CollectionElementFlag & element_flags()
Definition TypeObject.h:3633
RTPS_DllAPI bool consistent(const CommonCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bound(const LBound &_bound)
Definition TypeObject.h:3867
RTPS_DllAPI void bound(LBound &&_bound)
Definition TypeObject.h:3873
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)
RTPS_DllAPI const LBound & bound() const
Definition TypeObject.h:3879
RTPS_DllAPI LBound & bound()
Definition TypeObject.h:3884
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition TypeObject.h:1564
RTPS_DllAPI UnionDiscriminatorFlag & member_flags()
Definition TypeObject.h:1553
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:1570
RTPS_DllAPI void member_flags(const UnionDiscriminatorFlag &_member_flags)
Definition TypeObject.h:1536
RTPS_DllAPI CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
RTPS_DllAPI const UnionDiscriminatorFlag & member_flags() const
Definition TypeObject.h:1548
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition TypeObject.h:1558
RTPS_DllAPI CommonDiscriminatorMember(CommonDiscriminatorMember &&x)
RTPS_DllAPI CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
RTPS_DllAPI TypeIdentifier & type_id()
Definition TypeObject.h:1575
RTPS_DllAPI void member_flags(UnionDiscriminatorFlag &&_member_flags)
Definition TypeObject.h:1542
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition TypeObject.h:5359
RTPS_DllAPI BitBound & bit_bound()
Definition TypeObject.h:5376
RTPS_DllAPI bool consistent(const CommonEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const BitBound & bit_bound() const
Definition TypeObject.h:5371
RTPS_DllAPI CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition TypeObject.h:5365
RTPS_DllAPI CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
RTPS_DllAPI CommonEnumeratedHeader(CommonEnumeratedHeader &&x)
RTPS_DllAPI bool operator==(const CommonEnumeratedHeader &other) const
RTPS_DllAPI void flags(const EnumeratedLiteralFlag &_flags)
Definition TypeObject.h:5097
RTPS_DllAPI CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
RTPS_DllAPI EnumeratedLiteralFlag & flags()
Definition TypeObject.h:5114
RTPS_DllAPI void flags(EnumeratedLiteralFlag &&_flags)
Definition TypeObject.h:5103
RTPS_DllAPI CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
RTPS_DllAPI const int32_t & value() const
Definition TypeObject.h:5087
RTPS_DllAPI int32_t & value()
Definition TypeObject.h:5092
RTPS_DllAPI const EnumeratedLiteralFlag & flags() const
Definition TypeObject.h:5109
RTPS_DllAPI bool operator==(const CommonEnumeratedLiteral &other) const
RTPS_DllAPI void value(const int32_t &_value)
Definition TypeObject.h:5075
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:5081
RTPS_DllAPI void member_flags(const StructMemberFlag &_member_flags)
Definition TypeObject.h:80
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition TypeObject.h:108
RTPS_DllAPI bool operator==(const CommonStructMember &other) const
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition TypeObject.h:102
RTPS_DllAPI StructMemberFlag & member_flags()
Definition TypeObject.h:97
RTPS_DllAPI bool consistent(const CommonStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition TypeObject.h:64
RTPS_DllAPI MemberId & member_id()
Definition TypeObject.h:75
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition TypeObject.h:119
RTPS_DllAPI CommonStructMember & operator=(const CommonStructMember &x)
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition TypeObject.h:58
RTPS_DllAPI CommonStructMember(const CommonStructMember &x)
RTPS_DllAPI CommonStructMember(CommonStructMember &&x)
RTPS_DllAPI const MemberId & member_id() const
Definition TypeObject.h:70
RTPS_DllAPI void member_flags(StructMemberFlag &&_member_flags)
Definition TypeObject.h:86
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition TypeObject.h:114
RTPS_DllAPI const StructMemberFlag & member_flags() const
Definition TypeObject.h:92
RTPS_DllAPI bool operator==(const CommonUnionMember &other) const
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition TypeObject.h:1256
RTPS_DllAPI void member_flags(UnionMemberFlag &&_member_flags)
Definition TypeObject.h:1234
RTPS_DllAPI UnionMemberFlag & member_flags()
Definition TypeObject.h:1245
RTPS_DllAPI CommonUnionMember & operator=(const CommonUnionMember &x)
RTPS_DllAPI const UnionMemberFlag & member_flags() const
Definition TypeObject.h:1240
RTPS_DllAPI void member_flags(const UnionMemberFlag &_member_flags)
Definition TypeObject.h:1228
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition TypeObject.h:1262
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition TypeObject.h:1212
RTPS_DllAPI void label_seq(const UnionCaseLabelSeq &_label_seq)
Definition TypeObject.h:1272
RTPS_DllAPI MemberId & member_id()
Definition TypeObject.h:1223
RTPS_DllAPI bool consistent(const CommonUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonUnionMember(const CommonUnionMember &x)
RTPS_DllAPI UnionCaseLabelSeq & label_seq()
Definition TypeObject.h:1289
RTPS_DllAPI CommonUnionMember(CommonUnionMember &&x)
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition TypeObject.h:1206
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition TypeObject.h:1250
RTPS_DllAPI const MemberId & member_id() const
Definition TypeObject.h:1218
RTPS_DllAPI void label_seq(UnionCaseLabelSeq &&_label_seq)
Definition TypeObject.h:1278
RTPS_DllAPI const UnionCaseLabelSeq & label_seq() const
Definition TypeObject.h:1284
RTPS_DllAPI TypeIdentifier & type_id()
Definition TypeObject.h:1267
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition TypeObject.h:3034
RTPS_DllAPI bool operator==(const CompleteAliasBody &other) const
RTPS_DllAPI CommonAliasBody & common()
Definition TypeObject.h:3017
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition TypeObject.h:3039
RTPS_DllAPI CompleteAliasBody(const CompleteAliasBody &x)
RTPS_DllAPI const CommonAliasBody & common() const
Definition TypeObject.h:3012
RTPS_DllAPI CompleteAliasBody & operator=(const CompleteAliasBody &x)
RTPS_DllAPI CompleteAliasBody(CompleteAliasBody &&x)
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition TypeObject.h:3000
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition TypeObject.h:3006
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition TypeObject.h:3050
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition TypeObject.h:3044
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition TypeObject.h:3022
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition TypeObject.h:3056
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition TypeObject.h:3028
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition TypeObject.h:3061
RTPS_DllAPI CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition TypeObject.h:3186
RTPS_DllAPI CompleteAliasHeader(CompleteAliasHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:3180
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:3192
RTPS_DllAPI bool operator==(const CompleteAliasHeader &other) const
RTPS_DllAPI CompleteAliasHeader(const CompleteAliasHeader &x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:3197
RTPS_DllAPI const CompleteAliasHeader & header() const
Definition TypeObject.h:3330
RTPS_DllAPI CompleteAliasType & operator=(const CompleteAliasType &x)
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition TypeObject.h:3313
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition TypeObject.h:3296
RTPS_DllAPI void header(CompleteAliasHeader &&_header)
Definition TypeObject.h:3324
RTPS_DllAPI void body(CompleteAliasBody &&_body)
Definition TypeObject.h:3346
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition TypeObject.h:3302
RTPS_DllAPI void body(const CompleteAliasBody &_body)
Definition TypeObject.h:3340
RTPS_DllAPI CompleteAliasBody & body()
Definition TypeObject.h:3357
RTPS_DllAPI const CompleteAliasBody & body() const
Definition TypeObject.h:3352
RTPS_DllAPI CompleteAliasHeader & header()
Definition TypeObject.h:3335
RTPS_DllAPI bool operator==(const CompleteAliasType &other) const
RTPS_DllAPI void header(const CompleteAliasHeader &_header)
Definition TypeObject.h:3318
RTPS_DllAPI CompleteAliasType(CompleteAliasType &&x)
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition TypeObject.h:3308
RTPS_DllAPI CompleteAliasType(const CompleteAliasType &x)
RTPS_DllAPI QualifiedTypeName & annotation_name()
Definition TypeObject.h:2576
RTPS_DllAPI void annotation_name(const QualifiedTypeName &_annotation_name)
Definition TypeObject.h:2559
RTPS_DllAPI void annotation_name(QualifiedTypeName &&_annotation_name)
Definition TypeObject.h:2565
RTPS_DllAPI bool consistent(const CompleteAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationHeader(CompleteAnnotationHeader &&x)
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:2571
RTPS_DllAPI CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
RTPS_DllAPI CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
RTPS_DllAPI CommonAnnotationParameter & common()
Definition TypeObject.h:2343
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition TypeObject.h:2387
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition TypeObject.h:2326
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition TypeObject.h:2370
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition TypeObject.h:2338
RTPS_DllAPI void name(const MemberName &_name)
Definition TypeObject.h:2348
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition TypeObject.h:2332
RTPS_DllAPI CompleteAnnotationParameter(CompleteAnnotationParameter &&x)
RTPS_DllAPI void name(MemberName &&_name)
Definition TypeObject.h:2354
RTPS_DllAPI const MemberName & name() const
Definition TypeObject.h:2360
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition TypeObject.h:2382
RTPS_DllAPI bool consistent(const CompleteAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MemberName & name()
Definition TypeObject.h:2365
RTPS_DllAPI CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition TypeObject.h:2376
RTPS_DllAPI bool operator==(const CompleteAnnotationParameter &other) const
RTPS_DllAPI void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
Definition TypeObject.h:2727
RTPS_DllAPI CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition TypeObject.h:2677
RTPS_DllAPI CompleteAnnotationHeader & header()
Definition TypeObject.h:2716
RTPS_DllAPI void header(CompleteAnnotationHeader &&_header)
Definition TypeObject.h:2705
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition TypeObject.h:2683
RTPS_DllAPI bool operator==(const CompleteAnnotationType &other) const
RTPS_DllAPI bool consistent(const CompleteAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationType(const CompleteAnnotationType &x)
RTPS_DllAPI const CompleteAnnotationParameterSeq & member_seq() const
Definition TypeObject.h:2733
RTPS_DllAPI CompleteAnnotationType(CompleteAnnotationType &&x)
RTPS_DllAPI void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
Definition TypeObject.h:2721
RTPS_DllAPI const CompleteAnnotationHeader & header() const
Definition TypeObject.h:2711
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition TypeObject.h:2694
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition TypeObject.h:2689
RTPS_DllAPI void header(const CompleteAnnotationHeader &_header)
Definition TypeObject.h:2699
RTPS_DllAPI CompleteAnnotationParameterSeq & member_seq()
Definition TypeObject.h:2738
RTPS_DllAPI bool consistent(const CompleteArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition TypeObject.h:4404
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition TypeObject.h:4426
RTPS_DllAPI CommonArrayHeader & common()
Definition TypeObject.h:4415
RTPS_DllAPI CompleteArrayHeader(CompleteArrayHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:4420
RTPS_DllAPI CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
RTPS_DllAPI const CommonArrayHeader & common() const
Definition TypeObject.h:4410
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:4432
RTPS_DllAPI bool operator==(const CompleteArrayHeader &other) const
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:4437
RTPS_DllAPI void common(const CommonArrayHeader &_common)
Definition TypeObject.h:4398
RTPS_DllAPI CompleteArrayHeader(const CompleteArrayHeader &x)
RTPS_DllAPI CompleteArrayType & operator=(const CompleteArrayType &x)
RTPS_DllAPI void header(const CompleteArrayHeader &_header)
Definition TypeObject.h:4581
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition TypeObject.h:4571
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition TypeObject.h:4603
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition TypeObject.h:4609
RTPS_DllAPI CompleteCollectionElement & element()
Definition TypeObject.h:4620
RTPS_DllAPI void header(CompleteArrayHeader &&_header)
Definition TypeObject.h:4587
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition TypeObject.h:4559
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition TypeObject.h:4615
RTPS_DllAPI CompleteArrayType(CompleteArrayType &&x)
RTPS_DllAPI bool operator==(const CompleteArrayType &other) const
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition TypeObject.h:4565
RTPS_DllAPI CompleteArrayHeader & header()
Definition TypeObject.h:4598
RTPS_DllAPI const CompleteArrayHeader & header() const
Definition TypeObject.h:4593
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition TypeObject.h:4576
RTPS_DllAPI bool consistent(const CompleteArrayType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteArrayType(const CompleteArrayType &x)
RTPS_DllAPI CompleteMemberDetail & detail()
Definition TypeObject.h:6585
RTPS_DllAPI const CommonBitfield & common() const
Definition TypeObject.h:6558
RTPS_DllAPI CommonBitfield & common()
Definition TypeObject.h:6563
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition TypeObject.h:6546
RTPS_DllAPI CompleteBitfield(CompleteBitfield &&x)
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition TypeObject.h:6580
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition TypeObject.h:6552
RTPS_DllAPI bool consistent(const CompleteBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition TypeObject.h:6568
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition TypeObject.h:6574
RTPS_DllAPI bool operator==(const CompleteBitfield &other) const
RTPS_DllAPI CompleteBitfield & operator=(const CompleteBitfield &x)
RTPS_DllAPI CompleteBitfield(const CompleteBitfield &x)
Definition TypeObject.h:5901
RTPS_DllAPI CompleteMemberDetail & detail()
Definition TypeObject.h:5954
RTPS_DllAPI CommonBitflag & common()
Definition TypeObject.h:5932
RTPS_DllAPI CompleteBitflag & operator=(const CompleteBitflag &x)
RTPS_DllAPI CompleteBitflag(CompleteBitflag &&x)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition TypeObject.h:5921
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition TypeObject.h:5949
RTPS_DllAPI bool consistent(const CompleteBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition TypeObject.h:5937
RTPS_DllAPI const CommonBitflag & common() const
Definition TypeObject.h:5927
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition TypeObject.h:5943
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition TypeObject.h:5915
RTPS_DllAPI bool operator==(const CompleteBitflag &other) const
RTPS_DllAPI CompleteBitflag(const CompleteBitflag &x)
RTPS_DllAPI CompleteBitmaskType(const CompleteBitmaskType &x)
RTPS_DllAPI void header(const CompleteBitmaskHeader &_header)
Definition TypeObject.h:6196
RTPS_DllAPI CompleteBitflagSeq & flag_seq()
Definition TypeObject.h:6235
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition TypeObject.h:6180
RTPS_DllAPI const CompleteBitflagSeq & flag_seq() const
Definition TypeObject.h:6230
RTPS_DllAPI void flag_seq(const CompleteBitflagSeq &_flag_seq)
Definition TypeObject.h:6218
RTPS_DllAPI bool operator==(const CompleteBitmaskType &other) const
RTPS_DllAPI CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
RTPS_DllAPI CompleteBitmaskHeader & header()
Definition TypeObject.h:6213
RTPS_DllAPI void flag_seq(CompleteBitflagSeq &&_flag_seq)
Definition TypeObject.h:6224
RTPS_DllAPI void header(CompleteBitmaskHeader &&_header)
Definition TypeObject.h:6202
RTPS_DllAPI CompleteBitmaskType(CompleteBitmaskType &&x)
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition TypeObject.h:6191
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition TypeObject.h:6186
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:6174
RTPS_DllAPI const CompleteBitmaskHeader & header() const
Definition TypeObject.h:6208
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition TypeObject.h:6743
RTPS_DllAPI bool operator==(const CompleteBitsetHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition TypeObject.h:6759
RTPS_DllAPI bool consistent(const CompleteBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:6753
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:6765
RTPS_DllAPI TypeIdentifier & base_type()
Definition TypeObject.h:6748
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:6770
RTPS_DllAPI CompleteBitsetHeader(const CompleteBitsetHeader &x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition TypeObject.h:6731
RTPS_DllAPI CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
RTPS_DllAPI CompleteBitsetHeader(CompleteBitsetHeader &&x)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition TypeObject.h:6737
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition TypeObject.h:6897
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition TypeObject.h:6908
RTPS_DllAPI void header(const CompleteBitsetHeader &_header)
Definition TypeObject.h:6913
RTPS_DllAPI bool consistent(const CompleteBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteBitsetHeader & header() const
Definition TypeObject.h:6925
RTPS_DllAPI CompleteBitfieldSeq & field_seq()
Definition TypeObject.h:6952
RTPS_DllAPI void header(CompleteBitsetHeader &&_header)
Definition TypeObject.h:6919
RTPS_DllAPI CompleteBitsetType(const CompleteBitsetType &x)
RTPS_DllAPI bool operator==(const CompleteBitsetType &other) const
RTPS_DllAPI const CompleteBitfieldSeq & field_seq() const
Definition TypeObject.h:6947
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition TypeObject.h:6891
RTPS_DllAPI CompleteBitsetType & operator=(const CompleteBitsetType &x)
RTPS_DllAPI void field_seq(CompleteBitfieldSeq &&_field_seq)
Definition TypeObject.h:6941
RTPS_DllAPI CompleteBitsetHeader & header()
Definition TypeObject.h:6930
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition TypeObject.h:6903
RTPS_DllAPI CompleteBitsetType(CompleteBitsetType &&x)
RTPS_DllAPI void field_seq(const CompleteBitfieldSeq &_field_seq)
Definition TypeObject.h:6935
RTPS_DllAPI CompleteElementDetail & detail()
Definition TypeObject.h:3747
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition TypeObject.h:3708
RTPS_DllAPI void detail(CompleteElementDetail &&_detail)
Definition TypeObject.h:3736
RTPS_DllAPI CompleteCollectionElement(const CompleteCollectionElement &x)
RTPS_DllAPI const CompleteElementDetail & detail() const
Definition TypeObject.h:3742
RTPS_DllAPI const CommonCollectionElement & common() const
Definition TypeObject.h:3720
RTPS_DllAPI CompleteCollectionElement(CompleteCollectionElement &&x)
RTPS_DllAPI void detail(const CompleteElementDetail &_detail)
Definition TypeObject.h:3730
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:3714
RTPS_DllAPI CommonCollectionElement & common()
Definition TypeObject.h:3725
RTPS_DllAPI bool operator==(const CompleteCollectionElement &other) const
RTPS_DllAPI CompleteCollectionHeader(const CompleteCollectionHeader &x)
RTPS_DllAPI CommonCollectionHeader & common()
Definition TypeObject.h:3953
RTPS_DllAPI bool consistent(const CompleteCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition TypeObject.h:3964
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition TypeObject.h:3936
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition TypeObject.h:3948
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:3958
RTPS_DllAPI CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:3970
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:3975
RTPS_DllAPI CompleteCollectionHeader(CompleteCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CompleteCollectionHeader &other) const
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition TypeObject.h:3942
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition TypeObject.h:1636
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition TypeObject.h:1669
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition TypeObject.h:1642
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition TypeObject.h:1664
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition TypeObject.h:1652
RTPS_DllAPI bool consistent(const CompleteDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition TypeObject.h:1658
RTPS_DllAPI CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x)
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition TypeObject.h:1630
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:1680
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition TypeObject.h:1647
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition TypeObject.h:1674
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition TypeObject.h:1686
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition TypeObject.h:1691
RTPS_DllAPI CompleteElementDetail(const CompleteElementDetail &x)
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition TypeObject.h:3537
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition TypeObject.h:3542
RTPS_DllAPI bool operator==(const CompleteElementDetail &other) const
RTPS_DllAPI CompleteElementDetail(CompleteElementDetail &&x)
RTPS_DllAPI CompleteElementDetail & operator=(const CompleteElementDetail &x)
RTPS_DllAPI bool consistent(const CompleteElementDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition TypeObject.h:3553
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition TypeObject.h:3547
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition TypeObject.h:3525
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition TypeObject.h:3559
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition TypeObject.h:3531
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition TypeObject.h:3564
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)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition TypeObject.h:5445
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition TypeObject.h:5456
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:5450
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition TypeObject.h:5440
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:5462
RTPS_DllAPI bool operator==(const CompleteEnumeratedHeader &other) const
RTPS_DllAPI CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:5467
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition TypeObject.h:5428
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition TypeObject.h:5434
RTPS_DllAPI CompleteMemberDetail & detail()
Definition TypeObject.h:5208
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition TypeObject.h:5175
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition TypeObject.h:5186
RTPS_DllAPI bool consistent(const CompleteEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition TypeObject.h:5203
RTPS_DllAPI CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x)
RTPS_DllAPI CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition TypeObject.h:5191
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition TypeObject.h:5197
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition TypeObject.h:5169
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition TypeObject.h:5181
RTPS_DllAPI bool operator==(const CompleteEnumeratedLiteral &other) const
RTPS_DllAPI bool consistent(const CompleteEnumeratedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteEnumeratedType(const CompleteEnumeratedType &x)
RTPS_DllAPI CompleteEnumeratedHeader & header()
Definition TypeObject.h:5629
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition TypeObject.h:5590
RTPS_DllAPI CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition TypeObject.h:5596
RTPS_DllAPI CompleteEnumeratedType(CompleteEnumeratedType &&x)
RTPS_DllAPI CompleteEnumeratedLiteralSeq & literal_seq()
Definition TypeObject.h:5651
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition TypeObject.h:5607
RTPS_DllAPI const CompleteEnumeratedHeader & header() const
Definition TypeObject.h:5624
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition TypeObject.h:5602
RTPS_DllAPI void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
Definition TypeObject.h:5640
RTPS_DllAPI const CompleteEnumeratedLiteralSeq & literal_seq() const
Definition TypeObject.h:5646
RTPS_DllAPI void header(CompleteEnumeratedHeader &&_header)
Definition TypeObject.h:5618
RTPS_DllAPI bool operator==(const CompleteEnumeratedType &other) const
RTPS_DllAPI void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
Definition TypeObject.h:5634
RTPS_DllAPI void header(const CompleteEnumeratedHeader &_header)
Definition TypeObject.h:5612
RTPS_DllAPI CompleteExtendedType(const CompleteExtendedType &x)
RTPS_DllAPI bool consistent(const CompleteExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteExtendedType(CompleteExtendedType &&x)
RTPS_DllAPI bool operator==(const CompleteExtendedType &) const
Definition TypeObject.h:7141
RTPS_DllAPI CompleteExtendedType & operator=(const CompleteExtendedType &x)
Definition TypeObject.h:4779
RTPS_DllAPI bool consistent(const CompleteMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CompleteMapType &other) const
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition TypeObject.h:4805
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition TypeObject.h:4859
RTPS_DllAPI void key(const CompleteCollectionElement &_key)
Definition TypeObject.h:4837
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition TypeObject.h:4815
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition TypeObject.h:4865
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition TypeObject.h:4827
RTPS_DllAPI CompleteCollectionElement & element()
Definition TypeObject.h:4876
RTPS_DllAPI CompleteCollectionElement & key()
Definition TypeObject.h:4854
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition TypeObject.h:4793
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition TypeObject.h:4821
RTPS_DllAPI CompleteMapType & operator=(const CompleteMapType &x)
RTPS_DllAPI void key(CompleteCollectionElement &&_key)
Definition TypeObject.h:4843
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition TypeObject.h:4871
RTPS_DllAPI const CompleteCollectionElement & key() const
Definition TypeObject.h:4849
RTPS_DllAPI CompleteCollectionHeader & header()
Definition TypeObject.h:4832
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition TypeObject.h:4799
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition TypeObject.h:4810
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:209
RTPS_DllAPI bool consistent(const CompleteMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CompleteMemberDetail &other) const
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition TypeObject.h:214
RTPS_DllAPI void name(const MemberName &_name)
Definition TypeObject.h:175
RTPS_DllAPI CompleteMemberDetail(const CompleteMemberDetail &x)
RTPS_DllAPI void name(MemberName &&_name)
Definition TypeObject.h:181
RTPS_DllAPI const MemberName & name() const
Definition TypeObject.h:187
RTPS_DllAPI MemberName & name()
Definition TypeObject.h:192
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition TypeObject.h:225
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition TypeObject.h:219
RTPS_DllAPI CompleteMemberDetail(CompleteMemberDetail &&x)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition TypeObject.h:197
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition TypeObject.h:231
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition TypeObject.h:203
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition TypeObject.h:236
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition TypeObject.h:4110
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition TypeObject.h:4142
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition TypeObject.h:4120
RTPS_DllAPI CompleteSequenceType & operator=(const CompleteSequenceType &x)
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition TypeObject.h:4148
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition TypeObject.h:4132
RTPS_DllAPI CompleteCollectionElement & element()
Definition TypeObject.h:4159
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition TypeObject.h:4098
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition TypeObject.h:4126
RTPS_DllAPI bool consistent(const CompleteSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition TypeObject.h:4154
RTPS_DllAPI CompleteSequenceType(const CompleteSequenceType &x)
RTPS_DllAPI CompleteCollectionHeader & header()
Definition TypeObject.h:4137
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition TypeObject.h:4104
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition TypeObject.h:4115
RTPS_DllAPI bool operator==(const CompleteSequenceType &other) const
RTPS_DllAPI CompleteSequenceType(CompleteSequenceType &&x)
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition TypeObject.h:795
RTPS_DllAPI bool operator==(const CompleteStructHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition TypeObject.h:811
RTPS_DllAPI CompleteStructHeader & operator=(const CompleteStructHeader &x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:805
RTPS_DllAPI CompleteStructHeader(const CompleteStructHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:817
RTPS_DllAPI TypeIdentifier & base_type()
Definition TypeObject.h:800
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:822
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:783
RTPS_DllAPI CompleteStructHeader(CompleteStructHeader &&x)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition TypeObject.h:789
RTPS_DllAPI CompleteMemberDetail & detail()
Definition TypeObject.h:400
RTPS_DllAPI CompleteStructMember(CompleteStructMember &&x)
RTPS_DllAPI bool operator==(const CompleteStructMember &other) const
RTPS_DllAPI CompleteStructMember(const CompleteStructMember &x)
RTPS_DllAPI const CommonStructMember & common() const
Definition TypeObject.h:373
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition TypeObject.h:395
RTPS_DllAPI bool consistent(const CompleteStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition TypeObject.h:361
RTPS_DllAPI CommonStructMember & common()
Definition TypeObject.h:378
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition TypeObject.h:383
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition TypeObject.h:389
RTPS_DllAPI CompleteStructMember & operator=(const CompleteStructMember &x)
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition TypeObject.h:367
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition TypeObject.h:973
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition TypeObject.h:979
RTPS_DllAPI void header(const CompleteStructHeader &_header)
Definition TypeObject.h:989
RTPS_DllAPI CompleteStructMemberSeq & member_seq()
Definition TypeObject.h:1028
RTPS_DllAPI CompleteStructType(CompleteStructType &&x)
RTPS_DllAPI const CompleteStructMemberSeq & member_seq() const
Definition TypeObject.h:1023
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:967
RTPS_DllAPI const CompleteStructHeader & header() const
Definition TypeObject.h:1001
RTPS_DllAPI void member_seq(const CompleteStructMemberSeq &_member_seq)
Definition TypeObject.h:1011
RTPS_DllAPI bool consistent(const CompleteStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition TypeObject.h:984
RTPS_DllAPI void header(CompleteStructHeader &&_header)
Definition TypeObject.h:995
RTPS_DllAPI CompleteStructHeader & header()
Definition TypeObject.h:1006
RTPS_DllAPI void member_seq(CompleteStructMemberSeq &&_member_seq)
Definition TypeObject.h:1017
RTPS_DllAPI bool operator==(const CompleteStructType &other) const
RTPS_DllAPI CompleteTypeDetail(const CompleteTypeDetail &x)
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition TypeObject.h:686
RTPS_DllAPI const QualifiedTypeName & type_name() const
Definition TypeObject.h:725
RTPS_DllAPI QualifiedTypeName & type_name()
Definition TypeObject.h:730
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition TypeObject.h:681
RTPS_DllAPI CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
RTPS_DllAPI CompleteTypeDetail(CompleteTypeDetail &&x)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition TypeObject.h:669
RTPS_DllAPI bool consistent(const CompleteTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition TypeObject.h:675
RTPS_DllAPI void type_name(const QualifiedTypeName &_type_name)
Definition TypeObject.h:713
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition TypeObject.h:697
RTPS_DllAPI bool operator==(const CompleteTypeDetail &other) const
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition TypeObject.h:691
RTPS_DllAPI void type_name(QualifiedTypeName &&_type_name)
Definition TypeObject.h:719
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition TypeObject.h:703
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition TypeObject.h:708
RTPS_DllAPI void annotation_type(CompleteAnnotationType _annotation_type)
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 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 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 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 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:1819
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition TypeObject.h:1813
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition TypeObject.h:1825
RTPS_DllAPI bool consistent(const CompleteUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteTypeDetail & detail()
Definition TypeObject.h:1830
RTPS_DllAPI CompleteMemberDetail & detail()
Definition TypeObject.h:1384
RTPS_DllAPI CompleteUnionMember(const CompleteUnionMember &x)
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition TypeObject.h:1345
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition TypeObject.h:1351
RTPS_DllAPI bool consistent(const CompleteUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition TypeObject.h:1379
RTPS_DllAPI const CommonUnionMember & common() const
Definition TypeObject.h:1357
RTPS_DllAPI CompleteUnionMember & operator=(const CompleteUnionMember &x)
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition TypeObject.h:1367
RTPS_DllAPI CompleteUnionMember(CompleteUnionMember &&x)
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition TypeObject.h:1373
RTPS_DllAPI bool operator==(const CompleteUnionMember &other) const
RTPS_DllAPI CommonUnionMember & common()
Definition TypeObject.h:1362
RTPS_DllAPI CompleteDiscriminatorMember & discriminator()
Definition TypeObject.h:2013
RTPS_DllAPI void discriminator(const CompleteDiscriminatorMember &_discriminator)
Definition TypeObject.h:1996
RTPS_DllAPI const CompleteUnionMemberSeq & member_seq() const
Definition TypeObject.h:2030
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:2024
RTPS_DllAPI bool operator==(const CompleteUnionType &other) const
RTPS_DllAPI const CompleteUnionHeader & header() const
Definition TypeObject.h:1986
RTPS_DllAPI CompleteUnionType(const CompleteUnionType &x)
RTPS_DllAPI void header(const CompleteUnionHeader &_header)
Definition TypeObject.h:1974
RTPS_DllAPI const CompleteDiscriminatorMember & discriminator() const
Definition TypeObject.h:2008
RTPS_DllAPI CompleteUnionHeader & header()
Definition TypeObject.h:1991
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition TypeObject.h:1952
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition TypeObject.h:1964
RTPS_DllAPI void member_seq(const CompleteUnionMemberSeq &_member_seq)
Definition TypeObject.h:2018
RTPS_DllAPI CompleteUnionType(CompleteUnionType &&x)
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition TypeObject.h:1969
RTPS_DllAPI CompleteUnionMemberSeq & member_seq()
Definition TypeObject.h:2035
RTPS_DllAPI void discriminator(CompleteDiscriminatorMember &&_discriminator)
Definition TypeObject.h:2002
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition TypeObject.h:1958
RTPS_DllAPI void header(CompleteUnionHeader &&_header)
Definition TypeObject.h:1980
Definition TypesBase.h:336
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:3130
RTPS_DllAPI const CommonAliasBody & common() const
Definition TypeObject.h:3125
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition TypeObject.h:3113
RTPS_DllAPI MinimalAliasBody(MinimalAliasBody &&x)
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition TypeObject.h:3119
RTPS_DllAPI MinimalAliasHeader(MinimalAliasHeader &&x)
RTPS_DllAPI MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
RTPS_DllAPI bool operator==(const MinimalAliasHeader &) const
Definition TypeObject.h:3263
RTPS_DllAPI MinimalAliasHeader(const MinimalAliasHeader &x)
RTPS_DllAPI void header(const MinimalAliasHeader &_header)
Definition TypeObject.h:3432
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition TypeObject.h:3427
RTPS_DllAPI bool operator==(const MinimalAliasType &other) const
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition TypeObject.h:3410
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition TypeObject.h:3416
RTPS_DllAPI MinimalAliasType(const MinimalAliasType &x)
RTPS_DllAPI void body(const MinimalAliasBody &_body)
Definition TypeObject.h:3454
RTPS_DllAPI void header(MinimalAliasHeader &&_header)
Definition TypeObject.h:3438
RTPS_DllAPI const MinimalAliasBody & body() const
Definition TypeObject.h:3466
RTPS_DllAPI const MinimalAliasHeader & header() const
Definition TypeObject.h:3444
RTPS_DllAPI MinimalAliasType(MinimalAliasType &&x)
RTPS_DllAPI void body(MinimalAliasBody &&_body)
Definition TypeObject.h:3460
RTPS_DllAPI MinimalAliasHeader & header()
Definition TypeObject.h:3449
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition TypeObject.h:3422
RTPS_DllAPI MinimalAliasType & operator=(const MinimalAliasType &x)
RTPS_DllAPI MinimalAliasBody & body()
Definition TypeObject.h:3471
RTPS_DllAPI MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
RTPS_DllAPI MinimalAnnotationHeader(MinimalAnnotationHeader &&x)
RTPS_DllAPI MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
RTPS_DllAPI bool operator==(const MinimalAnnotationHeader &) const
Definition TypeObject.h:2643
RTPS_DllAPI bool consistent(const MinimalAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonAnnotationParameter & common()
Definition TypeObject.h:2460
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition TypeObject.h:2504
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:2443
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition TypeObject.h:2487
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition TypeObject.h:2455
RTPS_DllAPI void name(const MemberName &_name)
Definition TypeObject.h:2465
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition TypeObject.h:2449
RTPS_DllAPI void name(MemberName &&_name)
Definition TypeObject.h:2471
RTPS_DllAPI MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
RTPS_DllAPI const MemberName & name() const
Definition TypeObject.h:2477
RTPS_DllAPI MinimalAnnotationParameter(MinimalAnnotationParameter &&x)
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition TypeObject.h:2499
RTPS_DllAPI bool operator==(const MinimalAnnotationParameter &other) const
RTPS_DllAPI MemberName & name()
Definition TypeObject.h:2482
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition TypeObject.h:2493
RTPS_DllAPI MinimalAnnotationType(MinimalAnnotationType &&x)
RTPS_DllAPI const MinimalAnnotationParameterSeq & member_seq() const
Definition TypeObject.h:2848
RTPS_DllAPI void header(const MinimalAnnotationHeader &_header)
Definition TypeObject.h:2814
RTPS_DllAPI void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
Definition TypeObject.h:2836
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition TypeObject.h:2792
RTPS_DllAPI MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
RTPS_DllAPI void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
Definition TypeObject.h:2842
RTPS_DllAPI const MinimalAnnotationHeader & header() const
Definition TypeObject.h:2826
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition TypeObject.h:2798
RTPS_DllAPI void header(MinimalAnnotationHeader &&_header)
Definition TypeObject.h:2820
RTPS_DllAPI MinimalAnnotationHeader & header()
Definition TypeObject.h:2831
RTPS_DllAPI bool consistent(const MinimalAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalAnnotationParameterSeq & member_seq()
Definition TypeObject.h:2853
RTPS_DllAPI MinimalAnnotationType(const MinimalAnnotationType &x)
RTPS_DllAPI bool operator==(const MinimalAnnotationType &other) const
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition TypeObject.h:2809
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition TypeObject.h:2804
RTPS_DllAPI MinimalArrayHeader(MinimalArrayHeader &&x)
RTPS_DllAPI MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition TypeObject.h:4495
RTPS_DllAPI CommonArrayHeader & common()
Definition TypeObject.h:4506
RTPS_DllAPI const CommonArrayHeader & common() const
Definition TypeObject.h:4501
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:4489
RTPS_DllAPI MinimalArrayHeader(const MinimalArrayHeader &x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition TypeObject.h:4687
RTPS_DllAPI MinimalArrayHeader & header()
Definition TypeObject.h:4714
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition TypeObject.h:4731
RTPS_DllAPI void header(const MinimalArrayHeader &_header)
Definition TypeObject.h:4697
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:4675
RTPS_DllAPI MinimalArrayType(MinimalArrayType &&x)
RTPS_DllAPI void header(MinimalArrayHeader &&_header)
Definition TypeObject.h:4703
RTPS_DllAPI MinimalArrayType(const MinimalArrayType &x)
RTPS_DllAPI bool operator==(const MinimalArrayType &other) const
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition TypeObject.h:4719
RTPS_DllAPI MinimalArrayType & operator=(const MinimalArrayType &x)
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition TypeObject.h:4681
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition TypeObject.h:4692
RTPS_DllAPI MinimalCollectionElement & element()
Definition TypeObject.h:4736
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition TypeObject.h:4725
RTPS_DllAPI const MinimalArrayHeader & header() const
Definition TypeObject.h:4709
Definition TypeObject.h:6625
RTPS_DllAPI MinimalBitfield(MinimalBitfield &&x)
RTPS_DllAPI const CommonBitfield & common() const
Definition TypeObject.h:6673
RTPS_DllAPI CommonBitfield & common()
Definition TypeObject.h:6678
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition TypeObject.h:6661
RTPS_DllAPI MinimalBitfield & operator=(const MinimalBitfield &x)
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition TypeObject.h:6667
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:6639
RTPS_DllAPI const NameHash & name_hash() const
Definition TypeObject.h:6651
RTPS_DllAPI bool consistent(const MinimalBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI NameHash & name_hash()
Definition TypeObject.h:6656
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition TypeObject.h:6645
Definition TypeObject.h:5994
RTPS_DllAPI MinimalBitflag(const MinimalBitflag &x)
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition TypeObject.h:6042
RTPS_DllAPI MinimalBitflag & operator=(const MinimalBitflag &x)
RTPS_DllAPI CommonBitflag & common()
Definition TypeObject.h:6025
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition TypeObject.h:6014
RTPS_DllAPI MinimalMemberDetail & detail()
Definition TypeObject.h:6047
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition TypeObject.h:6036
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:6020
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition TypeObject.h:6008
RTPS_DllAPI MinimalBitflag(MinimalBitflag &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition TypeObject.h:6030
RTPS_DllAPI MinimalBitmaskHeader & header()
Definition TypeObject.h:6329
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition TypeObject.h:6296
RTPS_DllAPI void flag_seq(MinimalBitflagSeq &&_flag_seq)
Definition TypeObject.h:6340
RTPS_DllAPI MinimalBitmaskType(MinimalBitmaskType &&x)
RTPS_DllAPI const MinimalBitflagSeq & flag_seq() const
Definition TypeObject.h:6346
RTPS_DllAPI void header(const MinimalBitmaskHeader &_header)
Definition TypeObject.h:6312
RTPS_DllAPI bool operator==(const MinimalBitmaskType &other) const
RTPS_DllAPI bool consistent(const MinimalBitmaskType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
RTPS_DllAPI MinimalBitflagSeq & flag_seq()
Definition TypeObject.h:6351
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition TypeObject.h:6307
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition TypeObject.h:6302
RTPS_DllAPI void flag_seq(const MinimalBitflagSeq &_flag_seq)
Definition TypeObject.h:6334
RTPS_DllAPI MinimalBitmaskType(const MinimalBitmaskType &x)
RTPS_DllAPI const MinimalBitmaskHeader & header() const
Definition TypeObject.h:6324
RTPS_DllAPI void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
Definition TypeObject.h:6290
RTPS_DllAPI void header(MinimalBitmaskHeader &&_header)
Definition TypeObject.h:6318
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition TypeObject.h:6834
RTPS_DllAPI MinimalBitsetHeader(MinimalBitsetHeader &&x)
RTPS_DllAPI bool operator==(const MinimalBitsetHeader &other) const
RTPS_DllAPI MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
RTPS_DllAPI MinimalBitsetHeader(const MinimalBitsetHeader &x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition TypeObject.h:6839
RTPS_DllAPI bool consistent(const MinimalBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition TypeObject.h:6822
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition TypeObject.h:6828
RTPS_DllAPI bool consistent(const MinimalBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition TypeObject.h:7013
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition TypeObject.h:7024
RTPS_DllAPI bool operator==(const MinimalBitsetType &other) const
RTPS_DllAPI void header(MinimalBitsetHeader &&_header)
Definition TypeObject.h:7035
RTPS_DllAPI void field_seq(MinimalBitfieldSeq &&_field_seq)
Definition TypeObject.h:7057
RTPS_DllAPI MinimalBitsetType & operator=(const MinimalBitsetType &x)
RTPS_DllAPI MinimalBitfieldSeq & field_seq()
Definition TypeObject.h:7068
RTPS_DllAPI void header(const MinimalBitsetHeader &_header)
Definition TypeObject.h:7029
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition TypeObject.h:7007
RTPS_DllAPI void field_seq(const MinimalBitfieldSeq &_field_seq)
Definition TypeObject.h:7051
RTPS_DllAPI MinimalBitsetType(const MinimalBitsetType &x)
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition TypeObject.h:7019
RTPS_DllAPI MinimalBitsetType(MinimalBitsetType &&x)
RTPS_DllAPI MinimalBitsetHeader & header()
Definition TypeObject.h:7046
RTPS_DllAPI const MinimalBitfieldSeq & field_seq() const
Definition TypeObject.h:7063
RTPS_DllAPI const MinimalBitsetHeader & header() const
Definition TypeObject.h:7041
RTPS_DllAPI MinimalCollectionElement(const MinimalCollectionElement &x)
RTPS_DllAPI MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition TypeObject.h:3799
RTPS_DllAPI const CommonCollectionElement & common() const
Definition TypeObject.h:3811
RTPS_DllAPI bool operator==(const MinimalCollectionElement &other) const
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition TypeObject.h:3805
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:3816
RTPS_DllAPI CommonCollectionHeader & common()
Definition TypeObject.h:4044
RTPS_DllAPI bool consistent(const MinimalCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition TypeObject.h:4027
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition TypeObject.h:4039
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:4033
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition TypeObject.h:1751
RTPS_DllAPI MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x)
RTPS_DllAPI bool consistent(const MinimalDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition TypeObject.h:1757
RTPS_DllAPI MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
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:1745
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition TypeObject.h:1762
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:5536
RTPS_DllAPI MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
RTPS_DllAPI bool operator==(const MinimalEnumeratedHeader &other) const
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition TypeObject.h:5531
RTPS_DllAPI MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition TypeObject.h:5519
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition TypeObject.h:5525
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition TypeObject.h:5299
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition TypeObject.h:5271
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition TypeObject.h:5282
RTPS_DllAPI MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI bool consistent(const MinimalEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalMemberDetail & detail()
Definition TypeObject.h:5304
RTPS_DllAPI MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition TypeObject.h:5293
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition TypeObject.h:5265
RTPS_DllAPI bool operator==(const MinimalEnumeratedLiteral &other) const
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition TypeObject.h:5277
RTPS_DllAPI MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition TypeObject.h:5287
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:5762
RTPS_DllAPI MinimalEnumeratedHeader & header()
Definition TypeObject.h:5745
RTPS_DllAPI void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
Definition TypeObject.h:5750
RTPS_DllAPI bool operator==(const MinimalEnumeratedType &other) const
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition TypeObject.h:5706
RTPS_DllAPI MinimalEnumeratedLiteralSeq & literal_seq()
Definition TypeObject.h:5767
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition TypeObject.h:5712
RTPS_DllAPI MinimalEnumeratedType(MinimalEnumeratedType &&x)
RTPS_DllAPI MinimalEnumeratedType(const MinimalEnumeratedType &x)
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition TypeObject.h:5723
RTPS_DllAPI void header(const MinimalEnumeratedHeader &_header)
Definition TypeObject.h:5728
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition TypeObject.h:5718
RTPS_DllAPI void header(MinimalEnumeratedHeader &&_header)
Definition TypeObject.h:5734
RTPS_DllAPI void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
Definition TypeObject.h:5756
RTPS_DllAPI const MinimalEnumeratedHeader & header() const
Definition TypeObject.h:5740
RTPS_DllAPI MinimalExtendedType & operator=(const MinimalExtendedType &x)
RTPS_DllAPI MinimalExtendedType(MinimalExtendedType &&x)
RTPS_DllAPI MinimalExtendedType(const MinimalExtendedType &x)
RTPS_DllAPI bool operator==(const MinimalExtendedType &) const
Definition TypeObject.h:7189
RTPS_DllAPI bool consistent(const MinimalExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
Definition TypeObject.h:4918
RTPS_DllAPI MinimalMapType & operator=(const MinimalMapType &x)
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition TypeObject.h:4966
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition TypeObject.h:4944
RTPS_DllAPI MinimalCollectionElement & key()
Definition TypeObject.h:4993
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition TypeObject.h:5010
RTPS_DllAPI void key(MinimalCollectionElement &&_key)
Definition TypeObject.h:4982
RTPS_DllAPI void key(const MinimalCollectionElement &_key)
Definition TypeObject.h:4976
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition TypeObject.h:4932
RTPS_DllAPI const MinimalCollectionElement & key() const
Definition TypeObject.h:4988
RTPS_DllAPI MinimalMapType(MinimalMapType &&x)
RTPS_DllAPI MinimalCollectionHeader & header()
Definition TypeObject.h:4971
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition TypeObject.h:4998
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition TypeObject.h:4938
RTPS_DllAPI bool operator==(const MinimalMapType &other) const
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition TypeObject.h:4960
RTPS_DllAPI MinimalMapType(const MinimalMapType &x)
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition TypeObject.h:4949
RTPS_DllAPI MinimalCollectionElement & element()
Definition TypeObject.h:5015
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition TypeObject.h:5004
RTPS_DllAPI bool consistent(const MinimalMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition TypeObject.h:4954
RTPS_DllAPI bool operator==(const MinimalMemberDetail &other) const
RTPS_DllAPI MinimalMemberDetail(MinimalMemberDetail &&x)
RTPS_DllAPI MinimalMemberDetail(const MinimalMemberDetail &x)
RTPS_DllAPI void name_hash(const NameHash &_name_hash)
Definition TypeObject.h:291
RTPS_DllAPI MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
RTPS_DllAPI const NameHash & name_hash() const
Definition TypeObject.h:303
RTPS_DllAPI NameHash & name_hash()
Definition TypeObject.h:308
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition TypeObject.h:297
RTPS_DllAPI bool consistent(const MinimalMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition TypeObject.h:4248
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition TypeObject.h:4226
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition TypeObject.h:4270
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition TypeObject.h:4214
RTPS_DllAPI MinimalSequenceType & operator=(const MinimalSequenceType &x)
RTPS_DllAPI MinimalCollectionHeader & header()
Definition TypeObject.h:4253
RTPS_DllAPI MinimalSequenceType(const MinimalSequenceType &x)
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition TypeObject.h:4258
RTPS_DllAPI bool consistent(const MinimalSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition TypeObject.h:4220
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition TypeObject.h:4242
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition TypeObject.h:4231
RTPS_DllAPI bool operator==(const MinimalSequenceType &other) const
RTPS_DllAPI MinimalSequenceType(MinimalSequenceType &&x)
RTPS_DllAPI MinimalCollectionElement & element()
Definition TypeObject.h:4275
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition TypeObject.h:4264
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition TypeObject.h:4236
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition TypeObject.h:886
RTPS_DllAPI bool consistent(const MinimalStructHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition TypeObject.h:896
RTPS_DllAPI MinimalStructHeader(MinimalStructHeader &&x)
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition TypeObject.h:902
RTPS_DllAPI MinimalTypeDetail & detail()
Definition TypeObject.h:913
RTPS_DllAPI MinimalStructHeader(const MinimalStructHeader &x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition TypeObject.h:891
RTPS_DllAPI MinimalStructHeader & operator=(const MinimalStructHeader &x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition TypeObject.h:874
RTPS_DllAPI bool operator==(const MinimalStructHeader &other) const
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition TypeObject.h:880
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition TypeObject.h:908
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition TypeObject.h:491
RTPS_DllAPI bool consistent(const MinimalStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalStructMember & operator=(const MinimalStructMember &x)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition TypeObject.h:496
RTPS_DllAPI const CommonStructMember & common() const
Definition TypeObject.h:469
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition TypeObject.h:457
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition TypeObject.h:485
RTPS_DllAPI MinimalStructMember(MinimalStructMember &&x)
RTPS_DllAPI CommonStructMember & common()
Definition TypeObject.h:474
RTPS_DllAPI MinimalStructMember(const MinimalStructMember &x)
RTPS_DllAPI bool operator==(const MinimalStructMember &other) const
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition TypeObject.h:463
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition TypeObject.h:479
RTPS_DllAPI MinimalStructMemberSeq & member_seq()
Definition TypeObject.h:1144
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition TypeObject.h:1089
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition TypeObject.h:1095
RTPS_DllAPI MinimalStructType(MinimalStructType &&x)
RTPS_DllAPI void member_seq(const MinimalStructMemberSeq &_member_seq)
Definition TypeObject.h:1127
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition TypeObject.h:1083
RTPS_DllAPI void header(const MinimalStructHeader &_header)
Definition TypeObject.h:1105
RTPS_DllAPI void header(MinimalStructHeader &&_header)
Definition TypeObject.h:1111
RTPS_DllAPI const MinimalStructHeader & header() const
Definition TypeObject.h:1117
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition TypeObject.h:1100
RTPS_DllAPI void member_seq(MinimalStructMemberSeq &&_member_seq)
Definition TypeObject.h:1133
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:1122
RTPS_DllAPI const MinimalStructMemberSeq & member_seq() const
Definition TypeObject.h:1139
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 MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
RTPS_DllAPI bool operator==(const MinimalTypeDetail &) const
Definition TypeObject.h:635
RTPS_DllAPI bool consistent(const MinimalTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
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 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 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(MinimalTypeObject &&x)
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:1881
RTPS_DllAPI MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition TypeObject.h:1887
RTPS_DllAPI MinimalTypeDetail & detail()
Definition TypeObject.h:1898
RTPS_DllAPI bool consistent(const MinimalUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const MinimalUnionHeader &other) const
RTPS_DllAPI MinimalUnionHeader(const MinimalUnionHeader &x)
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition TypeObject.h:1893
RTPS_DllAPI bool consistent(const MinimalUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition TypeObject.h:1475
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition TypeObject.h:1441
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition TypeObject.h:1447
RTPS_DllAPI MinimalMemberDetail & detail()
Definition TypeObject.h:1480
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition TypeObject.h:1469
RTPS_DllAPI const CommonUnionMember & common() const
Definition TypeObject.h:1453
RTPS_DllAPI MinimalUnionMember(MinimalUnionMember &&x)
RTPS_DllAPI MinimalUnionMember & operator=(const MinimalUnionMember &x)
RTPS_DllAPI bool operator==(const MinimalUnionMember &other) const
RTPS_DllAPI MinimalUnionMember(const MinimalUnionMember &x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition TypeObject.h:1463
RTPS_DllAPI CommonUnionMember & common()
Definition TypeObject.h:1458
RTPS_DllAPI void member_seq(const MinimalUnionMemberSeq &_member_seq)
Definition TypeObject.h:2158
RTPS_DllAPI bool consistent(const MinimalUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void discriminator(const MinimalDiscriminatorMember &_discriminator)
Definition TypeObject.h:2136
RTPS_DllAPI const MinimalUnionHeader & header() const
Definition TypeObject.h:2126
RTPS_DllAPI const MinimalDiscriminatorMember & discriminator() const
Definition TypeObject.h:2148
RTPS_DllAPI void discriminator(MinimalDiscriminatorMember &&_discriminator)
Definition TypeObject.h:2142
RTPS_DllAPI MinimalUnionType(const MinimalUnionType &x)
RTPS_DllAPI bool operator==(const MinimalUnionType &other) const
RTPS_DllAPI const MinimalUnionMemberSeq & member_seq() const
Definition TypeObject.h:2170
RTPS_DllAPI MinimalUnionType(MinimalUnionType &&x)
RTPS_DllAPI MinimalUnionHeader & header()
Definition TypeObject.h:2131
RTPS_DllAPI MinimalDiscriminatorMember & discriminator()
Definition TypeObject.h:2153
RTPS_DllAPI MinimalUnionType & operator=(const MinimalUnionType &x)
RTPS_DllAPI MinimalUnionMemberSeq & member_seq()
Definition TypeObject.h:2175
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition TypeObject.h:2092
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition TypeObject.h:2104
RTPS_DllAPI void member_seq(MinimalUnionMemberSeq &&_member_seq)
Definition TypeObject.h:2164
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition TypeObject.h:2109
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition TypeObject.h:2098
RTPS_DllAPI void header(MinimalUnionHeader &&_header)
Definition TypeObject.h:2120
RTPS_DllAPI void header(const MinimalUnionHeader &_header)
Definition TypeObject.h:2114
Definition TypesBase.h:500
Definition TypeIdentifier.h:81
RTPS_DllAPI TypeIdentifierPair(TypeIdentifierPair &&x)
RTPS_DllAPI const TypeIdentifier & type_identifier2() const
Definition TypeObject.h:7745
RTPS_DllAPI const TypeIdentifier & type_identifier1() const
Definition TypeObject.h:7723
RTPS_DllAPI void type_identifier1(TypeIdentifier &&_type_identifier1)
Definition TypeObject.h:7717
RTPS_DllAPI void type_identifier2(TypeIdentifier &&_type_identifier2)
Definition TypeObject.h:7739
RTPS_DllAPI TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
RTPS_DllAPI void type_identifier1(const TypeIdentifier &_type_identifier1)
Definition TypeObject.h:7711
RTPS_DllAPI TypeIdentifierPair(const TypeIdentifierPair &x)
RTPS_DllAPI void type_identifier2(const TypeIdentifier &_type_identifier2)
Definition TypeObject.h:7733
RTPS_DllAPI TypeIdentifier & type_identifier1()
Definition TypeObject.h:7728
RTPS_DllAPI TypeIdentifier & type_identifier2()
Definition TypeObject.h:7750
RTPS_DllAPI TypeObject & type_object()
Definition TypeObject.h:7664
RTPS_DllAPI void type_object(TypeObject &&_type_object)
Definition TypeObject.h:7653
RTPS_DllAPI TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x)
RTPS_DllAPI TypeIdentifier & type_identifier()
Definition TypeObject.h:7642
RTPS_DllAPI const TypeIdentifier & type_identifier() const
Definition TypeObject.h:7637
RTPS_DllAPI void type_identifier(const TypeIdentifier &_type_identifier)
Definition TypeObject.h:7625
RTPS_DllAPI TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI void type_identifier(TypeIdentifier &&_type_identifier)
Definition TypeObject.h:7631
RTPS_DllAPI void type_object(const TypeObject &_type_object)
Definition TypeObject.h:7647
RTPS_DllAPI TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI const TypeObject & type_object() const
Definition TypeObject.h:7659
RTPS_DllAPI const int32_t & dependent_typeid_count() const
Definition TypeObject.h:7920
RTPS_DllAPI TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeid_with_size(const TypeIdentifierWithSize &_typeid_with_size)
Definition TypeObject.h:7886
RTPS_DllAPI const TypeIdentifierWithSizeSeq & dependent_typeids() const
Definition TypeObject.h:7942
RTPS_DllAPI int32_t & dependent_typeid_count()
Definition TypeObject.h:7925
RTPS_DllAPI void typeid_with_size(TypeIdentifierWithSize &&_typeid_with_size)
Definition TypeObject.h:7892
RTPS_DllAPI void dependent_typeids(const TypeIdentifierWithSizeSeq &_dependent_typeids)
Definition TypeObject.h:7930
RTPS_DllAPI TypeIdentifierWithSizeSeq & dependent_typeids()
Definition TypeObject.h:7947
RTPS_DllAPI void dependent_typeid_count(int32_t &&_dependent_typeid_count)
Definition TypeObject.h:7914
RTPS_DllAPI const TypeIdentifierWithSize & typeid_with_size() const
Definition TypeObject.h:7898
RTPS_DllAPI TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x)
RTPS_DllAPI void dependent_typeid_count(const int32_t &_dependent_typeid_count)
Definition TypeObject.h:7908
RTPS_DllAPI TypeIdentifierWithSize & typeid_with_size()
Definition TypeObject.h:7903
RTPS_DllAPI void dependent_typeids(TypeIdentifierWithSizeSeq &&_dependent_typeids)
Definition TypeObject.h:7936
RTPS_DllAPI TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeobject_serialized_size(uint32_t &&_typeobject_serialized_size)
Definition TypeObject.h:7825
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition TypeObject.h:7803
RTPS_DllAPI TypeIdentifierWithSize & operator=(const TypeIdentifierWithSize &x)
RTPS_DllAPI const uint32_t & typeobject_serialized_size() const
Definition TypeObject.h:7831
RTPS_DllAPI TypeIdentifierWithSize(const TypeIdentifierWithSize &x)
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition TypeObject.h:7809
RTPS_DllAPI uint32_t & typeobject_serialized_size()
Definition TypeObject.h:7836
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition TypeObject.h:7797
RTPS_DllAPI TypeIdentifierWithSize(TypeIdentifierWithSize &&x)
RTPS_DllAPI void typeobject_serialized_size(const uint32_t &_typeobject_serialized_size)
Definition TypeObject.h:7819
RTPS_DllAPI TypeIdentifier & type_id()
Definition TypeObject.h:7814
Definition TypeObject.h:7986
RTPS_DllAPI const TypeIdentifierWithDependencies & minimal() const
Definition TypeObject.h:8012
RTPS_DllAPI void complete(TypeIdentifierWithDependencies &&_complete)
Definition TypeObject.h:8028
RTPS_DllAPI TypeIdentifierWithDependencies & minimal()
Definition TypeObject.h:8017
RTPS_DllAPI void complete(const TypeIdentifierWithDependencies &_complete)
Definition TypeObject.h:8022
RTPS_DllAPI const TypeIdentifierWithDependencies & complete() const
Definition TypeObject.h:8034
RTPS_DllAPI TypeIdentifierWithDependencies & complete()
Definition TypeObject.h:8039
RTPS_DllAPI void minimal(TypeIdentifierWithDependencies &&_minimal)
Definition TypeObject.h:8006
RTPS_DllAPI TypeInformation(TypeInformation &&x)
RTPS_DllAPI TypeInformation & operator=(const TypeInformation &x)
RTPS_DllAPI void minimal(const TypeIdentifierWithDependencies &_minimal)
Definition TypeObject.h:8000
RTPS_DllAPI TypeInformation(const TypeInformation &x)
Definition TypeObject.h:7431
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.
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 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 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 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:6082
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition TypeObject.h:6712
uint32_t MemberId
Definition TypesBase.h:285
TypeObjectSeq StronglyConnectedComponent
Definition TypeObject.h:7604
std::vector< TypeObject > TypeObjectSeq
Definition TypeObject.h:7598
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition TypeObject.h:6153
std::vector< int32_t > UnionCaseLabelSeq
Definition TypeObject.h:1183
std::vector< CompleteBitfield > CompleteBitfieldSeq
Definition TypeObject.h:6619
uint32_t LBound
Definition TypesBase.h:294
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition TypeObject.h:2540
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition TypeObject.h:1515
std::string MemberName
Definition TypesBase.h:166
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition TypeObject.h:6151
std::vector< TypeIdentifierWithSize > TypeIdentifierWithSizeSeq
Definition TypeObject.h:7863
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition TypeObject.h:531
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition TypeObject.h:7975
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition TypeObject.h:5339
std::vector< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition TypeObject.h:2422
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition TypeObject.h:7690
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition TypeObject.h:5988
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition TypeObject.h:435
std::vector< TypeInformation > TypeInformationSeq
Definition TypeObject.h:8068
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition TypeObject.h:5242
std::string QualifiedTypeName
Definition TypesBase.h:171
uint16_t BitBound
Definition TypeObject.h:5052
std::vector< CompleteUnionMember > CompleteUnionMemberSeq
Definition TypeObject.h:1419
std::vector< LBound > LBoundSeq
Definition TypesBase.h:295
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition AnnotationParameterValue.h:1150
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition TypeObject.h:7777
octet TypeKind
Definition TypesBase.h:120
std::array< uint8_t, 4 > NameHash
Definition TypesBase.h:179
eProsima namespace.
Definition LibrarySettingsAttributes.h:23