| Fast DDS Version 3.3.0 Fast DDS

Loading...
Searching...
No Matches
dds_xtypes_typeobject.hpp
1// Copyright 2016 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
21
22#ifndef FAST_DDS_GENERATED__DDS_XTYPES_TYPEOBJECT_HPP
23#define FAST_DDS_GENERATED__DDS_XTYPES_TYPEOBJECT_HPP
24
25#include <array>
26#include <cstdint>
27#include <functional>
28#include <string>
29#include <utility>
30#include <vector>
31
32#include <fastcdr/cdr/fixed_size_string.hpp>
33#include <fastcdr/xcdr/external.hpp>
34#include <fastcdr/xcdr/optional.hpp>
35#include <fastcdr/exceptions/BadParamException.h>
36
37
38#if defined(_WIN32)
39#if defined(EPROSIMA_USER_DLL_EXPORT)
40#define eProsima_user_DllExport __declspec( dllexport )
41#else
42#define eProsima_user_DllExport
43#endif // EPROSIMA_USER_DLL_EXPORT
44#else
45#define eProsima_user_DllExport
46#endif // _WIN32
47
48#if defined(_WIN32)
49#if defined(EPROSIMA_USER_DLL_EXPORT)
50#if defined(DDS_XTYPES_TYPEOBJECT_SOURCE)
51#define DDS_XTYPES_TYPEOBJECT_DllAPI __declspec( dllexport )
52#else
53#define DDS_XTYPES_TYPEOBJECT_DllAPI __declspec( dllimport )
54#endif // DDS_XTYPES_TYPEOBJECT_SOURCE
55#else
56#define DDS_XTYPES_TYPEOBJECT_DllAPI
57#endif // EPROSIMA_USER_DLL_EXPORT
58#else
59#define DDS_XTYPES_TYPEOBJECT_DllAPI
60#endif // _WIN32
61
62 namespace eprosima {
63
64 namespace fastdds {
65
66 namespace dds {
67
68
69 namespace xtypes {
70
71
72 typedef uint8_t EquivalenceKind;
73
74 const uint8_t EK_MINIMAL = 0xF1;
75 const uint8_t EK_COMPLETE = 0xF2;
76 const uint8_t EK_BOTH = 0xF3;
77 typedef uint8_t TypeKind;
78
79 const uint8_t TK_NONE = 0x00;
80 const uint8_t TK_BOOLEAN = 0x01;
81 const uint8_t TK_BYTE = 0x02;
82 const uint8_t TK_INT16 = 0x03;
83 const uint8_t TK_INT32 = 0x04;
84 const uint8_t TK_INT64 = 0x05;
85 const uint8_t TK_UINT16 = 0x06;
86 const uint8_t TK_UINT32 = 0x07;
87 const uint8_t TK_UINT64 = 0x08;
88 const uint8_t TK_FLOAT32 = 0x09;
89 const uint8_t TK_FLOAT64 = 0x0A;
90 const uint8_t TK_FLOAT128 = 0x0B;
91 const uint8_t TK_INT8 = 0x0C;
92 const uint8_t TK_UINT8 = 0x0D;
93 const uint8_t TK_CHAR8 = 0x10;
94 const uint8_t TK_CHAR16 = 0x11;
95 const uint8_t TK_STRING8 = 0x20;
96 const uint8_t TK_STRING16 = 0x21;
97 const uint8_t TK_ALIAS = 0x30;
98 const uint8_t TK_ENUM = 0x40;
99 const uint8_t TK_BITMASK = 0x41;
100 const uint8_t TK_ANNOTATION = 0x50;
101 const uint8_t TK_STRUCTURE = 0x51;
102 const uint8_t TK_UNION = 0x52;
103 const uint8_t TK_BITSET = 0x53;
104 const uint8_t TK_SEQUENCE = 0x60;
105 const uint8_t TK_ARRAY = 0x61;
106 const uint8_t TK_MAP = 0x62;
107 typedef uint8_t TypeIdentiferKind;
108
109 const uint8_t TI_STRING8_SMALL = 0x70;
110 const uint8_t TI_STRING8_LARGE = 0x71;
111 const uint8_t TI_STRING16_SMALL = 0x72;
112 const uint8_t TI_STRING16_LARGE = 0x73;
113 const uint8_t TI_PLAIN_SEQUENCE_SMALL = 0x80;
114 const uint8_t TI_PLAIN_SEQUENCE_LARGE = 0x81;
115 const uint8_t TI_PLAIN_ARRAY_SMALL = 0x90;
116 const uint8_t TI_PLAIN_ARRAY_LARGE = 0x91;
117 const uint8_t TI_PLAIN_MAP_SMALL = 0xA0;
118 const uint8_t TI_PLAIN_MAP_LARGE = 0xA1;
119 const uint8_t TI_STRONGLY_CONNECTED_COMPONENT = 0xB0;
120 const int32_t MEMBER_NAME_MAX_LENGTH = 256;
121 typedef eprosima::fastcdr::fixed_string<MEMBER_NAME_MAX_LENGTH> MemberName;
122
123 const int32_t TYPE_NAME_MAX_LENGTH = 256;
124 typedef eprosima::fastcdr::fixed_string<TYPE_NAME_MAX_LENGTH> QualifiedTypeName;
125
126 typedef uint8_t PrimitiveTypeId;
127
128 typedef std::array<uint8_t, 14> EquivalenceHash;
129
130 typedef std::array<uint8_t, 4> NameHash;
131
132 typedef uint32_t LBound;
133
134 typedef std::vector<LBound> LBoundSeq;
135
136 const LBound INVALID_LBOUND = 0;
137 typedef uint8_t SBound;
138
139 typedef std::vector<SBound> SBoundSeq;
140
141 const SBound INVALID_SBOUND = 0;
146 class TypeObjectHashId
147{
148 public:
149
153 eProsima_user_DllExport TypeObjectHashId()
154 {
155 }
156
160 eProsima_user_DllExport ~TypeObjectHashId()
161 {
162 if (member_destructor_)
163 {
164 member_destructor_();
165 }
166 }
167
172 eProsima_user_DllExport TypeObjectHashId(
173 const TypeObjectHashId& x)
174 {
175 m__d = x.m__d;
176
177 switch (x.selected_member_)
178 {
179 case 0x00000001:
180 hash_() = x.m_hash;
181 break;
182
183 }
184 }
185
190 eProsima_user_DllExport TypeObjectHashId(
191 TypeObjectHashId&& x) noexcept
192 {
193 m__d = x.m__d;
194
195 switch (x.selected_member_)
196 {
197 case 0x00000001:
198 hash_() = std::move(x.m_hash);
199 break;
200
201 }
202 }
203
208 eProsima_user_DllExport TypeObjectHashId& operator =(
209 const TypeObjectHashId& x)
210 {
211 m__d = x.m__d;
212
213 switch (x.selected_member_)
214 {
215 case 0x00000001:
216 hash_() = x.m_hash;
217 break;
218
219 }
220
221 return *this;
222 }
223
228 eProsima_user_DllExport TypeObjectHashId& operator =(
229 TypeObjectHashId&& x) noexcept
230 {
231 m__d = x.m__d;
232
233 switch (x.selected_member_)
234 {
235 case 0x00000001:
236 hash_() = std::move(x.m_hash);
237 break;
238
239 }
240
241 return *this;
242 }
243
248 eProsima_user_DllExport bool operator ==(
249 const TypeObjectHashId& x) const
250 {
251 bool ret_value {false};
252
253 if (x.selected_member_ == selected_member_)
254 {
255 if (0x0FFFFFFFu != selected_member_)
256 {
257 if (x.m__d == m__d)
258 {
259 switch (selected_member_)
260 {
261 case 0x00000001:
262 ret_value = (x.m_hash == m_hash);
263 break;
264
265 }
266 }
267 }
268 else
269 {
270 ret_value = true;
271 }
272 }
273
274 return ret_value;
275 }
276
281 eProsima_user_DllExport bool operator !=(
282 const TypeObjectHashId& x) const
283 {
284 return !(*this == x);
285 }
286
292 eProsima_user_DllExport void _d(
293 uint8_t __d)
294 {
295 bool valid_discriminator = false;
296
297 switch (__d)
298 {
299 case EK_COMPLETE:
300 case EK_MINIMAL:
301 if (0x00000001 == selected_member_)
302 {
303 valid_discriminator = true;
304 }
305 break;
306
307 }
308
309 if (!valid_discriminator)
310 {
311 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
312 }
313
314 m__d = __d;
315 }
316
321 eProsima_user_DllExport uint8_t _d() const
322 {
323 return m__d;
324 }
325
330 eProsima_user_DllExport void hash(
331 const EquivalenceHash& _hash)
332 {
333 hash_() = _hash;
334 m__d = EK_COMPLETE;
335 }
336
341 eProsima_user_DllExport void hash(
342 EquivalenceHash&& _hash)
343 {
344 hash_() = _hash;
345 m__d = EK_COMPLETE;
346 }
347
353 eProsima_user_DllExport const EquivalenceHash& hash() const
354 {
355 if (0x00000001 != selected_member_)
356 {
357 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
358 }
359
360 return m_hash;
361 }
362
368 eProsima_user_DllExport EquivalenceHash& hash()
369 {
370 if (0x00000001 != selected_member_)
371 {
372 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
373 }
374
375 return m_hash;
376 }
377
378
379 void _default()
380 {
381 if (member_destructor_)
382 {
383 member_destructor_();
384 }
385
386 selected_member_ = 0x0FFFFFFFu;
387 }
388
389
390 private:
391
392 EquivalenceHash& hash_()
393 {
394 if (0x00000001 != selected_member_)
395 {
396 if (member_destructor_)
397 {
398 member_destructor_();
399 }
400
401 selected_member_ = 0x00000001;
402 member_destructor_ = [&]()
403 {
404 using namespace eprosima::fastdds::dds::xtypes;
405 m_hash.~EquivalenceHash();
406 };
407 new(&m_hash) EquivalenceHash();
408
409 }
410
411 return m_hash;
412 }
413
414
415 uint8_t m__d {127};
416
417 union
418 {
419 EquivalenceHash m_hash;
420 };
421
422 uint32_t selected_member_ {0x0FFFFFFFu};
423
424 std::function<void()> member_destructor_;
425};
426
430 enum MemberFlagBits : uint16_t
431{
432 TRY_CONSTRUCT1 = 0x01ull << 0,
433 TRY_CONSTRUCT2 = 0x01ull << 1,
434 IS_EXTERNAL = 0x01ull << 2,
435 IS_OPTIONAL = 0x01ull << 3,
436 IS_MUST_UNDERSTAND = 0x01ull << 4,
437 IS_KEY = 0x01ull << 5,
438 IS_DEFAULT = 0x01ull << 6
439};
440 typedef uint16_t MemberFlag;
441 typedef MemberFlag CollectionElementFlag;
442
443 typedef MemberFlag StructMemberFlag;
444
445 typedef MemberFlag UnionMemberFlag;
446
447 typedef MemberFlag UnionDiscriminatorFlag;
448
449 typedef MemberFlag EnumeratedLiteralFlag;
450
451 typedef MemberFlag AnnotationParameterFlag;
452
453 typedef MemberFlag AliasMemberFlag;
454
455 typedef MemberFlag BitflagFlag;
456
457 typedef MemberFlag BitsetMemberFlag;
458
459 const uint16_t MemberFlagMinimalMask = 0x003f;
464 enum TypeFlagBits : uint16_t
465{
466 IS_FINAL = 0x01ull << 0,
467 IS_APPENDABLE = 0x01ull << 1,
468 IS_MUTABLE = 0x01ull << 2,
469 IS_NESTED = 0x01ull << 3,
470 IS_AUTOID_HASH = 0x01ull << 4
471};
472 typedef uint16_t TypeFlag;
473 typedef TypeFlag StructTypeFlag;
474
475 typedef TypeFlag UnionTypeFlag;
476
477 typedef TypeFlag CollectionTypeFlag;
478
479 typedef TypeFlag AnnotationTypeFlag;
480
481 typedef TypeFlag AliasTypeFlag;
482
483 typedef TypeFlag EnumTypeFlag;
484
485 typedef TypeFlag BitmaskTypeFlag;
486
487 typedef TypeFlag BitsetTypeFlag;
488
489 const uint16_t TypeFlagMinimalMask = 0x0007;
490 class TypeIdentifier;
491
496 class StringSTypeDefn
497{
498 public:
499
503 eProsima_user_DllExport StringSTypeDefn()
504 {
505 }
506
510 eProsima_user_DllExport ~StringSTypeDefn()
511 {
512 }
513
518 eProsima_user_DllExport StringSTypeDefn(
519 const StringSTypeDefn& x)
520 {
521 m_bound = x.m_bound;
522
523 }
524
529 eProsima_user_DllExport StringSTypeDefn(
530 StringSTypeDefn&& x) noexcept
531 {
532 m_bound = x.m_bound;
533 }
534
539 eProsima_user_DllExport StringSTypeDefn& operator =(
540 const StringSTypeDefn& x)
541 {
542
543 m_bound = x.m_bound;
544
545 return *this;
546 }
547
552 eProsima_user_DllExport StringSTypeDefn& operator =(
553 StringSTypeDefn&& x) noexcept
554 {
555
556 m_bound = x.m_bound;
557 return *this;
558 }
559
564 eProsima_user_DllExport bool operator ==(
565 const StringSTypeDefn& x) const
566 {
567 return (m_bound == x.m_bound);
568 }
569
574 eProsima_user_DllExport bool operator !=(
575 const StringSTypeDefn& x) const
576 {
577 return !(*this == x);
578 }
579
584 eProsima_user_DllExport void bound(
585 SBound _bound)
586 {
587 m_bound = _bound;
588 }
589
594 eProsima_user_DllExport SBound bound() const
595 {
596 return m_bound;
597 }
598
603 eProsima_user_DllExport SBound& bound()
604 {
605 return m_bound;
606 }
607
608
609
610 private:
611
612 SBound m_bound{0};
613
614};
615
619 class StringLTypeDefn
620{
621 public:
622
626 eProsima_user_DllExport StringLTypeDefn()
627 {
628 }
629
633 eProsima_user_DllExport ~StringLTypeDefn()
634 {
635 }
636
641 eProsima_user_DllExport StringLTypeDefn(
642 const StringLTypeDefn& x)
643 {
644 m_bound = x.m_bound;
645
646 }
647
652 eProsima_user_DllExport StringLTypeDefn(
653 StringLTypeDefn&& x) noexcept
654 {
655 m_bound = x.m_bound;
656 }
657
662 eProsima_user_DllExport StringLTypeDefn& operator =(
663 const StringLTypeDefn& x)
664 {
665
666 m_bound = x.m_bound;
667
668 return *this;
669 }
670
675 eProsima_user_DllExport StringLTypeDefn& operator =(
676 StringLTypeDefn&& x) noexcept
677 {
678
679 m_bound = x.m_bound;
680 return *this;
681 }
682
687 eProsima_user_DllExport bool operator ==(
688 const StringLTypeDefn& x) const
689 {
690 return (m_bound == x.m_bound);
691 }
692
697 eProsima_user_DllExport bool operator !=(
698 const StringLTypeDefn& x) const
699 {
700 return !(*this == x);
701 }
702
707 eProsima_user_DllExport void bound(
708 LBound _bound)
709 {
710 m_bound = _bound;
711 }
712
717 eProsima_user_DllExport LBound bound() const
718 {
719 return m_bound;
720 }
721
726 eProsima_user_DllExport LBound& bound()
727 {
728 return m_bound;
729 }
730
731
732
733 private:
734
735 LBound m_bound{0};
736
737};
738
742 class PlainCollectionHeader
743{
744 public:
745
749 eProsima_user_DllExport PlainCollectionHeader()
750 {
751 }
752
756 eProsima_user_DllExport ~PlainCollectionHeader()
757 {
758 }
759
764 eProsima_user_DllExport PlainCollectionHeader(
765 const PlainCollectionHeader& x)
766 {
767 m_equiv_kind = x.m_equiv_kind;
768
769 m_element_flags = x.m_element_flags;
770
771 }
772
777 eProsima_user_DllExport PlainCollectionHeader(
778 PlainCollectionHeader&& x) noexcept
779 {
780 m_equiv_kind = x.m_equiv_kind;
781 m_element_flags = std::move(x.m_element_flags);
782 }
783
788 eProsima_user_DllExport PlainCollectionHeader& operator =(
789 const PlainCollectionHeader& x)
790 {
791
792 m_equiv_kind = x.m_equiv_kind;
793
794 m_element_flags = x.m_element_flags;
795
796 return *this;
797 }
798
803 eProsima_user_DllExport PlainCollectionHeader& operator =(
804 PlainCollectionHeader&& x) noexcept
805 {
806
807 m_equiv_kind = x.m_equiv_kind;
808 m_element_flags = std::move(x.m_element_flags);
809 return *this;
810 }
811
816 eProsima_user_DllExport bool operator ==(
817 const PlainCollectionHeader& x) const
818 {
819 return (m_equiv_kind == x.m_equiv_kind &&
820 m_element_flags == x.m_element_flags);
821 }
822
827 eProsima_user_DllExport bool operator !=(
828 const PlainCollectionHeader& x) const
829 {
830 return !(*this == x);
831 }
832
837 eProsima_user_DllExport void equiv_kind(
838 EquivalenceKind _equiv_kind)
839 {
840 m_equiv_kind = _equiv_kind;
841 }
842
847 eProsima_user_DllExport EquivalenceKind equiv_kind() const
848 {
849 return m_equiv_kind;
850 }
851
856 eProsima_user_DllExport EquivalenceKind& equiv_kind()
857 {
858 return m_equiv_kind;
859 }
860
861
866 eProsima_user_DllExport void element_flags(
867 const CollectionElementFlag& _element_flags)
868 {
869 m_element_flags = _element_flags;
870 }
871
876 eProsima_user_DllExport void element_flags(
877 CollectionElementFlag&& _element_flags)
878 {
879 m_element_flags = std::move(_element_flags);
880 }
881
886 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
887 {
888 return m_element_flags;
889 }
890
895 eProsima_user_DllExport CollectionElementFlag& element_flags()
896 {
897 return m_element_flags;
898 }
899
900
901
902 private:
903
904 EquivalenceKind m_equiv_kind{0};
905 CollectionElementFlag m_element_flags{0};
906
907};
908
912 class PlainSequenceSElemDefn
913{
914 public:
915
919 eProsima_user_DllExport PlainSequenceSElemDefn()
920 {
921 }
922
926 eProsima_user_DllExport ~PlainSequenceSElemDefn()
927 {
928 }
929
934 eProsima_user_DllExport PlainSequenceSElemDefn(
935 const PlainSequenceSElemDefn& x)
936 {
937 m_header = x.m_header;
938
939 m_bound = x.m_bound;
940
941 m_element_identifier = x.m_element_identifier;
942
943 }
944
949 eProsima_user_DllExport PlainSequenceSElemDefn(
950 PlainSequenceSElemDefn&& x) noexcept
951 {
952 m_header = std::move(x.m_header);
953 m_bound = x.m_bound;
954 m_element_identifier = std::move(x.m_element_identifier);
955 }
956
961 eProsima_user_DllExport PlainSequenceSElemDefn& operator =(
962 const PlainSequenceSElemDefn& x)
963 {
964
965 m_header = x.m_header;
966
967 m_bound = x.m_bound;
968
969 m_element_identifier = x.m_element_identifier;
970
971 return *this;
972 }
973
978 eProsima_user_DllExport PlainSequenceSElemDefn& operator =(
979 PlainSequenceSElemDefn&& x) noexcept
980 {
981
982 m_header = std::move(x.m_header);
983 m_bound = x.m_bound;
984 m_element_identifier = std::move(x.m_element_identifier);
985 return *this;
986 }
987
992 eProsima_user_DllExport bool operator ==(
993 const PlainSequenceSElemDefn& x) const
994 {
995 return (m_header == x.m_header &&
996 m_bound == x.m_bound &&
997 m_element_identifier == x.m_element_identifier);
998 }
999
1004 eProsima_user_DllExport bool operator !=(
1005 const PlainSequenceSElemDefn& x) const
1006 {
1007 return !(*this == x);
1008 }
1009
1014 eProsima_user_DllExport void header(
1015 const PlainCollectionHeader& _header)
1016 {
1017 m_header = _header;
1018 }
1019
1024 eProsima_user_DllExport void header(
1025 PlainCollectionHeader&& _header)
1026 {
1027 m_header = std::move(_header);
1028 }
1029
1034 eProsima_user_DllExport const PlainCollectionHeader& header() const
1035 {
1036 return m_header;
1037 }
1038
1043 eProsima_user_DllExport PlainCollectionHeader& header()
1044 {
1045 return m_header;
1046 }
1047
1048
1053 eProsima_user_DllExport void bound(
1054 SBound _bound)
1055 {
1056 m_bound = _bound;
1057 }
1058
1063 eProsima_user_DllExport SBound bound() const
1064 {
1065 return m_bound;
1066 }
1067
1072 eProsima_user_DllExport SBound& bound()
1073 {
1074 return m_bound;
1075 }
1076
1077
1082 eProsima_user_DllExport void element_identifier(
1083 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1084 {
1085 m_element_identifier = _element_identifier;
1086 }
1087
1092 eProsima_user_DllExport void element_identifier(
1093 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1094 {
1095 m_element_identifier = std::move(_element_identifier);
1096 }
1097
1102 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1103 {
1104 return m_element_identifier;
1105 }
1106
1111 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1112 {
1113 return m_element_identifier;
1114 }
1115
1116
1117
1118 private:
1119
1120 PlainCollectionHeader m_header;
1121 SBound m_bound{0};
1122 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1123
1124};
1125
1129 class PlainSequenceLElemDefn
1130{
1131 public:
1132
1136 eProsima_user_DllExport PlainSequenceLElemDefn()
1137 {
1138 }
1139
1143 eProsima_user_DllExport ~PlainSequenceLElemDefn()
1144 {
1145 }
1146
1151 eProsima_user_DllExport PlainSequenceLElemDefn(
1152 const PlainSequenceLElemDefn& x)
1153 {
1154 m_header = x.m_header;
1155
1156 m_bound = x.m_bound;
1157
1158 m_element_identifier = x.m_element_identifier;
1159
1160 }
1161
1166 eProsima_user_DllExport PlainSequenceLElemDefn(
1167 PlainSequenceLElemDefn&& x) noexcept
1168 {
1169 m_header = std::move(x.m_header);
1170 m_bound = x.m_bound;
1171 m_element_identifier = std::move(x.m_element_identifier);
1172 }
1173
1178 eProsima_user_DllExport PlainSequenceLElemDefn& operator =(
1179 const PlainSequenceLElemDefn& x)
1180 {
1181
1182 m_header = x.m_header;
1183
1184 m_bound = x.m_bound;
1185
1186 m_element_identifier = x.m_element_identifier;
1187
1188 return *this;
1189 }
1190
1195 eProsima_user_DllExport PlainSequenceLElemDefn& operator =(
1196 PlainSequenceLElemDefn&& x) noexcept
1197 {
1198
1199 m_header = std::move(x.m_header);
1200 m_bound = x.m_bound;
1201 m_element_identifier = std::move(x.m_element_identifier);
1202 return *this;
1203 }
1204
1209 eProsima_user_DllExport bool operator ==(
1210 const PlainSequenceLElemDefn& x) const
1211 {
1212 return (m_header == x.m_header &&
1213 m_bound == x.m_bound &&
1214 m_element_identifier == x.m_element_identifier);
1215 }
1216
1221 eProsima_user_DllExport bool operator !=(
1222 const PlainSequenceLElemDefn& x) const
1223 {
1224 return !(*this == x);
1225 }
1226
1231 eProsima_user_DllExport void header(
1232 const PlainCollectionHeader& _header)
1233 {
1234 m_header = _header;
1235 }
1236
1241 eProsima_user_DllExport void header(
1242 PlainCollectionHeader&& _header)
1243 {
1244 m_header = std::move(_header);
1245 }
1246
1251 eProsima_user_DllExport const PlainCollectionHeader& header() const
1252 {
1253 return m_header;
1254 }
1255
1260 eProsima_user_DllExport PlainCollectionHeader& header()
1261 {
1262 return m_header;
1263 }
1264
1265
1270 eProsima_user_DllExport void bound(
1271 LBound _bound)
1272 {
1273 m_bound = _bound;
1274 }
1275
1280 eProsima_user_DllExport LBound bound() const
1281 {
1282 return m_bound;
1283 }
1284
1289 eProsima_user_DllExport LBound& bound()
1290 {
1291 return m_bound;
1292 }
1293
1294
1299 eProsima_user_DllExport void element_identifier(
1300 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1301 {
1302 m_element_identifier = _element_identifier;
1303 }
1304
1309 eProsima_user_DllExport void element_identifier(
1310 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1311 {
1312 m_element_identifier = std::move(_element_identifier);
1313 }
1314
1319 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1320 {
1321 return m_element_identifier;
1322 }
1323
1328 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1329 {
1330 return m_element_identifier;
1331 }
1332
1333
1334
1335 private:
1336
1337 PlainCollectionHeader m_header;
1338 LBound m_bound{0};
1339 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1340
1341};
1342
1346 class PlainArraySElemDefn
1347{
1348 public:
1349
1353 eProsima_user_DllExport PlainArraySElemDefn()
1354 {
1355 }
1356
1360 eProsima_user_DllExport ~PlainArraySElemDefn()
1361 {
1362 }
1363
1368 eProsima_user_DllExport PlainArraySElemDefn(
1369 const PlainArraySElemDefn& x)
1370 {
1371 m_header = x.m_header;
1372
1373 m_array_bound_seq = x.m_array_bound_seq;
1374
1375 m_element_identifier = x.m_element_identifier;
1376
1377 }
1378
1383 eProsima_user_DllExport PlainArraySElemDefn(
1384 PlainArraySElemDefn&& x) noexcept
1385 {
1386 m_header = std::move(x.m_header);
1387 m_array_bound_seq = std::move(x.m_array_bound_seq);
1388 m_element_identifier = std::move(x.m_element_identifier);
1389 }
1390
1395 eProsima_user_DllExport PlainArraySElemDefn& operator =(
1396 const PlainArraySElemDefn& x)
1397 {
1398
1399 m_header = x.m_header;
1400
1401 m_array_bound_seq = x.m_array_bound_seq;
1402
1403 m_element_identifier = x.m_element_identifier;
1404
1405 return *this;
1406 }
1407
1412 eProsima_user_DllExport PlainArraySElemDefn& operator =(
1413 PlainArraySElemDefn&& x) noexcept
1414 {
1415
1416 m_header = std::move(x.m_header);
1417 m_array_bound_seq = std::move(x.m_array_bound_seq);
1418 m_element_identifier = std::move(x.m_element_identifier);
1419 return *this;
1420 }
1421
1426 eProsima_user_DllExport bool operator ==(
1427 const PlainArraySElemDefn& x) const
1428 {
1429 return (m_header == x.m_header &&
1430 m_array_bound_seq == x.m_array_bound_seq &&
1431 m_element_identifier == x.m_element_identifier);
1432 }
1433
1438 eProsima_user_DllExport bool operator !=(
1439 const PlainArraySElemDefn& x) const
1440 {
1441 return !(*this == x);
1442 }
1443
1448 eProsima_user_DllExport void header(
1449 const PlainCollectionHeader& _header)
1450 {
1451 m_header = _header;
1452 }
1453
1458 eProsima_user_DllExport void header(
1459 PlainCollectionHeader&& _header)
1460 {
1461 m_header = std::move(_header);
1462 }
1463
1468 eProsima_user_DllExport const PlainCollectionHeader& header() const
1469 {
1470 return m_header;
1471 }
1472
1477 eProsima_user_DllExport PlainCollectionHeader& header()
1478 {
1479 return m_header;
1480 }
1481
1482
1487 eProsima_user_DllExport void array_bound_seq(
1488 const SBoundSeq& _array_bound_seq)
1489 {
1490 m_array_bound_seq = _array_bound_seq;
1491 }
1492
1497 eProsima_user_DllExport void array_bound_seq(
1498 SBoundSeq&& _array_bound_seq)
1499 {
1500 m_array_bound_seq = std::move(_array_bound_seq);
1501 }
1502
1507 eProsima_user_DllExport const SBoundSeq& array_bound_seq() const
1508 {
1509 return m_array_bound_seq;
1510 }
1511
1516 eProsima_user_DllExport SBoundSeq& array_bound_seq()
1517 {
1518 return m_array_bound_seq;
1519 }
1520
1521
1526 eProsima_user_DllExport void element_identifier(
1527 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1528 {
1529 m_element_identifier = _element_identifier;
1530 }
1531
1536 eProsima_user_DllExport void element_identifier(
1537 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1538 {
1539 m_element_identifier = std::move(_element_identifier);
1540 }
1541
1546 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1547 {
1548 return m_element_identifier;
1549 }
1550
1555 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1556 {
1557 return m_element_identifier;
1558 }
1559
1560
1561
1562 private:
1563
1564 PlainCollectionHeader m_header;
1565 SBoundSeq m_array_bound_seq;
1566 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1567
1568};
1569
1573 class PlainArrayLElemDefn
1574{
1575 public:
1576
1580 eProsima_user_DllExport PlainArrayLElemDefn()
1581 {
1582 }
1583
1587 eProsima_user_DllExport ~PlainArrayLElemDefn()
1588 {
1589 }
1590
1595 eProsima_user_DllExport PlainArrayLElemDefn(
1596 const PlainArrayLElemDefn& x)
1597 {
1598 m_header = x.m_header;
1599
1600 m_array_bound_seq = x.m_array_bound_seq;
1601
1602 m_element_identifier = x.m_element_identifier;
1603
1604 }
1605
1610 eProsima_user_DllExport PlainArrayLElemDefn(
1611 PlainArrayLElemDefn&& x) noexcept
1612 {
1613 m_header = std::move(x.m_header);
1614 m_array_bound_seq = std::move(x.m_array_bound_seq);
1615 m_element_identifier = std::move(x.m_element_identifier);
1616 }
1617
1622 eProsima_user_DllExport PlainArrayLElemDefn& operator =(
1623 const PlainArrayLElemDefn& x)
1624 {
1625
1626 m_header = x.m_header;
1627
1628 m_array_bound_seq = x.m_array_bound_seq;
1629
1630 m_element_identifier = x.m_element_identifier;
1631
1632 return *this;
1633 }
1634
1639 eProsima_user_DllExport PlainArrayLElemDefn& operator =(
1640 PlainArrayLElemDefn&& x) noexcept
1641 {
1642
1643 m_header = std::move(x.m_header);
1644 m_array_bound_seq = std::move(x.m_array_bound_seq);
1645 m_element_identifier = std::move(x.m_element_identifier);
1646 return *this;
1647 }
1648
1653 eProsima_user_DllExport bool operator ==(
1654 const PlainArrayLElemDefn& x) const
1655 {
1656 return (m_header == x.m_header &&
1657 m_array_bound_seq == x.m_array_bound_seq &&
1658 m_element_identifier == x.m_element_identifier);
1659 }
1660
1665 eProsima_user_DllExport bool operator !=(
1666 const PlainArrayLElemDefn& x) const
1667 {
1668 return !(*this == x);
1669 }
1670
1675 eProsima_user_DllExport void header(
1676 const PlainCollectionHeader& _header)
1677 {
1678 m_header = _header;
1679 }
1680
1685 eProsima_user_DllExport void header(
1686 PlainCollectionHeader&& _header)
1687 {
1688 m_header = std::move(_header);
1689 }
1690
1695 eProsima_user_DllExport const PlainCollectionHeader& header() const
1696 {
1697 return m_header;
1698 }
1699
1704 eProsima_user_DllExport PlainCollectionHeader& header()
1705 {
1706 return m_header;
1707 }
1708
1709
1714 eProsima_user_DllExport void array_bound_seq(
1715 const LBoundSeq& _array_bound_seq)
1716 {
1717 m_array_bound_seq = _array_bound_seq;
1718 }
1719
1724 eProsima_user_DllExport void array_bound_seq(
1725 LBoundSeq&& _array_bound_seq)
1726 {
1727 m_array_bound_seq = std::move(_array_bound_seq);
1728 }
1729
1734 eProsima_user_DllExport const LBoundSeq& array_bound_seq() const
1735 {
1736 return m_array_bound_seq;
1737 }
1738
1743 eProsima_user_DllExport LBoundSeq& array_bound_seq()
1744 {
1745 return m_array_bound_seq;
1746 }
1747
1748
1753 eProsima_user_DllExport void element_identifier(
1754 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1755 {
1756 m_element_identifier = _element_identifier;
1757 }
1758
1763 eProsima_user_DllExport void element_identifier(
1764 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1765 {
1766 m_element_identifier = std::move(_element_identifier);
1767 }
1768
1773 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1774 {
1775 return m_element_identifier;
1776 }
1777
1782 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1783 {
1784 return m_element_identifier;
1785 }
1786
1787
1788
1789 private:
1790
1791 PlainCollectionHeader m_header;
1792 LBoundSeq m_array_bound_seq;
1793 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1794
1795};
1796
1800 class PlainMapSTypeDefn
1801{
1802 public:
1803
1807 eProsima_user_DllExport PlainMapSTypeDefn()
1808 {
1809 }
1810
1814 eProsima_user_DllExport ~PlainMapSTypeDefn()
1815 {
1816 }
1817
1822 eProsima_user_DllExport PlainMapSTypeDefn(
1823 const PlainMapSTypeDefn& x)
1824 {
1825 m_header = x.m_header;
1826
1827 m_bound = x.m_bound;
1828
1829 m_element_identifier = x.m_element_identifier;
1830
1831 m_key_flags = x.m_key_flags;
1832
1833 m_key_identifier = x.m_key_identifier;
1834
1835 }
1836
1841 eProsima_user_DllExport PlainMapSTypeDefn(
1842 PlainMapSTypeDefn&& x) noexcept
1843 {
1844 m_header = std::move(x.m_header);
1845 m_bound = x.m_bound;
1846 m_element_identifier = std::move(x.m_element_identifier);
1847 m_key_flags = std::move(x.m_key_flags);
1848 m_key_identifier = std::move(x.m_key_identifier);
1849 }
1850
1855 eProsima_user_DllExport PlainMapSTypeDefn& operator =(
1856 const PlainMapSTypeDefn& x)
1857 {
1858
1859 m_header = x.m_header;
1860
1861 m_bound = x.m_bound;
1862
1863 m_element_identifier = x.m_element_identifier;
1864
1865 m_key_flags = x.m_key_flags;
1866
1867 m_key_identifier = x.m_key_identifier;
1868
1869 return *this;
1870 }
1871
1876 eProsima_user_DllExport PlainMapSTypeDefn& operator =(
1877 PlainMapSTypeDefn&& x) noexcept
1878 {
1879
1880 m_header = std::move(x.m_header);
1881 m_bound = x.m_bound;
1882 m_element_identifier = std::move(x.m_element_identifier);
1883 m_key_flags = std::move(x.m_key_flags);
1884 m_key_identifier = std::move(x.m_key_identifier);
1885 return *this;
1886 }
1887
1892 eProsima_user_DllExport bool operator ==(
1893 const PlainMapSTypeDefn& x) const
1894 {
1895 return (m_header == x.m_header &&
1896 m_bound == x.m_bound &&
1897 m_element_identifier == x.m_element_identifier &&
1898 m_key_flags == x.m_key_flags &&
1899 m_key_identifier == x.m_key_identifier);
1900 }
1901
1906 eProsima_user_DllExport bool operator !=(
1907 const PlainMapSTypeDefn& x) const
1908 {
1909 return !(*this == x);
1910 }
1911
1916 eProsima_user_DllExport void header(
1917 const PlainCollectionHeader& _header)
1918 {
1919 m_header = _header;
1920 }
1921
1926 eProsima_user_DllExport void header(
1927 PlainCollectionHeader&& _header)
1928 {
1929 m_header = std::move(_header);
1930 }
1931
1936 eProsima_user_DllExport const PlainCollectionHeader& header() const
1937 {
1938 return m_header;
1939 }
1940
1945 eProsima_user_DllExport PlainCollectionHeader& header()
1946 {
1947 return m_header;
1948 }
1949
1950
1955 eProsima_user_DllExport void bound(
1956 SBound _bound)
1957 {
1958 m_bound = _bound;
1959 }
1960
1965 eProsima_user_DllExport SBound bound() const
1966 {
1967 return m_bound;
1968 }
1969
1974 eProsima_user_DllExport SBound& bound()
1975 {
1976 return m_bound;
1977 }
1978
1979
1984 eProsima_user_DllExport void element_identifier(
1985 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1986 {
1987 m_element_identifier = _element_identifier;
1988 }
1989
1994 eProsima_user_DllExport void element_identifier(
1995 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1996 {
1997 m_element_identifier = std::move(_element_identifier);
1998 }
1999
2004 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
2005 {
2006 return m_element_identifier;
2007 }
2008
2013 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
2014 {
2015 return m_element_identifier;
2016 }
2017
2018
2023 eProsima_user_DllExport void key_flags(
2024 const CollectionElementFlag& _key_flags)
2025 {
2026 m_key_flags = _key_flags;
2027 }
2028
2033 eProsima_user_DllExport void key_flags(
2034 CollectionElementFlag&& _key_flags)
2035 {
2036 m_key_flags = std::move(_key_flags);
2037 }
2038
2043 eProsima_user_DllExport const CollectionElementFlag& key_flags() const
2044 {
2045 return m_key_flags;
2046 }
2047
2052 eProsima_user_DllExport CollectionElementFlag& key_flags()
2053 {
2054 return m_key_flags;
2055 }
2056
2057
2062 eProsima_user_DllExport void key_identifier(
2063 const eprosima::fastcdr::external<TypeIdentifier>& _key_identifier)
2064 {
2065 m_key_identifier = _key_identifier;
2066 }
2067
2072 eProsima_user_DllExport void key_identifier(
2073 eprosima::fastcdr::external<TypeIdentifier>&& _key_identifier)
2074 {
2075 m_key_identifier = std::move(_key_identifier);
2076 }
2077
2082 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& key_identifier() const
2083 {
2084 return m_key_identifier;
2085 }
2086
2091 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& key_identifier()
2092 {
2093 return m_key_identifier;
2094 }
2095
2096
2097
2098 private:
2099
2100 PlainCollectionHeader m_header;
2101 SBound m_bound{0};
2102 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
2103 CollectionElementFlag m_key_flags{0};
2104 eprosima::fastcdr::external<TypeIdentifier> m_key_identifier;
2105
2106};
2107
2111 class PlainMapLTypeDefn
2112{
2113 public:
2114
2118 eProsima_user_DllExport PlainMapLTypeDefn()
2119 {
2120 }
2121
2125 eProsima_user_DllExport ~PlainMapLTypeDefn()
2126 {
2127 }
2128
2133 eProsima_user_DllExport PlainMapLTypeDefn(
2134 const PlainMapLTypeDefn& x)
2135 {
2136 m_header = x.m_header;
2137
2138 m_bound = x.m_bound;
2139
2140 m_element_identifier = x.m_element_identifier;
2141
2142 m_key_flags = x.m_key_flags;
2143
2144 m_key_identifier = x.m_key_identifier;
2145
2146 }
2147
2152 eProsima_user_DllExport PlainMapLTypeDefn(
2153 PlainMapLTypeDefn&& x) noexcept
2154 {
2155 m_header = std::move(x.m_header);
2156 m_bound = x.m_bound;
2157 m_element_identifier = std::move(x.m_element_identifier);
2158 m_key_flags = std::move(x.m_key_flags);
2159 m_key_identifier = std::move(x.m_key_identifier);
2160 }
2161
2166 eProsima_user_DllExport PlainMapLTypeDefn& operator =(
2167 const PlainMapLTypeDefn& x)
2168 {
2169
2170 m_header = x.m_header;
2171
2172 m_bound = x.m_bound;
2173
2174 m_element_identifier = x.m_element_identifier;
2175
2176 m_key_flags = x.m_key_flags;
2177
2178 m_key_identifier = x.m_key_identifier;
2179
2180 return *this;
2181 }
2182
2187 eProsima_user_DllExport PlainMapLTypeDefn& operator =(
2188 PlainMapLTypeDefn&& x) noexcept
2189 {
2190
2191 m_header = std::move(x.m_header);
2192 m_bound = x.m_bound;
2193 m_element_identifier = std::move(x.m_element_identifier);
2194 m_key_flags = std::move(x.m_key_flags);
2195 m_key_identifier = std::move(x.m_key_identifier);
2196 return *this;
2197 }
2198
2203 eProsima_user_DllExport bool operator ==(
2204 const PlainMapLTypeDefn& x) const
2205 {
2206 return (m_header == x.m_header &&
2207 m_bound == x.m_bound &&
2208 m_element_identifier == x.m_element_identifier &&
2209 m_key_flags == x.m_key_flags &&
2210 m_key_identifier == x.m_key_identifier);
2211 }
2212
2217 eProsima_user_DllExport bool operator !=(
2218 const PlainMapLTypeDefn& x) const
2219 {
2220 return !(*this == x);
2221 }
2222
2227 eProsima_user_DllExport void header(
2228 const PlainCollectionHeader& _header)
2229 {
2230 m_header = _header;
2231 }
2232
2237 eProsima_user_DllExport void header(
2238 PlainCollectionHeader&& _header)
2239 {
2240 m_header = std::move(_header);
2241 }
2242
2247 eProsima_user_DllExport const PlainCollectionHeader& header() const
2248 {
2249 return m_header;
2250 }
2251
2256 eProsima_user_DllExport PlainCollectionHeader& header()
2257 {
2258 return m_header;
2259 }
2260
2261
2266 eProsima_user_DllExport void bound(
2267 LBound _bound)
2268 {
2269 m_bound = _bound;
2270 }
2271
2276 eProsima_user_DllExport LBound bound() const
2277 {
2278 return m_bound;
2279 }
2280
2285 eProsima_user_DllExport LBound& bound()
2286 {
2287 return m_bound;
2288 }
2289
2290
2295 eProsima_user_DllExport void element_identifier(
2296 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
2297 {
2298 m_element_identifier = _element_identifier;
2299 }
2300
2305 eProsima_user_DllExport void element_identifier(
2306 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
2307 {
2308 m_element_identifier = std::move(_element_identifier);
2309 }
2310
2315 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
2316 {
2317 return m_element_identifier;
2318 }
2319
2324 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
2325 {
2326 return m_element_identifier;
2327 }
2328
2329
2334 eProsima_user_DllExport void key_flags(
2335 const CollectionElementFlag& _key_flags)
2336 {
2337 m_key_flags = _key_flags;
2338 }
2339
2344 eProsima_user_DllExport void key_flags(
2345 CollectionElementFlag&& _key_flags)
2346 {
2347 m_key_flags = std::move(_key_flags);
2348 }
2349
2354 eProsima_user_DllExport const CollectionElementFlag& key_flags() const
2355 {
2356 return m_key_flags;
2357 }
2358
2363 eProsima_user_DllExport CollectionElementFlag& key_flags()
2364 {
2365 return m_key_flags;
2366 }
2367
2368
2373 eProsima_user_DllExport void key_identifier(
2374 const eprosima::fastcdr::external<TypeIdentifier>& _key_identifier)
2375 {
2376 m_key_identifier = _key_identifier;
2377 }
2378
2383 eProsima_user_DllExport void key_identifier(
2384 eprosima::fastcdr::external<TypeIdentifier>&& _key_identifier)
2385 {
2386 m_key_identifier = std::move(_key_identifier);
2387 }
2388
2393 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& key_identifier() const
2394 {
2395 return m_key_identifier;
2396 }
2397
2402 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& key_identifier()
2403 {
2404 return m_key_identifier;
2405 }
2406
2407
2408
2409 private:
2410
2411 PlainCollectionHeader m_header;
2412 LBound m_bound{0};
2413 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
2414 CollectionElementFlag m_key_flags{0};
2415 eprosima::fastcdr::external<TypeIdentifier> m_key_identifier;
2416
2417};
2418
2422 class StronglyConnectedComponentId
2423{
2424 public:
2425
2429 eProsima_user_DllExport StronglyConnectedComponentId()
2430 {
2431 }
2432
2436 eProsima_user_DllExport ~StronglyConnectedComponentId()
2437 {
2438 }
2439
2444 eProsima_user_DllExport StronglyConnectedComponentId(
2445 const StronglyConnectedComponentId& x)
2446 {
2447 m_sc_component_id = x.m_sc_component_id;
2448
2449 m_scc_length = x.m_scc_length;
2450
2451 m_scc_index = x.m_scc_index;
2452
2453 }
2454
2459 eProsima_user_DllExport StronglyConnectedComponentId(
2460 StronglyConnectedComponentId&& x) noexcept
2461 {
2462 m_sc_component_id = std::move(x.m_sc_component_id);
2463 m_scc_length = x.m_scc_length;
2464 m_scc_index = x.m_scc_index;
2465 }
2466
2471 eProsima_user_DllExport StronglyConnectedComponentId& operator =(
2472 const StronglyConnectedComponentId& x)
2473 {
2474
2475 m_sc_component_id = x.m_sc_component_id;
2476
2477 m_scc_length = x.m_scc_length;
2478
2479 m_scc_index = x.m_scc_index;
2480
2481 return *this;
2482 }
2483
2488 eProsima_user_DllExport StronglyConnectedComponentId& operator =(
2489 StronglyConnectedComponentId&& x) noexcept
2490 {
2491
2492 m_sc_component_id = std::move(x.m_sc_component_id);
2493 m_scc_length = x.m_scc_length;
2494 m_scc_index = x.m_scc_index;
2495 return *this;
2496 }
2497
2502 eProsima_user_DllExport bool operator ==(
2503 const StronglyConnectedComponentId& x) const
2504 {
2505 return (m_sc_component_id == x.m_sc_component_id &&
2506 m_scc_length == x.m_scc_length &&
2507 m_scc_index == x.m_scc_index);
2508 }
2509
2514 eProsima_user_DllExport bool operator !=(
2515 const StronglyConnectedComponentId& x) const
2516 {
2517 return !(*this == x);
2518 }
2519
2524 eProsima_user_DllExport void sc_component_id(
2525 const TypeObjectHashId& _sc_component_id)
2526 {
2527 m_sc_component_id = _sc_component_id;
2528 }
2529
2534 eProsima_user_DllExport void sc_component_id(
2535 TypeObjectHashId&& _sc_component_id)
2536 {
2537 m_sc_component_id = std::move(_sc_component_id);
2538 }
2539
2544 eProsima_user_DllExport const TypeObjectHashId& sc_component_id() const
2545 {
2546 return m_sc_component_id;
2547 }
2548
2553 eProsima_user_DllExport TypeObjectHashId& sc_component_id()
2554 {
2555 return m_sc_component_id;
2556 }
2557
2558
2563 eProsima_user_DllExport void scc_length(
2564 int32_t _scc_length)
2565 {
2566 m_scc_length = _scc_length;
2567 }
2568
2573 eProsima_user_DllExport int32_t scc_length() const
2574 {
2575 return m_scc_length;
2576 }
2577
2582 eProsima_user_DllExport int32_t& scc_length()
2583 {
2584 return m_scc_length;
2585 }
2586
2587
2592 eProsima_user_DllExport void scc_index(
2593 int32_t _scc_index)
2594 {
2595 m_scc_index = _scc_index;
2596 }
2597
2602 eProsima_user_DllExport int32_t scc_index() const
2603 {
2604 return m_scc_index;
2605 }
2606
2611 eProsima_user_DllExport int32_t& scc_index()
2612 {
2613 return m_scc_index;
2614 }
2615
2616
2617
2618 private:
2619
2620 TypeObjectHashId m_sc_component_id;
2621 int32_t m_scc_length{0};
2622 int32_t m_scc_index{0};
2623
2624};
2625
2629 class ExtendedTypeDefn
2630{
2631 public:
2632
2636 eProsima_user_DllExport ExtendedTypeDefn()
2637 {
2638 }
2639
2643 eProsima_user_DllExport ~ExtendedTypeDefn()
2644 {
2645 }
2646
2651 eProsima_user_DllExport ExtendedTypeDefn(
2652 const ExtendedTypeDefn& x)
2653 {
2654 static_cast<void>(x);
2655 }
2656
2661 eProsima_user_DllExport ExtendedTypeDefn(
2662 ExtendedTypeDefn&& x) noexcept
2663 {
2664 static_cast<void>(x);
2665 }
2666
2671 eProsima_user_DllExport ExtendedTypeDefn& operator =(
2672 const ExtendedTypeDefn& x)
2673 {
2674
2675 static_cast<void>(x);
2676
2677 return *this;
2678 }
2679
2684 eProsima_user_DllExport ExtendedTypeDefn& operator =(
2685 ExtendedTypeDefn&& x) noexcept
2686 {
2687
2688 static_cast<void>(x);
2689
2690 return *this;
2691 }
2692
2697 eProsima_user_DllExport bool operator ==(
2698 const ExtendedTypeDefn& x) const
2699 {
2700 static_cast<void>(x);
2701 return true;
2702 }
2703
2708 eProsima_user_DllExport bool operator !=(
2709 const ExtendedTypeDefn& x) const
2710 {
2711 return !(*this == x);
2712 }
2713
2714
2715
2716 private:
2717
2718
2719};
2720
2724 class Dummy
2725{
2726 public:
2727
2731 eProsima_user_DllExport Dummy()
2732 {
2733 }
2734
2738 eProsima_user_DllExport ~Dummy()
2739 {
2740 }
2741
2746 eProsima_user_DllExport Dummy(
2747 const Dummy& x)
2748 {
2749 static_cast<void>(x);
2750 }
2751
2756 eProsima_user_DllExport Dummy(
2757 Dummy&& x) noexcept
2758 {
2759 static_cast<void>(x);
2760 }
2761
2766 eProsima_user_DllExport Dummy& operator =(
2767 const Dummy& x)
2768 {
2769
2770 static_cast<void>(x);
2771
2772 return *this;
2773 }
2774
2779 eProsima_user_DllExport Dummy& operator =(
2780 Dummy&& x) noexcept
2781 {
2782
2783 static_cast<void>(x);
2784
2785 return *this;
2786 }
2787
2792 eProsima_user_DllExport bool operator ==(
2793 const Dummy& x) const
2794 {
2795 static_cast<void>(x);
2796 return true;
2797 }
2798
2803 eProsima_user_DllExport bool operator !=(
2804 const Dummy& x) const
2805 {
2806 return !(*this == x);
2807 }
2808
2809
2810
2811 private:
2812
2813
2814};
2815
2819 class TypeIdentifier
2820{
2821 public:
2822
2826 eProsima_user_DllExport TypeIdentifier()
2827 {
2828 selected_member_ = 0x00000001;
2829 member_destructor_ = [&]()
2830 {
2831 m_no_value.~Dummy();
2832 };
2833 new(&m_no_value) Dummy();
2834
2835 }
2836
2840 eProsima_user_DllExport ~TypeIdentifier()
2841 {
2842 if (member_destructor_)
2843 {
2844 member_destructor_();
2845 }
2846 }
2847
2852 eProsima_user_DllExport TypeIdentifier(
2853 const TypeIdentifier& x)
2854 {
2855 m__d = x.m__d;
2856
2857 switch (x.selected_member_)
2858 {
2859 case 0x00000001:
2860 no_value_() = x.m_no_value;
2861 break;
2862
2863 case 0x00000002:
2864 string_sdefn_() = x.m_string_sdefn;
2865 break;
2866
2867 case 0x00000003:
2868 string_ldefn_() = x.m_string_ldefn;
2869 break;
2870
2871 case 0x00000004:
2872 seq_sdefn_() = x.m_seq_sdefn;
2873 break;
2874
2875 case 0x00000005:
2876 seq_ldefn_() = x.m_seq_ldefn;
2877 break;
2878
2879 case 0x00000006:
2880 array_sdefn_() = x.m_array_sdefn;
2881 break;
2882
2883 case 0x00000007:
2884 array_ldefn_() = x.m_array_ldefn;
2885 break;
2886
2887 case 0x00000008:
2888 map_sdefn_() = x.m_map_sdefn;
2889 break;
2890
2891 case 0x00000009:
2892 map_ldefn_() = x.m_map_ldefn;
2893 break;
2894
2895 case 0x0000000a:
2896 sc_component_id_() = x.m_sc_component_id;
2897 break;
2898
2899 case 0x0000000b:
2900 equivalence_hash_() = x.m_equivalence_hash;
2901 break;
2902
2903 case 0x0000000c:
2904 extended_defn_() = x.m_extended_defn;
2905 break;
2906
2907 }
2908 }
2909
2914 eProsima_user_DllExport TypeIdentifier(
2915 TypeIdentifier&& x) noexcept
2916 {
2917 m__d = x.m__d;
2918
2919 switch (x.selected_member_)
2920 {
2921 case 0x00000001:
2922 no_value_() = std::move(x.m_no_value);
2923 break;
2924
2925 case 0x00000002:
2926 string_sdefn_() = std::move(x.m_string_sdefn);
2927 break;
2928
2929 case 0x00000003:
2930 string_ldefn_() = std::move(x.m_string_ldefn);
2931 break;
2932
2933 case 0x00000004:
2934 seq_sdefn_() = std::move(x.m_seq_sdefn);
2935 break;
2936
2937 case 0x00000005:
2938 seq_ldefn_() = std::move(x.m_seq_ldefn);
2939 break;
2940
2941 case 0x00000006:
2942 array_sdefn_() = std::move(x.m_array_sdefn);
2943 break;
2944
2945 case 0x00000007:
2946 array_ldefn_() = std::move(x.m_array_ldefn);
2947 break;
2948
2949 case 0x00000008:
2950 map_sdefn_() = std::move(x.m_map_sdefn);
2951 break;
2952
2953 case 0x00000009:
2954 map_ldefn_() = std::move(x.m_map_ldefn);
2955 break;
2956
2957 case 0x0000000a:
2958 sc_component_id_() = std::move(x.m_sc_component_id);
2959 break;
2960
2961 case 0x0000000b:
2962 equivalence_hash_() = std::move(x.m_equivalence_hash);
2963 break;
2964
2965 case 0x0000000c:
2966 extended_defn_() = std::move(x.m_extended_defn);
2967 break;
2968
2969 }
2970 }
2971
2976 eProsima_user_DllExport TypeIdentifier& operator =(
2977 const TypeIdentifier& x)
2978 {
2979 m__d = x.m__d;
2980
2981 switch (x.selected_member_)
2982 {
2983 case 0x00000001:
2984 no_value_() = x.m_no_value;
2985 break;
2986
2987 case 0x00000002:
2988 string_sdefn_() = x.m_string_sdefn;
2989 break;
2990
2991 case 0x00000003:
2992 string_ldefn_() = x.m_string_ldefn;
2993 break;
2994
2995 case 0x00000004:
2996 seq_sdefn_() = x.m_seq_sdefn;
2997 break;
2998
2999 case 0x00000005:
3000 seq_ldefn_() = x.m_seq_ldefn;
3001 break;
3002
3003 case 0x00000006:
3004 array_sdefn_() = x.m_array_sdefn;
3005 break;
3006
3007 case 0x00000007:
3008 array_ldefn_() = x.m_array_ldefn;
3009 break;
3010
3011 case 0x00000008:
3012 map_sdefn_() = x.m_map_sdefn;
3013 break;
3014
3015 case 0x00000009:
3016 map_ldefn_() = x.m_map_ldefn;
3017 break;
3018
3019 case 0x0000000a:
3020 sc_component_id_() = x.m_sc_component_id;
3021 break;
3022
3023 case 0x0000000b:
3024 equivalence_hash_() = x.m_equivalence_hash;
3025 break;
3026
3027 case 0x0000000c:
3028 extended_defn_() = x.m_extended_defn;
3029 break;
3030
3031 }
3032
3033 return *this;
3034 }
3035
3040 eProsima_user_DllExport TypeIdentifier& operator =(
3041 TypeIdentifier&& x) noexcept
3042 {
3043 m__d = x.m__d;
3044
3045 switch (x.selected_member_)
3046 {
3047 case 0x00000001:
3048 no_value_() = std::move(x.m_no_value);
3049 break;
3050
3051 case 0x00000002:
3052 string_sdefn_() = std::move(x.m_string_sdefn);
3053 break;
3054
3055 case 0x00000003:
3056 string_ldefn_() = std::move(x.m_string_ldefn);
3057 break;
3058
3059 case 0x00000004:
3060 seq_sdefn_() = std::move(x.m_seq_sdefn);
3061 break;
3062
3063 case 0x00000005:
3064 seq_ldefn_() = std::move(x.m_seq_ldefn);
3065 break;
3066
3067 case 0x00000006:
3068 array_sdefn_() = std::move(x.m_array_sdefn);
3069 break;
3070
3071 case 0x00000007:
3072 array_ldefn_() = std::move(x.m_array_ldefn);
3073 break;
3074
3075 case 0x00000008:
3076 map_sdefn_() = std::move(x.m_map_sdefn);
3077 break;
3078
3079 case 0x00000009:
3080 map_ldefn_() = std::move(x.m_map_ldefn);
3081 break;
3082
3083 case 0x0000000a:
3084 sc_component_id_() = std::move(x.m_sc_component_id);
3085 break;
3086
3087 case 0x0000000b:
3088 equivalence_hash_() = std::move(x.m_equivalence_hash);
3089 break;
3090
3091 case 0x0000000c:
3092 extended_defn_() = std::move(x.m_extended_defn);
3093 break;
3094
3095 }
3096
3097 return *this;
3098 }
3099
3104 eProsima_user_DllExport bool operator ==(
3105 const TypeIdentifier& x) const
3106 {
3107 bool ret_value {false};
3108
3109 if (x.selected_member_ == selected_member_)
3110 {
3111 if (0x0FFFFFFFu != selected_member_)
3112 {
3113 if (x.m__d == m__d)
3114 {
3115 switch (selected_member_)
3116 {
3117 case 0x00000001:
3118 ret_value = (x.m_no_value == m_no_value);
3119 break;
3120
3121 case 0x00000002:
3122 ret_value = (x.m_string_sdefn == m_string_sdefn);
3123 break;
3124
3125 case 0x00000003:
3126 ret_value = (x.m_string_ldefn == m_string_ldefn);
3127 break;
3128
3129 case 0x00000004:
3130 ret_value = (x.m_seq_sdefn == m_seq_sdefn);
3131 break;
3132
3133 case 0x00000005:
3134 ret_value = (x.m_seq_ldefn == m_seq_ldefn);
3135 break;
3136
3137 case 0x00000006:
3138 ret_value = (x.m_array_sdefn == m_array_sdefn);
3139 break;
3140
3141 case 0x00000007:
3142 ret_value = (x.m_array_ldefn == m_array_ldefn);
3143 break;
3144
3145 case 0x00000008:
3146 ret_value = (x.m_map_sdefn == m_map_sdefn);
3147 break;
3148
3149 case 0x00000009:
3150 ret_value = (x.m_map_ldefn == m_map_ldefn);
3151 break;
3152
3153 case 0x0000000a:
3154 ret_value = (x.m_sc_component_id == m_sc_component_id);
3155 break;
3156
3157 case 0x0000000b:
3158 ret_value = (x.m_equivalence_hash == m_equivalence_hash);
3159 break;
3160
3161 case 0x0000000c:
3162 ret_value = (x.m_extended_defn == m_extended_defn);
3163 break;
3164
3165 }
3166 }
3167 }
3168 else
3169 {
3170 ret_value = true;
3171 }
3172 }
3173
3174 return ret_value;
3175 }
3176
3181 eProsima_user_DllExport bool operator !=(
3182 const TypeIdentifier& x) const
3183 {
3184 return !(*this == x);
3185 }
3186
3192 eProsima_user_DllExport void _d(
3193 uint8_t __d)
3194 {
3195 bool valid_discriminator = false;
3196
3197 switch (__d)
3198 {
3199 case TK_NONE:
3200 case TK_BOOLEAN:
3201 case TK_BYTE:
3202 case TK_INT8:
3203 case TK_INT16:
3204 case TK_INT32:
3205 case TK_INT64:
3206 case TK_UINT8:
3207 case TK_UINT16:
3208 case TK_UINT32:
3209 case TK_UINT64:
3210 case TK_FLOAT32:
3211 case TK_FLOAT64:
3212 case TK_FLOAT128:
3213 case TK_CHAR8:
3214 case TK_CHAR16:
3215 if (0x00000001 == selected_member_)
3216 {
3217 valid_discriminator = true;
3218 }
3219 break;
3220
3221 case TI_STRING8_SMALL:
3222 case TI_STRING16_SMALL:
3223 if (0x00000002 == selected_member_)
3224 {
3225 valid_discriminator = true;
3226 }
3227 break;
3228
3229 case TI_STRING8_LARGE:
3230 case TI_STRING16_LARGE:
3231 if (0x00000003 == selected_member_)
3232 {
3233 valid_discriminator = true;
3234 }
3235 break;
3236
3237 case TI_PLAIN_SEQUENCE_SMALL:
3238 if (0x00000004 == selected_member_)
3239 {
3240 valid_discriminator = true;
3241 }
3242 break;
3243
3244 case TI_PLAIN_SEQUENCE_LARGE:
3245 if (0x00000005 == selected_member_)
3246 {
3247 valid_discriminator = true;
3248 }
3249 break;
3250
3251 case TI_PLAIN_ARRAY_SMALL:
3252 if (0x00000006 == selected_member_)
3253 {
3254 valid_discriminator = true;
3255 }
3256 break;
3257
3258 case TI_PLAIN_ARRAY_LARGE:
3259 if (0x00000007 == selected_member_)
3260 {
3261 valid_discriminator = true;
3262 }
3263 break;
3264
3265 case TI_PLAIN_MAP_SMALL:
3266 if (0x00000008 == selected_member_)
3267 {
3268 valid_discriminator = true;
3269 }
3270 break;
3271
3272 case TI_PLAIN_MAP_LARGE:
3273 if (0x00000009 == selected_member_)
3274 {
3275 valid_discriminator = true;
3276 }
3277 break;
3278
3279 case TI_STRONGLY_CONNECTED_COMPONENT:
3280 if (0x0000000a == selected_member_)
3281 {
3282 valid_discriminator = true;
3283 }
3284 break;
3285
3286 case EK_COMPLETE:
3287 case EK_MINIMAL:
3288 if (0x0000000b == selected_member_)
3289 {
3290 valid_discriminator = true;
3291 }
3292 break;
3293
3294 default:
3295 if (0x0000000c == selected_member_)
3296 {
3297 valid_discriminator = true;
3298 }
3299 break;
3300
3301 }
3302
3303 if (!valid_discriminator)
3304 {
3305 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
3306 }
3307
3308 m__d = __d;
3309 }
3310
3315 eProsima_user_DllExport uint8_t _d() const
3316 {
3317 return m__d;
3318 }
3319
3324 eProsima_user_DllExport void no_value(
3325 const Dummy& _no_value)
3326 {
3327 no_value_() = _no_value;
3328 m__d = TK_NONE;
3329 }
3330
3335 eProsima_user_DllExport void no_value(
3336 Dummy&& _no_value)
3337 {
3338 no_value_() = _no_value;
3339 m__d = TK_NONE;
3340 }
3341
3347 eProsima_user_DllExport const Dummy& no_value() const
3348 {
3349 if (0x00000001 != selected_member_)
3350 {
3351 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3352 }
3353
3354 return m_no_value;
3355 }
3356
3362 eProsima_user_DllExport Dummy& no_value()
3363 {
3364 if (0x00000001 != selected_member_)
3365 {
3366 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3367 }
3368
3369 return m_no_value;
3370 }
3371
3372
3377 eProsima_user_DllExport void string_sdefn(
3378 const StringSTypeDefn& _string_sdefn)
3379 {
3380 string_sdefn_() = _string_sdefn;
3381 m__d = TI_STRING8_SMALL;
3382 }
3383
3388 eProsima_user_DllExport void string_sdefn(
3389 StringSTypeDefn&& _string_sdefn)
3390 {
3391 string_sdefn_() = _string_sdefn;
3392 m__d = TI_STRING8_SMALL;
3393 }
3394
3400 eProsima_user_DllExport const StringSTypeDefn& string_sdefn() const
3401 {
3402 if (0x00000002 != selected_member_)
3403 {
3404 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3405 }
3406
3407 return m_string_sdefn;
3408 }
3409
3415 eProsima_user_DllExport StringSTypeDefn& string_sdefn()
3416 {
3417 if (0x00000002 != selected_member_)
3418 {
3419 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3420 }
3421
3422 return m_string_sdefn;
3423 }
3424
3425
3430 eProsima_user_DllExport void string_ldefn(
3431 const StringLTypeDefn& _string_ldefn)
3432 {
3433 string_ldefn_() = _string_ldefn;
3434 m__d = TI_STRING8_LARGE;
3435 }
3436
3441 eProsima_user_DllExport void string_ldefn(
3442 StringLTypeDefn&& _string_ldefn)
3443 {
3444 string_ldefn_() = _string_ldefn;
3445 m__d = TI_STRING8_LARGE;
3446 }
3447
3453 eProsima_user_DllExport const StringLTypeDefn& string_ldefn() const
3454 {
3455 if (0x00000003 != selected_member_)
3456 {
3457 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3458 }
3459
3460 return m_string_ldefn;
3461 }
3462
3468 eProsima_user_DllExport StringLTypeDefn& string_ldefn()
3469 {
3470 if (0x00000003 != selected_member_)
3471 {
3472 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3473 }
3474
3475 return m_string_ldefn;
3476 }
3477
3478
3483 eProsima_user_DllExport void seq_sdefn(
3484 const PlainSequenceSElemDefn& _seq_sdefn)
3485 {
3486 seq_sdefn_() = _seq_sdefn;
3487 m__d = TI_PLAIN_SEQUENCE_SMALL;
3488 }
3489
3494 eProsima_user_DllExport void seq_sdefn(
3495 PlainSequenceSElemDefn&& _seq_sdefn)
3496 {
3497 seq_sdefn_() = _seq_sdefn;
3498 m__d = TI_PLAIN_SEQUENCE_SMALL;
3499 }
3500
3506 eProsima_user_DllExport const PlainSequenceSElemDefn& seq_sdefn() const
3507 {
3508 if (0x00000004 != selected_member_)
3509 {
3510 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3511 }
3512
3513 return m_seq_sdefn;
3514 }
3515
3521 eProsima_user_DllExport PlainSequenceSElemDefn& seq_sdefn()
3522 {
3523 if (0x00000004 != selected_member_)
3524 {
3525 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3526 }
3527
3528 return m_seq_sdefn;
3529 }
3530
3531
3536 eProsima_user_DllExport void seq_ldefn(
3537 const PlainSequenceLElemDefn& _seq_ldefn)
3538 {
3539 seq_ldefn_() = _seq_ldefn;
3540 m__d = TI_PLAIN_SEQUENCE_LARGE;
3541 }
3542
3547 eProsima_user_DllExport void seq_ldefn(
3548 PlainSequenceLElemDefn&& _seq_ldefn)
3549 {
3550 seq_ldefn_() = _seq_ldefn;
3551 m__d = TI_PLAIN_SEQUENCE_LARGE;
3552 }
3553
3559 eProsima_user_DllExport const PlainSequenceLElemDefn& seq_ldefn() const
3560 {
3561 if (0x00000005 != selected_member_)
3562 {
3563 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3564 }
3565
3566 return m_seq_ldefn;
3567 }
3568
3574 eProsima_user_DllExport PlainSequenceLElemDefn& seq_ldefn()
3575 {
3576 if (0x00000005 != selected_member_)
3577 {
3578 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3579 }
3580
3581 return m_seq_ldefn;
3582 }
3583
3584
3589 eProsima_user_DllExport void array_sdefn(
3590 const PlainArraySElemDefn& _array_sdefn)
3591 {
3592 array_sdefn_() = _array_sdefn;
3593 m__d = TI_PLAIN_ARRAY_SMALL;
3594 }
3595
3600 eProsima_user_DllExport void array_sdefn(
3601 PlainArraySElemDefn&& _array_sdefn)
3602 {
3603 array_sdefn_() = _array_sdefn;
3604 m__d = TI_PLAIN_ARRAY_SMALL;
3605 }
3606
3612 eProsima_user_DllExport const PlainArraySElemDefn& array_sdefn() const
3613 {
3614 if (0x00000006 != selected_member_)
3615 {
3616 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3617 }
3618
3619 return m_array_sdefn;
3620 }
3621
3627 eProsima_user_DllExport PlainArraySElemDefn& array_sdefn()
3628 {
3629 if (0x00000006 != selected_member_)
3630 {
3631 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3632 }
3633
3634 return m_array_sdefn;
3635 }
3636
3637
3642 eProsima_user_DllExport void array_ldefn(
3643 const PlainArrayLElemDefn& _array_ldefn)
3644 {
3645 array_ldefn_() = _array_ldefn;
3646 m__d = TI_PLAIN_ARRAY_LARGE;
3647 }
3648
3653 eProsima_user_DllExport void array_ldefn(
3654 PlainArrayLElemDefn&& _array_ldefn)
3655 {
3656 array_ldefn_() = _array_ldefn;
3657 m__d = TI_PLAIN_ARRAY_LARGE;
3658 }
3659
3665 eProsima_user_DllExport const PlainArrayLElemDefn& array_ldefn() const
3666 {
3667 if (0x00000007 != selected_member_)
3668 {
3669 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3670 }
3671
3672 return m_array_ldefn;
3673 }
3674
3680 eProsima_user_DllExport PlainArrayLElemDefn& array_ldefn()
3681 {
3682 if (0x00000007 != selected_member_)
3683 {
3684 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3685 }
3686
3687 return m_array_ldefn;
3688 }
3689
3690
3695 eProsima_user_DllExport void map_sdefn(
3696 const PlainMapSTypeDefn& _map_sdefn)
3697 {
3698 map_sdefn_() = _map_sdefn;
3699 m__d = TI_PLAIN_MAP_SMALL;
3700 }
3701
3706 eProsima_user_DllExport void map_sdefn(
3707 PlainMapSTypeDefn&& _map_sdefn)
3708 {
3709 map_sdefn_() = _map_sdefn;
3710 m__d = TI_PLAIN_MAP_SMALL;
3711 }
3712
3718 eProsima_user_DllExport const PlainMapSTypeDefn& map_sdefn() const
3719 {
3720 if (0x00000008 != selected_member_)
3721 {
3722 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3723 }
3724
3725 return m_map_sdefn;
3726 }
3727
3733 eProsima_user_DllExport PlainMapSTypeDefn& map_sdefn()
3734 {
3735 if (0x00000008 != selected_member_)
3736 {
3737 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3738 }
3739
3740 return m_map_sdefn;
3741 }
3742
3743
3748 eProsima_user_DllExport void map_ldefn(
3749 const PlainMapLTypeDefn& _map_ldefn)
3750 {
3751 map_ldefn_() = _map_ldefn;
3752 m__d = TI_PLAIN_MAP_LARGE;
3753 }
3754
3759 eProsima_user_DllExport void map_ldefn(
3760 PlainMapLTypeDefn&& _map_ldefn)
3761 {
3762 map_ldefn_() = _map_ldefn;
3763 m__d = TI_PLAIN_MAP_LARGE;
3764 }
3765
3771 eProsima_user_DllExport const PlainMapLTypeDefn& map_ldefn() const
3772 {
3773 if (0x00000009 != selected_member_)
3774 {
3775 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3776 }
3777
3778 return m_map_ldefn;
3779 }
3780
3786 eProsima_user_DllExport PlainMapLTypeDefn& map_ldefn()
3787 {
3788 if (0x00000009 != selected_member_)
3789 {
3790 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3791 }
3792
3793 return m_map_ldefn;
3794 }
3795
3796
3801 eProsima_user_DllExport void sc_component_id(
3802 const StronglyConnectedComponentId& _sc_component_id)
3803 {
3804 sc_component_id_() = _sc_component_id;
3805 m__d = TI_STRONGLY_CONNECTED_COMPONENT;
3806 }
3807
3812 eProsima_user_DllExport void sc_component_id(
3813 StronglyConnectedComponentId&& _sc_component_id)
3814 {
3815 sc_component_id_() = _sc_component_id;
3816 m__d = TI_STRONGLY_CONNECTED_COMPONENT;
3817 }
3818
3824 eProsima_user_DllExport const StronglyConnectedComponentId& sc_component_id() const
3825 {
3826 if (0x0000000a != selected_member_)
3827 {
3828 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3829 }
3830
3831 return m_sc_component_id;
3832 }
3833
3839 eProsima_user_DllExport StronglyConnectedComponentId& sc_component_id()
3840 {
3841 if (0x0000000a != selected_member_)
3842 {
3843 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3844 }
3845
3846 return m_sc_component_id;
3847 }
3848
3849
3854 eProsima_user_DllExport void equivalence_hash(
3855 const EquivalenceHash& _equivalence_hash)
3856 {
3857 equivalence_hash_() = _equivalence_hash;
3858 m__d = EK_COMPLETE;
3859 }
3860
3865 eProsima_user_DllExport void equivalence_hash(
3866 EquivalenceHash&& _equivalence_hash)
3867 {
3868 equivalence_hash_() = _equivalence_hash;
3869 m__d = EK_COMPLETE;
3870 }
3871
3877 eProsima_user_DllExport const EquivalenceHash& equivalence_hash() const
3878 {
3879 if (0x0000000b != selected_member_)
3880 {
3881 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3882 }
3883
3884 return m_equivalence_hash;
3885 }
3886
3892 eProsima_user_DllExport EquivalenceHash& equivalence_hash()
3893 {
3894 if (0x0000000b != selected_member_)
3895 {
3896 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3897 }
3898
3899 return m_equivalence_hash;
3900 }
3901
3902
3907 eProsima_user_DllExport void extended_defn(
3908 const ExtendedTypeDefn& _extended_defn)
3909 {
3910 extended_defn_() = _extended_defn;
3911 m__d = 127;
3912 }
3913
3918 eProsima_user_DllExport void extended_defn(
3919 ExtendedTypeDefn&& _extended_defn)
3920 {
3921 extended_defn_() = _extended_defn;
3922 m__d = 127;
3923 }
3924
3930 eProsima_user_DllExport const ExtendedTypeDefn& extended_defn() const
3931 {
3932 if (0x0000000c != selected_member_)
3933 {
3934 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3935 }
3936
3937 return m_extended_defn;
3938 }
3939
3945 eProsima_user_DllExport ExtendedTypeDefn& extended_defn()
3946 {
3947 if (0x0000000c != selected_member_)
3948 {
3949 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3950 }
3951
3952 return m_extended_defn;
3953 }
3954
3955
3956
3957 private:
3958
3959 Dummy& no_value_()
3960 {
3961 if (0x00000001 != selected_member_)
3962 {
3963 if (member_destructor_)
3964 {
3965 member_destructor_();
3966 }
3967
3968 selected_member_ = 0x00000001;
3969 member_destructor_ = [&]()
3970 {
3971 m_no_value.~Dummy();
3972 };
3973 new(&m_no_value) Dummy();
3974
3975 }
3976
3977 return m_no_value;
3978 }
3979
3980 StringSTypeDefn& string_sdefn_()
3981 {
3982 if (0x00000002 != selected_member_)
3983 {
3984 if (member_destructor_)
3985 {
3986 member_destructor_();
3987 }
3988
3989 selected_member_ = 0x00000002;
3990 member_destructor_ = [&]()
3991 {
3992 m_string_sdefn.~StringSTypeDefn();
3993 };
3994 new(&m_string_sdefn) StringSTypeDefn();
3995
3996 }
3997
3998 return m_string_sdefn;
3999 }
4000
4001 StringLTypeDefn& string_ldefn_()
4002 {
4003 if (0x00000003 != selected_member_)
4004 {
4005 if (member_destructor_)
4006 {
4007 member_destructor_();
4008 }
4009
4010 selected_member_ = 0x00000003;
4011 member_destructor_ = [&]()
4012 {
4013 m_string_ldefn.~StringLTypeDefn();
4014 };
4015 new(&m_string_ldefn) StringLTypeDefn();
4016
4017 }
4018
4019 return m_string_ldefn;
4020 }
4021
4022 PlainSequenceSElemDefn& seq_sdefn_()
4023 {
4024 if (0x00000004 != selected_member_)
4025 {
4026 if (member_destructor_)
4027 {
4028 member_destructor_();
4029 }
4030
4031 selected_member_ = 0x00000004;
4032 member_destructor_ = [&]()
4033 {
4034 m_seq_sdefn.~PlainSequenceSElemDefn();
4035 };
4036 new(&m_seq_sdefn) PlainSequenceSElemDefn();
4037
4038 }
4039
4040 return m_seq_sdefn;
4041 }
4042
4043 PlainSequenceLElemDefn& seq_ldefn_()
4044 {
4045 if (0x00000005 != selected_member_)
4046 {
4047 if (member_destructor_)
4048 {
4049 member_destructor_();
4050 }
4051
4052 selected_member_ = 0x00000005;
4053 member_destructor_ = [&]()
4054 {
4055 m_seq_ldefn.~PlainSequenceLElemDefn();
4056 };
4057 new(&m_seq_ldefn) PlainSequenceLElemDefn();
4058
4059 }
4060
4061 return m_seq_ldefn;
4062 }
4063
4064 PlainArraySElemDefn& array_sdefn_()
4065 {
4066 if (0x00000006 != selected_member_)
4067 {
4068 if (member_destructor_)
4069 {
4070 member_destructor_();
4071 }
4072
4073 selected_member_ = 0x00000006;
4074 member_destructor_ = [&]()
4075 {
4076 m_array_sdefn.~PlainArraySElemDefn();
4077 };
4078 new(&m_array_sdefn) PlainArraySElemDefn();
4079
4080 }
4081
4082 return m_array_sdefn;
4083 }
4084
4085 PlainArrayLElemDefn& array_ldefn_()
4086 {
4087 if (0x00000007 != selected_member_)
4088 {
4089 if (member_destructor_)
4090 {
4091 member_destructor_();
4092 }
4093
4094 selected_member_ = 0x00000007;
4095 member_destructor_ = [&]()
4096 {
4097 m_array_ldefn.~PlainArrayLElemDefn();
4098 };
4099 new(&m_array_ldefn) PlainArrayLElemDefn();
4100
4101 }
4102
4103 return m_array_ldefn;
4104 }
4105
4106 PlainMapSTypeDefn& map_sdefn_()
4107 {
4108 if (0x00000008 != selected_member_)
4109 {
4110 if (member_destructor_)
4111 {
4112 member_destructor_();
4113 }
4114
4115 selected_member_ = 0x00000008;
4116 member_destructor_ = [&]()
4117 {
4118 m_map_sdefn.~PlainMapSTypeDefn();
4119 };
4120 new(&m_map_sdefn) PlainMapSTypeDefn();
4121
4122 }
4123
4124 return m_map_sdefn;
4125 }
4126
4127 PlainMapLTypeDefn& map_ldefn_()
4128 {
4129 if (0x00000009 != selected_member_)
4130 {
4131 if (member_destructor_)
4132 {
4133 member_destructor_();
4134 }
4135
4136 selected_member_ = 0x00000009;
4137 member_destructor_ = [&]()
4138 {
4139 m_map_ldefn.~PlainMapLTypeDefn();
4140 };
4141 new(&m_map_ldefn) PlainMapLTypeDefn();
4142
4143 }
4144
4145 return m_map_ldefn;
4146 }
4147
4148 StronglyConnectedComponentId& sc_component_id_()
4149 {
4150 if (0x0000000a != selected_member_)
4151 {
4152 if (member_destructor_)
4153 {
4154 member_destructor_();
4155 }
4156
4157 selected_member_ = 0x0000000a;
4158 member_destructor_ = [&]()
4159 {
4160 m_sc_component_id.~StronglyConnectedComponentId();
4161 };
4162 new(&m_sc_component_id) StronglyConnectedComponentId();
4163
4164 }
4165
4166 return m_sc_component_id;
4167 }
4168
4169 EquivalenceHash& equivalence_hash_()
4170 {
4171 if (0x0000000b != selected_member_)
4172 {
4173 if (member_destructor_)
4174 {
4175 member_destructor_();
4176 }
4177
4178 selected_member_ = 0x0000000b;
4179 member_destructor_ = [&]()
4180 {
4181 using namespace eprosima::fastdds::dds::xtypes;
4182 m_equivalence_hash.~EquivalenceHash();
4183 };
4184 new(&m_equivalence_hash) EquivalenceHash();
4185
4186 }
4187
4188 return m_equivalence_hash;
4189 }
4190
4191 ExtendedTypeDefn& extended_defn_()
4192 {
4193 if (0x0000000c != selected_member_)
4194 {
4195 if (member_destructor_)
4196 {
4197 member_destructor_();
4198 }
4199
4200 selected_member_ = 0x0000000c;
4201 member_destructor_ = [&]()
4202 {
4203 m_extended_defn.~ExtendedTypeDefn();
4204 };
4205 new(&m_extended_defn) ExtendedTypeDefn();
4206
4207 }
4208
4209 return m_extended_defn;
4210 }
4211
4212
4213 uint8_t m__d {TK_NONE};
4214
4215 union
4216 {
4217 Dummy m_no_value;
4218 StringSTypeDefn m_string_sdefn;
4219 StringLTypeDefn m_string_ldefn;
4220 PlainSequenceSElemDefn m_seq_sdefn;
4221 PlainSequenceLElemDefn m_seq_ldefn;
4222 PlainArraySElemDefn m_array_sdefn;
4223 PlainArrayLElemDefn m_array_ldefn;
4224 PlainMapSTypeDefn m_map_sdefn;
4225 PlainMapLTypeDefn m_map_ldefn;
4226 StronglyConnectedComponentId m_sc_component_id;
4227 EquivalenceHash m_equivalence_hash;
4228 ExtendedTypeDefn m_extended_defn;
4229 };
4230
4231 uint32_t selected_member_ {0x0FFFFFFFu};
4232
4233 std::function<void()> member_destructor_;
4234};
4235 typedef std::vector<TypeIdentifier> TypeIdentifierSeq;
4236
4237 typedef uint32_t MemberId;
4238
4239 const uint32_t ANNOTATION_STR_VALUE_MAX_LEN = 128;
4240 const uint32_t ANNOTATION_OCTETSEC_VALUE_MAX_LEN = 128;
4245 class ExtendedAnnotationParameterValue
4246{
4247 public:
4248
4252 eProsima_user_DllExport ExtendedAnnotationParameterValue()
4253 {
4254 }
4255
4259 eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
4260 {
4261 }
4262
4267 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4268 const ExtendedAnnotationParameterValue& x)
4269 {
4270 static_cast<void>(x);
4271 }
4272
4277 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4278 ExtendedAnnotationParameterValue&& x) noexcept
4279 {
4280 static_cast<void>(x);
4281 }
4282
4287 eProsima_user_DllExport ExtendedAnnotationParameterValue& operator =(
4288 const ExtendedAnnotationParameterValue& x)
4289 {
4290
4291 static_cast<void>(x);
4292
4293 return *this;
4294 }
4295
4300 eProsima_user_DllExport ExtendedAnnotationParameterValue& operator =(
4301 ExtendedAnnotationParameterValue&& x) noexcept
4302 {
4303
4304 static_cast<void>(x);
4305
4306 return *this;
4307 }
4308
4313 eProsima_user_DllExport bool operator ==(
4314 const ExtendedAnnotationParameterValue& x) const
4315 {
4316 static_cast<void>(x);
4317 return true;
4318 }
4319
4324 eProsima_user_DllExport bool operator !=(
4325 const ExtendedAnnotationParameterValue& x) const
4326 {
4327 return !(*this == x);
4328 }
4329
4330
4331
4332 private:
4333
4334
4335};
4336
4340 class AnnotationParameterValue
4341{
4342 public:
4343
4347 eProsima_user_DllExport AnnotationParameterValue()
4348 {
4349 selected_member_ = 0x00000013;
4350 member_destructor_ = [&]()
4351 {
4352 m_extended_value.~ExtendedAnnotationParameterValue();
4353 };
4354 new(&m_extended_value) ExtendedAnnotationParameterValue();
4355
4356 }
4357
4361 eProsima_user_DllExport ~AnnotationParameterValue()
4362 {
4363 if (member_destructor_)
4364 {
4365 member_destructor_();
4366 }
4367 }
4368
4373 eProsima_user_DllExport AnnotationParameterValue(
4374 const AnnotationParameterValue& x)
4375 {
4376 m__d = x.m__d;
4377
4378 switch (x.selected_member_)
4379 {
4380 case 0x00000001:
4381 boolean_value_() = x.m_boolean_value;
4382 break;
4383
4384 case 0x00000002:
4385 byte_value_() = x.m_byte_value;
4386 break;
4387
4388 case 0x00000003:
4389 int8_value_() = x.m_int8_value;
4390 break;
4391
4392 case 0x00000004:
4393 uint8_value_() = x.m_uint8_value;
4394 break;
4395
4396 case 0x00000005:
4397 int16_value_() = x.m_int16_value;
4398 break;
4399
4400 case 0x00000006:
4401 uint_16_value_() = x.m_uint_16_value;
4402 break;
4403
4404 case 0x00000007:
4405 int32_value_() = x.m_int32_value;
4406 break;
4407
4408 case 0x00000008:
4409 uint32_value_() = x.m_uint32_value;
4410 break;
4411
4412 case 0x00000009:
4413 int64_value_() = x.m_int64_value;
4414 break;
4415
4416 case 0x0000000a:
4417 uint64_value_() = x.m_uint64_value;
4418 break;
4419
4420 case 0x0000000b:
4421 float32_value_() = x.m_float32_value;
4422 break;
4423
4424 case 0x0000000c:
4425 float64_value_() = x.m_float64_value;
4426 break;
4427
4428 case 0x0000000d:
4429 float128_value_() = x.m_float128_value;
4430 break;
4431
4432 case 0x0000000e:
4433 char_value_() = x.m_char_value;
4434 break;
4435
4436 case 0x0000000f:
4437 wchar_value_() = x.m_wchar_value;
4438 break;
4439
4440 case 0x00000010:
4441 enumerated_value_() = x.m_enumerated_value;
4442 break;
4443
4444 case 0x00000011:
4445 string8_value_() = x.m_string8_value;
4446 break;
4447
4448 case 0x00000012:
4449 string16_value_() = x.m_string16_value;
4450 break;
4451
4452 case 0x00000013:
4453 extended_value_() = x.m_extended_value;
4454 break;
4455
4456 }
4457 }
4458
4463 eProsima_user_DllExport AnnotationParameterValue(
4464 AnnotationParameterValue&& x) noexcept
4465 {
4466 m__d = x.m__d;
4467
4468 switch (x.selected_member_)
4469 {
4470 case 0x00000001:
4471 boolean_value_() = std::move(x.m_boolean_value);
4472 break;
4473
4474 case 0x00000002:
4475 byte_value_() = std::move(x.m_byte_value);
4476 break;
4477
4478 case 0x00000003:
4479 int8_value_() = std::move(x.m_int8_value);
4480 break;
4481
4482 case 0x00000004:
4483 uint8_value_() = std::move(x.m_uint8_value);
4484 break;
4485
4486 case 0x00000005:
4487 int16_value_() = std::move(x.m_int16_value);
4488 break;
4489
4490 case 0x00000006:
4491 uint_16_value_() = std::move(x.m_uint_16_value);
4492 break;
4493
4494 case 0x00000007:
4495 int32_value_() = std::move(x.m_int32_value);
4496 break;
4497
4498 case 0x00000008:
4499 uint32_value_() = std::move(x.m_uint32_value);
4500 break;
4501
4502 case 0x00000009:
4503 int64_value_() = std::move(x.m_int64_value);
4504 break;
4505
4506 case 0x0000000a:
4507 uint64_value_() = std::move(x.m_uint64_value);
4508 break;
4509
4510 case 0x0000000b:
4511 float32_value_() = std::move(x.m_float32_value);
4512 break;
4513
4514 case 0x0000000c:
4515 float64_value_() = std::move(x.m_float64_value);
4516 break;
4517
4518 case 0x0000000d:
4519 float128_value_() = std::move(x.m_float128_value);
4520 break;
4521
4522 case 0x0000000e:
4523 char_value_() = std::move(x.m_char_value);
4524 break;
4525
4526 case 0x0000000f:
4527 wchar_value_() = std::move(x.m_wchar_value);
4528 break;
4529
4530 case 0x00000010:
4531 enumerated_value_() = std::move(x.m_enumerated_value);
4532 break;
4533
4534 case 0x00000011:
4535 string8_value_() = std::move(x.m_string8_value);
4536 break;
4537
4538 case 0x00000012:
4539 string16_value_() = std::move(x.m_string16_value);
4540 break;
4541
4542 case 0x00000013:
4543 extended_value_() = std::move(x.m_extended_value);
4544 break;
4545
4546 }
4547 }
4548
4553 eProsima_user_DllExport AnnotationParameterValue& operator =(
4554 const AnnotationParameterValue& x)
4555 {
4556 m__d = x.m__d;
4557
4558 switch (x.selected_member_)
4559 {
4560 case 0x00000001:
4561 boolean_value_() = x.m_boolean_value;
4562 break;
4563
4564 case 0x00000002:
4565 byte_value_() = x.m_byte_value;
4566 break;
4567
4568 case 0x00000003:
4569 int8_value_() = x.m_int8_value;
4570 break;
4571
4572 case 0x00000004:
4573 uint8_value_() = x.m_uint8_value;
4574 break;
4575
4576 case 0x00000005:
4577 int16_value_() = x.m_int16_value;
4578 break;
4579
4580 case 0x00000006:
4581 uint_16_value_() = x.m_uint_16_value;
4582 break;
4583
4584 case 0x00000007:
4585 int32_value_() = x.m_int32_value;
4586 break;
4587
4588 case 0x00000008:
4589 uint32_value_() = x.m_uint32_value;
4590 break;
4591
4592 case 0x00000009:
4593 int64_value_() = x.m_int64_value;
4594 break;
4595
4596 case 0x0000000a:
4597 uint64_value_() = x.m_uint64_value;
4598 break;
4599
4600 case 0x0000000b:
4601 float32_value_() = x.m_float32_value;
4602 break;
4603
4604 case 0x0000000c:
4605 float64_value_() = x.m_float64_value;
4606 break;
4607
4608 case 0x0000000d:
4609 float128_value_() = x.m_float128_value;
4610 break;
4611
4612 case 0x0000000e:
4613 char_value_() = x.m_char_value;
4614 break;
4615
4616 case 0x0000000f:
4617 wchar_value_() = x.m_wchar_value;
4618 break;
4619
4620 case 0x00000010:
4621 enumerated_value_() = x.m_enumerated_value;
4622 break;
4623
4624 case 0x00000011:
4625 string8_value_() = x.m_string8_value;
4626 break;
4627
4628 case 0x00000012:
4629 string16_value_() = x.m_string16_value;
4630 break;
4631
4632 case 0x00000013:
4633 extended_value_() = x.m_extended_value;
4634 break;
4635
4636 }
4637
4638 return *this;
4639 }
4640
4645 eProsima_user_DllExport AnnotationParameterValue& operator =(
4646 AnnotationParameterValue&& x) noexcept
4647 {
4648 m__d = x.m__d;
4649
4650 switch (x.selected_member_)
4651 {
4652 case 0x00000001:
4653 boolean_value_() = std::move(x.m_boolean_value);
4654 break;
4655
4656 case 0x00000002:
4657 byte_value_() = std::move(x.m_byte_value);
4658 break;
4659
4660 case 0x00000003:
4661 int8_value_() = std::move(x.m_int8_value);
4662 break;
4663
4664 case 0x00000004:
4665 uint8_value_() = std::move(x.m_uint8_value);
4666 break;
4667
4668 case 0x00000005:
4669 int16_value_() = std::move(x.m_int16_value);
4670 break;
4671
4672 case 0x00000006:
4673 uint_16_value_() = std::move(x.m_uint_16_value);
4674 break;
4675
4676 case 0x00000007:
4677 int32_value_() = std::move(x.m_int32_value);
4678 break;
4679
4680 case 0x00000008:
4681 uint32_value_() = std::move(x.m_uint32_value);
4682 break;
4683
4684 case 0x00000009:
4685 int64_value_() = std::move(x.m_int64_value);
4686 break;
4687
4688 case 0x0000000a:
4689 uint64_value_() = std::move(x.m_uint64_value);
4690 break;
4691
4692 case 0x0000000b:
4693 float32_value_() = std::move(x.m_float32_value);
4694 break;
4695
4696 case 0x0000000c:
4697 float64_value_() = std::move(x.m_float64_value);
4698 break;
4699
4700 case 0x0000000d:
4701 float128_value_() = std::move(x.m_float128_value);
4702 break;
4703
4704 case 0x0000000e:
4705 char_value_() = std::move(x.m_char_value);
4706 break;
4707
4708 case 0x0000000f:
4709 wchar_value_() = std::move(x.m_wchar_value);
4710 break;
4711
4712 case 0x00000010:
4713 enumerated_value_() = std::move(x.m_enumerated_value);
4714 break;
4715
4716 case 0x00000011:
4717 string8_value_() = std::move(x.m_string8_value);
4718 break;
4719
4720 case 0x00000012:
4721 string16_value_() = std::move(x.m_string16_value);
4722 break;
4723
4724 case 0x00000013:
4725 extended_value_() = std::move(x.m_extended_value);
4726 break;
4727
4728 }
4729
4730 return *this;
4731 }
4732
4737 eProsima_user_DllExport bool operator ==(
4738 const AnnotationParameterValue& x) const
4739 {
4740 bool ret_value {false};
4741
4742 if (x.selected_member_ == selected_member_)
4743 {
4744 if (0x0FFFFFFFu != selected_member_)
4745 {
4746 if (x.m__d == m__d)
4747 {
4748 switch (selected_member_)
4749 {
4750 case 0x00000001:
4751 ret_value = (x.m_boolean_value == m_boolean_value);
4752 break;
4753
4754 case 0x00000002:
4755 ret_value = (x.m_byte_value == m_byte_value);
4756 break;
4757
4758 case 0x00000003:
4759 ret_value = (x.m_int8_value == m_int8_value);
4760 break;
4761
4762 case 0x00000004:
4763 ret_value = (x.m_uint8_value == m_uint8_value);
4764 break;
4765
4766 case 0x00000005:
4767 ret_value = (x.m_int16_value == m_int16_value);
4768 break;
4769
4770 case 0x00000006:
4771 ret_value = (x.m_uint_16_value == m_uint_16_value);
4772 break;
4773
4774 case 0x00000007:
4775 ret_value = (x.m_int32_value == m_int32_value);
4776 break;
4777
4778 case 0x00000008:
4779 ret_value = (x.m_uint32_value == m_uint32_value);
4780 break;
4781
4782 case 0x00000009:
4783 ret_value = (x.m_int64_value == m_int64_value);
4784 break;
4785
4786 case 0x0000000a:
4787 ret_value = (x.m_uint64_value == m_uint64_value);
4788 break;
4789
4790 case 0x0000000b:
4791 ret_value = (x.m_float32_value == m_float32_value);
4792 break;
4793
4794 case 0x0000000c:
4795 ret_value = (x.m_float64_value == m_float64_value);
4796 break;
4797
4798 case 0x0000000d:
4799 ret_value = (x.m_float128_value == m_float128_value);
4800 break;
4801
4802 case 0x0000000e:
4803 ret_value = (x.m_char_value == m_char_value);
4804 break;
4805
4806 case 0x0000000f:
4807 ret_value = (x.m_wchar_value == m_wchar_value);
4808 break;
4809
4810 case 0x00000010:
4811 ret_value = (x.m_enumerated_value == m_enumerated_value);
4812 break;
4813
4814 case 0x00000011:
4815 ret_value = (x.m_string8_value == m_string8_value);
4816 break;
4817
4818 case 0x00000012:
4819 ret_value = (x.m_string16_value == m_string16_value);
4820 break;
4821
4822 case 0x00000013:
4823 ret_value = (x.m_extended_value == m_extended_value);
4824 break;
4825
4826 }
4827 }
4828 }
4829 else
4830 {
4831 ret_value = true;
4832 }
4833 }
4834
4835 return ret_value;
4836 }
4837
4842 eProsima_user_DllExport bool operator !=(
4843 const AnnotationParameterValue& x) const
4844 {
4845 return !(*this == x);
4846 }
4847
4853 eProsima_user_DllExport void _d(
4854 uint8_t __d)
4855 {
4856 bool valid_discriminator = false;
4857
4858 switch (__d)
4859 {
4860 case TK_BOOLEAN:
4861 if (0x00000001 == selected_member_)
4862 {
4863 valid_discriminator = true;
4864 }
4865 break;
4866
4867 case TK_BYTE:
4868 if (0x00000002 == selected_member_)
4869 {
4870 valid_discriminator = true;
4871 }
4872 break;
4873
4874 case TK_INT8:
4875 if (0x00000003 == selected_member_)
4876 {
4877 valid_discriminator = true;
4878 }
4879 break;
4880
4881 case TK_UINT8:
4882 if (0x00000004 == selected_member_)
4883 {
4884 valid_discriminator = true;
4885 }
4886 break;
4887
4888 case TK_INT16:
4889 if (0x00000005 == selected_member_)
4890 {
4891 valid_discriminator = true;
4892 }
4893 break;
4894
4895 case TK_UINT16:
4896 if (0x00000006 == selected_member_)
4897 {
4898 valid_discriminator = true;
4899 }
4900 break;
4901
4902 case TK_INT32:
4903 if (0x00000007 == selected_member_)
4904 {
4905 valid_discriminator = true;
4906 }
4907 break;
4908
4909 case TK_UINT32:
4910 if (0x00000008 == selected_member_)
4911 {
4912 valid_discriminator = true;
4913 }
4914 break;
4915
4916 case TK_INT64:
4917 if (0x00000009 == selected_member_)
4918 {
4919 valid_discriminator = true;
4920 }
4921 break;
4922
4923 case TK_UINT64:
4924 if (0x0000000a == selected_member_)
4925 {
4926 valid_discriminator = true;
4927 }
4928 break;
4929
4930 case TK_FLOAT32:
4931 if (0x0000000b == selected_member_)
4932 {
4933 valid_discriminator = true;
4934 }
4935 break;
4936
4937 case TK_FLOAT64:
4938 if (0x0000000c == selected_member_)
4939 {
4940 valid_discriminator = true;
4941 }
4942 break;
4943
4944 case TK_FLOAT128:
4945 if (0x0000000d == selected_member_)
4946 {
4947 valid_discriminator = true;
4948 }
4949 break;
4950
4951 case TK_CHAR8:
4952 if (0x0000000e == selected_member_)
4953 {
4954 valid_discriminator = true;
4955 }
4956 break;
4957
4958 case TK_CHAR16:
4959 if (0x0000000f == selected_member_)
4960 {
4961 valid_discriminator = true;
4962 }
4963 break;
4964
4965 case TK_ENUM:
4966 if (0x00000010 == selected_member_)
4967 {
4968 valid_discriminator = true;
4969 }
4970 break;
4971
4972 case TK_STRING8:
4973 if (0x00000011 == selected_member_)
4974 {
4975 valid_discriminator = true;
4976 }
4977 break;
4978
4979 case TK_STRING16:
4980 if (0x00000012 == selected_member_)
4981 {
4982 valid_discriminator = true;
4983 }
4984 break;
4985
4986 default:
4987 if (0x00000013 == selected_member_)
4988 {
4989 valid_discriminator = true;
4990 }
4991 break;
4992
4993 }
4994
4995 if (!valid_discriminator)
4996 {
4997 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
4998 }
4999
5000 m__d = __d;
5001 }
5002
5007 eProsima_user_DllExport uint8_t _d() const
5008 {
5009 return m__d;
5010 }
5011
5016 eProsima_user_DllExport void boolean_value(
5017 bool _boolean_value)
5018 {
5019 boolean_value_() = _boolean_value;
5020 m__d = TK_BOOLEAN;
5021 }
5022
5028 eProsima_user_DllExport bool boolean_value() const
5029 {
5030 if (0x00000001 != selected_member_)
5031 {
5032 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5033 }
5034
5035 return m_boolean_value;
5036 }
5037
5043 eProsima_user_DllExport bool& boolean_value()
5044 {
5045 if (0x00000001 != selected_member_)
5046 {
5047 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5048 }
5049
5050 return m_boolean_value;
5051 }
5052
5053
5058 eProsima_user_DllExport void byte_value(
5059 uint8_t _byte_value)
5060 {
5061 byte_value_() = _byte_value;
5062 m__d = TK_BYTE;
5063 }
5064
5070 eProsima_user_DllExport uint8_t byte_value() const
5071 {
5072 if (0x00000002 != selected_member_)
5073 {
5074 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5075 }
5076
5077 return m_byte_value;
5078 }
5079
5085 eProsima_user_DllExport uint8_t& byte_value()
5086 {
5087 if (0x00000002 != selected_member_)
5088 {
5089 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5090 }
5091
5092 return m_byte_value;
5093 }
5094
5095
5100 eProsima_user_DllExport void int8_value(
5101 int8_t _int8_value)
5102 {
5103 int8_value_() = _int8_value;
5104 m__d = TK_INT8;
5105 }
5106
5112 eProsima_user_DllExport int8_t int8_value() const
5113 {
5114 if (0x00000003 != selected_member_)
5115 {
5116 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5117 }
5118
5119 return m_int8_value;
5120 }
5121
5127 eProsima_user_DllExport int8_t& int8_value()
5128 {
5129 if (0x00000003 != selected_member_)
5130 {
5131 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5132 }
5133
5134 return m_int8_value;
5135 }
5136
5137
5142 eProsima_user_DllExport void uint8_value(
5143 uint8_t _uint8_value)
5144 {
5145 uint8_value_() = _uint8_value;
5146 m__d = TK_UINT8;
5147 }
5148
5154 eProsima_user_DllExport uint8_t uint8_value() const
5155 {
5156 if (0x00000004 != selected_member_)
5157 {
5158 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5159 }
5160
5161 return m_uint8_value;
5162 }
5163
5169 eProsima_user_DllExport uint8_t& uint8_value()
5170 {
5171 if (0x00000004 != selected_member_)
5172 {
5173 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5174 }
5175
5176 return m_uint8_value;
5177 }
5178
5179
5184 eProsima_user_DllExport void int16_value(
5185 int16_t _int16_value)
5186 {
5187 int16_value_() = _int16_value;
5188 m__d = TK_INT16;
5189 }
5190
5196 eProsima_user_DllExport int16_t int16_value() const
5197 {
5198 if (0x00000005 != selected_member_)
5199 {
5200 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5201 }
5202
5203 return m_int16_value;
5204 }
5205
5211 eProsima_user_DllExport int16_t& int16_value()
5212 {
5213 if (0x00000005 != selected_member_)
5214 {
5215 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5216 }
5217
5218 return m_int16_value;
5219 }
5220
5221
5226 eProsima_user_DllExport void uint_16_value(
5227 uint16_t _uint_16_value)
5228 {
5229 uint_16_value_() = _uint_16_value;
5230 m__d = TK_UINT16;
5231 }
5232
5238 eProsima_user_DllExport uint16_t uint_16_value() const
5239 {
5240 if (0x00000006 != selected_member_)
5241 {
5242 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5243 }
5244
5245 return m_uint_16_value;
5246 }
5247
5253 eProsima_user_DllExport uint16_t& uint_16_value()
5254 {
5255 if (0x00000006 != selected_member_)
5256 {
5257 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5258 }
5259
5260 return m_uint_16_value;
5261 }
5262
5263
5268 eProsima_user_DllExport void int32_value(
5269 int32_t _int32_value)
5270 {
5271 int32_value_() = _int32_value;
5272 m__d = TK_INT32;
5273 }
5274
5280 eProsima_user_DllExport int32_t int32_value() const
5281 {
5282 if (0x00000007 != selected_member_)
5283 {
5284 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5285 }
5286
5287 return m_int32_value;
5288 }
5289
5295 eProsima_user_DllExport int32_t& int32_value()
5296 {
5297 if (0x00000007 != selected_member_)
5298 {
5299 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5300 }
5301
5302 return m_int32_value;
5303 }
5304
5305
5310 eProsima_user_DllExport void uint32_value(
5311 uint32_t _uint32_value)
5312 {
5313 uint32_value_() = _uint32_value;
5314 m__d = TK_UINT32;
5315 }
5316
5322 eProsima_user_DllExport uint32_t uint32_value() const
5323 {
5324 if (0x00000008 != selected_member_)
5325 {
5326 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5327 }
5328
5329 return m_uint32_value;
5330 }
5331
5337 eProsima_user_DllExport uint32_t& uint32_value()
5338 {
5339 if (0x00000008 != selected_member_)
5340 {
5341 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5342 }
5343
5344 return m_uint32_value;
5345 }
5346
5347
5352 eProsima_user_DllExport void int64_value(
5353 int64_t _int64_value)
5354 {
5355 int64_value_() = _int64_value;
5356 m__d = TK_INT64;
5357 }
5358
5364 eProsima_user_DllExport int64_t int64_value() const
5365 {
5366 if (0x00000009 != selected_member_)
5367 {
5368 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5369 }
5370
5371 return m_int64_value;
5372 }
5373
5379 eProsima_user_DllExport int64_t& int64_value()
5380 {
5381 if (0x00000009 != selected_member_)
5382 {
5383 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5384 }
5385
5386 return m_int64_value;
5387 }
5388
5389
5394 eProsima_user_DllExport void uint64_value(
5395 uint64_t _uint64_value)
5396 {
5397 uint64_value_() = _uint64_value;
5398 m__d = TK_UINT64;
5399 }
5400
5406 eProsima_user_DllExport uint64_t uint64_value() const
5407 {
5408 if (0x0000000a != selected_member_)
5409 {
5410 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5411 }
5412
5413 return m_uint64_value;
5414 }
5415
5421 eProsima_user_DllExport uint64_t& uint64_value()
5422 {
5423 if (0x0000000a != selected_member_)
5424 {
5425 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5426 }
5427
5428 return m_uint64_value;
5429 }
5430
5431
5436 eProsima_user_DllExport void float32_value(
5437 float _float32_value)
5438 {
5439 float32_value_() = _float32_value;
5440 m__d = TK_FLOAT32;
5441 }
5442
5448 eProsima_user_DllExport float float32_value() const
5449 {
5450 if (0x0000000b != selected_member_)
5451 {
5452 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5453 }
5454
5455 return m_float32_value;
5456 }
5457
5463 eProsima_user_DllExport float& float32_value()
5464 {
5465 if (0x0000000b != selected_member_)
5466 {
5467 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5468 }
5469
5470 return m_float32_value;
5471 }
5472
5473
5478 eProsima_user_DllExport void float64_value(
5479 double _float64_value)
5480 {
5481 float64_value_() = _float64_value;
5482 m__d = TK_FLOAT64;
5483 }
5484
5490 eProsima_user_DllExport double float64_value() const
5491 {
5492 if (0x0000000c != selected_member_)
5493 {
5494 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5495 }
5496
5497 return m_float64_value;
5498 }
5499
5505 eProsima_user_DllExport double& float64_value()
5506 {
5507 if (0x0000000c != selected_member_)
5508 {
5509 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5510 }
5511
5512 return m_float64_value;
5513 }
5514
5515
5520 eProsima_user_DllExport void float128_value(
5521 long double _float128_value)
5522 {
5523 float128_value_() = _float128_value;
5524 m__d = TK_FLOAT128;
5525 }
5526
5532 eProsima_user_DllExport long double float128_value() const
5533 {
5534 if (0x0000000d != selected_member_)
5535 {
5536 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5537 }
5538
5539 return m_float128_value;
5540 }
5541
5547 eProsima_user_DllExport long double& float128_value()
5548 {
5549 if (0x0000000d != selected_member_)
5550 {
5551 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5552 }
5553
5554 return m_float128_value;
5555 }
5556
5557
5562 eProsima_user_DllExport void char_value(
5563 char _char_value)
5564 {
5565 char_value_() = _char_value;
5566 m__d = TK_CHAR8;
5567 }
5568
5574 eProsima_user_DllExport char char_value() const
5575 {
5576 if (0x0000000e != selected_member_)
5577 {
5578 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5579 }
5580
5581 return m_char_value;
5582 }
5583
5589 eProsima_user_DllExport char& char_value()
5590 {
5591 if (0x0000000e != selected_member_)
5592 {
5593 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5594 }
5595
5596 return m_char_value;
5597 }
5598
5599
5604 eProsima_user_DllExport void wchar_value(
5605 wchar_t _wchar_value)
5606 {
5607 wchar_value_() = _wchar_value;
5608 m__d = TK_CHAR16;
5609 }
5610
5616 eProsima_user_DllExport wchar_t wchar_value() const
5617 {
5618 if (0x0000000f != selected_member_)
5619 {
5620 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5621 }
5622
5623 return m_wchar_value;
5624 }
5625
5631 eProsima_user_DllExport wchar_t& wchar_value()
5632 {
5633 if (0x0000000f != selected_member_)
5634 {
5635 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5636 }
5637
5638 return m_wchar_value;
5639 }
5640
5641
5646 eProsima_user_DllExport void enumerated_value(
5647 int32_t _enumerated_value)
5648 {
5649 enumerated_value_() = _enumerated_value;
5650 m__d = TK_ENUM;
5651 }
5652
5658 eProsima_user_DllExport int32_t enumerated_value() const
5659 {
5660 if (0x00000010 != selected_member_)
5661 {
5662 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5663 }
5664
5665 return m_enumerated_value;
5666 }
5667
5673 eProsima_user_DllExport int32_t& enumerated_value()
5674 {
5675 if (0x00000010 != selected_member_)
5676 {
5677 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5678 }
5679
5680 return m_enumerated_value;
5681 }
5682
5683
5688 eProsima_user_DllExport void string8_value(
5689 const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& _string8_value)
5690 {
5691 string8_value_() = _string8_value;
5692 m__d = TK_STRING8;
5693 }
5694
5699 eProsima_user_DllExport void string8_value(
5700 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>&& _string8_value)
5701 {
5702 string8_value_() = _string8_value;
5703 m__d = TK_STRING8;
5704 }
5705
5711 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value() const
5712 {
5713 if (0x00000011 != selected_member_)
5714 {
5715 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5716 }
5717
5718 return m_string8_value;
5719 }
5720
5726 eProsima_user_DllExport eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value()
5727 {
5728 if (0x00000011 != selected_member_)
5729 {
5730 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5731 }
5732
5733 return m_string8_value;
5734 }
5735
5736
5741 eProsima_user_DllExport void string16_value(
5742 const std::wstring& _string16_value)
5743 {
5744 string16_value_() = _string16_value;
5745 m__d = TK_STRING16;
5746 }
5747
5752 eProsima_user_DllExport void string16_value(
5753 std::wstring&& _string16_value)
5754 {
5755 string16_value_() = _string16_value;
5756 m__d = TK_STRING16;
5757 }
5758
5764 eProsima_user_DllExport const std::wstring& string16_value() const
5765 {
5766 if (0x00000012 != selected_member_)
5767 {
5768 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5769 }
5770
5771 return m_string16_value;
5772 }
5773
5779 eProsima_user_DllExport std::wstring& string16_value()
5780 {
5781 if (0x00000012 != selected_member_)
5782 {
5783 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5784 }
5785
5786 return m_string16_value;
5787 }
5788
5789
5794 eProsima_user_DllExport void extended_value(
5795 const ExtendedAnnotationParameterValue& _extended_value)
5796 {
5797 extended_value_() = _extended_value;
5798 m__d = 127;
5799 }
5800
5805 eProsima_user_DllExport void extended_value(
5806 ExtendedAnnotationParameterValue&& _extended_value)
5807 {
5808 extended_value_() = _extended_value;
5809 m__d = 127;
5810 }
5811
5817 eProsima_user_DllExport const ExtendedAnnotationParameterValue& extended_value() const
5818 {
5819 if (0x00000013 != selected_member_)
5820 {
5821 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5822 }
5823
5824 return m_extended_value;
5825 }
5826
5832 eProsima_user_DllExport ExtendedAnnotationParameterValue& extended_value()
5833 {
5834 if (0x00000013 != selected_member_)
5835 {
5836 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5837 }
5838
5839 return m_extended_value;
5840 }
5841
5842
5843
5844 private:
5845
5846 bool& boolean_value_()
5847 {
5848 if (0x00000001 != selected_member_)
5849 {
5850 if (member_destructor_)
5851 {
5852 member_destructor_();
5853 }
5854
5855 selected_member_ = 0x00000001;
5856 member_destructor_ = nullptr;
5857 m_boolean_value = {false};
5858
5859 }
5860
5861 return m_boolean_value;
5862 }
5863
5864 uint8_t& byte_value_()
5865 {
5866 if (0x00000002 != selected_member_)
5867 {
5868 if (member_destructor_)
5869 {
5870 member_destructor_();
5871 }
5872
5873 selected_member_ = 0x00000002;
5874 member_destructor_ = nullptr;
5875 m_byte_value = {0};
5876
5877 }
5878
5879 return m_byte_value;
5880 }
5881
5882 int8_t& int8_value_()
5883 {
5884 if (0x00000003 != selected_member_)
5885 {
5886 if (member_destructor_)
5887 {
5888 member_destructor_();
5889 }
5890
5891 selected_member_ = 0x00000003;
5892 member_destructor_ = nullptr;
5893 m_int8_value = {0};
5894
5895 }
5896
5897 return m_int8_value;
5898 }
5899
5900 uint8_t& uint8_value_()
5901 {
5902 if (0x00000004 != selected_member_)
5903 {
5904 if (member_destructor_)
5905 {
5906 member_destructor_();
5907 }
5908
5909 selected_member_ = 0x00000004;
5910 member_destructor_ = nullptr;
5911 m_uint8_value = {0};
5912
5913 }
5914
5915 return m_uint8_value;
5916 }
5917
5918 int16_t& int16_value_()
5919 {
5920 if (0x00000005 != selected_member_)
5921 {
5922 if (member_destructor_)
5923 {
5924 member_destructor_();
5925 }
5926
5927 selected_member_ = 0x00000005;
5928 member_destructor_ = nullptr;
5929 m_int16_value = {0};
5930
5931 }
5932
5933 return m_int16_value;
5934 }
5935
5936 uint16_t& uint_16_value_()
5937 {
5938 if (0x00000006 != selected_member_)
5939 {
5940 if (member_destructor_)
5941 {
5942 member_destructor_();
5943 }
5944
5945 selected_member_ = 0x00000006;
5946 member_destructor_ = nullptr;
5947 m_uint_16_value = {0};
5948
5949 }
5950
5951 return m_uint_16_value;
5952 }
5953
5954 int32_t& int32_value_()
5955 {
5956 if (0x00000007 != selected_member_)
5957 {
5958 if (member_destructor_)
5959 {
5960 member_destructor_();
5961 }
5962
5963 selected_member_ = 0x00000007;
5964 member_destructor_ = nullptr;
5965 m_int32_value = {0};
5966
5967 }
5968
5969 return m_int32_value;
5970 }
5971
5972 uint32_t& uint32_value_()
5973 {
5974 if (0x00000008 != selected_member_)
5975 {
5976 if (member_destructor_)
5977 {
5978 member_destructor_();
5979 }
5980
5981 selected_member_ = 0x00000008;
5982 member_destructor_ = nullptr;
5983 m_uint32_value = {0};
5984
5985 }
5986
5987 return m_uint32_value;
5988 }
5989
5990 int64_t& int64_value_()
5991 {
5992 if (0x00000009 != selected_member_)
5993 {
5994 if (member_destructor_)
5995 {
5996 member_destructor_();
5997 }
5998
5999 selected_member_ = 0x00000009;
6000 member_destructor_ = nullptr;
6001 m_int64_value = {0};
6002
6003 }
6004
6005 return m_int64_value;
6006 }
6007
6008 uint64_t& uint64_value_()
6009 {
6010 if (0x0000000a != selected_member_)
6011 {
6012 if (member_destructor_)
6013 {
6014 member_destructor_();
6015 }
6016
6017 selected_member_ = 0x0000000a;
6018 member_destructor_ = nullptr;
6019 m_uint64_value = {0};
6020
6021 }
6022
6023 return m_uint64_value;
6024 }
6025
6026 float& float32_value_()
6027 {
6028 if (0x0000000b != selected_member_)
6029 {
6030 if (member_destructor_)
6031 {
6032 member_destructor_();
6033 }
6034
6035 selected_member_ = 0x0000000b;
6036 member_destructor_ = nullptr;
6037 m_float32_value = {0.0};
6038
6039 }
6040
6041 return m_float32_value;
6042 }
6043
6044 double& float64_value_()
6045 {
6046 if (0x0000000c != selected_member_)
6047 {
6048 if (member_destructor_)
6049 {
6050 member_destructor_();
6051 }
6052
6053 selected_member_ = 0x0000000c;
6054 member_destructor_ = nullptr;
6055 m_float64_value = {0.0};
6056
6057 }
6058
6059 return m_float64_value;
6060 }
6061
6062 long double& float128_value_()
6063 {
6064 if (0x0000000d != selected_member_)
6065 {
6066 if (member_destructor_)
6067 {
6068 member_destructor_();
6069 }
6070
6071 selected_member_ = 0x0000000d;
6072 member_destructor_ = nullptr;
6073 m_float128_value = {0.0};
6074
6075 }
6076
6077 return m_float128_value;
6078 }
6079
6080 char& char_value_()
6081 {
6082 if (0x0000000e != selected_member_)
6083 {
6084 if (member_destructor_)
6085 {
6086 member_destructor_();
6087 }
6088
6089 selected_member_ = 0x0000000e;
6090 member_destructor_ = nullptr;
6091 m_char_value = {0};
6092
6093 }
6094
6095 return m_char_value;
6096 }
6097
6098 wchar_t& wchar_value_()
6099 {
6100 if (0x0000000f != selected_member_)
6101 {
6102 if (member_destructor_)
6103 {
6104 member_destructor_();
6105 }
6106
6107 selected_member_ = 0x0000000f;
6108 member_destructor_ = nullptr;
6109 m_wchar_value = {0};
6110
6111 }
6112
6113 return m_wchar_value;
6114 }
6115
6116 int32_t& enumerated_value_()
6117 {
6118 if (0x00000010 != selected_member_)
6119 {
6120 if (member_destructor_)
6121 {
6122 member_destructor_();
6123 }
6124
6125 selected_member_ = 0x00000010;
6126 member_destructor_ = nullptr;
6127 m_enumerated_value = {0};
6128
6129 }
6130
6131 return m_enumerated_value;
6132 }
6133
6134 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value_()
6135 {
6136 if (0x00000011 != selected_member_)
6137 {
6138 if (member_destructor_)
6139 {
6140 member_destructor_();
6141 }
6142
6143 selected_member_ = 0x00000011;
6144 member_destructor_ = [&]()
6145 {
6146 m_string8_value.~fixed_string();
6147 };
6148 new(&m_string8_value) eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>();
6149
6150 }
6151
6152 return m_string8_value;
6153 }
6154
6155 std::wstring& string16_value_()
6156 {
6157 if (0x00000012 != selected_member_)
6158 {
6159 if (member_destructor_)
6160 {
6161 member_destructor_();
6162 }
6163
6164 selected_member_ = 0x00000012;
6165 member_destructor_ = [&]()
6166 {
6167 m_string16_value.~basic_string();
6168 };
6169 new(&m_string16_value) std::wstring();
6170
6171 }
6172
6173 return m_string16_value;
6174 }
6175
6176 ExtendedAnnotationParameterValue& extended_value_()
6177 {
6178 if (0x00000013 != selected_member_)
6179 {
6180 if (member_destructor_)
6181 {
6182 member_destructor_();
6183 }
6184
6185 selected_member_ = 0x00000013;
6186 member_destructor_ = [&]()
6187 {
6188 m_extended_value.~ExtendedAnnotationParameterValue();
6189 };
6190 new(&m_extended_value) ExtendedAnnotationParameterValue();
6191
6192 }
6193
6194 return m_extended_value;
6195 }
6196
6197
6198 uint8_t m__d {127};
6199
6200 union
6201 {
6202 bool m_boolean_value;
6203 uint8_t m_byte_value;
6204 int8_t m_int8_value;
6205 uint8_t m_uint8_value;
6206 int16_t m_int16_value;
6207 uint16_t m_uint_16_value;
6208 int32_t m_int32_value;
6209 uint32_t m_uint32_value;
6210 int64_t m_int64_value;
6211 uint64_t m_uint64_value;
6212 float m_float32_value;
6213 double m_float64_value;
6214 long double m_float128_value;
6215 char m_char_value;
6216 wchar_t m_wchar_value;
6217 int32_t m_enumerated_value;
6218 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN> m_string8_value;
6219 std::wstring m_string16_value;
6220 ExtendedAnnotationParameterValue m_extended_value;
6221 };
6222
6223 uint32_t selected_member_ {0x0FFFFFFFu};
6224
6225 std::function<void()> member_destructor_;
6226};
6227
6231 class AppliedAnnotationParameter
6232{
6233 public:
6234
6238 eProsima_user_DllExport AppliedAnnotationParameter()
6239 {
6240 }
6241
6245 eProsima_user_DllExport ~AppliedAnnotationParameter()
6246 {
6247 }
6248
6253 eProsima_user_DllExport AppliedAnnotationParameter(
6254 const AppliedAnnotationParameter& x)
6255 {
6256 m_paramname_hash = x.m_paramname_hash;
6257
6258 m_value = x.m_value;
6259
6260 }
6261
6266 eProsima_user_DllExport AppliedAnnotationParameter(
6267 AppliedAnnotationParameter&& x) noexcept
6268 {
6269 m_paramname_hash = std::move(x.m_paramname_hash);
6270 m_value = std::move(x.m_value);
6271 }
6272
6277 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6278 const AppliedAnnotationParameter& x)
6279 {
6280
6281 m_paramname_hash = x.m_paramname_hash;
6282
6283 m_value = x.m_value;
6284
6285 return *this;
6286 }
6287
6292 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6293 AppliedAnnotationParameter&& x) noexcept
6294 {
6295
6296 m_paramname_hash = std::move(x.m_paramname_hash);
6297 m_value = std::move(x.m_value);
6298 return *this;
6299 }
6300
6305 eProsima_user_DllExport bool operator ==(
6306 const AppliedAnnotationParameter& x) const
6307 {
6308 return (m_paramname_hash == x.m_paramname_hash &&
6309 m_value == x.m_value);
6310 }
6311
6316 eProsima_user_DllExport bool operator !=(
6317 const AppliedAnnotationParameter& x) const
6318 {
6319 return !(*this == x);
6320 }
6321
6326 eProsima_user_DllExport void paramname_hash(
6327 const NameHash& _paramname_hash)
6328 {
6329 m_paramname_hash = _paramname_hash;
6330 }
6331
6336 eProsima_user_DllExport void paramname_hash(
6337 NameHash&& _paramname_hash)
6338 {
6339 m_paramname_hash = std::move(_paramname_hash);
6340 }
6341
6346 eProsima_user_DllExport const NameHash& paramname_hash() const
6347 {
6348 return m_paramname_hash;
6349 }
6350
6355 eProsima_user_DllExport NameHash& paramname_hash()
6356 {
6357 return m_paramname_hash;
6358 }
6359
6360
6365 eProsima_user_DllExport void value(
6366 const AnnotationParameterValue& _value)
6367 {
6368 m_value = _value;
6369 }
6370
6375 eProsima_user_DllExport void value(
6376 AnnotationParameterValue&& _value)
6377 {
6378 m_value = std::move(_value);
6379 }
6380
6385 eProsima_user_DllExport const AnnotationParameterValue& value() const
6386 {
6387 return m_value;
6388 }
6389
6394 eProsima_user_DllExport AnnotationParameterValue& value()
6395 {
6396 return m_value;
6397 }
6398
6399
6400
6401 private:
6402
6403 NameHash m_paramname_hash{0};
6404 AnnotationParameterValue m_value;
6405
6406};
6407 typedef std::vector<AppliedAnnotationParameter> AppliedAnnotationParameterSeq;
6408
6413 class AppliedAnnotation
6414{
6415 public:
6416
6420 eProsima_user_DllExport AppliedAnnotation()
6421 {
6422 }
6423
6427 eProsima_user_DllExport ~AppliedAnnotation()
6428 {
6429 }
6430
6435 eProsima_user_DllExport AppliedAnnotation(
6436 const AppliedAnnotation& x)
6437 {
6438 m_annotation_typeid = x.m_annotation_typeid;
6439
6440 m_param_seq = x.m_param_seq;
6441
6442 }
6443
6448 eProsima_user_DllExport AppliedAnnotation(
6449 AppliedAnnotation&& x) noexcept
6450 {
6451 m_annotation_typeid = std::move(x.m_annotation_typeid);
6452 m_param_seq = std::move(x.m_param_seq);
6453 }
6454
6459 eProsima_user_DllExport AppliedAnnotation& operator =(
6460 const AppliedAnnotation& x)
6461 {
6462
6463 m_annotation_typeid = x.m_annotation_typeid;
6464
6465 m_param_seq = x.m_param_seq;
6466
6467 return *this;
6468 }
6469
6474 eProsima_user_DllExport AppliedAnnotation& operator =(
6475 AppliedAnnotation&& x) noexcept
6476 {
6477
6478 m_annotation_typeid = std::move(x.m_annotation_typeid);
6479 m_param_seq = std::move(x.m_param_seq);
6480 return *this;
6481 }
6482
6487 eProsima_user_DllExport bool operator ==(
6488 const AppliedAnnotation& x) const
6489 {
6490 return (m_annotation_typeid == x.m_annotation_typeid &&
6491 m_param_seq == x.m_param_seq);
6492 }
6493
6498 eProsima_user_DllExport bool operator !=(
6499 const AppliedAnnotation& x) const
6500 {
6501 return !(*this == x);
6502 }
6503
6508 eProsima_user_DllExport void annotation_typeid(
6509 const TypeIdentifier& _annotation_typeid)
6510 {
6511 m_annotation_typeid = _annotation_typeid;
6512 }
6513
6518 eProsima_user_DllExport void annotation_typeid(
6519 TypeIdentifier&& _annotation_typeid)
6520 {
6521 m_annotation_typeid = std::move(_annotation_typeid);
6522 }
6523
6528 eProsima_user_DllExport const TypeIdentifier& annotation_typeid() const
6529 {
6530 return m_annotation_typeid;
6531 }
6532
6537 eProsima_user_DllExport TypeIdentifier& annotation_typeid()
6538 {
6539 return m_annotation_typeid;
6540 }
6541
6542
6547 eProsima_user_DllExport void param_seq(
6548 const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& _param_seq)
6549 {
6550 m_param_seq = _param_seq;
6551 }
6552
6557 eProsima_user_DllExport void param_seq(
6558 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>&& _param_seq)
6559 {
6560 m_param_seq = std::move(_param_seq);
6561 }
6562
6567 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq() const
6568 {
6569 return m_param_seq;
6570 }
6571
6576 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq()
6577 {
6578 return m_param_seq;
6579 }
6580
6581
6582
6583 private:
6584
6585 TypeIdentifier m_annotation_typeid;
6586 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq> m_param_seq;
6587
6588};
6589 typedef std::vector<AppliedAnnotation> AppliedAnnotationSeq;
6590
6595 class AppliedVerbatimAnnotation
6596{
6597 public:
6598
6602 eProsima_user_DllExport AppliedVerbatimAnnotation()
6603 {
6604 }
6605
6609 eProsima_user_DllExport ~AppliedVerbatimAnnotation()
6610 {
6611 }
6612
6617 eProsima_user_DllExport AppliedVerbatimAnnotation(
6618 const AppliedVerbatimAnnotation& x)
6619 {
6620 m_placement = x.m_placement;
6621
6622 m_language = x.m_language;
6623
6624 m_text = x.m_text;
6625
6626 }
6627
6632 eProsima_user_DllExport AppliedVerbatimAnnotation(
6633 AppliedVerbatimAnnotation&& x) noexcept
6634 {
6635 m_placement = std::move(x.m_placement);
6636 m_language = std::move(x.m_language);
6637 m_text = std::move(x.m_text);
6638 }
6639
6644 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6645 const AppliedVerbatimAnnotation& x)
6646 {
6647
6648 m_placement = x.m_placement;
6649
6650 m_language = x.m_language;
6651
6652 m_text = x.m_text;
6653
6654 return *this;
6655 }
6656
6661 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6662 AppliedVerbatimAnnotation&& x) noexcept
6663 {
6664
6665 m_placement = std::move(x.m_placement);
6666 m_language = std::move(x.m_language);
6667 m_text = std::move(x.m_text);
6668 return *this;
6669 }
6670
6675 eProsima_user_DllExport bool operator ==(
6676 const AppliedVerbatimAnnotation& x) const
6677 {
6678 return (m_placement == x.m_placement &&
6679 m_language == x.m_language &&
6680 m_text == x.m_text);
6681 }
6682
6687 eProsima_user_DllExport bool operator !=(
6688 const AppliedVerbatimAnnotation& x) const
6689 {
6690 return !(*this == x);
6691 }
6692
6697 eProsima_user_DllExport void placement(
6698 const eprosima::fastcdr::fixed_string<32>& _placement)
6699 {
6700 m_placement = _placement;
6701 }
6702
6707 eProsima_user_DllExport void placement(
6708 eprosima::fastcdr::fixed_string<32>&& _placement)
6709 {
6710 m_placement = std::move(_placement);
6711 }
6712
6717 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& placement() const
6718 {
6719 return m_placement;
6720 }
6721
6726 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& placement()
6727 {
6728 return m_placement;
6729 }
6730
6731
6736 eProsima_user_DllExport void language(
6737 const eprosima::fastcdr::fixed_string<32>& _language)
6738 {
6739 m_language = _language;
6740 }
6741
6746 eProsima_user_DllExport void language(
6747 eprosima::fastcdr::fixed_string<32>&& _language)
6748 {
6749 m_language = std::move(_language);
6750 }
6751
6756 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& language() const
6757 {
6758 return m_language;
6759 }
6760
6765 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& language()
6766 {
6767 return m_language;
6768 }
6769
6770
6775 eProsima_user_DllExport void text(
6776 const std::string& _text)
6777 {
6778 m_text = _text;
6779 }
6780
6785 eProsima_user_DllExport void text(
6786 std::string&& _text)
6787 {
6788 m_text = std::move(_text);
6789 }
6790
6795 eProsima_user_DllExport const std::string& text() const
6796 {
6797 return m_text;
6798 }
6799
6804 eProsima_user_DllExport std::string& text()
6805 {
6806 return m_text;
6807 }
6808
6809
6810
6811 private:
6812
6813 eprosima::fastcdr::fixed_string<32> m_placement;
6814 eprosima::fastcdr::fixed_string<32> m_language;
6815 std::string m_text;
6816
6817};
6818
6822 class AppliedBuiltinMemberAnnotations
6823{
6824 public:
6825
6829 eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
6830 {
6831 }
6832
6836 eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
6837 {
6838 }
6839
6844 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6845 const AppliedBuiltinMemberAnnotations& x)
6846 {
6847 m_unit = x.m_unit;
6848
6849 m_min = x.m_min;
6850
6851 m_max = x.m_max;
6852
6853 m_hash_id = x.m_hash_id;
6854
6855 }
6856
6861 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6862 AppliedBuiltinMemberAnnotations&& x) noexcept
6863 {
6864 m_unit = std::move(x.m_unit);
6865 m_min = std::move(x.m_min);
6866 m_max = std::move(x.m_max);
6867 m_hash_id = std::move(x.m_hash_id);
6868 }
6869
6874 eProsima_user_DllExport AppliedBuiltinMemberAnnotations& operator =(
6875 const AppliedBuiltinMemberAnnotations& x)
6876 {
6877
6878 m_unit = x.m_unit;
6879
6880 m_min = x.m_min;
6881
6882 m_max = x.m_max;
6883
6884 m_hash_id = x.m_hash_id;
6885
6886 return *this;
6887 }
6888
6893 eProsima_user_DllExport AppliedBuiltinMemberAnnotations& operator =(
6894 AppliedBuiltinMemberAnnotations&& x) noexcept
6895 {
6896
6897 m_unit = std::move(x.m_unit);
6898 m_min = std::move(x.m_min);
6899 m_max = std::move(x.m_max);
6900 m_hash_id = std::move(x.m_hash_id);
6901 return *this;
6902 }
6903
6908 eProsima_user_DllExport bool operator ==(
6909 const AppliedBuiltinMemberAnnotations& x) const
6910 {
6911 return (m_unit == x.m_unit &&
6912 m_min == x.m_min &&
6913 m_max == x.m_max &&
6914 m_hash_id == x.m_hash_id);
6915 }
6916
6921 eProsima_user_DllExport bool operator !=(
6922 const AppliedBuiltinMemberAnnotations& x) const
6923 {
6924 return !(*this == x);
6925 }
6926
6931 eProsima_user_DllExport void unit(
6932 const eprosima::fastcdr::optional<std::string>& _unit)
6933 {
6934 m_unit = _unit;
6935 }
6936
6941 eProsima_user_DllExport void unit(
6942 eprosima::fastcdr::optional<std::string>&& _unit)
6943 {
6944 m_unit = std::move(_unit);
6945 }
6946
6951 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& unit() const
6952 {
6953 return m_unit;
6954 }
6955
6960 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& unit()
6961 {
6962 return m_unit;
6963 }
6964
6965
6970 eProsima_user_DllExport void min(
6971 const eprosima::fastcdr::optional<AnnotationParameterValue>& _min)
6972 {
6973 m_min = _min;
6974 }
6975
6980 eProsima_user_DllExport void min(
6981 eprosima::fastcdr::optional<AnnotationParameterValue>&& _min)
6982 {
6983 m_min = std::move(_min);
6984 }
6985
6990 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& min() const
6991 {
6992 return m_min;
6993 }
6994
6999 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& min()
7000 {
7001 return m_min;
7002 }
7003
7004
7009 eProsima_user_DllExport void max(
7010 const eprosima::fastcdr::optional<AnnotationParameterValue>& _max)
7011 {
7012 m_max = _max;
7013 }
7014
7019 eProsima_user_DllExport void max(
7020 eprosima::fastcdr::optional<AnnotationParameterValue>&& _max)
7021 {
7022 m_max = std::move(_max);
7023 }
7024
7029 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& max() const
7030 {
7031 return m_max;
7032 }
7033
7038 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& max()
7039 {
7040 return m_max;
7041 }
7042
7043
7048 eProsima_user_DllExport void hash_id(
7049 const eprosima::fastcdr::optional<std::string>& _hash_id)
7050 {
7051 m_hash_id = _hash_id;
7052 }
7053
7058 eProsima_user_DllExport void hash_id(
7059 eprosima::fastcdr::optional<std::string>&& _hash_id)
7060 {
7061 m_hash_id = std::move(_hash_id);
7062 }
7063
7068 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& hash_id() const
7069 {
7070 return m_hash_id;
7071 }
7072
7077 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& hash_id()
7078 {
7079 return m_hash_id;
7080 }
7081
7082
7083
7084 private:
7085
7086 eprosima::fastcdr::optional<std::string> m_unit;
7087 eprosima::fastcdr::optional<AnnotationParameterValue> m_min;
7088 eprosima::fastcdr::optional<AnnotationParameterValue> m_max;
7089 eprosima::fastcdr::optional<std::string> m_hash_id;
7090
7091};
7092
7096 class CommonStructMember
7097{
7098 public:
7099
7103 eProsima_user_DllExport CommonStructMember()
7104 {
7105 }
7106
7110 eProsima_user_DllExport ~CommonStructMember()
7111 {
7112 }
7113
7118 eProsima_user_DllExport CommonStructMember(
7119 const CommonStructMember& x)
7120 {
7121 m_member_id = x.m_member_id;
7122
7123 m_member_flags = x.m_member_flags;
7124
7125 m_member_type_id = x.m_member_type_id;
7126
7127 }
7128
7133 eProsima_user_DllExport CommonStructMember(
7134 CommonStructMember&& x) noexcept
7135 {
7136 m_member_id = x.m_member_id;
7137 m_member_flags = std::move(x.m_member_flags);
7138 m_member_type_id = std::move(x.m_member_type_id);
7139 }
7140
7145 eProsima_user_DllExport CommonStructMember& operator =(
7146 const CommonStructMember& x)
7147 {
7148
7149 m_member_id = x.m_member_id;
7150
7151 m_member_flags = x.m_member_flags;
7152
7153 m_member_type_id = x.m_member_type_id;
7154
7155 return *this;
7156 }
7157
7162 eProsima_user_DllExport CommonStructMember& operator =(
7163 CommonStructMember&& x) noexcept
7164 {
7165
7166 m_member_id = x.m_member_id;
7167 m_member_flags = std::move(x.m_member_flags);
7168 m_member_type_id = std::move(x.m_member_type_id);
7169 return *this;
7170 }
7171
7176 eProsima_user_DllExport bool operator ==(
7177 const CommonStructMember& x) const
7178 {
7179 return (m_member_id == x.m_member_id &&
7180 m_member_flags == x.m_member_flags &&
7181 m_member_type_id == x.m_member_type_id);
7182 }
7183
7188 eProsima_user_DllExport bool operator !=(
7189 const CommonStructMember& x) const
7190 {
7191 return !(*this == x);
7192 }
7193
7198 eProsima_user_DllExport void member_id(
7199 MemberId _member_id)
7200 {
7201 m_member_id = _member_id;
7202 }
7203
7208 eProsima_user_DllExport MemberId member_id() const
7209 {
7210 return m_member_id;
7211 }
7212
7217 eProsima_user_DllExport MemberId& member_id()
7218 {
7219 return m_member_id;
7220 }
7221
7222
7227 eProsima_user_DllExport void member_flags(
7228 const StructMemberFlag& _member_flags)
7229 {
7230 m_member_flags = _member_flags;
7231 }
7232
7237 eProsima_user_DllExport void member_flags(
7238 StructMemberFlag&& _member_flags)
7239 {
7240 m_member_flags = std::move(_member_flags);
7241 }
7242
7247 eProsima_user_DllExport const StructMemberFlag& member_flags() const
7248 {
7249 return m_member_flags;
7250 }
7251
7256 eProsima_user_DllExport StructMemberFlag& member_flags()
7257 {
7258 return m_member_flags;
7259 }
7260
7261
7266 eProsima_user_DllExport void member_type_id(
7267 const TypeIdentifier& _member_type_id)
7268 {
7269 m_member_type_id = _member_type_id;
7270 }
7271
7276 eProsima_user_DllExport void member_type_id(
7277 TypeIdentifier&& _member_type_id)
7278 {
7279 m_member_type_id = std::move(_member_type_id);
7280 }
7281
7286 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
7287 {
7288 return m_member_type_id;
7289 }
7290
7295 eProsima_user_DllExport TypeIdentifier& member_type_id()
7296 {
7297 return m_member_type_id;
7298 }
7299
7300
7301
7302 private:
7303
7304 MemberId m_member_id{0};
7305 StructMemberFlag m_member_flags{0};
7306 TypeIdentifier m_member_type_id;
7307
7308};
7309
7313 class CompleteMemberDetail
7314{
7315 public:
7316
7320 eProsima_user_DllExport CompleteMemberDetail()
7321 {
7322 }
7323
7327 eProsima_user_DllExport ~CompleteMemberDetail()
7328 {
7329 }
7330
7335 eProsima_user_DllExport CompleteMemberDetail(
7336 const CompleteMemberDetail& x)
7337 {
7338 m_name = x.m_name;
7339
7340 m_ann_builtin = x.m_ann_builtin;
7341
7342 m_ann_custom = x.m_ann_custom;
7343
7344 }
7345
7350 eProsima_user_DllExport CompleteMemberDetail(
7351 CompleteMemberDetail&& x) noexcept
7352 {
7353 m_name = std::move(x.m_name);
7354 m_ann_builtin = std::move(x.m_ann_builtin);
7355 m_ann_custom = std::move(x.m_ann_custom);
7356 }
7357
7362 eProsima_user_DllExport CompleteMemberDetail& operator =(
7363 const CompleteMemberDetail& x)
7364 {
7365
7366 m_name = x.m_name;
7367
7368 m_ann_builtin = x.m_ann_builtin;
7369
7370 m_ann_custom = x.m_ann_custom;
7371
7372 return *this;
7373 }
7374
7379 eProsima_user_DllExport CompleteMemberDetail& operator =(
7380 CompleteMemberDetail&& x) noexcept
7381 {
7382
7383 m_name = std::move(x.m_name);
7384 m_ann_builtin = std::move(x.m_ann_builtin);
7385 m_ann_custom = std::move(x.m_ann_custom);
7386 return *this;
7387 }
7388
7393 eProsima_user_DllExport bool operator ==(
7394 const CompleteMemberDetail& x) const
7395 {
7396 return (m_name == x.m_name &&
7397 m_ann_builtin == x.m_ann_builtin &&
7398 m_ann_custom == x.m_ann_custom);
7399 }
7400
7405 eProsima_user_DllExport bool operator !=(
7406 const CompleteMemberDetail& x) const
7407 {
7408 return !(*this == x);
7409 }
7410
7415 eProsima_user_DllExport void name(
7416 const MemberName& _name)
7417 {
7418 m_name = _name;
7419 }
7420
7425 eProsima_user_DllExport void name(
7426 MemberName&& _name)
7427 {
7428 m_name = std::move(_name);
7429 }
7430
7435 eProsima_user_DllExport const MemberName& name() const
7436 {
7437 return m_name;
7438 }
7439
7444 eProsima_user_DllExport MemberName& name()
7445 {
7446 return m_name;
7447 }
7448
7449
7454 eProsima_user_DllExport void ann_builtin(
7455 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
7456 {
7457 m_ann_builtin = _ann_builtin;
7458 }
7459
7464 eProsima_user_DllExport void ann_builtin(
7465 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
7466 {
7467 m_ann_builtin = std::move(_ann_builtin);
7468 }
7469
7474 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
7475 {
7476 return m_ann_builtin;
7477 }
7478
7483 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
7484 {
7485 return m_ann_builtin;
7486 }
7487
7488
7493 eProsima_user_DllExport void ann_custom(
7494 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
7495 {
7496 m_ann_custom = _ann_custom;
7497 }
7498
7503 eProsima_user_DllExport void ann_custom(
7504 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
7505 {
7506 m_ann_custom = std::move(_ann_custom);
7507 }
7508
7513 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
7514 {
7515 return m_ann_custom;
7516 }
7517
7522 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
7523 {
7524 return m_ann_custom;
7525 }
7526
7527
7528
7529 private:
7530
7531 MemberName m_name;
7532 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
7533 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
7534
7535};
7536
7540 class MinimalMemberDetail
7541{
7542 public:
7543
7547 eProsima_user_DllExport MinimalMemberDetail()
7548 {
7549 }
7550
7554 eProsima_user_DllExport ~MinimalMemberDetail()
7555 {
7556 }
7557
7562 eProsima_user_DllExport MinimalMemberDetail(
7563 const MinimalMemberDetail& x)
7564 {
7565 m_name_hash = x.m_name_hash;
7566
7567 }
7568
7573 eProsima_user_DllExport MinimalMemberDetail(
7574 MinimalMemberDetail&& x) noexcept
7575 {
7576 m_name_hash = std::move(x.m_name_hash);
7577 }
7578
7583 eProsima_user_DllExport MinimalMemberDetail& operator =(
7584 const MinimalMemberDetail& x)
7585 {
7586
7587 m_name_hash = x.m_name_hash;
7588
7589 return *this;
7590 }
7591
7596 eProsima_user_DllExport MinimalMemberDetail& operator =(
7597 MinimalMemberDetail&& x) noexcept
7598 {
7599
7600 m_name_hash = std::move(x.m_name_hash);
7601 return *this;
7602 }
7603
7608 eProsima_user_DllExport bool operator ==(
7609 const MinimalMemberDetail& x) const
7610 {
7611 return (m_name_hash == x.m_name_hash);
7612 }
7613
7618 eProsima_user_DllExport bool operator !=(
7619 const MinimalMemberDetail& x) const
7620 {
7621 return !(*this == x);
7622 }
7623
7628 eProsima_user_DllExport void name_hash(
7629 const NameHash& _name_hash)
7630 {
7631 m_name_hash = _name_hash;
7632 }
7633
7638 eProsima_user_DllExport void name_hash(
7639 NameHash&& _name_hash)
7640 {
7641 m_name_hash = std::move(_name_hash);
7642 }
7643
7648 eProsima_user_DllExport const NameHash& name_hash() const
7649 {
7650 return m_name_hash;
7651 }
7652
7657 eProsima_user_DllExport NameHash& name_hash()
7658 {
7659 return m_name_hash;
7660 }
7661
7662
7663
7664 private:
7665
7666 NameHash m_name_hash{0};
7667
7668};
7669
7673 class CompleteStructMember
7674{
7675 public:
7676
7680 eProsima_user_DllExport CompleteStructMember()
7681 {
7682 }
7683
7687 eProsima_user_DllExport ~CompleteStructMember()
7688 {
7689 }
7690
7695 eProsima_user_DllExport CompleteStructMember(
7696 const CompleteStructMember& x)
7697 {
7698 m_common = x.m_common;
7699
7700 m_detail = x.m_detail;
7701
7702 }
7703
7708 eProsima_user_DllExport CompleteStructMember(
7709 CompleteStructMember&& x) noexcept
7710 {
7711 m_common = std::move(x.m_common);
7712 m_detail = std::move(x.m_detail);
7713 }
7714
7719 eProsima_user_DllExport CompleteStructMember& operator =(
7720 const CompleteStructMember& x)
7721 {
7722
7723 m_common = x.m_common;
7724
7725 m_detail = x.m_detail;
7726
7727 return *this;
7728 }
7729
7734 eProsima_user_DllExport CompleteStructMember& operator =(
7735 CompleteStructMember&& x) noexcept
7736 {
7737
7738 m_common = std::move(x.m_common);
7739 m_detail = std::move(x.m_detail);
7740 return *this;
7741 }
7742
7747 eProsima_user_DllExport bool operator ==(
7748 const CompleteStructMember& x) const
7749 {
7750 return (m_common == x.m_common &&
7751 m_detail == x.m_detail);
7752 }
7753
7758 eProsima_user_DllExport bool operator !=(
7759 const CompleteStructMember& x) const
7760 {
7761 return !(*this == x);
7762 }
7763
7768 eProsima_user_DllExport void common(
7769 const CommonStructMember& _common)
7770 {
7771 m_common = _common;
7772 }
7773
7778 eProsima_user_DllExport void common(
7779 CommonStructMember&& _common)
7780 {
7781 m_common = std::move(_common);
7782 }
7783
7788 eProsima_user_DllExport const CommonStructMember& common() const
7789 {
7790 return m_common;
7791 }
7792
7797 eProsima_user_DllExport CommonStructMember& common()
7798 {
7799 return m_common;
7800 }
7801
7802
7807 eProsima_user_DllExport void detail(
7808 const CompleteMemberDetail& _detail)
7809 {
7810 m_detail = _detail;
7811 }
7812
7817 eProsima_user_DllExport void detail(
7818 CompleteMemberDetail&& _detail)
7819 {
7820 m_detail = std::move(_detail);
7821 }
7822
7827 eProsima_user_DllExport const CompleteMemberDetail& detail() const
7828 {
7829 return m_detail;
7830 }
7831
7836 eProsima_user_DllExport CompleteMemberDetail& detail()
7837 {
7838 return m_detail;
7839 }
7840
7841
7842
7843 private:
7844
7845 CommonStructMember m_common;
7846 CompleteMemberDetail m_detail;
7847
7848};
7849 typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
7850
7855 class MinimalStructMember
7856{
7857 public:
7858
7862 eProsima_user_DllExport MinimalStructMember()
7863 {
7864 }
7865
7869 eProsima_user_DllExport ~MinimalStructMember()
7870 {
7871 }
7872
7877 eProsima_user_DllExport MinimalStructMember(
7878 const MinimalStructMember& x)
7879 {
7880 m_common = x.m_common;
7881
7882 m_detail = x.m_detail;
7883
7884 }
7885
7890 eProsima_user_DllExport MinimalStructMember(
7891 MinimalStructMember&& x) noexcept
7892 {
7893 m_common = std::move(x.m_common);
7894 m_detail = std::move(x.m_detail);
7895 }
7896
7901 eProsima_user_DllExport MinimalStructMember& operator =(
7902 const MinimalStructMember& x)
7903 {
7904
7905 m_common = x.m_common;
7906
7907 m_detail = x.m_detail;
7908
7909 return *this;
7910 }
7911
7916 eProsima_user_DllExport MinimalStructMember& operator =(
7917 MinimalStructMember&& x) noexcept
7918 {
7919
7920 m_common = std::move(x.m_common);
7921 m_detail = std::move(x.m_detail);
7922 return *this;
7923 }
7924
7929 eProsima_user_DllExport bool operator ==(
7930 const MinimalStructMember& x) const
7931 {
7932 return (m_common == x.m_common &&
7933 m_detail == x.m_detail);
7934 }
7935
7940 eProsima_user_DllExport bool operator !=(
7941 const MinimalStructMember& x) const
7942 {
7943 return !(*this == x);
7944 }
7945
7950 eProsima_user_DllExport void common(
7951 const CommonStructMember& _common)
7952 {
7953 m_common = _common;
7954 }
7955
7960 eProsima_user_DllExport void common(
7961 CommonStructMember&& _common)
7962 {
7963 m_common = std::move(_common);
7964 }
7965
7970 eProsima_user_DllExport const CommonStructMember& common() const
7971 {
7972 return m_common;
7973 }
7974
7979 eProsima_user_DllExport CommonStructMember& common()
7980 {
7981 return m_common;
7982 }
7983
7984
7989 eProsima_user_DllExport void detail(
7990 const MinimalMemberDetail& _detail)
7991 {
7992 m_detail = _detail;
7993 }
7994
7999 eProsima_user_DllExport void detail(
8000 MinimalMemberDetail&& _detail)
8001 {
8002 m_detail = std::move(_detail);
8003 }
8004
8009 eProsima_user_DllExport const MinimalMemberDetail& detail() const
8010 {
8011 return m_detail;
8012 }
8013
8018 eProsima_user_DllExport MinimalMemberDetail& detail()
8019 {
8020 return m_detail;
8021 }
8022
8023
8024
8025 private:
8026
8027 CommonStructMember m_common;
8028 MinimalMemberDetail m_detail;
8029
8030};
8031 typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
8032
8037 class AppliedBuiltinTypeAnnotations
8038{
8039 public:
8040
8044 eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
8045 {
8046 }
8047
8051 eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
8052 {
8053 }
8054
8059 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
8060 const AppliedBuiltinTypeAnnotations& x)
8061 {
8062 m_verbatim = x.m_verbatim;
8063
8064 }
8065
8070 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
8071 AppliedBuiltinTypeAnnotations&& x) noexcept
8072 {
8073 m_verbatim = std::move(x.m_verbatim);
8074 }
8075
8080 eProsima_user_DllExport AppliedBuiltinTypeAnnotations& operator =(
8081 const AppliedBuiltinTypeAnnotations& x)
8082 {
8083
8084 m_verbatim = x.m_verbatim;
8085
8086 return *this;
8087 }
8088
8093 eProsima_user_DllExport AppliedBuiltinTypeAnnotations& operator =(
8094 AppliedBuiltinTypeAnnotations&& x) noexcept
8095 {
8096
8097 m_verbatim = std::move(x.m_verbatim);
8098 return *this;
8099 }
8100
8105 eProsima_user_DllExport bool operator ==(
8106 const AppliedBuiltinTypeAnnotations& x) const
8107 {
8108 return (m_verbatim == x.m_verbatim);
8109 }
8110
8115 eProsima_user_DllExport bool operator !=(
8116 const AppliedBuiltinTypeAnnotations& x) const
8117 {
8118 return !(*this == x);
8119 }
8120
8125 eProsima_user_DllExport void verbatim(
8126 const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& _verbatim)
8127 {
8128 m_verbatim = _verbatim;
8129 }
8130
8135 eProsima_user_DllExport void verbatim(
8136 eprosima::fastcdr::optional<AppliedVerbatimAnnotation>&& _verbatim)
8137 {
8138 m_verbatim = std::move(_verbatim);
8139 }
8140
8145 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim() const
8146 {
8147 return m_verbatim;
8148 }
8149
8154 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim()
8155 {
8156 return m_verbatim;
8157 }
8158
8159
8160
8161 private:
8162
8163 eprosima::fastcdr::optional<AppliedVerbatimAnnotation> m_verbatim;
8164
8165};
8166
8170 class MinimalTypeDetail
8171{
8172 public:
8173
8177 eProsima_user_DllExport MinimalTypeDetail()
8178 {
8179 }
8180
8184 eProsima_user_DllExport ~MinimalTypeDetail()
8185 {
8186 }
8187
8192 eProsima_user_DllExport MinimalTypeDetail(
8193 const MinimalTypeDetail& x)
8194 {
8195 static_cast<void>(x);
8196 }
8197
8202 eProsima_user_DllExport MinimalTypeDetail(
8203 MinimalTypeDetail&& x) noexcept
8204 {
8205 static_cast<void>(x);
8206 }
8207
8212 eProsima_user_DllExport MinimalTypeDetail& operator =(
8213 const MinimalTypeDetail& x)
8214 {
8215
8216 static_cast<void>(x);
8217
8218 return *this;
8219 }
8220
8225 eProsima_user_DllExport MinimalTypeDetail& operator =(
8226 MinimalTypeDetail&& x) noexcept
8227 {
8228
8229 static_cast<void>(x);
8230
8231 return *this;
8232 }
8233
8238 eProsima_user_DllExport bool operator ==(
8239 const MinimalTypeDetail& x) const
8240 {
8241 static_cast<void>(x);
8242 return true;
8243 }
8244
8249 eProsima_user_DllExport bool operator !=(
8250 const MinimalTypeDetail& x) const
8251 {
8252 return !(*this == x);
8253 }
8254
8255
8256
8257 private:
8258
8259
8260};
8261
8265 class CompleteTypeDetail
8266{
8267 public:
8268
8272 eProsima_user_DllExport CompleteTypeDetail()
8273 {
8274 }
8275
8279 eProsima_user_DllExport ~CompleteTypeDetail()
8280 {
8281 }
8282
8287 eProsima_user_DllExport CompleteTypeDetail(
8288 const CompleteTypeDetail& x)
8289 {
8290 m_ann_builtin = x.m_ann_builtin;
8291
8292 m_ann_custom = x.m_ann_custom;
8293
8294 m_type_name = x.m_type_name;
8295
8296 }
8297
8302 eProsima_user_DllExport CompleteTypeDetail(
8303 CompleteTypeDetail&& x) noexcept
8304 {
8305 m_ann_builtin = std::move(x.m_ann_builtin);
8306 m_ann_custom = std::move(x.m_ann_custom);
8307 m_type_name = std::move(x.m_type_name);
8308 }
8309
8314 eProsima_user_DllExport CompleteTypeDetail& operator =(
8315 const CompleteTypeDetail& x)
8316 {
8317
8318 m_ann_builtin = x.m_ann_builtin;
8319
8320 m_ann_custom = x.m_ann_custom;
8321
8322 m_type_name = x.m_type_name;
8323
8324 return *this;
8325 }
8326
8331 eProsima_user_DllExport CompleteTypeDetail& operator =(
8332 CompleteTypeDetail&& x) noexcept
8333 {
8334
8335 m_ann_builtin = std::move(x.m_ann_builtin);
8336 m_ann_custom = std::move(x.m_ann_custom);
8337 m_type_name = std::move(x.m_type_name);
8338 return *this;
8339 }
8340
8345 eProsima_user_DllExport bool operator ==(
8346 const CompleteTypeDetail& x) const
8347 {
8348 return (m_ann_builtin == x.m_ann_builtin &&
8349 m_ann_custom == x.m_ann_custom &&
8350 m_type_name == x.m_type_name);
8351 }
8352
8357 eProsima_user_DllExport bool operator !=(
8358 const CompleteTypeDetail& x) const
8359 {
8360 return !(*this == x);
8361 }
8362
8367 eProsima_user_DllExport void ann_builtin(
8368 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
8369 {
8370 m_ann_builtin = _ann_builtin;
8371 }
8372
8377 eProsima_user_DllExport void ann_builtin(
8378 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
8379 {
8380 m_ann_builtin = std::move(_ann_builtin);
8381 }
8382
8387 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
8388 {
8389 return m_ann_builtin;
8390 }
8391
8396 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
8397 {
8398 return m_ann_builtin;
8399 }
8400
8401
8406 eProsima_user_DllExport void ann_custom(
8407 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
8408 {
8409 m_ann_custom = _ann_custom;
8410 }
8411
8416 eProsima_user_DllExport void ann_custom(
8417 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
8418 {
8419 m_ann_custom = std::move(_ann_custom);
8420 }
8421
8426 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
8427 {
8428 return m_ann_custom;
8429 }
8430
8435 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
8436 {
8437 return m_ann_custom;
8438 }
8439
8440
8445 eProsima_user_DllExport void type_name(
8446 const QualifiedTypeName& _type_name)
8447 {
8448 m_type_name = _type_name;
8449 }
8450
8455 eProsima_user_DllExport void type_name(
8456 QualifiedTypeName&& _type_name)
8457 {
8458 m_type_name = std::move(_type_name);
8459 }
8460
8465 eProsima_user_DllExport const QualifiedTypeName& type_name() const
8466 {
8467 return m_type_name;
8468 }
8469
8474 eProsima_user_DllExport QualifiedTypeName& type_name()
8475 {
8476 return m_type_name;
8477 }
8478
8479
8480
8481 private:
8482
8483 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
8484 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
8485 QualifiedTypeName m_type_name;
8486
8487};
8488
8492 class CompleteStructHeader
8493{
8494 public:
8495
8499 eProsima_user_DllExport CompleteStructHeader()
8500 {
8501 }
8502
8506 eProsima_user_DllExport ~CompleteStructHeader()
8507 {
8508 }
8509
8514 eProsima_user_DllExport CompleteStructHeader(
8515 const CompleteStructHeader& x)
8516 {
8517 m_base_type = x.m_base_type;
8518
8519 m_detail = x.m_detail;
8520
8521 }
8522
8527 eProsima_user_DllExport CompleteStructHeader(
8528 CompleteStructHeader&& x) noexcept
8529 {
8530 m_base_type = std::move(x.m_base_type);
8531 m_detail = std::move(x.m_detail);
8532 }
8533
8538 eProsima_user_DllExport CompleteStructHeader& operator =(
8539 const CompleteStructHeader& x)
8540 {
8541
8542 m_base_type = x.m_base_type;
8543
8544 m_detail = x.m_detail;
8545
8546 return *this;
8547 }
8548
8553 eProsima_user_DllExport CompleteStructHeader& operator =(
8554 CompleteStructHeader&& x) noexcept
8555 {
8556
8557 m_base_type = std::move(x.m_base_type);
8558 m_detail = std::move(x.m_detail);
8559 return *this;
8560 }
8561
8566 eProsima_user_DllExport bool operator ==(
8567 const CompleteStructHeader& x) const
8568 {
8569 return (m_base_type == x.m_base_type &&
8570 m_detail == x.m_detail);
8571 }
8572
8577 eProsima_user_DllExport bool operator !=(
8578 const CompleteStructHeader& x) const
8579 {
8580 return !(*this == x);
8581 }
8582
8587 eProsima_user_DllExport void base_type(
8588 const TypeIdentifier& _base_type)
8589 {
8590 m_base_type = _base_type;
8591 }
8592
8597 eProsima_user_DllExport void base_type(
8598 TypeIdentifier&& _base_type)
8599 {
8600 m_base_type = std::move(_base_type);
8601 }
8602
8607 eProsima_user_DllExport const TypeIdentifier& base_type() const
8608 {
8609 return m_base_type;
8610 }
8611
8616 eProsima_user_DllExport TypeIdentifier& base_type()
8617 {
8618 return m_base_type;
8619 }
8620
8621
8626 eProsima_user_DllExport void detail(
8627 const CompleteTypeDetail& _detail)
8628 {
8629 m_detail = _detail;
8630 }
8631
8636 eProsima_user_DllExport void detail(
8637 CompleteTypeDetail&& _detail)
8638 {
8639 m_detail = std::move(_detail);
8640 }
8641
8646 eProsima_user_DllExport const CompleteTypeDetail& detail() const
8647 {
8648 return m_detail;
8649 }
8650
8655 eProsima_user_DllExport CompleteTypeDetail& detail()
8656 {
8657 return m_detail;
8658 }
8659
8660
8661
8662 private:
8663
8664 TypeIdentifier m_base_type;
8665 CompleteTypeDetail m_detail;
8666
8667};
8668
8672 class MinimalStructHeader
8673{
8674 public:
8675
8679 eProsima_user_DllExport MinimalStructHeader()
8680 {
8681 }
8682
8686 eProsima_user_DllExport ~MinimalStructHeader()
8687 {
8688 }
8689
8694 eProsima_user_DllExport MinimalStructHeader(
8695 const MinimalStructHeader& x)
8696 {
8697 m_base_type = x.m_base_type;
8698
8699 m_detail = x.m_detail;
8700
8701 }
8702
8707 eProsima_user_DllExport MinimalStructHeader(
8708 MinimalStructHeader&& x) noexcept
8709 {
8710 m_base_type = std::move(x.m_base_type);
8711 m_detail = std::move(x.m_detail);
8712 }
8713
8718 eProsima_user_DllExport MinimalStructHeader& operator =(
8719 const MinimalStructHeader& x)
8720 {
8721
8722 m_base_type = x.m_base_type;
8723
8724 m_detail = x.m_detail;
8725
8726 return *this;
8727 }
8728
8733 eProsima_user_DllExport MinimalStructHeader& operator =(
8734 MinimalStructHeader&& x) noexcept
8735 {
8736
8737 m_base_type = std::move(x.m_base_type);
8738 m_detail = std::move(x.m_detail);
8739 return *this;
8740 }
8741
8746 eProsima_user_DllExport bool operator ==(
8747 const MinimalStructHeader& x) const
8748 {
8749 return (m_base_type == x.m_base_type &&
8750 m_detail == x.m_detail);
8751 }
8752
8757 eProsima_user_DllExport bool operator !=(
8758 const MinimalStructHeader& x) const
8759 {
8760 return !(*this == x);
8761 }
8762
8767 eProsima_user_DllExport void base_type(
8768 const TypeIdentifier& _base_type)
8769 {
8770 m_base_type = _base_type;
8771 }
8772
8777 eProsima_user_DllExport void base_type(
8778 TypeIdentifier&& _base_type)
8779 {
8780 m_base_type = std::move(_base_type);
8781 }
8782
8787 eProsima_user_DllExport const TypeIdentifier& base_type() const
8788 {
8789 return m_base_type;
8790 }
8791
8796 eProsima_user_DllExport TypeIdentifier& base_type()
8797 {
8798 return m_base_type;
8799 }
8800
8801
8806 eProsima_user_DllExport void detail(
8807 const MinimalTypeDetail& _detail)
8808 {
8809 m_detail = _detail;
8810 }
8811
8816 eProsima_user_DllExport void detail(
8817 MinimalTypeDetail&& _detail)
8818 {
8819 m_detail = std::move(_detail);
8820 }
8821
8826 eProsima_user_DllExport const MinimalTypeDetail& detail() const
8827 {
8828 return m_detail;
8829 }
8830
8835 eProsima_user_DllExport MinimalTypeDetail& detail()
8836 {
8837 return m_detail;
8838 }
8839
8840
8841
8842 private:
8843
8844 TypeIdentifier m_base_type;
8845 MinimalTypeDetail m_detail;
8846
8847};
8848
8852 class CompleteStructType
8853{
8854 public:
8855
8859 eProsima_user_DllExport CompleteStructType()
8860 {
8861 }
8862
8866 eProsima_user_DllExport ~CompleteStructType()
8867 {
8868 }
8869
8874 eProsima_user_DllExport CompleteStructType(
8875 const CompleteStructType& x)
8876 {
8877 m_struct_flags = x.m_struct_flags;
8878
8879 m_header = x.m_header;
8880
8881 m_member_seq = x.m_member_seq;
8882
8883 }
8884
8889 eProsima_user_DllExport CompleteStructType(
8890 CompleteStructType&& x) noexcept
8891 {
8892 m_struct_flags = std::move(x.m_struct_flags);
8893 m_header = std::move(x.m_header);
8894 m_member_seq = std::move(x.m_member_seq);
8895 }
8896
8901 eProsima_user_DllExport CompleteStructType& operator =(
8902 const CompleteStructType& x)
8903 {
8904
8905 m_struct_flags = x.m_struct_flags;
8906
8907 m_header = x.m_header;
8908
8909 m_member_seq = x.m_member_seq;
8910
8911 return *this;
8912 }
8913
8918 eProsima_user_DllExport CompleteStructType& operator =(
8919 CompleteStructType&& x) noexcept
8920 {
8921
8922 m_struct_flags = std::move(x.m_struct_flags);
8923 m_header = std::move(x.m_header);
8924 m_member_seq = std::move(x.m_member_seq);
8925 return *this;
8926 }
8927
8932 eProsima_user_DllExport bool operator ==(
8933 const CompleteStructType& x) const
8934 {
8935 return (m_struct_flags == x.m_struct_flags &&
8936 m_header == x.m_header &&
8937 m_member_seq == x.m_member_seq);
8938 }
8939
8944 eProsima_user_DllExport bool operator !=(
8945 const CompleteStructType& x) const
8946 {
8947 return !(*this == x);
8948 }
8949
8954 eProsima_user_DllExport void struct_flags(
8955 const StructTypeFlag& _struct_flags)
8956 {
8957 m_struct_flags = _struct_flags;
8958 }
8959
8964 eProsima_user_DllExport void struct_flags(
8965 StructTypeFlag&& _struct_flags)
8966 {
8967 m_struct_flags = std::move(_struct_flags);
8968 }
8969
8974 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
8975 {
8976 return m_struct_flags;
8977 }
8978
8983 eProsima_user_DllExport StructTypeFlag& struct_flags()
8984 {
8985 return m_struct_flags;
8986 }
8987
8988
8993 eProsima_user_DllExport void header(
8994 const CompleteStructHeader& _header)
8995 {
8996 m_header = _header;
8997 }
8998
9003 eProsima_user_DllExport void header(
9004 CompleteStructHeader&& _header)
9005 {
9006 m_header = std::move(_header);
9007 }
9008
9013 eProsima_user_DllExport const CompleteStructHeader& header() const
9014 {
9015 return m_header;
9016 }
9017
9022 eProsima_user_DllExport CompleteStructHeader& header()
9023 {
9024 return m_header;
9025 }
9026
9027
9032 eProsima_user_DllExport void member_seq(
9033 const CompleteStructMemberSeq& _member_seq)
9034 {
9035 m_member_seq = _member_seq;
9036 }
9037
9042 eProsima_user_DllExport void member_seq(
9043 CompleteStructMemberSeq&& _member_seq)
9044 {
9045 m_member_seq = std::move(_member_seq);
9046 }
9047
9052 eProsima_user_DllExport const CompleteStructMemberSeq& member_seq() const
9053 {
9054 return m_member_seq;
9055 }
9056
9061 eProsima_user_DllExport CompleteStructMemberSeq& member_seq()
9062 {
9063 return m_member_seq;
9064 }
9065
9066
9067
9068 private:
9069
9070 StructTypeFlag m_struct_flags{0};
9071 CompleteStructHeader m_header;
9072 CompleteStructMemberSeq m_member_seq;
9073
9074};
9075
9079 class MinimalStructType
9080{
9081 public:
9082
9086 eProsima_user_DllExport MinimalStructType()
9087 {
9088 }
9089
9093 eProsima_user_DllExport ~MinimalStructType()
9094 {
9095 }
9096
9101 eProsima_user_DllExport MinimalStructType(
9102 const MinimalStructType& x)
9103 {
9104 m_struct_flags = x.m_struct_flags;
9105
9106 m_header = x.m_header;
9107
9108 m_member_seq = x.m_member_seq;
9109
9110 }
9111
9116 eProsima_user_DllExport MinimalStructType(
9117 MinimalStructType&& x) noexcept
9118 {
9119 m_struct_flags = std::move(x.m_struct_flags);
9120 m_header = std::move(x.m_header);
9121 m_member_seq = std::move(x.m_member_seq);
9122 }
9123
9128 eProsima_user_DllExport MinimalStructType& operator =(
9129 const MinimalStructType& x)
9130 {
9131
9132 m_struct_flags = x.m_struct_flags;
9133
9134 m_header = x.m_header;
9135
9136 m_member_seq = x.m_member_seq;
9137
9138 return *this;
9139 }
9140
9145 eProsima_user_DllExport MinimalStructType& operator =(
9146 MinimalStructType&& x) noexcept
9147 {
9148
9149 m_struct_flags = std::move(x.m_struct_flags);
9150 m_header = std::move(x.m_header);
9151 m_member_seq = std::move(x.m_member_seq);
9152 return *this;
9153 }
9154
9159 eProsima_user_DllExport bool operator ==(
9160 const MinimalStructType& x) const
9161 {
9162 return (m_struct_flags == x.m_struct_flags &&
9163 m_header == x.m_header &&
9164 m_member_seq == x.m_member_seq);
9165 }
9166
9171 eProsima_user_DllExport bool operator !=(
9172 const MinimalStructType& x) const
9173 {
9174 return !(*this == x);
9175 }
9176
9181 eProsima_user_DllExport void struct_flags(
9182 const StructTypeFlag& _struct_flags)
9183 {
9184 m_struct_flags = _struct_flags;
9185 }
9186
9191 eProsima_user_DllExport void struct_flags(
9192 StructTypeFlag&& _struct_flags)
9193 {
9194 m_struct_flags = std::move(_struct_flags);
9195 }
9196
9201 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
9202 {
9203 return m_struct_flags;
9204 }
9205
9210 eProsima_user_DllExport StructTypeFlag& struct_flags()
9211 {
9212 return m_struct_flags;
9213 }
9214
9215
9220 eProsima_user_DllExport void header(
9221 const MinimalStructHeader& _header)
9222 {
9223 m_header = _header;
9224 }
9225
9230 eProsima_user_DllExport void header(
9231 MinimalStructHeader&& _header)
9232 {
9233 m_header = std::move(_header);
9234 }
9235
9240 eProsima_user_DllExport const MinimalStructHeader& header() const
9241 {
9242 return m_header;
9243 }
9244
9249 eProsima_user_DllExport MinimalStructHeader& header()
9250 {
9251 return m_header;
9252 }
9253
9254
9259 eProsima_user_DllExport void member_seq(
9260 const MinimalStructMemberSeq& _member_seq)
9261 {
9262 m_member_seq = _member_seq;
9263 }
9264
9269 eProsima_user_DllExport void member_seq(
9270 MinimalStructMemberSeq&& _member_seq)
9271 {
9272 m_member_seq = std::move(_member_seq);
9273 }
9274
9279 eProsima_user_DllExport const MinimalStructMemberSeq& member_seq() const
9280 {
9281 return m_member_seq;
9282 }
9283
9288 eProsima_user_DllExport MinimalStructMemberSeq& member_seq()
9289 {
9290 return m_member_seq;
9291 }
9292
9293
9294
9295 private:
9296
9297 StructTypeFlag m_struct_flags{0};
9298 MinimalStructHeader m_header;
9299 MinimalStructMemberSeq m_member_seq;
9300
9301};
9302 typedef std::vector<int32_t> UnionCaseLabelSeq;
9303
9308 class CommonUnionMember
9309{
9310 public:
9311
9315 eProsima_user_DllExport CommonUnionMember()
9316 {
9317 }
9318
9322 eProsima_user_DllExport ~CommonUnionMember()
9323 {
9324 }
9325
9330 eProsima_user_DllExport CommonUnionMember(
9331 const CommonUnionMember& x)
9332 {
9333 m_member_id = x.m_member_id;
9334
9335 m_member_flags = x.m_member_flags;
9336
9337 m_type_id = x.m_type_id;
9338
9339 m_label_seq = x.m_label_seq;
9340
9341 }
9342
9347 eProsima_user_DllExport CommonUnionMember(
9348 CommonUnionMember&& x) noexcept
9349 {
9350 m_member_id = x.m_member_id;
9351 m_member_flags = std::move(x.m_member_flags);
9352 m_type_id = std::move(x.m_type_id);
9353 m_label_seq = std::move(x.m_label_seq);
9354 }
9355
9360 eProsima_user_DllExport CommonUnionMember& operator =(
9361 const CommonUnionMember& x)
9362 {
9363
9364 m_member_id = x.m_member_id;
9365
9366 m_member_flags = x.m_member_flags;
9367
9368 m_type_id = x.m_type_id;
9369
9370 m_label_seq = x.m_label_seq;
9371
9372 return *this;
9373 }
9374
9379 eProsima_user_DllExport CommonUnionMember& operator =(
9380 CommonUnionMember&& x) noexcept
9381 {
9382
9383 m_member_id = x.m_member_id;
9384 m_member_flags = std::move(x.m_member_flags);
9385 m_type_id = std::move(x.m_type_id);
9386 m_label_seq = std::move(x.m_label_seq);
9387 return *this;
9388 }
9389
9394 eProsima_user_DllExport bool operator ==(
9395 const CommonUnionMember& x) const
9396 {
9397 return (m_member_id == x.m_member_id &&
9398 m_member_flags == x.m_member_flags &&
9399 m_type_id == x.m_type_id &&
9400 m_label_seq == x.m_label_seq);
9401 }
9402
9407 eProsima_user_DllExport bool operator !=(
9408 const CommonUnionMember& x) const
9409 {
9410 return !(*this == x);
9411 }
9412
9417 eProsima_user_DllExport void member_id(
9418 MemberId _member_id)
9419 {
9420 m_member_id = _member_id;
9421 }
9422
9427 eProsima_user_DllExport MemberId member_id() const
9428 {
9429 return m_member_id;
9430 }
9431
9436 eProsima_user_DllExport MemberId& member_id()
9437 {
9438 return m_member_id;
9439 }
9440
9441
9446 eProsima_user_DllExport void member_flags(
9447 const UnionMemberFlag& _member_flags)
9448 {
9449 m_member_flags = _member_flags;
9450 }
9451
9456 eProsima_user_DllExport void member_flags(
9457 UnionMemberFlag&& _member_flags)
9458 {
9459 m_member_flags = std::move(_member_flags);
9460 }
9461
9466 eProsima_user_DllExport const UnionMemberFlag& member_flags() const
9467 {
9468 return m_member_flags;
9469 }
9470
9475 eProsima_user_DllExport UnionMemberFlag& member_flags()
9476 {
9477 return m_member_flags;
9478 }
9479
9480
9485 eProsima_user_DllExport void type_id(
9486 const TypeIdentifier& _type_id)
9487 {
9488 m_type_id = _type_id;
9489 }
9490
9495 eProsima_user_DllExport void type_id(
9496 TypeIdentifier&& _type_id)
9497 {
9498 m_type_id = std::move(_type_id);
9499 }
9500
9505 eProsima_user_DllExport const TypeIdentifier& type_id() const
9506 {
9507 return m_type_id;
9508 }
9509
9514 eProsima_user_DllExport TypeIdentifier& type_id()
9515 {
9516 return m_type_id;
9517 }
9518
9519
9524 eProsima_user_DllExport void label_seq(
9525 const UnionCaseLabelSeq& _label_seq)
9526 {
9527 m_label_seq = _label_seq;
9528 }
9529
9534 eProsima_user_DllExport void label_seq(
9535 UnionCaseLabelSeq&& _label_seq)
9536 {
9537 m_label_seq = std::move(_label_seq);
9538 }
9539
9544 eProsima_user_DllExport const UnionCaseLabelSeq& label_seq() const
9545 {
9546 return m_label_seq;
9547 }
9548
9553 eProsima_user_DllExport UnionCaseLabelSeq& label_seq()
9554 {
9555 return m_label_seq;
9556 }
9557
9558
9559
9560 private:
9561
9562 MemberId m_member_id{0};
9563 UnionMemberFlag m_member_flags{0};
9564 TypeIdentifier m_type_id;
9565 UnionCaseLabelSeq m_label_seq;
9566
9567};
9568
9572 class CompleteUnionMember
9573{
9574 public:
9575
9579 eProsima_user_DllExport CompleteUnionMember()
9580 {
9581 }
9582
9586 eProsima_user_DllExport ~CompleteUnionMember()
9587 {
9588 }
9589
9594 eProsima_user_DllExport CompleteUnionMember(
9595 const CompleteUnionMember& x)
9596 {
9597 m_common = x.m_common;
9598
9599 m_detail = x.m_detail;
9600
9601 }
9602
9607 eProsima_user_DllExport CompleteUnionMember(
9608 CompleteUnionMember&& x) noexcept
9609 {
9610 m_common = std::move(x.m_common);
9611 m_detail = std::move(x.m_detail);
9612 }
9613
9618 eProsima_user_DllExport CompleteUnionMember& operator =(
9619 const CompleteUnionMember& x)
9620 {
9621
9622 m_common = x.m_common;
9623
9624 m_detail = x.m_detail;
9625
9626 return *this;
9627 }
9628
9633 eProsima_user_DllExport CompleteUnionMember& operator =(
9634 CompleteUnionMember&& x) noexcept
9635 {
9636
9637 m_common = std::move(x.m_common);
9638 m_detail = std::move(x.m_detail);
9639 return *this;
9640 }
9641
9646 eProsima_user_DllExport bool operator ==(
9647 const CompleteUnionMember& x) const
9648 {
9649 return (m_common == x.m_common &&
9650 m_detail == x.m_detail);
9651 }
9652
9657 eProsima_user_DllExport bool operator !=(
9658 const CompleteUnionMember& x) const
9659 {
9660 return !(*this == x);
9661 }
9662
9667 eProsima_user_DllExport void common(
9668 const CommonUnionMember& _common)
9669 {
9670 m_common = _common;
9671 }
9672
9677 eProsima_user_DllExport void common(
9678 CommonUnionMember&& _common)
9679 {
9680 m_common = std::move(_common);
9681 }
9682
9687 eProsima_user_DllExport const CommonUnionMember& common() const
9688 {
9689 return m_common;
9690 }
9691
9696 eProsima_user_DllExport CommonUnionMember& common()
9697 {
9698 return m_common;
9699 }
9700
9701
9706 eProsima_user_DllExport void detail(
9707 const CompleteMemberDetail& _detail)
9708 {
9709 m_detail = _detail;
9710 }
9711
9716 eProsima_user_DllExport void detail(
9717 CompleteMemberDetail&& _detail)
9718 {
9719 m_detail = std::move(_detail);
9720 }
9721
9726 eProsima_user_DllExport const CompleteMemberDetail& detail() const
9727 {
9728 return m_detail;
9729 }
9730
9735 eProsima_user_DllExport CompleteMemberDetail& detail()
9736 {
9737 return m_detail;
9738 }
9739
9740
9741
9742 private:
9743
9744 CommonUnionMember m_common;
9745 CompleteMemberDetail m_detail;
9746
9747};
9748 typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
9749
9754 class MinimalUnionMember
9755{
9756 public:
9757
9761 eProsima_user_DllExport MinimalUnionMember()
9762 {
9763 }
9764
9768 eProsima_user_DllExport ~MinimalUnionMember()
9769 {
9770 }
9771
9776 eProsima_user_DllExport MinimalUnionMember(
9777 const MinimalUnionMember& x)
9778 {
9779 m_common = x.m_common;
9780
9781 m_detail = x.m_detail;
9782
9783 }
9784
9789 eProsima_user_DllExport MinimalUnionMember(
9790 MinimalUnionMember&& x) noexcept
9791 {
9792 m_common = std::move(x.m_common);
9793 m_detail = std::move(x.m_detail);
9794 }
9795
9800 eProsima_user_DllExport MinimalUnionMember& operator =(
9801 const MinimalUnionMember& x)
9802 {
9803
9804 m_common = x.m_common;
9805
9806 m_detail = x.m_detail;
9807
9808 return *this;
9809 }
9810
9815 eProsima_user_DllExport MinimalUnionMember& operator =(
9816 MinimalUnionMember&& x) noexcept
9817 {
9818
9819 m_common = std::move(x.m_common);
9820 m_detail = std::move(x.m_detail);
9821 return *this;
9822 }
9823
9828 eProsima_user_DllExport bool operator ==(
9829 const MinimalUnionMember& x) const
9830 {
9831 return (m_common == x.m_common &&
9832 m_detail == x.m_detail);
9833 }
9834
9839 eProsima_user_DllExport bool operator !=(
9840 const MinimalUnionMember& x) const
9841 {
9842 return !(*this == x);
9843 }
9844
9849 eProsima_user_DllExport void common(
9850 const CommonUnionMember& _common)
9851 {
9852 m_common = _common;
9853 }
9854
9859 eProsima_user_DllExport void common(
9860 CommonUnionMember&& _common)
9861 {
9862 m_common = std::move(_common);
9863 }
9864
9869 eProsima_user_DllExport const CommonUnionMember& common() const
9870 {
9871 return m_common;
9872 }
9873
9878 eProsima_user_DllExport CommonUnionMember& common()
9879 {
9880 return m_common;
9881 }
9882
9883
9888 eProsima_user_DllExport void detail(
9889 const MinimalMemberDetail& _detail)
9890 {
9891 m_detail = _detail;
9892 }
9893
9898 eProsima_user_DllExport void detail(
9899 MinimalMemberDetail&& _detail)
9900 {
9901 m_detail = std::move(_detail);
9902 }
9903
9908 eProsima_user_DllExport const MinimalMemberDetail& detail() const
9909 {
9910 return m_detail;
9911 }
9912
9917 eProsima_user_DllExport MinimalMemberDetail& detail()
9918 {
9919 return m_detail;
9920 }
9921
9922
9923
9924 private:
9925
9926 CommonUnionMember m_common;
9927 MinimalMemberDetail m_detail;
9928
9929};
9930 typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
9931
9936 class CommonDiscriminatorMember
9937{
9938 public:
9939
9943 eProsima_user_DllExport CommonDiscriminatorMember()
9944 {
9945 }
9946
9950 eProsima_user_DllExport ~CommonDiscriminatorMember()
9951 {
9952 }
9953
9958 eProsima_user_DllExport CommonDiscriminatorMember(
9959 const CommonDiscriminatorMember& x)
9960 {
9961 m_member_flags = x.m_member_flags;
9962
9963 m_type_id = x.m_type_id;
9964
9965 }
9966
9971 eProsima_user_DllExport CommonDiscriminatorMember(
9972 CommonDiscriminatorMember&& x) noexcept
9973 {
9974 m_member_flags = std::move(x.m_member_flags);
9975 m_type_id = std::move(x.m_type_id);
9976 }
9977
9982 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9983 const CommonDiscriminatorMember& x)
9984 {
9985
9986 m_member_flags = x.m_member_flags;
9987
9988 m_type_id = x.m_type_id;
9989
9990 return *this;
9991 }
9992
9997 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9998 CommonDiscriminatorMember&& x) noexcept
9999 {
10000
10001 m_member_flags = std::move(x.m_member_flags);
10002 m_type_id = std::move(x.m_type_id);
10003 return *this;
10004 }
10005
10010 eProsima_user_DllExport bool operator ==(
10011 const CommonDiscriminatorMember& x) const
10012 {
10013 return (m_member_flags == x.m_member_flags &&
10014 m_type_id == x.m_type_id);
10015 }
10016
10021 eProsima_user_DllExport bool operator !=(
10022 const CommonDiscriminatorMember& x) const
10023 {
10024 return !(*this == x);
10025 }
10026
10031 eProsima_user_DllExport void member_flags(
10032 const UnionDiscriminatorFlag& _member_flags)
10033 {
10034 m_member_flags = _member_flags;
10035 }
10036
10041 eProsima_user_DllExport void member_flags(
10042 UnionDiscriminatorFlag&& _member_flags)
10043 {
10044 m_member_flags = std::move(_member_flags);
10045 }
10046
10051 eProsima_user_DllExport const UnionDiscriminatorFlag& member_flags() const
10052 {
10053 return m_member_flags;
10054 }
10055
10060 eProsima_user_DllExport UnionDiscriminatorFlag& member_flags()
10061 {
10062 return m_member_flags;
10063 }
10064
10065
10070 eProsima_user_DllExport void type_id(
10071 const TypeIdentifier& _type_id)
10072 {
10073 m_type_id = _type_id;
10074 }
10075
10080 eProsima_user_DllExport void type_id(
10081 TypeIdentifier&& _type_id)
10082 {
10083 m_type_id = std::move(_type_id);
10084 }
10085
10090 eProsima_user_DllExport const TypeIdentifier& type_id() const
10091 {
10092 return m_type_id;
10093 }
10094
10099 eProsima_user_DllExport TypeIdentifier& type_id()
10100 {
10101 return m_type_id;
10102 }
10103
10104
10105
10106 private:
10107
10108 UnionDiscriminatorFlag m_member_flags{0};
10109 TypeIdentifier m_type_id;
10110
10111};
10112
10116 class CompleteDiscriminatorMember
10117{
10118 public:
10119
10123 eProsima_user_DllExport CompleteDiscriminatorMember()
10124 {
10125 }
10126
10130 eProsima_user_DllExport ~CompleteDiscriminatorMember()
10131 {
10132 }
10133
10138 eProsima_user_DllExport CompleteDiscriminatorMember(
10139 const CompleteDiscriminatorMember& x)
10140 {
10141 m_common = x.m_common;
10142
10143 m_ann_builtin = x.m_ann_builtin;
10144
10145 m_ann_custom = x.m_ann_custom;
10146
10147 }
10148
10153 eProsima_user_DllExport CompleteDiscriminatorMember(
10154 CompleteDiscriminatorMember&& x) noexcept
10155 {
10156 m_common = std::move(x.m_common);
10157 m_ann_builtin = std::move(x.m_ann_builtin);
10158 m_ann_custom = std::move(x.m_ann_custom);
10159 }
10160
10165 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10166 const CompleteDiscriminatorMember& x)
10167 {
10168
10169 m_common = x.m_common;
10170
10171 m_ann_builtin = x.m_ann_builtin;
10172
10173 m_ann_custom = x.m_ann_custom;
10174
10175 return *this;
10176 }
10177
10182 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10183 CompleteDiscriminatorMember&& x) noexcept
10184 {
10185
10186 m_common = std::move(x.m_common);
10187 m_ann_builtin = std::move(x.m_ann_builtin);
10188 m_ann_custom = std::move(x.m_ann_custom);
10189 return *this;
10190 }
10191
10196 eProsima_user_DllExport bool operator ==(
10197 const CompleteDiscriminatorMember& x) const
10198 {
10199 return (m_common == x.m_common &&
10200 m_ann_builtin == x.m_ann_builtin &&
10201 m_ann_custom == x.m_ann_custom);
10202 }
10203
10208 eProsima_user_DllExport bool operator !=(
10209 const CompleteDiscriminatorMember& x) const
10210 {
10211 return !(*this == x);
10212 }
10213
10218 eProsima_user_DllExport void common(
10219 const CommonDiscriminatorMember& _common)
10220 {
10221 m_common = _common;
10222 }
10223
10228 eProsima_user_DllExport void common(
10229 CommonDiscriminatorMember&& _common)
10230 {
10231 m_common = std::move(_common);
10232 }
10233
10238 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10239 {
10240 return m_common;
10241 }
10242
10247 eProsima_user_DllExport CommonDiscriminatorMember& common()
10248 {
10249 return m_common;
10250 }
10251
10252
10257 eProsima_user_DllExport void ann_builtin(
10258 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
10259 {
10260 m_ann_builtin = _ann_builtin;
10261 }
10262
10267 eProsima_user_DllExport void ann_builtin(
10268 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
10269 {
10270 m_ann_builtin = std::move(_ann_builtin);
10271 }
10272
10277 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
10278 {
10279 return m_ann_builtin;
10280 }
10281
10286 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
10287 {
10288 return m_ann_builtin;
10289 }
10290
10291
10296 eProsima_user_DllExport void ann_custom(
10297 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
10298 {
10299 m_ann_custom = _ann_custom;
10300 }
10301
10306 eProsima_user_DllExport void ann_custom(
10307 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
10308 {
10309 m_ann_custom = std::move(_ann_custom);
10310 }
10311
10316 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
10317 {
10318 return m_ann_custom;
10319 }
10320
10325 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
10326 {
10327 return m_ann_custom;
10328 }
10329
10330
10331
10332 private:
10333
10334 CommonDiscriminatorMember m_common;
10335 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
10336 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
10337
10338};
10339
10343 class MinimalDiscriminatorMember
10344{
10345 public:
10346
10350 eProsima_user_DllExport MinimalDiscriminatorMember()
10351 {
10352 }
10353
10357 eProsima_user_DllExport ~MinimalDiscriminatorMember()
10358 {
10359 }
10360
10365 eProsima_user_DllExport MinimalDiscriminatorMember(
10366 const MinimalDiscriminatorMember& x)
10367 {
10368 m_common = x.m_common;
10369
10370 }
10371
10376 eProsima_user_DllExport MinimalDiscriminatorMember(
10377 MinimalDiscriminatorMember&& x) noexcept
10378 {
10379 m_common = std::move(x.m_common);
10380 }
10381
10386 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10387 const MinimalDiscriminatorMember& x)
10388 {
10389
10390 m_common = x.m_common;
10391
10392 return *this;
10393 }
10394
10399 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10400 MinimalDiscriminatorMember&& x) noexcept
10401 {
10402
10403 m_common = std::move(x.m_common);
10404 return *this;
10405 }
10406
10411 eProsima_user_DllExport bool operator ==(
10412 const MinimalDiscriminatorMember& x) const
10413 {
10414 return (m_common == x.m_common);
10415 }
10416
10421 eProsima_user_DllExport bool operator !=(
10422 const MinimalDiscriminatorMember& x) const
10423 {
10424 return !(*this == x);
10425 }
10426
10431 eProsima_user_DllExport void common(
10432 const CommonDiscriminatorMember& _common)
10433 {
10434 m_common = _common;
10435 }
10436
10441 eProsima_user_DllExport void common(
10442 CommonDiscriminatorMember&& _common)
10443 {
10444 m_common = std::move(_common);
10445 }
10446
10451 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10452 {
10453 return m_common;
10454 }
10455
10460 eProsima_user_DllExport CommonDiscriminatorMember& common()
10461 {
10462 return m_common;
10463 }
10464
10465
10466
10467 private:
10468
10469 CommonDiscriminatorMember m_common;
10470
10471};
10472
10476 class CompleteUnionHeader
10477{
10478 public:
10479
10483 eProsima_user_DllExport CompleteUnionHeader()
10484 {
10485 }
10486
10490 eProsima_user_DllExport ~CompleteUnionHeader()
10491 {
10492 }
10493
10498 eProsima_user_DllExport CompleteUnionHeader(
10499 const CompleteUnionHeader& x)
10500 {
10501 m_detail = x.m_detail;
10502
10503 }
10504
10509 eProsima_user_DllExport CompleteUnionHeader(
10510 CompleteUnionHeader&& x) noexcept
10511 {
10512 m_detail = std::move(x.m_detail);
10513 }
10514
10519 eProsima_user_DllExport CompleteUnionHeader& operator =(
10520 const CompleteUnionHeader& x)
10521 {
10522
10523 m_detail = x.m_detail;
10524
10525 return *this;
10526 }
10527
10532 eProsima_user_DllExport CompleteUnionHeader& operator =(
10533 CompleteUnionHeader&& x) noexcept
10534 {
10535
10536 m_detail = std::move(x.m_detail);
10537 return *this;
10538 }
10539
10544 eProsima_user_DllExport bool operator ==(
10545 const CompleteUnionHeader& x) const
10546 {
10547 return (m_detail == x.m_detail);
10548 }
10549
10554 eProsima_user_DllExport bool operator !=(
10555 const CompleteUnionHeader& x) const
10556 {
10557 return !(*this == x);
10558 }
10559
10564 eProsima_user_DllExport void detail(
10565 const CompleteTypeDetail& _detail)
10566 {
10567 m_detail = _detail;
10568 }
10569
10574 eProsima_user_DllExport void detail(
10575 CompleteTypeDetail&& _detail)
10576 {
10577 m_detail = std::move(_detail);
10578 }
10579
10584 eProsima_user_DllExport const CompleteTypeDetail& detail() const
10585 {
10586 return m_detail;
10587 }
10588
10593 eProsima_user_DllExport CompleteTypeDetail& detail()
10594 {
10595 return m_detail;
10596 }
10597
10598
10599
10600 private:
10601
10602 CompleteTypeDetail m_detail;
10603
10604};
10605
10609 class MinimalUnionHeader
10610{
10611 public:
10612
10616 eProsima_user_DllExport MinimalUnionHeader()
10617 {
10618 }
10619
10623 eProsima_user_DllExport ~MinimalUnionHeader()
10624 {
10625 }
10626
10631 eProsima_user_DllExport MinimalUnionHeader(
10632 const MinimalUnionHeader& x)
10633 {
10634 m_detail = x.m_detail;
10635
10636 }
10637
10642 eProsima_user_DllExport MinimalUnionHeader(
10643 MinimalUnionHeader&& x) noexcept
10644 {
10645 m_detail = std::move(x.m_detail);
10646 }
10647
10652 eProsima_user_DllExport MinimalUnionHeader& operator =(
10653 const MinimalUnionHeader& x)
10654 {
10655
10656 m_detail = x.m_detail;
10657
10658 return *this;
10659 }
10660
10665 eProsima_user_DllExport MinimalUnionHeader& operator =(
10666 MinimalUnionHeader&& x) noexcept
10667 {
10668
10669 m_detail = std::move(x.m_detail);
10670 return *this;
10671 }
10672
10677 eProsima_user_DllExport bool operator ==(
10678 const MinimalUnionHeader& x) const
10679 {
10680 return (m_detail == x.m_detail);
10681 }
10682
10687 eProsima_user_DllExport bool operator !=(
10688 const MinimalUnionHeader& x) const
10689 {
10690 return !(*this == x);
10691 }
10692
10697 eProsima_user_DllExport void detail(
10698 const MinimalTypeDetail& _detail)
10699 {
10700 m_detail = _detail;
10701 }
10702
10707 eProsima_user_DllExport void detail(
10708 MinimalTypeDetail&& _detail)
10709 {
10710 m_detail = std::move(_detail);
10711 }
10712
10717 eProsima_user_DllExport const MinimalTypeDetail& detail() const
10718 {
10719 return m_detail;
10720 }
10721
10726 eProsima_user_DllExport MinimalTypeDetail& detail()
10727 {
10728 return m_detail;
10729 }
10730
10731
10732
10733 private:
10734
10735 MinimalTypeDetail m_detail;
10736
10737};
10738
10742 class CompleteUnionType
10743{
10744 public:
10745
10749 eProsima_user_DllExport CompleteUnionType()
10750 {
10751 }
10752
10756 eProsima_user_DllExport ~CompleteUnionType()
10757 {
10758 }
10759
10764 eProsima_user_DllExport CompleteUnionType(
10765 const CompleteUnionType& x)
10766 {
10767 m_union_flags = x.m_union_flags;
10768
10769 m_header = x.m_header;
10770
10771 m_discriminator = x.m_discriminator;
10772
10773 m_member_seq = x.m_member_seq;
10774
10775 }
10776
10781 eProsima_user_DllExport CompleteUnionType(
10782 CompleteUnionType&& x) noexcept
10783 {
10784 m_union_flags = std::move(x.m_union_flags);
10785 m_header = std::move(x.m_header);
10786 m_discriminator = std::move(x.m_discriminator);
10787 m_member_seq = std::move(x.m_member_seq);
10788 }
10789
10794 eProsima_user_DllExport CompleteUnionType& operator =(
10795 const CompleteUnionType& x)
10796 {
10797
10798 m_union_flags = x.m_union_flags;
10799
10800 m_header = x.m_header;
10801
10802 m_discriminator = x.m_discriminator;
10803
10804 m_member_seq = x.m_member_seq;
10805
10806 return *this;
10807 }
10808
10813 eProsima_user_DllExport CompleteUnionType& operator =(
10814 CompleteUnionType&& x) noexcept
10815 {
10816
10817 m_union_flags = std::move(x.m_union_flags);
10818 m_header = std::move(x.m_header);
10819 m_discriminator = std::move(x.m_discriminator);
10820 m_member_seq = std::move(x.m_member_seq);
10821 return *this;
10822 }
10823
10828 eProsima_user_DllExport bool operator ==(
10829 const CompleteUnionType& x) const
10830 {
10831 return (m_union_flags == x.m_union_flags &&
10832 m_header == x.m_header &&
10833 m_discriminator == x.m_discriminator &&
10834 m_member_seq == x.m_member_seq);
10835 }
10836
10841 eProsima_user_DllExport bool operator !=(
10842 const CompleteUnionType& x) const
10843 {
10844 return !(*this == x);
10845 }
10846
10851 eProsima_user_DllExport void union_flags(
10852 const UnionTypeFlag& _union_flags)
10853 {
10854 m_union_flags = _union_flags;
10855 }
10856
10861 eProsima_user_DllExport void union_flags(
10862 UnionTypeFlag&& _union_flags)
10863 {
10864 m_union_flags = std::move(_union_flags);
10865 }
10866
10871 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
10872 {
10873 return m_union_flags;
10874 }
10875
10880 eProsima_user_DllExport UnionTypeFlag& union_flags()
10881 {
10882 return m_union_flags;
10883 }
10884
10885
10890 eProsima_user_DllExport void header(
10891 const CompleteUnionHeader& _header)
10892 {
10893 m_header = _header;
10894 }
10895
10900 eProsima_user_DllExport void header(
10901 CompleteUnionHeader&& _header)
10902 {
10903 m_header = std::move(_header);
10904 }
10905
10910 eProsima_user_DllExport const CompleteUnionHeader& header() const
10911 {
10912 return m_header;
10913 }
10914
10919 eProsima_user_DllExport CompleteUnionHeader& header()
10920 {
10921 return m_header;
10922 }
10923
10924
10929 eProsima_user_DllExport void discriminator(
10930 const CompleteDiscriminatorMember& _discriminator)
10931 {
10932 m_discriminator = _discriminator;
10933 }
10934
10939 eProsima_user_DllExport void discriminator(
10940 CompleteDiscriminatorMember&& _discriminator)
10941 {
10942 m_discriminator = std::move(_discriminator);
10943 }
10944
10949 eProsima_user_DllExport const CompleteDiscriminatorMember& discriminator() const
10950 {
10951 return m_discriminator;
10952 }
10953
10958 eProsima_user_DllExport CompleteDiscriminatorMember& discriminator()
10959 {
10960 return m_discriminator;
10961 }
10962
10963
10968 eProsima_user_DllExport void member_seq(
10969 const CompleteUnionMemberSeq& _member_seq)
10970 {
10971 m_member_seq = _member_seq;
10972 }
10973
10978 eProsima_user_DllExport void member_seq(
10979 CompleteUnionMemberSeq&& _member_seq)
10980 {
10981 m_member_seq = std::move(_member_seq);
10982 }
10983
10988 eProsima_user_DllExport const CompleteUnionMemberSeq& member_seq() const
10989 {
10990 return m_member_seq;
10991 }
10992
10997 eProsima_user_DllExport CompleteUnionMemberSeq& member_seq()
10998 {
10999 return m_member_seq;
11000 }
11001
11002
11003
11004 private:
11005
11006 UnionTypeFlag m_union_flags{0};
11007 CompleteUnionHeader m_header;
11008 CompleteDiscriminatorMember m_discriminator;
11009 CompleteUnionMemberSeq m_member_seq;
11010
11011};
11012
11016 class MinimalUnionType
11017{
11018 public:
11019
11023 eProsima_user_DllExport MinimalUnionType()
11024 {
11025 }
11026
11030 eProsima_user_DllExport ~MinimalUnionType()
11031 {
11032 }
11033
11038 eProsima_user_DllExport MinimalUnionType(
11039 const MinimalUnionType& x)
11040 {
11041 m_union_flags = x.m_union_flags;
11042
11043 m_header = x.m_header;
11044
11045 m_discriminator = x.m_discriminator;
11046
11047 m_member_seq = x.m_member_seq;
11048
11049 }
11050
11055 eProsima_user_DllExport MinimalUnionType(
11056 MinimalUnionType&& x) noexcept
11057 {
11058 m_union_flags = std::move(x.m_union_flags);
11059 m_header = std::move(x.m_header);
11060 m_discriminator = std::move(x.m_discriminator);
11061 m_member_seq = std::move(x.m_member_seq);
11062 }
11063
11068 eProsima_user_DllExport MinimalUnionType& operator =(
11069 const MinimalUnionType& x)
11070 {
11071
11072 m_union_flags = x.m_union_flags;
11073
11074 m_header = x.m_header;
11075
11076 m_discriminator = x.m_discriminator;
11077
11078 m_member_seq = x.m_member_seq;
11079
11080 return *this;
11081 }
11082
11087 eProsima_user_DllExport MinimalUnionType& operator =(
11088 MinimalUnionType&& x) noexcept
11089 {
11090
11091 m_union_flags = std::move(x.m_union_flags);
11092 m_header = std::move(x.m_header);
11093 m_discriminator = std::move(x.m_discriminator);
11094 m_member_seq = std::move(x.m_member_seq);
11095 return *this;
11096 }
11097
11102 eProsima_user_DllExport bool operator ==(
11103 const MinimalUnionType& x) const
11104 {
11105 return (m_union_flags == x.m_union_flags &&
11106 m_header == x.m_header &&
11107 m_discriminator == x.m_discriminator &&
11108 m_member_seq == x.m_member_seq);
11109 }
11110
11115 eProsima_user_DllExport bool operator !=(
11116 const MinimalUnionType& x) const
11117 {
11118 return !(*this == x);
11119 }
11120
11125 eProsima_user_DllExport void union_flags(
11126 const UnionTypeFlag& _union_flags)
11127 {
11128 m_union_flags = _union_flags;
11129 }
11130
11135 eProsima_user_DllExport void union_flags(
11136 UnionTypeFlag&& _union_flags)
11137 {
11138 m_union_flags = std::move(_union_flags);
11139 }
11140
11145 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
11146 {
11147 return m_union_flags;
11148 }
11149
11154 eProsima_user_DllExport UnionTypeFlag& union_flags()
11155 {
11156 return m_union_flags;
11157 }
11158
11159
11164 eProsima_user_DllExport void header(
11165 const MinimalUnionHeader& _header)
11166 {
11167 m_header = _header;
11168 }
11169
11174 eProsima_user_DllExport void header(
11175 MinimalUnionHeader&& _header)
11176 {
11177 m_header = std::move(_header);
11178 }
11179
11184 eProsima_user_DllExport const MinimalUnionHeader& header() const
11185 {
11186 return m_header;
11187 }
11188
11193 eProsima_user_DllExport MinimalUnionHeader& header()
11194 {
11195 return m_header;
11196 }
11197
11198
11203 eProsima_user_DllExport void discriminator(
11204 const MinimalDiscriminatorMember& _discriminator)
11205 {
11206 m_discriminator = _discriminator;
11207 }
11208
11213 eProsima_user_DllExport void discriminator(
11214 MinimalDiscriminatorMember&& _discriminator)
11215 {
11216 m_discriminator = std::move(_discriminator);
11217 }
11218
11223 eProsima_user_DllExport const MinimalDiscriminatorMember& discriminator() const
11224 {
11225 return m_discriminator;
11226 }
11227
11232 eProsima_user_DllExport MinimalDiscriminatorMember& discriminator()
11233 {
11234 return m_discriminator;
11235 }
11236
11237
11242 eProsima_user_DllExport void member_seq(
11243 const MinimalUnionMemberSeq& _member_seq)
11244 {
11245 m_member_seq = _member_seq;
11246 }
11247
11252 eProsima_user_DllExport void member_seq(
11253 MinimalUnionMemberSeq&& _member_seq)
11254 {
11255 m_member_seq = std::move(_member_seq);
11256 }
11257
11262 eProsima_user_DllExport const MinimalUnionMemberSeq& member_seq() const
11263 {
11264 return m_member_seq;
11265 }
11266
11271 eProsima_user_DllExport MinimalUnionMemberSeq& member_seq()
11272 {
11273 return m_member_seq;
11274 }
11275
11276
11277
11278 private:
11279
11280 UnionTypeFlag m_union_flags{0};
11281 MinimalUnionHeader m_header;
11282 MinimalDiscriminatorMember m_discriminator;
11283 MinimalUnionMemberSeq m_member_seq;
11284
11285};
11286
11290 class CommonAnnotationParameter
11291{
11292 public:
11293
11297 eProsima_user_DllExport CommonAnnotationParameter()
11298 {
11299 }
11300
11304 eProsima_user_DllExport ~CommonAnnotationParameter()
11305 {
11306 }
11307
11312 eProsima_user_DllExport CommonAnnotationParameter(
11313 const CommonAnnotationParameter& x)
11314 {
11315 m_member_flags = x.m_member_flags;
11316
11317 m_member_type_id = x.m_member_type_id;
11318
11319 }
11320
11325 eProsima_user_DllExport CommonAnnotationParameter(
11326 CommonAnnotationParameter&& x) noexcept
11327 {
11328 m_member_flags = std::move(x.m_member_flags);
11329 m_member_type_id = std::move(x.m_member_type_id);
11330 }
11331
11336 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11337 const CommonAnnotationParameter& x)
11338 {
11339
11340 m_member_flags = x.m_member_flags;
11341
11342 m_member_type_id = x.m_member_type_id;
11343
11344 return *this;
11345 }
11346
11351 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11352 CommonAnnotationParameter&& x) noexcept
11353 {
11354
11355 m_member_flags = std::move(x.m_member_flags);
11356 m_member_type_id = std::move(x.m_member_type_id);
11357 return *this;
11358 }
11359
11364 eProsima_user_DllExport bool operator ==(
11365 const CommonAnnotationParameter& x) const
11366 {
11367 return (m_member_flags == x.m_member_flags &&
11368 m_member_type_id == x.m_member_type_id);
11369 }
11370
11375 eProsima_user_DllExport bool operator !=(
11376 const CommonAnnotationParameter& x) const
11377 {
11378 return !(*this == x);
11379 }
11380
11385 eProsima_user_DllExport void member_flags(
11386 const AnnotationParameterFlag& _member_flags)
11387 {
11388 m_member_flags = _member_flags;
11389 }
11390
11395 eProsima_user_DllExport void member_flags(
11396 AnnotationParameterFlag&& _member_flags)
11397 {
11398 m_member_flags = std::move(_member_flags);
11399 }
11400
11405 eProsima_user_DllExport const AnnotationParameterFlag& member_flags() const
11406 {
11407 return m_member_flags;
11408 }
11409
11414 eProsima_user_DllExport AnnotationParameterFlag& member_flags()
11415 {
11416 return m_member_flags;
11417 }
11418
11419
11424 eProsima_user_DllExport void member_type_id(
11425 const TypeIdentifier& _member_type_id)
11426 {
11427 m_member_type_id = _member_type_id;
11428 }
11429
11434 eProsima_user_DllExport void member_type_id(
11435 TypeIdentifier&& _member_type_id)
11436 {
11437 m_member_type_id = std::move(_member_type_id);
11438 }
11439
11444 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
11445 {
11446 return m_member_type_id;
11447 }
11448
11453 eProsima_user_DllExport TypeIdentifier& member_type_id()
11454 {
11455 return m_member_type_id;
11456 }
11457
11458
11459
11460 private:
11461
11462 AnnotationParameterFlag m_member_flags{0};
11463 TypeIdentifier m_member_type_id;
11464
11465};
11466
11470 class CompleteAnnotationParameter
11471{
11472 public:
11473
11477 eProsima_user_DllExport CompleteAnnotationParameter()
11478 {
11479 }
11480
11484 eProsima_user_DllExport ~CompleteAnnotationParameter()
11485 {
11486 }
11487
11492 eProsima_user_DllExport CompleteAnnotationParameter(
11493 const CompleteAnnotationParameter& x)
11494 {
11495 m_common = x.m_common;
11496
11497 m_name = x.m_name;
11498
11499 m_default_value = x.m_default_value;
11500
11501 }
11502
11507 eProsima_user_DllExport CompleteAnnotationParameter(
11508 CompleteAnnotationParameter&& x) noexcept
11509 {
11510 m_common = std::move(x.m_common);
11511 m_name = std::move(x.m_name);
11512 m_default_value = std::move(x.m_default_value);
11513 }
11514
11519 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11520 const CompleteAnnotationParameter& x)
11521 {
11522
11523 m_common = x.m_common;
11524
11525 m_name = x.m_name;
11526
11527 m_default_value = x.m_default_value;
11528
11529 return *this;
11530 }
11531
11536 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11537 CompleteAnnotationParameter&& x) noexcept
11538 {
11539
11540 m_common = std::move(x.m_common);
11541 m_name = std::move(x.m_name);
11542 m_default_value = std::move(x.m_default_value);
11543 return *this;
11544 }
11545
11550 eProsima_user_DllExport bool operator ==(
11551 const CompleteAnnotationParameter& x) const
11552 {
11553 return (m_common == x.m_common &&
11554 m_name == x.m_name &&
11555 m_default_value == x.m_default_value);
11556 }
11557
11562 eProsima_user_DllExport bool operator !=(
11563 const CompleteAnnotationParameter& x) const
11564 {
11565 return !(*this == x);
11566 }
11567
11572 eProsima_user_DllExport void common(
11573 const CommonAnnotationParameter& _common)
11574 {
11575 m_common = _common;
11576 }
11577
11582 eProsima_user_DllExport void common(
11583 CommonAnnotationParameter&& _common)
11584 {
11585 m_common = std::move(_common);
11586 }
11587
11592 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11593 {
11594 return m_common;
11595 }
11596
11601 eProsima_user_DllExport CommonAnnotationParameter& common()
11602 {
11603 return m_common;
11604 }
11605
11606
11611 eProsima_user_DllExport void name(
11612 const MemberName& _name)
11613 {
11614 m_name = _name;
11615 }
11616
11621 eProsima_user_DllExport void name(
11622 MemberName&& _name)
11623 {
11624 m_name = std::move(_name);
11625 }
11626
11631 eProsima_user_DllExport const MemberName& name() const
11632 {
11633 return m_name;
11634 }
11635
11640 eProsima_user_DllExport MemberName& name()
11641 {
11642 return m_name;
11643 }
11644
11645
11650 eProsima_user_DllExport void default_value(
11651 const AnnotationParameterValue& _default_value)
11652 {
11653 m_default_value = _default_value;
11654 }
11655
11660 eProsima_user_DllExport void default_value(
11661 AnnotationParameterValue&& _default_value)
11662 {
11663 m_default_value = std::move(_default_value);
11664 }
11665
11670 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11671 {
11672 return m_default_value;
11673 }
11674
11679 eProsima_user_DllExport AnnotationParameterValue& default_value()
11680 {
11681 return m_default_value;
11682 }
11683
11684
11685
11686 private:
11687
11688 CommonAnnotationParameter m_common;
11689 MemberName m_name;
11690 AnnotationParameterValue m_default_value;
11691
11692};
11693 typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
11694
11699 class MinimalAnnotationParameter
11700{
11701 public:
11702
11706 eProsima_user_DllExport MinimalAnnotationParameter()
11707 {
11708 }
11709
11713 eProsima_user_DllExport ~MinimalAnnotationParameter()
11714 {
11715 }
11716
11721 eProsima_user_DllExport MinimalAnnotationParameter(
11722 const MinimalAnnotationParameter& x)
11723 {
11724 m_common = x.m_common;
11725
11726 m_name_hash = x.m_name_hash;
11727
11728 m_default_value = x.m_default_value;
11729
11730 }
11731
11736 eProsima_user_DllExport MinimalAnnotationParameter(
11737 MinimalAnnotationParameter&& x) noexcept
11738 {
11739 m_common = std::move(x.m_common);
11740 m_name_hash = std::move(x.m_name_hash);
11741 m_default_value = std::move(x.m_default_value);
11742 }
11743
11748 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11749 const MinimalAnnotationParameter& x)
11750 {
11751
11752 m_common = x.m_common;
11753
11754 m_name_hash = x.m_name_hash;
11755
11756 m_default_value = x.m_default_value;
11757
11758 return *this;
11759 }
11760
11765 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11766 MinimalAnnotationParameter&& x) noexcept
11767 {
11768
11769 m_common = std::move(x.m_common);
11770 m_name_hash = std::move(x.m_name_hash);
11771 m_default_value = std::move(x.m_default_value);
11772 return *this;
11773 }
11774
11779 eProsima_user_DllExport bool operator ==(
11780 const MinimalAnnotationParameter& x) const
11781 {
11782 return (m_common == x.m_common &&
11783 m_name_hash == x.m_name_hash &&
11784 m_default_value == x.m_default_value);
11785 }
11786
11791 eProsima_user_DllExport bool operator !=(
11792 const MinimalAnnotationParameter& x) const
11793 {
11794 return !(*this == x);
11795 }
11796
11801 eProsima_user_DllExport void common(
11802 const CommonAnnotationParameter& _common)
11803 {
11804 m_common = _common;
11805 }
11806
11811 eProsima_user_DllExport void common(
11812 CommonAnnotationParameter&& _common)
11813 {
11814 m_common = std::move(_common);
11815 }
11816
11821 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11822 {
11823 return m_common;
11824 }
11825
11830 eProsima_user_DllExport CommonAnnotationParameter& common()
11831 {
11832 return m_common;
11833 }
11834
11835
11840 eProsima_user_DllExport void name_hash(
11841 const NameHash& _name_hash)
11842 {
11843 m_name_hash = _name_hash;
11844 }
11845
11850 eProsima_user_DllExport void name_hash(
11851 NameHash&& _name_hash)
11852 {
11853 m_name_hash = std::move(_name_hash);
11854 }
11855
11860 eProsima_user_DllExport const NameHash& name_hash() const
11861 {
11862 return m_name_hash;
11863 }
11864
11869 eProsima_user_DllExport NameHash& name_hash()
11870 {
11871 return m_name_hash;
11872 }
11873
11874
11879 eProsima_user_DllExport void default_value(
11880 const AnnotationParameterValue& _default_value)
11881 {
11882 m_default_value = _default_value;
11883 }
11884
11889 eProsima_user_DllExport void default_value(
11890 AnnotationParameterValue&& _default_value)
11891 {
11892 m_default_value = std::move(_default_value);
11893 }
11894
11899 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11900 {
11901 return m_default_value;
11902 }
11903
11908 eProsima_user_DllExport AnnotationParameterValue& default_value()
11909 {
11910 return m_default_value;
11911 }
11912
11913
11914
11915 private:
11916
11917 CommonAnnotationParameter m_common;
11918 NameHash m_name_hash{0};
11919 AnnotationParameterValue m_default_value;
11920
11921};
11922 typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
11923
11928 class CompleteAnnotationHeader
11929{
11930 public:
11931
11935 eProsima_user_DllExport CompleteAnnotationHeader()
11936 {
11937 }
11938
11942 eProsima_user_DllExport ~CompleteAnnotationHeader()
11943 {
11944 }
11945
11950 eProsima_user_DllExport CompleteAnnotationHeader(
11951 const CompleteAnnotationHeader& x)
11952 {
11953 m_annotation_name = x.m_annotation_name;
11954
11955 }
11956
11961 eProsima_user_DllExport CompleteAnnotationHeader(
11962 CompleteAnnotationHeader&& x) noexcept
11963 {
11964 m_annotation_name = std::move(x.m_annotation_name);
11965 }
11966
11971 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11972 const CompleteAnnotationHeader& x)
11973 {
11974
11975 m_annotation_name = x.m_annotation_name;
11976
11977 return *this;
11978 }
11979
11984 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11985 CompleteAnnotationHeader&& x) noexcept
11986 {
11987
11988 m_annotation_name = std::move(x.m_annotation_name);
11989 return *this;
11990 }
11991
11996 eProsima_user_DllExport bool operator ==(
11997 const CompleteAnnotationHeader& x) const
11998 {
11999 return (m_annotation_name == x.m_annotation_name);
12000 }
12001
12006 eProsima_user_DllExport bool operator !=(
12007 const CompleteAnnotationHeader& x) const
12008 {
12009 return !(*this == x);
12010 }
12011
12016 eProsima_user_DllExport void annotation_name(
12017 const QualifiedTypeName& _annotation_name)
12018 {
12019 m_annotation_name = _annotation_name;
12020 }
12021
12026 eProsima_user_DllExport void annotation_name(
12027 QualifiedTypeName&& _annotation_name)
12028 {
12029 m_annotation_name = std::move(_annotation_name);
12030 }
12031
12036 eProsima_user_DllExport const QualifiedTypeName& annotation_name() const
12037 {
12038 return m_annotation_name;
12039 }
12040
12045 eProsima_user_DllExport QualifiedTypeName& annotation_name()
12046 {
12047 return m_annotation_name;
12048 }
12049
12050
12051
12052 private:
12053
12054 QualifiedTypeName m_annotation_name;
12055
12056};
12057
12061 class MinimalAnnotationHeader
12062{
12063 public:
12064
12068 eProsima_user_DllExport MinimalAnnotationHeader()
12069 {
12070 }
12071
12075 eProsima_user_DllExport ~MinimalAnnotationHeader()
12076 {
12077 }
12078
12083 eProsima_user_DllExport MinimalAnnotationHeader(
12084 const MinimalAnnotationHeader& x)
12085 {
12086 static_cast<void>(x);
12087 }
12088
12093 eProsima_user_DllExport MinimalAnnotationHeader(
12094 MinimalAnnotationHeader&& x) noexcept
12095 {
12096 static_cast<void>(x);
12097 }
12098
12103 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12104 const MinimalAnnotationHeader& x)
12105 {
12106
12107 static_cast<void>(x);
12108
12109 return *this;
12110 }
12111
12116 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12117 MinimalAnnotationHeader&& x) noexcept
12118 {
12119
12120 static_cast<void>(x);
12121
12122 return *this;
12123 }
12124
12129 eProsima_user_DllExport bool operator ==(
12130 const MinimalAnnotationHeader& x) const
12131 {
12132 static_cast<void>(x);
12133 return true;
12134 }
12135
12140 eProsima_user_DllExport bool operator !=(
12141 const MinimalAnnotationHeader& x) const
12142 {
12143 return !(*this == x);
12144 }
12145
12146
12147
12148 private:
12149
12150
12151};
12152
12156 class CompleteAnnotationType
12157{
12158 public:
12159
12163 eProsima_user_DllExport CompleteAnnotationType()
12164 {
12165 }
12166
12170 eProsima_user_DllExport ~CompleteAnnotationType()
12171 {
12172 }
12173
12178 eProsima_user_DllExport CompleteAnnotationType(
12179 const CompleteAnnotationType& x)
12180 {
12181 m_annotation_flag = x.m_annotation_flag;
12182
12183 m_header = x.m_header;
12184
12185 m_member_seq = x.m_member_seq;
12186
12187 }
12188
12193 eProsima_user_DllExport CompleteAnnotationType(
12194 CompleteAnnotationType&& x) noexcept
12195 {
12196 m_annotation_flag = std::move(x.m_annotation_flag);
12197 m_header = std::move(x.m_header);
12198 m_member_seq = std::move(x.m_member_seq);
12199 }
12200
12205 eProsima_user_DllExport CompleteAnnotationType& operator =(
12206 const CompleteAnnotationType& x)
12207 {
12208
12209 m_annotation_flag = x.m_annotation_flag;
12210
12211 m_header = x.m_header;
12212
12213 m_member_seq = x.m_member_seq;
12214
12215 return *this;
12216 }
12217
12222 eProsima_user_DllExport CompleteAnnotationType& operator =(
12223 CompleteAnnotationType&& x) noexcept
12224 {
12225
12226 m_annotation_flag = std::move(x.m_annotation_flag);
12227 m_header = std::move(x.m_header);
12228 m_member_seq = std::move(x.m_member_seq);
12229 return *this;
12230 }
12231
12236 eProsima_user_DllExport bool operator ==(
12237 const CompleteAnnotationType& x) const
12238 {
12239 return (m_annotation_flag == x.m_annotation_flag &&
12240 m_header == x.m_header &&
12241 m_member_seq == x.m_member_seq);
12242 }
12243
12248 eProsima_user_DllExport bool operator !=(
12249 const CompleteAnnotationType& x) const
12250 {
12251 return !(*this == x);
12252 }
12253
12258 eProsima_user_DllExport void annotation_flag(
12259 const AnnotationTypeFlag& _annotation_flag)
12260 {
12261 m_annotation_flag = _annotation_flag;
12262 }
12263
12268 eProsima_user_DllExport void annotation_flag(
12269 AnnotationTypeFlag&& _annotation_flag)
12270 {
12271 m_annotation_flag = std::move(_annotation_flag);
12272 }
12273
12278 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12279 {
12280 return m_annotation_flag;
12281 }
12282
12287 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12288 {
12289 return m_annotation_flag;
12290 }
12291
12292
12297 eProsima_user_DllExport void header(
12298 const CompleteAnnotationHeader& _header)
12299 {
12300 m_header = _header;
12301 }
12302
12307 eProsima_user_DllExport void header(
12308 CompleteAnnotationHeader&& _header)
12309 {
12310 m_header = std::move(_header);
12311 }
12312
12317 eProsima_user_DllExport const CompleteAnnotationHeader& header() const
12318 {
12319 return m_header;
12320 }
12321
12326 eProsima_user_DllExport CompleteAnnotationHeader& header()
12327 {
12328 return m_header;
12329 }
12330
12331
12336 eProsima_user_DllExport void member_seq(
12337 const CompleteAnnotationParameterSeq& _member_seq)
12338 {
12339 m_member_seq = _member_seq;
12340 }
12341
12346 eProsima_user_DllExport void member_seq(
12347 CompleteAnnotationParameterSeq&& _member_seq)
12348 {
12349 m_member_seq = std::move(_member_seq);
12350 }
12351
12356 eProsima_user_DllExport const CompleteAnnotationParameterSeq& member_seq() const
12357 {
12358 return m_member_seq;
12359 }
12360
12365 eProsima_user_DllExport CompleteAnnotationParameterSeq& member_seq()
12366 {
12367 return m_member_seq;
12368 }
12369
12370
12371
12372 private:
12373
12374 AnnotationTypeFlag m_annotation_flag{0};
12375 CompleteAnnotationHeader m_header;
12376 CompleteAnnotationParameterSeq m_member_seq;
12377
12378};
12379
12383 class MinimalAnnotationType
12384{
12385 public:
12386
12390 eProsima_user_DllExport MinimalAnnotationType()
12391 {
12392 }
12393
12397 eProsima_user_DllExport ~MinimalAnnotationType()
12398 {
12399 }
12400
12405 eProsima_user_DllExport MinimalAnnotationType(
12406 const MinimalAnnotationType& x)
12407 {
12408 m_annotation_flag = x.m_annotation_flag;
12409
12410 m_header = x.m_header;
12411
12412 m_member_seq = x.m_member_seq;
12413
12414 }
12415
12420 eProsima_user_DllExport MinimalAnnotationType(
12421 MinimalAnnotationType&& x) noexcept
12422 {
12423 m_annotation_flag = std::move(x.m_annotation_flag);
12424 m_header = std::move(x.m_header);
12425 m_member_seq = std::move(x.m_member_seq);
12426 }
12427
12432 eProsima_user_DllExport MinimalAnnotationType& operator =(
12433 const MinimalAnnotationType& x)
12434 {
12435
12436 m_annotation_flag = x.m_annotation_flag;
12437
12438 m_header = x.m_header;
12439
12440 m_member_seq = x.m_member_seq;
12441
12442 return *this;
12443 }
12444
12449 eProsima_user_DllExport MinimalAnnotationType& operator =(
12450 MinimalAnnotationType&& x) noexcept
12451 {
12452
12453 m_annotation_flag = std::move(x.m_annotation_flag);
12454 m_header = std::move(x.m_header);
12455 m_member_seq = std::move(x.m_member_seq);
12456 return *this;
12457 }
12458
12463 eProsima_user_DllExport bool operator ==(
12464 const MinimalAnnotationType& x) const
12465 {
12466 return (m_annotation_flag == x.m_annotation_flag &&
12467 m_header == x.m_header &&
12468 m_member_seq == x.m_member_seq);
12469 }
12470
12475 eProsima_user_DllExport bool operator !=(
12476 const MinimalAnnotationType& x) const
12477 {
12478 return !(*this == x);
12479 }
12480
12485 eProsima_user_DllExport void annotation_flag(
12486 const AnnotationTypeFlag& _annotation_flag)
12487 {
12488 m_annotation_flag = _annotation_flag;
12489 }
12490
12495 eProsima_user_DllExport void annotation_flag(
12496 AnnotationTypeFlag&& _annotation_flag)
12497 {
12498 m_annotation_flag = std::move(_annotation_flag);
12499 }
12500
12505 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12506 {
12507 return m_annotation_flag;
12508 }
12509
12514 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12515 {
12516 return m_annotation_flag;
12517 }
12518
12519
12524 eProsima_user_DllExport void header(
12525 const MinimalAnnotationHeader& _header)
12526 {
12527 m_header = _header;
12528 }
12529
12534 eProsima_user_DllExport void header(
12535 MinimalAnnotationHeader&& _header)
12536 {
12537 m_header = std::move(_header);
12538 }
12539
12544 eProsima_user_DllExport const MinimalAnnotationHeader& header() const
12545 {
12546 return m_header;
12547 }
12548
12553 eProsima_user_DllExport MinimalAnnotationHeader& header()
12554 {
12555 return m_header;
12556 }
12557
12558
12563 eProsima_user_DllExport void member_seq(
12564 const MinimalAnnotationParameterSeq& _member_seq)
12565 {
12566 m_member_seq = _member_seq;
12567 }
12568
12573 eProsima_user_DllExport void member_seq(
12574 MinimalAnnotationParameterSeq&& _member_seq)
12575 {
12576 m_member_seq = std::move(_member_seq);
12577 }
12578
12583 eProsima_user_DllExport const MinimalAnnotationParameterSeq& member_seq() const
12584 {
12585 return m_member_seq;
12586 }
12587
12592 eProsima_user_DllExport MinimalAnnotationParameterSeq& member_seq()
12593 {
12594 return m_member_seq;
12595 }
12596
12597
12598
12599 private:
12600
12601 AnnotationTypeFlag m_annotation_flag{0};
12602 MinimalAnnotationHeader m_header;
12603 MinimalAnnotationParameterSeq m_member_seq;
12604
12605};
12606
12610 class CommonAliasBody
12611{
12612 public:
12613
12617 eProsima_user_DllExport CommonAliasBody()
12618 {
12619 }
12620
12624 eProsima_user_DllExport ~CommonAliasBody()
12625 {
12626 }
12627
12632 eProsima_user_DllExport CommonAliasBody(
12633 const CommonAliasBody& x)
12634 {
12635 m_related_flags = x.m_related_flags;
12636
12637 m_related_type = x.m_related_type;
12638
12639 }
12640
12645 eProsima_user_DllExport CommonAliasBody(
12646 CommonAliasBody&& x) noexcept
12647 {
12648 m_related_flags = std::move(x.m_related_flags);
12649 m_related_type = std::move(x.m_related_type);
12650 }
12651
12656 eProsima_user_DllExport CommonAliasBody& operator =(
12657 const CommonAliasBody& x)
12658 {
12659
12660 m_related_flags = x.m_related_flags;
12661
12662 m_related_type = x.m_related_type;
12663
12664 return *this;
12665 }
12666
12671 eProsima_user_DllExport CommonAliasBody& operator =(
12672 CommonAliasBody&& x) noexcept
12673 {
12674
12675 m_related_flags = std::move(x.m_related_flags);
12676 m_related_type = std::move(x.m_related_type);
12677 return *this;
12678 }
12679
12684 eProsima_user_DllExport bool operator ==(
12685 const CommonAliasBody& x) const
12686 {
12687 return (m_related_flags == x.m_related_flags &&
12688 m_related_type == x.m_related_type);
12689 }
12690
12695 eProsima_user_DllExport bool operator !=(
12696 const CommonAliasBody& x) const
12697 {
12698 return !(*this == x);
12699 }
12700
12705 eProsima_user_DllExport void related_flags(
12706 const AliasMemberFlag& _related_flags)
12707 {
12708 m_related_flags = _related_flags;
12709 }
12710
12715 eProsima_user_DllExport void related_flags(
12716 AliasMemberFlag&& _related_flags)
12717 {
12718 m_related_flags = std::move(_related_flags);
12719 }
12720
12725 eProsima_user_DllExport const AliasMemberFlag& related_flags() const
12726 {
12727 return m_related_flags;
12728 }
12729
12734 eProsima_user_DllExport AliasMemberFlag& related_flags()
12735 {
12736 return m_related_flags;
12737 }
12738
12739
12744 eProsima_user_DllExport void related_type(
12745 const TypeIdentifier& _related_type)
12746 {
12747 m_related_type = _related_type;
12748 }
12749
12754 eProsima_user_DllExport void related_type(
12755 TypeIdentifier&& _related_type)
12756 {
12757 m_related_type = std::move(_related_type);
12758 }
12759
12764 eProsima_user_DllExport const TypeIdentifier& related_type() const
12765 {
12766 return m_related_type;
12767 }
12768
12773 eProsima_user_DllExport TypeIdentifier& related_type()
12774 {
12775 return m_related_type;
12776 }
12777
12778
12779
12780 private:
12781
12782 AliasMemberFlag m_related_flags{0};
12783 TypeIdentifier m_related_type;
12784
12785};
12786
12790 class CompleteAliasBody
12791{
12792 public:
12793
12797 eProsima_user_DllExport CompleteAliasBody()
12798 {
12799 }
12800
12804 eProsima_user_DllExport ~CompleteAliasBody()
12805 {
12806 }
12807
12812 eProsima_user_DllExport CompleteAliasBody(
12813 const CompleteAliasBody& x)
12814 {
12815 m_common = x.m_common;
12816
12817 m_ann_builtin = x.m_ann_builtin;
12818
12819 m_ann_custom = x.m_ann_custom;
12820
12821 }
12822
12827 eProsima_user_DllExport CompleteAliasBody(
12828 CompleteAliasBody&& x) noexcept
12829 {
12830 m_common = std::move(x.m_common);
12831 m_ann_builtin = std::move(x.m_ann_builtin);
12832 m_ann_custom = std::move(x.m_ann_custom);
12833 }
12834
12839 eProsima_user_DllExport CompleteAliasBody& operator =(
12840 const CompleteAliasBody& x)
12841 {
12842
12843 m_common = x.m_common;
12844
12845 m_ann_builtin = x.m_ann_builtin;
12846
12847 m_ann_custom = x.m_ann_custom;
12848
12849 return *this;
12850 }
12851
12856 eProsima_user_DllExport CompleteAliasBody& operator =(
12857 CompleteAliasBody&& x) noexcept
12858 {
12859
12860 m_common = std::move(x.m_common);
12861 m_ann_builtin = std::move(x.m_ann_builtin);
12862 m_ann_custom = std::move(x.m_ann_custom);
12863 return *this;
12864 }
12865
12870 eProsima_user_DllExport bool operator ==(
12871 const CompleteAliasBody& x) const
12872 {
12873 return (m_common == x.m_common &&
12874 m_ann_builtin == x.m_ann_builtin &&
12875 m_ann_custom == x.m_ann_custom);
12876 }
12877
12882 eProsima_user_DllExport bool operator !=(
12883 const CompleteAliasBody& x) const
12884 {
12885 return !(*this == x);
12886 }
12887
12892 eProsima_user_DllExport void common(
12893 const CommonAliasBody& _common)
12894 {
12895 m_common = _common;
12896 }
12897
12902 eProsima_user_DllExport void common(
12903 CommonAliasBody&& _common)
12904 {
12905 m_common = std::move(_common);
12906 }
12907
12912 eProsima_user_DllExport const CommonAliasBody& common() const
12913 {
12914 return m_common;
12915 }
12916
12921 eProsima_user_DllExport CommonAliasBody& common()
12922 {
12923 return m_common;
12924 }
12925
12926
12931 eProsima_user_DllExport void ann_builtin(
12932 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
12933 {
12934 m_ann_builtin = _ann_builtin;
12935 }
12936
12941 eProsima_user_DllExport void ann_builtin(
12942 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
12943 {
12944 m_ann_builtin = std::move(_ann_builtin);
12945 }
12946
12951 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
12952 {
12953 return m_ann_builtin;
12954 }
12955
12960 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
12961 {
12962 return m_ann_builtin;
12963 }
12964
12965
12970 eProsima_user_DllExport void ann_custom(
12971 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
12972 {
12973 m_ann_custom = _ann_custom;
12974 }
12975
12980 eProsima_user_DllExport void ann_custom(
12981 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
12982 {
12983 m_ann_custom = std::move(_ann_custom);
12984 }
12985
12990 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
12991 {
12992 return m_ann_custom;
12993 }
12994
12999 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
13000 {
13001 return m_ann_custom;
13002 }
13003
13004
13005
13006 private:
13007
13008 CommonAliasBody m_common;
13009 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
13010 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
13011
13012};
13013
13017 class MinimalAliasBody
13018{
13019 public:
13020
13024 eProsima_user_DllExport MinimalAliasBody()
13025 {
13026 }
13027
13031 eProsima_user_DllExport ~MinimalAliasBody()
13032 {
13033 }
13034
13039 eProsima_user_DllExport MinimalAliasBody(
13040 const MinimalAliasBody& x)
13041 {
13042 m_common = x.m_common;
13043
13044 }
13045
13050 eProsima_user_DllExport MinimalAliasBody(
13051 MinimalAliasBody&& x) noexcept
13052 {
13053 m_common = std::move(x.m_common);
13054 }
13055
13060 eProsima_user_DllExport MinimalAliasBody& operator =(
13061 const MinimalAliasBody& x)
13062 {
13063
13064 m_common = x.m_common;
13065
13066 return *this;
13067 }
13068
13073 eProsima_user_DllExport MinimalAliasBody& operator =(
13074 MinimalAliasBody&& x) noexcept
13075 {
13076
13077 m_common = std::move(x.m_common);
13078 return *this;
13079 }
13080
13085 eProsima_user_DllExport bool operator ==(
13086 const MinimalAliasBody& x) const
13087 {
13088 return (m_common == x.m_common);
13089 }
13090
13095 eProsima_user_DllExport bool operator !=(
13096 const MinimalAliasBody& x) const
13097 {
13098 return !(*this == x);
13099 }
13100
13105 eProsima_user_DllExport void common(
13106 const CommonAliasBody& _common)
13107 {
13108 m_common = _common;
13109 }
13110
13115 eProsima_user_DllExport void common(
13116 CommonAliasBody&& _common)
13117 {
13118 m_common = std::move(_common);
13119 }
13120
13125 eProsima_user_DllExport const CommonAliasBody& common() const
13126 {
13127 return m_common;
13128 }
13129
13134 eProsima_user_DllExport CommonAliasBody& common()
13135 {
13136 return m_common;
13137 }
13138
13139
13140
13141 private:
13142
13143 CommonAliasBody m_common;
13144
13145};
13146
13150 class CompleteAliasHeader
13151{
13152 public:
13153
13157 eProsima_user_DllExport CompleteAliasHeader()
13158 {
13159 }
13160
13164 eProsima_user_DllExport ~CompleteAliasHeader()
13165 {
13166 }
13167
13172 eProsima_user_DllExport CompleteAliasHeader(
13173 const CompleteAliasHeader& x)
13174 {
13175 m_detail = x.m_detail;
13176
13177 }
13178
13183 eProsima_user_DllExport CompleteAliasHeader(
13184 CompleteAliasHeader&& x) noexcept
13185 {
13186 m_detail = std::move(x.m_detail);
13187 }
13188
13193 eProsima_user_DllExport CompleteAliasHeader& operator =(
13194 const CompleteAliasHeader& x)
13195 {
13196
13197 m_detail = x.m_detail;
13198
13199 return *this;
13200 }
13201
13206 eProsima_user_DllExport CompleteAliasHeader& operator =(
13207 CompleteAliasHeader&& x) noexcept
13208 {
13209
13210 m_detail = std::move(x.m_detail);
13211 return *this;
13212 }
13213
13218 eProsima_user_DllExport bool operator ==(
13219 const CompleteAliasHeader& x) const
13220 {
13221 return (m_detail == x.m_detail);
13222 }
13223
13228 eProsima_user_DllExport bool operator !=(
13229 const CompleteAliasHeader& x) const
13230 {
13231 return !(*this == x);
13232 }
13233
13238 eProsima_user_DllExport void detail(
13239 const CompleteTypeDetail& _detail)
13240 {
13241 m_detail = _detail;
13242 }
13243
13248 eProsima_user_DllExport void detail(
13249 CompleteTypeDetail&& _detail)
13250 {
13251 m_detail = std::move(_detail);
13252 }
13253
13258 eProsima_user_DllExport const CompleteTypeDetail& detail() const
13259 {
13260 return m_detail;
13261 }
13262
13267 eProsima_user_DllExport CompleteTypeDetail& detail()
13268 {
13269 return m_detail;
13270 }
13271
13272
13273
13274 private:
13275
13276 CompleteTypeDetail m_detail;
13277
13278};
13279
13283 class MinimalAliasHeader
13284{
13285 public:
13286
13290 eProsima_user_DllExport MinimalAliasHeader()
13291 {
13292 }
13293
13297 eProsima_user_DllExport ~MinimalAliasHeader()
13298 {
13299 }
13300
13305 eProsima_user_DllExport MinimalAliasHeader(
13306 const MinimalAliasHeader& x)
13307 {
13308 static_cast<void>(x);
13309 }
13310
13315 eProsima_user_DllExport MinimalAliasHeader(
13316 MinimalAliasHeader&& x) noexcept
13317 {
13318 static_cast<void>(x);
13319 }
13320
13325 eProsima_user_DllExport MinimalAliasHeader& operator =(
13326 const MinimalAliasHeader& x)
13327 {
13328
13329 static_cast<void>(x);
13330
13331 return *this;
13332 }
13333
13338 eProsima_user_DllExport MinimalAliasHeader& operator =(
13339 MinimalAliasHeader&& x) noexcept
13340 {
13341
13342 static_cast<void>(x);
13343
13344 return *this;
13345 }
13346
13351 eProsima_user_DllExport bool operator ==(
13352 const MinimalAliasHeader& x) const
13353 {
13354 static_cast<void>(x);
13355 return true;
13356 }
13357
13362 eProsima_user_DllExport bool operator !=(
13363 const MinimalAliasHeader& x) const
13364 {
13365 return !(*this == x);
13366 }
13367
13368
13369
13370 private:
13371
13372
13373};
13374
13378 class CompleteAliasType
13379{
13380 public:
13381
13385 eProsima_user_DllExport CompleteAliasType()
13386 {
13387 }
13388
13392 eProsima_user_DllExport ~CompleteAliasType()
13393 {
13394 }
13395
13400 eProsima_user_DllExport CompleteAliasType(
13401 const CompleteAliasType& x)
13402 {
13403 m_alias_flags = x.m_alias_flags;
13404
13405 m_header = x.m_header;
13406
13407 m_body = x.m_body;
13408
13409 }
13410
13415 eProsima_user_DllExport CompleteAliasType(
13416 CompleteAliasType&& x) noexcept
13417 {
13418 m_alias_flags = std::move(x.m_alias_flags);
13419 m_header = std::move(x.m_header);
13420 m_body = std::move(x.m_body);
13421 }
13422
13427 eProsima_user_DllExport CompleteAliasType& operator =(
13428 const CompleteAliasType& x)
13429 {
13430
13431 m_alias_flags = x.m_alias_flags;
13432
13433 m_header = x.m_header;
13434
13435 m_body = x.m_body;
13436
13437 return *this;
13438 }
13439
13444 eProsima_user_DllExport CompleteAliasType& operator =(
13445 CompleteAliasType&& x) noexcept
13446 {
13447
13448 m_alias_flags = std::move(x.m_alias_flags);
13449 m_header = std::move(x.m_header);
13450 m_body = std::move(x.m_body);
13451 return *this;
13452 }
13453
13458 eProsima_user_DllExport bool operator ==(
13459 const CompleteAliasType& x) const
13460 {
13461 return (m_alias_flags == x.m_alias_flags &&
13462 m_header == x.m_header &&
13463 m_body == x.m_body);
13464 }
13465
13470 eProsima_user_DllExport bool operator !=(
13471 const CompleteAliasType& x) const
13472 {
13473 return !(*this == x);
13474 }
13475
13480 eProsima_user_DllExport void alias_flags(
13481 const AliasTypeFlag& _alias_flags)
13482 {
13483 m_alias_flags = _alias_flags;
13484 }
13485
13490 eProsima_user_DllExport void alias_flags(
13491 AliasTypeFlag&& _alias_flags)
13492 {
13493 m_alias_flags = std::move(_alias_flags);
13494 }
13495
13500 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13501 {
13502 return m_alias_flags;
13503 }
13504
13509 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13510 {
13511 return m_alias_flags;
13512 }
13513
13514
13519 eProsima_user_DllExport void header(
13520 const CompleteAliasHeader& _header)
13521 {
13522 m_header = _header;
13523 }
13524
13529 eProsima_user_DllExport void header(
13530 CompleteAliasHeader&& _header)
13531 {
13532 m_header = std::move(_header);
13533 }
13534
13539 eProsima_user_DllExport const CompleteAliasHeader& header() const
13540 {
13541 return m_header;
13542 }
13543
13548 eProsima_user_DllExport CompleteAliasHeader& header()
13549 {
13550 return m_header;
13551 }
13552
13553
13558 eProsima_user_DllExport void body(
13559 const CompleteAliasBody& _body)
13560 {
13561 m_body = _body;
13562 }
13563
13568 eProsima_user_DllExport void body(
13569 CompleteAliasBody&& _body)
13570 {
13571 m_body = std::move(_body);
13572 }
13573
13578 eProsima_user_DllExport const CompleteAliasBody& body() const
13579 {
13580 return m_body;
13581 }
13582
13587 eProsima_user_DllExport CompleteAliasBody& body()
13588 {
13589 return m_body;
13590 }
13591
13592
13593
13594 private:
13595
13596 AliasTypeFlag m_alias_flags{0};
13597 CompleteAliasHeader m_header;
13598 CompleteAliasBody m_body;
13599
13600};
13601
13605 class MinimalAliasType
13606{
13607 public:
13608
13612 eProsima_user_DllExport MinimalAliasType()
13613 {
13614 }
13615
13619 eProsima_user_DllExport ~MinimalAliasType()
13620 {
13621 }
13622
13627 eProsima_user_DllExport MinimalAliasType(
13628 const MinimalAliasType& x)
13629 {
13630 m_alias_flags = x.m_alias_flags;
13631
13632 m_header = x.m_header;
13633
13634 m_body = x.m_body;
13635
13636 }
13637
13642 eProsima_user_DllExport MinimalAliasType(
13643 MinimalAliasType&& x) noexcept
13644 {
13645 m_alias_flags = std::move(x.m_alias_flags);
13646 m_header = std::move(x.m_header);
13647 m_body = std::move(x.m_body);
13648 }
13649
13654 eProsima_user_DllExport MinimalAliasType& operator =(
13655 const MinimalAliasType& x)
13656 {
13657
13658 m_alias_flags = x.m_alias_flags;
13659
13660 m_header = x.m_header;
13661
13662 m_body = x.m_body;
13663
13664 return *this;
13665 }
13666
13671 eProsima_user_DllExport MinimalAliasType& operator =(
13672 MinimalAliasType&& x) noexcept
13673 {
13674
13675 m_alias_flags = std::move(x.m_alias_flags);
13676 m_header = std::move(x.m_header);
13677 m_body = std::move(x.m_body);
13678 return *this;
13679 }
13680
13685 eProsima_user_DllExport bool operator ==(
13686 const MinimalAliasType& x) const
13687 {
13688 return (m_alias_flags == x.m_alias_flags &&
13689 m_header == x.m_header &&
13690 m_body == x.m_body);
13691 }
13692
13697 eProsima_user_DllExport bool operator !=(
13698 const MinimalAliasType& x) const
13699 {
13700 return !(*this == x);
13701 }
13702
13707 eProsima_user_DllExport void alias_flags(
13708 const AliasTypeFlag& _alias_flags)
13709 {
13710 m_alias_flags = _alias_flags;
13711 }
13712
13717 eProsima_user_DllExport void alias_flags(
13718 AliasTypeFlag&& _alias_flags)
13719 {
13720 m_alias_flags = std::move(_alias_flags);
13721 }
13722
13727 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13728 {
13729 return m_alias_flags;
13730 }
13731
13736 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13737 {
13738 return m_alias_flags;
13739 }
13740
13741
13746 eProsima_user_DllExport void header(
13747 const MinimalAliasHeader& _header)
13748 {
13749 m_header = _header;
13750 }
13751
13756 eProsima_user_DllExport void header(
13757 MinimalAliasHeader&& _header)
13758 {
13759 m_header = std::move(_header);
13760 }
13761
13766 eProsima_user_DllExport const MinimalAliasHeader& header() const
13767 {
13768 return m_header;
13769 }
13770
13775 eProsima_user_DllExport MinimalAliasHeader& header()
13776 {
13777 return m_header;
13778 }
13779
13780
13785 eProsima_user_DllExport void body(
13786 const MinimalAliasBody& _body)
13787 {
13788 m_body = _body;
13789 }
13790
13795 eProsima_user_DllExport void body(
13796 MinimalAliasBody&& _body)
13797 {
13798 m_body = std::move(_body);
13799 }
13800
13805 eProsima_user_DllExport const MinimalAliasBody& body() const
13806 {
13807 return m_body;
13808 }
13809
13814 eProsima_user_DllExport MinimalAliasBody& body()
13815 {
13816 return m_body;
13817 }
13818
13819
13820
13821 private:
13822
13823 AliasTypeFlag m_alias_flags{0};
13824 MinimalAliasHeader m_header;
13825 MinimalAliasBody m_body;
13826
13827};
13828
13832 class CompleteElementDetail
13833{
13834 public:
13835
13839 eProsima_user_DllExport CompleteElementDetail()
13840 {
13841 }
13842
13846 eProsima_user_DllExport ~CompleteElementDetail()
13847 {
13848 }
13849
13854 eProsima_user_DllExport CompleteElementDetail(
13855 const CompleteElementDetail& x)
13856 {
13857 m_ann_builtin = x.m_ann_builtin;
13858
13859 m_ann_custom = x.m_ann_custom;
13860
13861 }
13862
13867 eProsima_user_DllExport CompleteElementDetail(
13868 CompleteElementDetail&& x) noexcept
13869 {
13870 m_ann_builtin = std::move(x.m_ann_builtin);
13871 m_ann_custom = std::move(x.m_ann_custom);
13872 }
13873
13878 eProsima_user_DllExport CompleteElementDetail& operator =(
13879 const CompleteElementDetail& x)
13880 {
13881
13882 m_ann_builtin = x.m_ann_builtin;
13883
13884 m_ann_custom = x.m_ann_custom;
13885
13886 return *this;
13887 }
13888
13893 eProsima_user_DllExport CompleteElementDetail& operator =(
13894 CompleteElementDetail&& x) noexcept
13895 {
13896
13897 m_ann_builtin = std::move(x.m_ann_builtin);
13898 m_ann_custom = std::move(x.m_ann_custom);
13899 return *this;
13900 }
13901
13906 eProsima_user_DllExport bool operator ==(
13907 const CompleteElementDetail& x) const
13908 {
13909 return (m_ann_builtin == x.m_ann_builtin &&
13910 m_ann_custom == x.m_ann_custom);
13911 }
13912
13917 eProsima_user_DllExport bool operator !=(
13918 const CompleteElementDetail& x) const
13919 {
13920 return !(*this == x);
13921 }
13922
13927 eProsima_user_DllExport void ann_builtin(
13928 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
13929 {
13930 m_ann_builtin = _ann_builtin;
13931 }
13932
13937 eProsima_user_DllExport void ann_builtin(
13938 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
13939 {
13940 m_ann_builtin = std::move(_ann_builtin);
13941 }
13942
13947 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
13948 {
13949 return m_ann_builtin;
13950 }
13951
13956 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
13957 {
13958 return m_ann_builtin;
13959 }
13960
13961
13966 eProsima_user_DllExport void ann_custom(
13967 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
13968 {
13969 m_ann_custom = _ann_custom;
13970 }
13971
13976 eProsima_user_DllExport void ann_custom(
13977 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
13978 {
13979 m_ann_custom = std::move(_ann_custom);
13980 }
13981
13986 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
13987 {
13988 return m_ann_custom;
13989 }
13990
13995 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
13996 {
13997 return m_ann_custom;
13998 }
13999
14000
14001
14002 private:
14003
14004 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
14005 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
14006
14007};
14008
14012 class CommonCollectionElement
14013{
14014 public:
14015
14019 eProsima_user_DllExport CommonCollectionElement()
14020 {
14021 }
14022
14026 eProsima_user_DllExport ~CommonCollectionElement()
14027 {
14028 }
14029
14034 eProsima_user_DllExport CommonCollectionElement(
14035 const CommonCollectionElement& x)
14036 {
14037 m_element_flags = x.m_element_flags;
14038
14039 m_type = x.m_type;
14040
14041 }
14042
14047 eProsima_user_DllExport CommonCollectionElement(
14048 CommonCollectionElement&& x) noexcept
14049 {
14050 m_element_flags = std::move(x.m_element_flags);
14051 m_type = std::move(x.m_type);
14052 }
14053
14058 eProsima_user_DllExport CommonCollectionElement& operator =(
14059 const CommonCollectionElement& x)
14060 {
14061
14062 m_element_flags = x.m_element_flags;
14063
14064 m_type = x.m_type;
14065
14066 return *this;
14067 }
14068
14073 eProsima_user_DllExport CommonCollectionElement& operator =(
14074 CommonCollectionElement&& x) noexcept
14075 {
14076
14077 m_element_flags = std::move(x.m_element_flags);
14078 m_type = std::move(x.m_type);
14079 return *this;
14080 }
14081
14086 eProsima_user_DllExport bool operator ==(
14087 const CommonCollectionElement& x) const
14088 {
14089 return (m_element_flags == x.m_element_flags &&
14090 m_type == x.m_type);
14091 }
14092
14097 eProsima_user_DllExport bool operator !=(
14098 const CommonCollectionElement& x) const
14099 {
14100 return !(*this == x);
14101 }
14102
14107 eProsima_user_DllExport void element_flags(
14108 const CollectionElementFlag& _element_flags)
14109 {
14110 m_element_flags = _element_flags;
14111 }
14112
14117 eProsima_user_DllExport void element_flags(
14118 CollectionElementFlag&& _element_flags)
14119 {
14120 m_element_flags = std::move(_element_flags);
14121 }
14122
14127 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
14128 {
14129 return m_element_flags;
14130 }
14131
14136 eProsima_user_DllExport CollectionElementFlag& element_flags()
14137 {
14138 return m_element_flags;
14139 }
14140
14141
14146 eProsima_user_DllExport void type(
14147 const TypeIdentifier& _type)
14148 {
14149 m_type = _type;
14150 }
14151
14156 eProsima_user_DllExport void type(
14157 TypeIdentifier&& _type)
14158 {
14159 m_type = std::move(_type);
14160 }
14161
14166 eProsima_user_DllExport const TypeIdentifier& type() const
14167 {
14168 return m_type;
14169 }
14170
14175 eProsima_user_DllExport TypeIdentifier& type()
14176 {
14177 return m_type;
14178 }
14179
14180
14181
14182 private:
14183
14184 CollectionElementFlag m_element_flags{0};
14185 TypeIdentifier m_type;
14186
14187};
14188
14192 class CompleteCollectionElement
14193{
14194 public:
14195
14199 eProsima_user_DllExport CompleteCollectionElement()
14200 {
14201 }
14202
14206 eProsima_user_DllExport ~CompleteCollectionElement()
14207 {
14208 }
14209
14214 eProsima_user_DllExport CompleteCollectionElement(
14215 const CompleteCollectionElement& x)
14216 {
14217 m_common = x.m_common;
14218
14219 m_detail = x.m_detail;
14220
14221 }
14222
14227 eProsima_user_DllExport CompleteCollectionElement(
14228 CompleteCollectionElement&& x) noexcept
14229 {
14230 m_common = std::move(x.m_common);
14231 m_detail = std::move(x.m_detail);
14232 }
14233
14238 eProsima_user_DllExport CompleteCollectionElement& operator =(
14239 const CompleteCollectionElement& x)
14240 {
14241
14242 m_common = x.m_common;
14243
14244 m_detail = x.m_detail;
14245
14246 return *this;
14247 }
14248
14253 eProsima_user_DllExport CompleteCollectionElement& operator =(
14254 CompleteCollectionElement&& x) noexcept
14255 {
14256
14257 m_common = std::move(x.m_common);
14258 m_detail = std::move(x.m_detail);
14259 return *this;
14260 }
14261
14266 eProsima_user_DllExport bool operator ==(
14267 const CompleteCollectionElement& x) const
14268 {
14269 return (m_common == x.m_common &&
14270 m_detail == x.m_detail);
14271 }
14272
14277 eProsima_user_DllExport bool operator !=(
14278 const CompleteCollectionElement& x) const
14279 {
14280 return !(*this == x);
14281 }
14282
14287 eProsima_user_DllExport void common(
14288 const CommonCollectionElement& _common)
14289 {
14290 m_common = _common;
14291 }
14292
14297 eProsima_user_DllExport void common(
14298 CommonCollectionElement&& _common)
14299 {
14300 m_common = std::move(_common);
14301 }
14302
14307 eProsima_user_DllExport const CommonCollectionElement& common() const
14308 {
14309 return m_common;
14310 }
14311
14316 eProsima_user_DllExport CommonCollectionElement& common()
14317 {
14318 return m_common;
14319 }
14320
14321
14326 eProsima_user_DllExport void detail(
14327 const CompleteElementDetail& _detail)
14328 {
14329 m_detail = _detail;
14330 }
14331
14336 eProsima_user_DllExport void detail(
14337 CompleteElementDetail&& _detail)
14338 {
14339 m_detail = std::move(_detail);
14340 }
14341
14346 eProsima_user_DllExport const CompleteElementDetail& detail() const
14347 {
14348 return m_detail;
14349 }
14350
14355 eProsima_user_DllExport CompleteElementDetail& detail()
14356 {
14357 return m_detail;
14358 }
14359
14360
14361
14362 private:
14363
14364 CommonCollectionElement m_common;
14365 CompleteElementDetail m_detail;
14366
14367};
14368
14372 class MinimalCollectionElement
14373{
14374 public:
14375
14379 eProsima_user_DllExport MinimalCollectionElement()
14380 {
14381 }
14382
14386 eProsima_user_DllExport ~MinimalCollectionElement()
14387 {
14388 }
14389
14394 eProsima_user_DllExport MinimalCollectionElement(
14395 const MinimalCollectionElement& x)
14396 {
14397 m_common = x.m_common;
14398
14399 }
14400
14405 eProsima_user_DllExport MinimalCollectionElement(
14406 MinimalCollectionElement&& x) noexcept
14407 {
14408 m_common = std::move(x.m_common);
14409 }
14410
14415 eProsima_user_DllExport MinimalCollectionElement& operator =(
14416 const MinimalCollectionElement& x)
14417 {
14418
14419 m_common = x.m_common;
14420
14421 return *this;
14422 }
14423
14428 eProsima_user_DllExport MinimalCollectionElement& operator =(
14429 MinimalCollectionElement&& x) noexcept
14430 {
14431
14432 m_common = std::move(x.m_common);
14433 return *this;
14434 }
14435
14440 eProsima_user_DllExport bool operator ==(
14441 const MinimalCollectionElement& x) const
14442 {
14443 return (m_common == x.m_common);
14444 }
14445
14450 eProsima_user_DllExport bool operator !=(
14451 const MinimalCollectionElement& x) const
14452 {
14453 return !(*this == x);
14454 }
14455
14460 eProsima_user_DllExport void common(
14461 const CommonCollectionElement& _common)
14462 {
14463 m_common = _common;
14464 }
14465
14470 eProsima_user_DllExport void common(
14471 CommonCollectionElement&& _common)
14472 {
14473 m_common = std::move(_common);
14474 }
14475
14480 eProsima_user_DllExport const CommonCollectionElement& common() const
14481 {
14482 return m_common;
14483 }
14484
14489 eProsima_user_DllExport CommonCollectionElement& common()
14490 {
14491 return m_common;
14492 }
14493
14494
14495
14496 private:
14497
14498 CommonCollectionElement m_common;
14499
14500};
14501
14505 class CommonCollectionHeader
14506{
14507 public:
14508
14512 eProsima_user_DllExport CommonCollectionHeader()
14513 {
14514 }
14515
14519 eProsima_user_DllExport ~CommonCollectionHeader()
14520 {
14521 }
14522
14527 eProsima_user_DllExport CommonCollectionHeader(
14528 const CommonCollectionHeader& x)
14529 {
14530 m_bound = x.m_bound;
14531
14532 }
14533
14538 eProsima_user_DllExport CommonCollectionHeader(
14539 CommonCollectionHeader&& x) noexcept
14540 {
14541 m_bound = x.m_bound;
14542 }
14543
14548 eProsima_user_DllExport CommonCollectionHeader& operator =(
14549 const CommonCollectionHeader& x)
14550 {
14551
14552 m_bound = x.m_bound;
14553
14554 return *this;
14555 }
14556
14561 eProsima_user_DllExport CommonCollectionHeader& operator =(
14562 CommonCollectionHeader&& x) noexcept
14563 {
14564
14565 m_bound = x.m_bound;
14566 return *this;
14567 }
14568
14573 eProsima_user_DllExport bool operator ==(
14574 const CommonCollectionHeader& x) const
14575 {
14576 return (m_bound == x.m_bound);
14577 }
14578
14583 eProsima_user_DllExport bool operator !=(
14584 const CommonCollectionHeader& x) const
14585 {
14586 return !(*this == x);
14587 }
14588
14593 eProsima_user_DllExport void bound(
14594 LBound _bound)
14595 {
14596 m_bound = _bound;
14597 }
14598
14603 eProsima_user_DllExport LBound bound() const
14604 {
14605 return m_bound;
14606 }
14607
14612 eProsima_user_DllExport LBound& bound()
14613 {
14614 return m_bound;
14615 }
14616
14617
14618
14619 private:
14620
14621 LBound m_bound{0};
14622
14623};
14624
14628 class CompleteCollectionHeader
14629{
14630 public:
14631
14635 eProsima_user_DllExport CompleteCollectionHeader()
14636 {
14637 }
14638
14642 eProsima_user_DllExport ~CompleteCollectionHeader()
14643 {
14644 }
14645
14650 eProsima_user_DllExport CompleteCollectionHeader(
14651 const CompleteCollectionHeader& x)
14652 {
14653 m_common = x.m_common;
14654
14655 m_detail = x.m_detail;
14656
14657 }
14658
14663 eProsima_user_DllExport CompleteCollectionHeader(
14664 CompleteCollectionHeader&& x) noexcept
14665 {
14666 m_common = std::move(x.m_common);
14667 m_detail = std::move(x.m_detail);
14668 }
14669
14674 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14675 const CompleteCollectionHeader& x)
14676 {
14677
14678 m_common = x.m_common;
14679
14680 m_detail = x.m_detail;
14681
14682 return *this;
14683 }
14684
14689 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14690 CompleteCollectionHeader&& x) noexcept
14691 {
14692
14693 m_common = std::move(x.m_common);
14694 m_detail = std::move(x.m_detail);
14695 return *this;
14696 }
14697
14702 eProsima_user_DllExport bool operator ==(
14703 const CompleteCollectionHeader& x) const
14704 {
14705 return (m_common == x.m_common &&
14706 m_detail == x.m_detail);
14707 }
14708
14713 eProsima_user_DllExport bool operator !=(
14714 const CompleteCollectionHeader& x) const
14715 {
14716 return !(*this == x);
14717 }
14718
14723 eProsima_user_DllExport void common(
14724 const CommonCollectionHeader& _common)
14725 {
14726 m_common = _common;
14727 }
14728
14733 eProsima_user_DllExport void common(
14734 CommonCollectionHeader&& _common)
14735 {
14736 m_common = std::move(_common);
14737 }
14738
14743 eProsima_user_DllExport const CommonCollectionHeader& common() const
14744 {
14745 return m_common;
14746 }
14747
14752 eProsima_user_DllExport CommonCollectionHeader& common()
14753 {
14754 return m_common;
14755 }
14756
14757
14762 eProsima_user_DllExport void detail(
14763 const eprosima::fastcdr::optional<CompleteTypeDetail>& _detail)
14764 {
14765 m_detail = _detail;
14766 }
14767
14772 eProsima_user_DllExport void detail(
14773 eprosima::fastcdr::optional<CompleteTypeDetail>&& _detail)
14774 {
14775 m_detail = std::move(_detail);
14776 }
14777
14782 eProsima_user_DllExport const eprosima::fastcdr::optional<CompleteTypeDetail>& detail() const
14783 {
14784 return m_detail;
14785 }
14786
14791 eProsima_user_DllExport eprosima::fastcdr::optional<CompleteTypeDetail>& detail()
14792 {
14793 return m_detail;
14794 }
14795
14796
14797
14798 private:
14799
14800 CommonCollectionHeader m_common;
14801 eprosima::fastcdr::optional<CompleteTypeDetail> m_detail;
14802
14803};
14804
14808 class MinimalCollectionHeader
14809{
14810 public:
14811
14815 eProsima_user_DllExport MinimalCollectionHeader()
14816 {
14817 }
14818
14822 eProsima_user_DllExport ~MinimalCollectionHeader()
14823 {
14824 }
14825
14830 eProsima_user_DllExport MinimalCollectionHeader(
14831 const MinimalCollectionHeader& x)
14832 {
14833 m_common = x.m_common;
14834
14835 }
14836
14841 eProsima_user_DllExport MinimalCollectionHeader(
14842 MinimalCollectionHeader&& x) noexcept
14843 {
14844 m_common = std::move(x.m_common);
14845 }
14846
14851 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14852 const MinimalCollectionHeader& x)
14853 {
14854
14855 m_common = x.m_common;
14856
14857 return *this;
14858 }
14859
14864 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14865 MinimalCollectionHeader&& x) noexcept
14866 {
14867
14868 m_common = std::move(x.m_common);
14869 return *this;
14870 }
14871
14876 eProsima_user_DllExport bool operator ==(
14877 const MinimalCollectionHeader& x) const
14878 {
14879 return (m_common == x.m_common);
14880 }
14881
14886 eProsima_user_DllExport bool operator !=(
14887 const MinimalCollectionHeader& x) const
14888 {
14889 return !(*this == x);
14890 }
14891
14896 eProsima_user_DllExport void common(
14897 const CommonCollectionHeader& _common)
14898 {
14899 m_common = _common;
14900 }
14901
14906 eProsima_user_DllExport void common(
14907 CommonCollectionHeader&& _common)
14908 {
14909 m_common = std::move(_common);
14910 }
14911
14916 eProsima_user_DllExport const CommonCollectionHeader& common() const
14917 {
14918 return m_common;
14919 }
14920
14925 eProsima_user_DllExport CommonCollectionHeader& common()
14926 {
14927 return m_common;
14928 }
14929
14930
14931
14932 private:
14933
14934 CommonCollectionHeader m_common;
14935
14936};
14937
14941 class CompleteSequenceType
14942{
14943 public:
14944
14948 eProsima_user_DllExport CompleteSequenceType()
14949 {
14950 }
14951
14955 eProsima_user_DllExport ~CompleteSequenceType()
14956 {
14957 }
14958
14963 eProsima_user_DllExport CompleteSequenceType(
14964 const CompleteSequenceType& x)
14965 {
14966 m_collection_flag = x.m_collection_flag;
14967
14968 m_header = x.m_header;
14969
14970 m_element = x.m_element;
14971
14972 }
14973
14978 eProsima_user_DllExport CompleteSequenceType(
14979 CompleteSequenceType&& x) noexcept
14980 {
14981 m_collection_flag = std::move(x.m_collection_flag);
14982 m_header = std::move(x.m_header);
14983 m_element = std::move(x.m_element);
14984 }
14985
14990 eProsima_user_DllExport CompleteSequenceType& operator =(
14991 const CompleteSequenceType& x)
14992 {
14993
14994 m_collection_flag = x.m_collection_flag;
14995
14996 m_header = x.m_header;
14997
14998 m_element = x.m_element;
14999
15000 return *this;
15001 }
15002
15007 eProsima_user_DllExport CompleteSequenceType& operator =(
15008 CompleteSequenceType&& x) noexcept
15009 {
15010
15011 m_collection_flag = std::move(x.m_collection_flag);
15012 m_header = std::move(x.m_header);
15013 m_element = std::move(x.m_element);
15014 return *this;
15015 }
15016
15021 eProsima_user_DllExport bool operator ==(
15022 const CompleteSequenceType& x) const
15023 {
15024 return (m_collection_flag == x.m_collection_flag &&
15025 m_header == x.m_header &&
15026 m_element == x.m_element);
15027 }
15028
15033 eProsima_user_DllExport bool operator !=(
15034 const CompleteSequenceType& x) const
15035 {
15036 return !(*this == x);
15037 }
15038
15043 eProsima_user_DllExport void collection_flag(
15044 const CollectionTypeFlag& _collection_flag)
15045 {
15046 m_collection_flag = _collection_flag;
15047 }
15048
15053 eProsima_user_DllExport void collection_flag(
15054 CollectionTypeFlag&& _collection_flag)
15055 {
15056 m_collection_flag = std::move(_collection_flag);
15057 }
15058
15063 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15064 {
15065 return m_collection_flag;
15066 }
15067
15072 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15073 {
15074 return m_collection_flag;
15075 }
15076
15077
15082 eProsima_user_DllExport void header(
15083 const CompleteCollectionHeader& _header)
15084 {
15085 m_header = _header;
15086 }
15087
15092 eProsima_user_DllExport void header(
15093 CompleteCollectionHeader&& _header)
15094 {
15095 m_header = std::move(_header);
15096 }
15097
15102 eProsima_user_DllExport const CompleteCollectionHeader& header() const
15103 {
15104 return m_header;
15105 }
15106
15111 eProsima_user_DllExport CompleteCollectionHeader& header()
15112 {
15113 return m_header;
15114 }
15115
15116
15121 eProsima_user_DllExport void element(
15122 const CompleteCollectionElement& _element)
15123 {
15124 m_element = _element;
15125 }
15126
15131 eProsima_user_DllExport void element(
15132 CompleteCollectionElement&& _element)
15133 {
15134 m_element = std::move(_element);
15135 }
15136
15141 eProsima_user_DllExport const CompleteCollectionElement& element() const
15142 {
15143 return m_element;
15144 }
15145
15150 eProsima_user_DllExport CompleteCollectionElement& element()
15151 {
15152 return m_element;
15153 }
15154
15155
15156
15157 private:
15158
15159 CollectionTypeFlag m_collection_flag{0};
15160 CompleteCollectionHeader m_header;
15161 CompleteCollectionElement m_element;
15162
15163};
15164
15168 class MinimalSequenceType
15169{
15170 public:
15171
15175 eProsima_user_DllExport MinimalSequenceType()
15176 {
15177 }
15178
15182 eProsima_user_DllExport ~MinimalSequenceType()
15183 {
15184 }
15185
15190 eProsima_user_DllExport MinimalSequenceType(
15191 const MinimalSequenceType& x)
15192 {
15193 m_collection_flag = x.m_collection_flag;
15194
15195 m_header = x.m_header;
15196
15197 m_element = x.m_element;
15198
15199 }
15200
15205 eProsima_user_DllExport MinimalSequenceType(
15206 MinimalSequenceType&& x) noexcept
15207 {
15208 m_collection_flag = std::move(x.m_collection_flag);
15209 m_header = std::move(x.m_header);
15210 m_element = std::move(x.m_element);
15211 }
15212
15217 eProsima_user_DllExport MinimalSequenceType& operator =(
15218 const MinimalSequenceType& x)
15219 {
15220
15221 m_collection_flag = x.m_collection_flag;
15222
15223 m_header = x.m_header;
15224
15225 m_element = x.m_element;
15226
15227 return *this;
15228 }
15229
15234 eProsima_user_DllExport MinimalSequenceType& operator =(
15235 MinimalSequenceType&& x) noexcept
15236 {
15237
15238 m_collection_flag = std::move(x.m_collection_flag);
15239 m_header = std::move(x.m_header);
15240 m_element = std::move(x.m_element);
15241 return *this;
15242 }
15243
15248 eProsima_user_DllExport bool operator ==(
15249 const MinimalSequenceType& x) const
15250 {
15251 return (m_collection_flag == x.m_collection_flag &&
15252 m_header == x.m_header &&
15253 m_element == x.m_element);
15254 }
15255
15260 eProsima_user_DllExport bool operator !=(
15261 const MinimalSequenceType& x) const
15262 {
15263 return !(*this == x);
15264 }
15265
15270 eProsima_user_DllExport void collection_flag(
15271 const CollectionTypeFlag& _collection_flag)
15272 {
15273 m_collection_flag = _collection_flag;
15274 }
15275
15280 eProsima_user_DllExport void collection_flag(
15281 CollectionTypeFlag&& _collection_flag)
15282 {
15283 m_collection_flag = std::move(_collection_flag);
15284 }
15285
15290 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15291 {
15292 return m_collection_flag;
15293 }
15294
15299 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15300 {
15301 return m_collection_flag;
15302 }
15303
15304
15309 eProsima_user_DllExport void header(
15310 const MinimalCollectionHeader& _header)
15311 {
15312 m_header = _header;
15313 }
15314
15319 eProsima_user_DllExport void header(
15320 MinimalCollectionHeader&& _header)
15321 {
15322 m_header = std::move(_header);
15323 }
15324
15329 eProsima_user_DllExport const MinimalCollectionHeader& header() const
15330 {
15331 return m_header;
15332 }
15333
15338 eProsima_user_DllExport MinimalCollectionHeader& header()
15339 {
15340 return m_header;
15341 }
15342
15343
15348 eProsima_user_DllExport void element(
15349 const MinimalCollectionElement& _element)
15350 {
15351 m_element = _element;
15352 }
15353
15358 eProsima_user_DllExport void element(
15359 MinimalCollectionElement&& _element)
15360 {
15361 m_element = std::move(_element);
15362 }
15363
15368 eProsima_user_DllExport const MinimalCollectionElement& element() const
15369 {
15370 return m_element;
15371 }
15372
15377 eProsima_user_DllExport MinimalCollectionElement& element()
15378 {
15379 return m_element;
15380 }
15381
15382
15383
15384 private:
15385
15386 CollectionTypeFlag m_collection_flag{0};
15387 MinimalCollectionHeader m_header;
15388 MinimalCollectionElement m_element;
15389
15390};
15391
15395 class CommonArrayHeader
15396{
15397 public:
15398
15402 eProsima_user_DllExport CommonArrayHeader()
15403 {
15404 }
15405
15409 eProsima_user_DllExport ~CommonArrayHeader()
15410 {
15411 }
15412
15417 eProsima_user_DllExport CommonArrayHeader(
15418 const CommonArrayHeader& x)
15419 {
15420 m_bound_seq = x.m_bound_seq;
15421
15422 }
15423
15428 eProsima_user_DllExport CommonArrayHeader(
15429 CommonArrayHeader&& x) noexcept
15430 {
15431 m_bound_seq = std::move(x.m_bound_seq);
15432 }
15433
15438 eProsima_user_DllExport CommonArrayHeader& operator =(
15439 const CommonArrayHeader& x)
15440 {
15441
15442 m_bound_seq = x.m_bound_seq;
15443
15444 return *this;
15445 }
15446
15451 eProsima_user_DllExport CommonArrayHeader& operator =(
15452 CommonArrayHeader&& x) noexcept
15453 {
15454
15455 m_bound_seq = std::move(x.m_bound_seq);
15456 return *this;
15457 }
15458
15463 eProsima_user_DllExport bool operator ==(
15464 const CommonArrayHeader& x) const
15465 {
15466 return (m_bound_seq == x.m_bound_seq);
15467 }
15468
15473 eProsima_user_DllExport bool operator !=(
15474 const CommonArrayHeader& x) const
15475 {
15476 return !(*this == x);
15477 }
15478
15483 eProsima_user_DllExport void bound_seq(
15484 const LBoundSeq& _bound_seq)
15485 {
15486 m_bound_seq = _bound_seq;
15487 }
15488
15493 eProsima_user_DllExport void bound_seq(
15494 LBoundSeq&& _bound_seq)
15495 {
15496 m_bound_seq = std::move(_bound_seq);
15497 }
15498
15503 eProsima_user_DllExport const LBoundSeq& bound_seq() const
15504 {
15505 return m_bound_seq;
15506 }
15507
15512 eProsima_user_DllExport LBoundSeq& bound_seq()
15513 {
15514 return m_bound_seq;
15515 }
15516
15517
15518
15519 private:
15520
15521 LBoundSeq m_bound_seq;
15522
15523};
15524
15528 class CompleteArrayHeader
15529{
15530 public:
15531
15535 eProsima_user_DllExport CompleteArrayHeader()
15536 {
15537 }
15538
15542 eProsima_user_DllExport ~CompleteArrayHeader()
15543 {
15544 }
15545
15550 eProsima_user_DllExport CompleteArrayHeader(
15551 const CompleteArrayHeader& x)
15552 {
15553 m_common = x.m_common;
15554
15555 m_detail = x.m_detail;
15556
15557 }
15558
15563 eProsima_user_DllExport CompleteArrayHeader(
15564 CompleteArrayHeader&& x) noexcept
15565 {
15566 m_common = std::move(x.m_common);
15567 m_detail = std::move(x.m_detail);
15568 }
15569
15574 eProsima_user_DllExport CompleteArrayHeader& operator =(
15575 const CompleteArrayHeader& x)
15576 {
15577
15578 m_common = x.m_common;
15579
15580 m_detail = x.m_detail;
15581
15582 return *this;
15583 }
15584
15589 eProsima_user_DllExport CompleteArrayHeader& operator =(
15590 CompleteArrayHeader&& x) noexcept
15591 {
15592
15593 m_common = std::move(x.m_common);
15594 m_detail = std::move(x.m_detail);
15595 return *this;
15596 }
15597
15602 eProsima_user_DllExport bool operator ==(
15603 const CompleteArrayHeader& x) const
15604 {
15605 return (m_common == x.m_common &&
15606 m_detail == x.m_detail);
15607 }
15608
15613 eProsima_user_DllExport bool operator !=(
15614 const CompleteArrayHeader& x) const
15615 {
15616 return !(*this == x);
15617 }
15618
15623 eProsima_user_DllExport void common(
15624 const CommonArrayHeader& _common)
15625 {
15626 m_common = _common;
15627 }
15628
15633 eProsima_user_DllExport void common(
15634 CommonArrayHeader&& _common)
15635 {
15636 m_common = std::move(_common);
15637 }
15638
15643 eProsima_user_DllExport const CommonArrayHeader& common() const
15644 {
15645 return m_common;
15646 }
15647
15652 eProsima_user_DllExport CommonArrayHeader& common()
15653 {
15654 return m_common;
15655 }
15656
15657
15662 eProsima_user_DllExport void detail(
15663 const CompleteTypeDetail& _detail)
15664 {
15665 m_detail = _detail;
15666 }
15667
15672 eProsima_user_DllExport void detail(
15673 CompleteTypeDetail&& _detail)
15674 {
15675 m_detail = std::move(_detail);
15676 }
15677
15682 eProsima_user_DllExport const CompleteTypeDetail& detail() const
15683 {
15684 return m_detail;
15685 }
15686
15691 eProsima_user_DllExport CompleteTypeDetail& detail()
15692 {
15693 return m_detail;
15694 }
15695
15696
15697
15698 private:
15699
15700 CommonArrayHeader m_common;
15701 CompleteTypeDetail m_detail;
15702
15703};
15704
15708 class MinimalArrayHeader
15709{
15710 public:
15711
15715 eProsima_user_DllExport MinimalArrayHeader()
15716 {
15717 }
15718
15722 eProsima_user_DllExport ~MinimalArrayHeader()
15723 {
15724 }
15725
15730 eProsima_user_DllExport MinimalArrayHeader(
15731 const MinimalArrayHeader& x)
15732 {
15733 m_common = x.m_common;
15734
15735 }
15736
15741 eProsima_user_DllExport MinimalArrayHeader(
15742 MinimalArrayHeader&& x) noexcept
15743 {
15744 m_common = std::move(x.m_common);
15745 }
15746
15751 eProsima_user_DllExport MinimalArrayHeader& operator =(
15752 const MinimalArrayHeader& x)
15753 {
15754
15755 m_common = x.m_common;
15756
15757 return *this;
15758 }
15759
15764 eProsima_user_DllExport MinimalArrayHeader& operator =(
15765 MinimalArrayHeader&& x) noexcept
15766 {
15767
15768 m_common = std::move(x.m_common);
15769 return *this;
15770 }
15771
15776 eProsima_user_DllExport bool operator ==(
15777 const MinimalArrayHeader& x) const
15778 {
15779 return (m_common == x.m_common);
15780 }
15781
15786 eProsima_user_DllExport bool operator !=(
15787 const MinimalArrayHeader& x) const
15788 {
15789 return !(*this == x);
15790 }
15791
15796 eProsima_user_DllExport void common(
15797 const CommonArrayHeader& _common)
15798 {
15799 m_common = _common;
15800 }
15801
15806 eProsima_user_DllExport void common(
15807 CommonArrayHeader&& _common)
15808 {
15809 m_common = std::move(_common);
15810 }
15811
15816 eProsima_user_DllExport const CommonArrayHeader& common() const
15817 {
15818 return m_common;
15819 }
15820
15825 eProsima_user_DllExport CommonArrayHeader& common()
15826 {
15827 return m_common;
15828 }
15829
15830
15831
15832 private:
15833
15834 CommonArrayHeader m_common;
15835
15836};
15837
15841 class CompleteArrayType
15842{
15843 public:
15844
15848 eProsima_user_DllExport CompleteArrayType()
15849 {
15850 }
15851
15855 eProsima_user_DllExport ~CompleteArrayType()
15856 {
15857 }
15858
15863 eProsima_user_DllExport CompleteArrayType(
15864 const CompleteArrayType& x)
15865 {
15866 m_collection_flag = x.m_collection_flag;
15867
15868 m_header = x.m_header;
15869
15870 m_element = x.m_element;
15871
15872 }
15873
15878 eProsima_user_DllExport CompleteArrayType(
15879 CompleteArrayType&& x) noexcept
15880 {
15881 m_collection_flag = std::move(x.m_collection_flag);
15882 m_header = std::move(x.m_header);
15883 m_element = std::move(x.m_element);
15884 }
15885
15890 eProsima_user_DllExport CompleteArrayType& operator =(
15891 const CompleteArrayType& x)
15892 {
15893
15894 m_collection_flag = x.m_collection_flag;
15895
15896 m_header = x.m_header;
15897
15898 m_element = x.m_element;
15899
15900 return *this;
15901 }
15902
15907 eProsima_user_DllExport CompleteArrayType& operator =(
15908 CompleteArrayType&& x) noexcept
15909 {
15910
15911 m_collection_flag = std::move(x.m_collection_flag);
15912 m_header = std::move(x.m_header);
15913 m_element = std::move(x.m_element);
15914 return *this;
15915 }
15916
15921 eProsima_user_DllExport bool operator ==(
15922 const CompleteArrayType& x) const
15923 {
15924 return (m_collection_flag == x.m_collection_flag &&
15925 m_header == x.m_header &&
15926 m_element == x.m_element);
15927 }
15928
15933 eProsima_user_DllExport bool operator !=(
15934 const CompleteArrayType& x) const
15935 {
15936 return !(*this == x);
15937 }
15938
15943 eProsima_user_DllExport void collection_flag(
15944 const CollectionTypeFlag& _collection_flag)
15945 {
15946 m_collection_flag = _collection_flag;
15947 }
15948
15953 eProsima_user_DllExport void collection_flag(
15954 CollectionTypeFlag&& _collection_flag)
15955 {
15956 m_collection_flag = std::move(_collection_flag);
15957 }
15958
15963 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15964 {
15965 return m_collection_flag;
15966 }
15967
15972 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15973 {
15974 return m_collection_flag;
15975 }
15976
15977
15982 eProsima_user_DllExport void header(
15983 const CompleteArrayHeader& _header)
15984 {
15985 m_header = _header;
15986 }
15987
15992 eProsima_user_DllExport void header(
15993 CompleteArrayHeader&& _header)
15994 {
15995 m_header = std::move(_header);
15996 }
15997
16002 eProsima_user_DllExport const CompleteArrayHeader& header() const
16003 {
16004 return m_header;
16005 }
16006
16011 eProsima_user_DllExport CompleteArrayHeader& header()
16012 {
16013 return m_header;
16014 }
16015
16016
16021 eProsima_user_DllExport void element(
16022 const CompleteCollectionElement& _element)
16023 {
16024 m_element = _element;
16025 }
16026
16031 eProsima_user_DllExport void element(
16032 CompleteCollectionElement&& _element)
16033 {
16034 m_element = std::move(_element);
16035 }
16036
16041 eProsima_user_DllExport const CompleteCollectionElement& element() const
16042 {
16043 return m_element;
16044 }
16045
16050 eProsima_user_DllExport CompleteCollectionElement& element()
16051 {
16052 return m_element;
16053 }
16054
16055
16056
16057 private:
16058
16059 CollectionTypeFlag m_collection_flag{0};
16060 CompleteArrayHeader m_header;
16061 CompleteCollectionElement m_element;
16062
16063};
16064
16068 class MinimalArrayType
16069{
16070 public:
16071
16075 eProsima_user_DllExport MinimalArrayType()
16076 {
16077 }
16078
16082 eProsima_user_DllExport ~MinimalArrayType()
16083 {
16084 }
16085
16090 eProsima_user_DllExport MinimalArrayType(
16091 const MinimalArrayType& x)
16092 {
16093 m_collection_flag = x.m_collection_flag;
16094
16095 m_header = x.m_header;
16096
16097 m_element = x.m_element;
16098
16099 }
16100
16105 eProsima_user_DllExport MinimalArrayType(
16106 MinimalArrayType&& x) noexcept
16107 {
16108 m_collection_flag = std::move(x.m_collection_flag);
16109 m_header = std::move(x.m_header);
16110 m_element = std::move(x.m_element);
16111 }
16112
16117 eProsima_user_DllExport MinimalArrayType& operator =(
16118 const MinimalArrayType& x)
16119 {
16120
16121 m_collection_flag = x.m_collection_flag;
16122
16123 m_header = x.m_header;
16124
16125 m_element = x.m_element;
16126
16127 return *this;
16128 }
16129
16134 eProsima_user_DllExport MinimalArrayType& operator =(
16135 MinimalArrayType&& x) noexcept
16136 {
16137
16138 m_collection_flag = std::move(x.m_collection_flag);
16139 m_header = std::move(x.m_header);
16140 m_element = std::move(x.m_element);
16141 return *this;
16142 }
16143
16148 eProsima_user_DllExport bool operator ==(
16149 const MinimalArrayType& x) const
16150 {
16151 return (m_collection_flag == x.m_collection_flag &&
16152 m_header == x.m_header &&
16153 m_element == x.m_element);
16154 }
16155
16160 eProsima_user_DllExport bool operator !=(
16161 const MinimalArrayType& x) const
16162 {
16163 return !(*this == x);
16164 }
16165
16170 eProsima_user_DllExport void collection_flag(
16171 const CollectionTypeFlag& _collection_flag)
16172 {
16173 m_collection_flag = _collection_flag;
16174 }
16175
16180 eProsima_user_DllExport void collection_flag(
16181 CollectionTypeFlag&& _collection_flag)
16182 {
16183 m_collection_flag = std::move(_collection_flag);
16184 }
16185
16190 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16191 {
16192 return m_collection_flag;
16193 }
16194
16199 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16200 {
16201 return m_collection_flag;
16202 }
16203
16204
16209 eProsima_user_DllExport void header(
16210 const MinimalArrayHeader& _header)
16211 {
16212 m_header = _header;
16213 }
16214
16219 eProsima_user_DllExport void header(
16220 MinimalArrayHeader&& _header)
16221 {
16222 m_header = std::move(_header);
16223 }
16224
16229 eProsima_user_DllExport const MinimalArrayHeader& header() const
16230 {
16231 return m_header;
16232 }
16233
16238 eProsima_user_DllExport MinimalArrayHeader& header()
16239 {
16240 return m_header;
16241 }
16242
16243
16248 eProsima_user_DllExport void element(
16249 const MinimalCollectionElement& _element)
16250 {
16251 m_element = _element;
16252 }
16253
16258 eProsima_user_DllExport void element(
16259 MinimalCollectionElement&& _element)
16260 {
16261 m_element = std::move(_element);
16262 }
16263
16268 eProsima_user_DllExport const MinimalCollectionElement& element() const
16269 {
16270 return m_element;
16271 }
16272
16277 eProsima_user_DllExport MinimalCollectionElement& element()
16278 {
16279 return m_element;
16280 }
16281
16282
16283
16284 private:
16285
16286 CollectionTypeFlag m_collection_flag{0};
16287 MinimalArrayHeader m_header;
16288 MinimalCollectionElement m_element;
16289
16290};
16291
16295 class CompleteMapType
16296{
16297 public:
16298
16302 eProsima_user_DllExport CompleteMapType()
16303 {
16304 }
16305
16309 eProsima_user_DllExport ~CompleteMapType()
16310 {
16311 }
16312
16317 eProsima_user_DllExport CompleteMapType(
16318 const CompleteMapType& x)
16319 {
16320 m_collection_flag = x.m_collection_flag;
16321
16322 m_header = x.m_header;
16323
16324 m_key = x.m_key;
16325
16326 m_element = x.m_element;
16327
16328 }
16329
16334 eProsima_user_DllExport CompleteMapType(
16335 CompleteMapType&& x) noexcept
16336 {
16337 m_collection_flag = std::move(x.m_collection_flag);
16338 m_header = std::move(x.m_header);
16339 m_key = std::move(x.m_key);
16340 m_element = std::move(x.m_element);
16341 }
16342
16347 eProsima_user_DllExport CompleteMapType& operator =(
16348 const CompleteMapType& x)
16349 {
16350
16351 m_collection_flag = x.m_collection_flag;
16352
16353 m_header = x.m_header;
16354
16355 m_key = x.m_key;
16356
16357 m_element = x.m_element;
16358
16359 return *this;
16360 }
16361
16366 eProsima_user_DllExport CompleteMapType& operator =(
16367 CompleteMapType&& x) noexcept
16368 {
16369
16370 m_collection_flag = std::move(x.m_collection_flag);
16371 m_header = std::move(x.m_header);
16372 m_key = std::move(x.m_key);
16373 m_element = std::move(x.m_element);
16374 return *this;
16375 }
16376
16381 eProsima_user_DllExport bool operator ==(
16382 const CompleteMapType& x) const
16383 {
16384 return (m_collection_flag == x.m_collection_flag &&
16385 m_header == x.m_header &&
16386 m_key == x.m_key &&
16387 m_element == x.m_element);
16388 }
16389
16394 eProsima_user_DllExport bool operator !=(
16395 const CompleteMapType& x) const
16396 {
16397 return !(*this == x);
16398 }
16399
16404 eProsima_user_DllExport void collection_flag(
16405 const CollectionTypeFlag& _collection_flag)
16406 {
16407 m_collection_flag = _collection_flag;
16408 }
16409
16414 eProsima_user_DllExport void collection_flag(
16415 CollectionTypeFlag&& _collection_flag)
16416 {
16417 m_collection_flag = std::move(_collection_flag);
16418 }
16419
16424 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16425 {
16426 return m_collection_flag;
16427 }
16428
16433 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16434 {
16435 return m_collection_flag;
16436 }
16437
16438
16443 eProsima_user_DllExport void header(
16444 const CompleteCollectionHeader& _header)
16445 {
16446 m_header = _header;
16447 }
16448
16453 eProsima_user_DllExport void header(
16454 CompleteCollectionHeader&& _header)
16455 {
16456 m_header = std::move(_header);
16457 }
16458
16463 eProsima_user_DllExport const CompleteCollectionHeader& header() const
16464 {
16465 return m_header;
16466 }
16467
16472 eProsima_user_DllExport CompleteCollectionHeader& header()
16473 {
16474 return m_header;
16475 }
16476
16477
16482 eProsima_user_DllExport void key(
16483 const CompleteCollectionElement& _key)
16484 {
16485 m_key = _key;
16486 }
16487
16492 eProsima_user_DllExport void key(
16493 CompleteCollectionElement&& _key)
16494 {
16495 m_key = std::move(_key);
16496 }
16497
16502 eProsima_user_DllExport const CompleteCollectionElement& key() const
16503 {
16504 return m_key;
16505 }
16506
16511 eProsima_user_DllExport CompleteCollectionElement& key()
16512 {
16513 return m_key;
16514 }
16515
16516
16521 eProsima_user_DllExport void element(
16522 const CompleteCollectionElement& _element)
16523 {
16524 m_element = _element;
16525 }
16526
16531 eProsima_user_DllExport void element(
16532 CompleteCollectionElement&& _element)
16533 {
16534 m_element = std::move(_element);
16535 }
16536
16541 eProsima_user_DllExport const CompleteCollectionElement& element() const
16542 {
16543 return m_element;
16544 }
16545
16550 eProsima_user_DllExport CompleteCollectionElement& element()
16551 {
16552 return m_element;
16553 }
16554
16555
16556
16557 private:
16558
16559 CollectionTypeFlag m_collection_flag{0};
16560 CompleteCollectionHeader m_header;
16561 CompleteCollectionElement m_key;
16562 CompleteCollectionElement m_element;
16563
16564};
16565
16569 class MinimalMapType
16570{
16571 public:
16572
16576 eProsima_user_DllExport MinimalMapType()
16577 {
16578 }
16579
16583 eProsima_user_DllExport ~MinimalMapType()
16584 {
16585 }
16586
16591 eProsima_user_DllExport MinimalMapType(
16592 const MinimalMapType& x)
16593 {
16594 m_collection_flag = x.m_collection_flag;
16595
16596 m_header = x.m_header;
16597
16598 m_key = x.m_key;
16599
16600 m_element = x.m_element;
16601
16602 }
16603
16608 eProsima_user_DllExport MinimalMapType(
16609 MinimalMapType&& x) noexcept
16610 {
16611 m_collection_flag = std::move(x.m_collection_flag);
16612 m_header = std::move(x.m_header);
16613 m_key = std::move(x.m_key);
16614 m_element = std::move(x.m_element);
16615 }
16616
16621 eProsima_user_DllExport MinimalMapType& operator =(
16622 const MinimalMapType& x)
16623 {
16624
16625 m_collection_flag = x.m_collection_flag;
16626
16627 m_header = x.m_header;
16628
16629 m_key = x.m_key;
16630
16631 m_element = x.m_element;
16632
16633 return *this;
16634 }
16635
16640 eProsima_user_DllExport MinimalMapType& operator =(
16641 MinimalMapType&& x) noexcept
16642 {
16643
16644 m_collection_flag = std::move(x.m_collection_flag);
16645 m_header = std::move(x.m_header);
16646 m_key = std::move(x.m_key);
16647 m_element = std::move(x.m_element);
16648 return *this;
16649 }
16650
16655 eProsima_user_DllExport bool operator ==(
16656 const MinimalMapType& x) const
16657 {
16658 return (m_collection_flag == x.m_collection_flag &&
16659 m_header == x.m_header &&
16660 m_key == x.m_key &&
16661 m_element == x.m_element);
16662 }
16663
16668 eProsima_user_DllExport bool operator !=(
16669 const MinimalMapType& x) const
16670 {
16671 return !(*this == x);
16672 }
16673
16678 eProsima_user_DllExport void collection_flag(
16679 const CollectionTypeFlag& _collection_flag)
16680 {
16681 m_collection_flag = _collection_flag;
16682 }
16683
16688 eProsima_user_DllExport void collection_flag(
16689 CollectionTypeFlag&& _collection_flag)
16690 {
16691 m_collection_flag = std::move(_collection_flag);
16692 }
16693
16698 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16699 {
16700 return m_collection_flag;
16701 }
16702
16707 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16708 {
16709 return m_collection_flag;
16710 }
16711
16712
16717 eProsima_user_DllExport void header(
16718 const MinimalCollectionHeader& _header)
16719 {
16720 m_header = _header;
16721 }
16722
16727 eProsima_user_DllExport void header(
16728 MinimalCollectionHeader&& _header)
16729 {
16730 m_header = std::move(_header);
16731 }
16732
16737 eProsima_user_DllExport const MinimalCollectionHeader& header() const
16738 {
16739 return m_header;
16740 }
16741
16746 eProsima_user_DllExport MinimalCollectionHeader& header()
16747 {
16748 return m_header;
16749 }
16750
16751
16756 eProsima_user_DllExport void key(
16757 const MinimalCollectionElement& _key)
16758 {
16759 m_key = _key;
16760 }
16761
16766 eProsima_user_DllExport void key(
16767 MinimalCollectionElement&& _key)
16768 {
16769 m_key = std::move(_key);
16770 }
16771
16776 eProsima_user_DllExport const MinimalCollectionElement& key() const
16777 {
16778 return m_key;
16779 }
16780
16785 eProsima_user_DllExport MinimalCollectionElement& key()
16786 {
16787 return m_key;
16788 }
16789
16790
16795 eProsima_user_DllExport void element(
16796 const MinimalCollectionElement& _element)
16797 {
16798 m_element = _element;
16799 }
16800
16805 eProsima_user_DllExport void element(
16806 MinimalCollectionElement&& _element)
16807 {
16808 m_element = std::move(_element);
16809 }
16810
16815 eProsima_user_DllExport const MinimalCollectionElement& element() const
16816 {
16817 return m_element;
16818 }
16819
16824 eProsima_user_DllExport MinimalCollectionElement& element()
16825 {
16826 return m_element;
16827 }
16828
16829
16830
16831 private:
16832
16833 CollectionTypeFlag m_collection_flag{0};
16834 MinimalCollectionHeader m_header;
16835 MinimalCollectionElement m_key;
16836 MinimalCollectionElement m_element;
16837
16838};
16839 typedef uint16_t BitBound;
16840
16845 class CommonEnumeratedLiteral
16846{
16847 public:
16848
16852 eProsima_user_DllExport CommonEnumeratedLiteral()
16853 {
16854 }
16855
16859 eProsima_user_DllExport ~CommonEnumeratedLiteral()
16860 {
16861 }
16862
16867 eProsima_user_DllExport CommonEnumeratedLiteral(
16868 const CommonEnumeratedLiteral& x)
16869 {
16870 m_value = x.m_value;
16871
16872 m_flags = x.m_flags;
16873
16874 }
16875
16880 eProsima_user_DllExport CommonEnumeratedLiteral(
16881 CommonEnumeratedLiteral&& x) noexcept
16882 {
16883 m_value = x.m_value;
16884 m_flags = std::move(x.m_flags);
16885 }
16886
16891 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16892 const CommonEnumeratedLiteral& x)
16893 {
16894
16895 m_value = x.m_value;
16896
16897 m_flags = x.m_flags;
16898
16899 return *this;
16900 }
16901
16906 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16907 CommonEnumeratedLiteral&& x) noexcept
16908 {
16909
16910 m_value = x.m_value;
16911 m_flags = std::move(x.m_flags);
16912 return *this;
16913 }
16914
16919 eProsima_user_DllExport bool operator ==(
16920 const CommonEnumeratedLiteral& x) const
16921 {
16922 return (m_value == x.m_value &&
16923 m_flags == x.m_flags);
16924 }
16925
16930 eProsima_user_DllExport bool operator !=(
16931 const CommonEnumeratedLiteral& x) const
16932 {
16933 return !(*this == x);
16934 }
16935
16940 eProsima_user_DllExport void value(
16941 int32_t _value)
16942 {
16943 m_value = _value;
16944 }
16945
16950 eProsima_user_DllExport int32_t value() const
16951 {
16952 return m_value;
16953 }
16954
16959 eProsima_user_DllExport int32_t& value()
16960 {
16961 return m_value;
16962 }
16963
16964
16969 eProsima_user_DllExport void flags(
16970 const EnumeratedLiteralFlag& _flags)
16971 {
16972 m_flags = _flags;
16973 }
16974
16979 eProsima_user_DllExport void flags(
16980 EnumeratedLiteralFlag&& _flags)
16981 {
16982 m_flags = std::move(_flags);
16983 }
16984
16989 eProsima_user_DllExport const EnumeratedLiteralFlag& flags() const
16990 {
16991 return m_flags;
16992 }
16993
16998 eProsima_user_DllExport EnumeratedLiteralFlag& flags()
16999 {
17000 return m_flags;
17001 }
17002
17003
17004
17005 private:
17006
17007 int32_t m_value{0};
17008 EnumeratedLiteralFlag m_flags{0};
17009
17010};
17011
17015 class CompleteEnumeratedLiteral
17016{
17017 public:
17018
17022 eProsima_user_DllExport CompleteEnumeratedLiteral()
17023 {
17024 }
17025
17029 eProsima_user_DllExport ~CompleteEnumeratedLiteral()
17030 {
17031 }
17032
17037 eProsima_user_DllExport CompleteEnumeratedLiteral(
17038 const CompleteEnumeratedLiteral& x)
17039 {
17040 m_common = x.m_common;
17041
17042 m_detail = x.m_detail;
17043
17044 }
17045
17050 eProsima_user_DllExport CompleteEnumeratedLiteral(
17051 CompleteEnumeratedLiteral&& x) noexcept
17052 {
17053 m_common = std::move(x.m_common);
17054 m_detail = std::move(x.m_detail);
17055 }
17056
17061 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
17062 const CompleteEnumeratedLiteral& x)
17063 {
17064
17065 m_common = x.m_common;
17066
17067 m_detail = x.m_detail;
17068
17069 return *this;
17070 }
17071
17076 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
17077 CompleteEnumeratedLiteral&& x) noexcept
17078 {
17079
17080 m_common = std::move(x.m_common);
17081 m_detail = std::move(x.m_detail);
17082 return *this;
17083 }
17084
17089 eProsima_user_DllExport bool operator ==(
17090 const CompleteEnumeratedLiteral& x) const
17091 {
17092 return (m_common == x.m_common &&
17093 m_detail == x.m_detail);
17094 }
17095
17100 eProsima_user_DllExport bool operator !=(
17101 const CompleteEnumeratedLiteral& x) const
17102 {
17103 return !(*this == x);
17104 }
17105
17110 eProsima_user_DllExport void common(
17111 const CommonEnumeratedLiteral& _common)
17112 {
17113 m_common = _common;
17114 }
17115
17120 eProsima_user_DllExport void common(
17121 CommonEnumeratedLiteral&& _common)
17122 {
17123 m_common = std::move(_common);
17124 }
17125
17130 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17131 {
17132 return m_common;
17133 }
17134
17139 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17140 {
17141 return m_common;
17142 }
17143
17144
17149 eProsima_user_DllExport void detail(
17150 const CompleteMemberDetail& _detail)
17151 {
17152 m_detail = _detail;
17153 }
17154
17159 eProsima_user_DllExport void detail(
17160 CompleteMemberDetail&& _detail)
17161 {
17162 m_detail = std::move(_detail);
17163 }
17164
17169 eProsima_user_DllExport const CompleteMemberDetail& detail() const
17170 {
17171 return m_detail;
17172 }
17173
17178 eProsima_user_DllExport CompleteMemberDetail& detail()
17179 {
17180 return m_detail;
17181 }
17182
17183
17184
17185 private:
17186
17187 CommonEnumeratedLiteral m_common;
17188 CompleteMemberDetail m_detail;
17189
17190};
17191 typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
17192
17197 class MinimalEnumeratedLiteral
17198{
17199 public:
17200
17204 eProsima_user_DllExport MinimalEnumeratedLiteral()
17205 {
17206 }
17207
17211 eProsima_user_DllExport ~MinimalEnumeratedLiteral()
17212 {
17213 }
17214
17219 eProsima_user_DllExport MinimalEnumeratedLiteral(
17220 const MinimalEnumeratedLiteral& x)
17221 {
17222 m_common = x.m_common;
17223
17224 m_detail = x.m_detail;
17225
17226 }
17227
17232 eProsima_user_DllExport MinimalEnumeratedLiteral(
17233 MinimalEnumeratedLiteral&& x) noexcept
17234 {
17235 m_common = std::move(x.m_common);
17236 m_detail = std::move(x.m_detail);
17237 }
17238
17243 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17244 const MinimalEnumeratedLiteral& x)
17245 {
17246
17247 m_common = x.m_common;
17248
17249 m_detail = x.m_detail;
17250
17251 return *this;
17252 }
17253
17258 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17259 MinimalEnumeratedLiteral&& x) noexcept
17260 {
17261
17262 m_common = std::move(x.m_common);
17263 m_detail = std::move(x.m_detail);
17264 return *this;
17265 }
17266
17271 eProsima_user_DllExport bool operator ==(
17272 const MinimalEnumeratedLiteral& x) const
17273 {
17274 return (m_common == x.m_common &&
17275 m_detail == x.m_detail);
17276 }
17277
17282 eProsima_user_DllExport bool operator !=(
17283 const MinimalEnumeratedLiteral& x) const
17284 {
17285 return !(*this == x);
17286 }
17287
17292 eProsima_user_DllExport void common(
17293 const CommonEnumeratedLiteral& _common)
17294 {
17295 m_common = _common;
17296 }
17297
17302 eProsima_user_DllExport void common(
17303 CommonEnumeratedLiteral&& _common)
17304 {
17305 m_common = std::move(_common);
17306 }
17307
17312 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17313 {
17314 return m_common;
17315 }
17316
17321 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17322 {
17323 return m_common;
17324 }
17325
17326
17331 eProsima_user_DllExport void detail(
17332 const MinimalMemberDetail& _detail)
17333 {
17334 m_detail = _detail;
17335 }
17336
17341 eProsima_user_DllExport void detail(
17342 MinimalMemberDetail&& _detail)
17343 {
17344 m_detail = std::move(_detail);
17345 }
17346
17351 eProsima_user_DllExport const MinimalMemberDetail& detail() const
17352 {
17353 return m_detail;
17354 }
17355
17360 eProsima_user_DllExport MinimalMemberDetail& detail()
17361 {
17362 return m_detail;
17363 }
17364
17365
17366
17367 private:
17368
17369 CommonEnumeratedLiteral m_common;
17370 MinimalMemberDetail m_detail;
17371
17372};
17373 typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
17374
17379 class CommonEnumeratedHeader
17380{
17381 public:
17382
17386 eProsima_user_DllExport CommonEnumeratedHeader()
17387 {
17388 }
17389
17393 eProsima_user_DllExport ~CommonEnumeratedHeader()
17394 {
17395 }
17396
17401 eProsima_user_DllExport CommonEnumeratedHeader(
17402 const CommonEnumeratedHeader& x)
17403 {
17404 m_bit_bound = x.m_bit_bound;
17405
17406 }
17407
17412 eProsima_user_DllExport CommonEnumeratedHeader(
17413 CommonEnumeratedHeader&& x) noexcept
17414 {
17415 m_bit_bound = x.m_bit_bound;
17416 }
17417
17422 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17423 const CommonEnumeratedHeader& x)
17424 {
17425
17426 m_bit_bound = x.m_bit_bound;
17427
17428 return *this;
17429 }
17430
17435 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17436 CommonEnumeratedHeader&& x) noexcept
17437 {
17438
17439 m_bit_bound = x.m_bit_bound;
17440 return *this;
17441 }
17442
17447 eProsima_user_DllExport bool operator ==(
17448 const CommonEnumeratedHeader& x) const
17449 {
17450 return (m_bit_bound == x.m_bit_bound);
17451 }
17452
17457 eProsima_user_DllExport bool operator !=(
17458 const CommonEnumeratedHeader& x) const
17459 {
17460 return !(*this == x);
17461 }
17462
17467 eProsima_user_DllExport void bit_bound(
17468 BitBound _bit_bound)
17469 {
17470 m_bit_bound = _bit_bound;
17471 }
17472
17477 eProsima_user_DllExport BitBound bit_bound() const
17478 {
17479 return m_bit_bound;
17480 }
17481
17486 eProsima_user_DllExport BitBound& bit_bound()
17487 {
17488 return m_bit_bound;
17489 }
17490
17491
17492
17493 private:
17494
17495 BitBound m_bit_bound{0};
17496
17497};
17498
17502 class CompleteEnumeratedHeader
17503{
17504 public:
17505
17509 eProsima_user_DllExport CompleteEnumeratedHeader()
17510 {
17511 }
17512
17516 eProsima_user_DllExport ~CompleteEnumeratedHeader()
17517 {
17518 }
17519
17524 eProsima_user_DllExport CompleteEnumeratedHeader(
17525 const CompleteEnumeratedHeader& x)
17526 {
17527 m_common = x.m_common;
17528
17529 m_detail = x.m_detail;
17530
17531 }
17532
17537 eProsima_user_DllExport CompleteEnumeratedHeader(
17538 CompleteEnumeratedHeader&& x) noexcept
17539 {
17540 m_common = std::move(x.m_common);
17541 m_detail = std::move(x.m_detail);
17542 }
17543
17548 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17549 const CompleteEnumeratedHeader& x)
17550 {
17551
17552 m_common = x.m_common;
17553
17554 m_detail = x.m_detail;
17555
17556 return *this;
17557 }
17558
17563 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17564 CompleteEnumeratedHeader&& x) noexcept
17565 {
17566
17567 m_common = std::move(x.m_common);
17568 m_detail = std::move(x.m_detail);
17569 return *this;
17570 }
17571
17576 eProsima_user_DllExport bool operator ==(
17577 const CompleteEnumeratedHeader& x) const
17578 {
17579 return (m_common == x.m_common &&
17580 m_detail == x.m_detail);
17581 }
17582
17587 eProsima_user_DllExport bool operator !=(
17588 const CompleteEnumeratedHeader& x) const
17589 {
17590 return !(*this == x);
17591 }
17592
17597 eProsima_user_DllExport void common(
17598 const CommonEnumeratedHeader& _common)
17599 {
17600 m_common = _common;
17601 }
17602
17607 eProsima_user_DllExport void common(
17608 CommonEnumeratedHeader&& _common)
17609 {
17610 m_common = std::move(_common);
17611 }
17612
17617 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17618 {
17619 return m_common;
17620 }
17621
17626 eProsima_user_DllExport CommonEnumeratedHeader& common()
17627 {
17628 return m_common;
17629 }
17630
17631
17636 eProsima_user_DllExport void detail(
17637 const CompleteTypeDetail& _detail)
17638 {
17639 m_detail = _detail;
17640 }
17641
17646 eProsima_user_DllExport void detail(
17647 CompleteTypeDetail&& _detail)
17648 {
17649 m_detail = std::move(_detail);
17650 }
17651
17656 eProsima_user_DllExport const CompleteTypeDetail& detail() const
17657 {
17658 return m_detail;
17659 }
17660
17665 eProsima_user_DllExport CompleteTypeDetail& detail()
17666 {
17667 return m_detail;
17668 }
17669
17670
17671
17672 private:
17673
17674 CommonEnumeratedHeader m_common;
17675 CompleteTypeDetail m_detail;
17676
17677};
17678
17682 class MinimalEnumeratedHeader
17683{
17684 public:
17685
17689 eProsima_user_DllExport MinimalEnumeratedHeader()
17690 {
17691 }
17692
17696 eProsima_user_DllExport ~MinimalEnumeratedHeader()
17697 {
17698 }
17699
17704 eProsima_user_DllExport MinimalEnumeratedHeader(
17705 const MinimalEnumeratedHeader& x)
17706 {
17707 m_common = x.m_common;
17708
17709 }
17710
17715 eProsima_user_DllExport MinimalEnumeratedHeader(
17716 MinimalEnumeratedHeader&& x) noexcept
17717 {
17718 m_common = std::move(x.m_common);
17719 }
17720
17725 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17726 const MinimalEnumeratedHeader& x)
17727 {
17728
17729 m_common = x.m_common;
17730
17731 return *this;
17732 }
17733
17738 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17739 MinimalEnumeratedHeader&& x) noexcept
17740 {
17741
17742 m_common = std::move(x.m_common);
17743 return *this;
17744 }
17745
17750 eProsima_user_DllExport bool operator ==(
17751 const MinimalEnumeratedHeader& x) const
17752 {
17753 return (m_common == x.m_common);
17754 }
17755
17760 eProsima_user_DllExport bool operator !=(
17761 const MinimalEnumeratedHeader& x) const
17762 {
17763 return !(*this == x);
17764 }
17765
17770 eProsima_user_DllExport void common(
17771 const CommonEnumeratedHeader& _common)
17772 {
17773 m_common = _common;
17774 }
17775
17780 eProsima_user_DllExport void common(
17781 CommonEnumeratedHeader&& _common)
17782 {
17783 m_common = std::move(_common);
17784 }
17785
17790 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17791 {
17792 return m_common;
17793 }
17794
17799 eProsima_user_DllExport CommonEnumeratedHeader& common()
17800 {
17801 return m_common;
17802 }
17803
17804
17805
17806 private:
17807
17808 CommonEnumeratedHeader m_common;
17809
17810};
17811
17815 class CompleteEnumeratedType
17816{
17817 public:
17818
17822 eProsima_user_DllExport CompleteEnumeratedType()
17823 {
17824 }
17825
17829 eProsima_user_DllExport ~CompleteEnumeratedType()
17830 {
17831 }
17832
17837 eProsima_user_DllExport CompleteEnumeratedType(
17838 const CompleteEnumeratedType& x)
17839 {
17840 m_enum_flags = x.m_enum_flags;
17841
17842 m_header = x.m_header;
17843
17844 m_literal_seq = x.m_literal_seq;
17845
17846 }
17847
17852 eProsima_user_DllExport CompleteEnumeratedType(
17853 CompleteEnumeratedType&& x) noexcept
17854 {
17855 m_enum_flags = std::move(x.m_enum_flags);
17856 m_header = std::move(x.m_header);
17857 m_literal_seq = std::move(x.m_literal_seq);
17858 }
17859
17864 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17865 const CompleteEnumeratedType& x)
17866 {
17867
17868 m_enum_flags = x.m_enum_flags;
17869
17870 m_header = x.m_header;
17871
17872 m_literal_seq = x.m_literal_seq;
17873
17874 return *this;
17875 }
17876
17881 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17882 CompleteEnumeratedType&& x) noexcept
17883 {
17884
17885 m_enum_flags = std::move(x.m_enum_flags);
17886 m_header = std::move(x.m_header);
17887 m_literal_seq = std::move(x.m_literal_seq);
17888 return *this;
17889 }
17890
17895 eProsima_user_DllExport bool operator ==(
17896 const CompleteEnumeratedType& x) const
17897 {
17898 return (m_enum_flags == x.m_enum_flags &&
17899 m_header == x.m_header &&
17900 m_literal_seq == x.m_literal_seq);
17901 }
17902
17907 eProsima_user_DllExport bool operator !=(
17908 const CompleteEnumeratedType& x) const
17909 {
17910 return !(*this == x);
17911 }
17912
17917 eProsima_user_DllExport void enum_flags(
17918 const EnumTypeFlag& _enum_flags)
17919 {
17920 m_enum_flags = _enum_flags;
17921 }
17922
17927 eProsima_user_DllExport void enum_flags(
17928 EnumTypeFlag&& _enum_flags)
17929 {
17930 m_enum_flags = std::move(_enum_flags);
17931 }
17932
17937 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
17938 {
17939 return m_enum_flags;
17940 }
17941
17946 eProsima_user_DllExport EnumTypeFlag& enum_flags()
17947 {
17948 return m_enum_flags;
17949 }
17950
17951
17956 eProsima_user_DllExport void header(
17957 const CompleteEnumeratedHeader& _header)
17958 {
17959 m_header = _header;
17960 }
17961
17966 eProsima_user_DllExport void header(
17967 CompleteEnumeratedHeader&& _header)
17968 {
17969 m_header = std::move(_header);
17970 }
17971
17976 eProsima_user_DllExport const CompleteEnumeratedHeader& header() const
17977 {
17978 return m_header;
17979 }
17980
17985 eProsima_user_DllExport CompleteEnumeratedHeader& header()
17986 {
17987 return m_header;
17988 }
17989
17990
17995 eProsima_user_DllExport void literal_seq(
17996 const CompleteEnumeratedLiteralSeq& _literal_seq)
17997 {
17998 m_literal_seq = _literal_seq;
17999 }
18000
18005 eProsima_user_DllExport void literal_seq(
18006 CompleteEnumeratedLiteralSeq&& _literal_seq)
18007 {
18008 m_literal_seq = std::move(_literal_seq);
18009 }
18010
18015 eProsima_user_DllExport const CompleteEnumeratedLiteralSeq& literal_seq() const
18016 {
18017 return m_literal_seq;
18018 }
18019
18024 eProsima_user_DllExport CompleteEnumeratedLiteralSeq& literal_seq()
18025 {
18026 return m_literal_seq;
18027 }
18028
18029
18030
18031 private:
18032
18033 EnumTypeFlag m_enum_flags{0};
18034 CompleteEnumeratedHeader m_header;
18035 CompleteEnumeratedLiteralSeq m_literal_seq;
18036
18037};
18038
18042 class MinimalEnumeratedType
18043{
18044 public:
18045
18049 eProsima_user_DllExport MinimalEnumeratedType()
18050 {
18051 }
18052
18056 eProsima_user_DllExport ~MinimalEnumeratedType()
18057 {
18058 }
18059
18064 eProsima_user_DllExport MinimalEnumeratedType(
18065 const MinimalEnumeratedType& x)
18066 {
18067 m_enum_flags = x.m_enum_flags;
18068
18069 m_header = x.m_header;
18070
18071 m_literal_seq = x.m_literal_seq;
18072
18073 }
18074
18079 eProsima_user_DllExport MinimalEnumeratedType(
18080 MinimalEnumeratedType&& x) noexcept
18081 {
18082 m_enum_flags = std::move(x.m_enum_flags);
18083 m_header = std::move(x.m_header);
18084 m_literal_seq = std::move(x.m_literal_seq);
18085 }
18086
18091 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18092 const MinimalEnumeratedType& x)
18093 {
18094
18095 m_enum_flags = x.m_enum_flags;
18096
18097 m_header = x.m_header;
18098
18099 m_literal_seq = x.m_literal_seq;
18100
18101 return *this;
18102 }
18103
18108 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18109 MinimalEnumeratedType&& x) noexcept
18110 {
18111
18112 m_enum_flags = std::move(x.m_enum_flags);
18113 m_header = std::move(x.m_header);
18114 m_literal_seq = std::move(x.m_literal_seq);
18115 return *this;
18116 }
18117
18122 eProsima_user_DllExport bool operator ==(
18123 const MinimalEnumeratedType& x) const
18124 {
18125 return (m_enum_flags == x.m_enum_flags &&
18126 m_header == x.m_header &&
18127 m_literal_seq == x.m_literal_seq);
18128 }
18129
18134 eProsima_user_DllExport bool operator !=(
18135 const MinimalEnumeratedType& x) const
18136 {
18137 return !(*this == x);
18138 }
18139
18144 eProsima_user_DllExport void enum_flags(
18145 const EnumTypeFlag& _enum_flags)
18146 {
18147 m_enum_flags = _enum_flags;
18148 }
18149
18154 eProsima_user_DllExport void enum_flags(
18155 EnumTypeFlag&& _enum_flags)
18156 {
18157 m_enum_flags = std::move(_enum_flags);
18158 }
18159
18164 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
18165 {
18166 return m_enum_flags;
18167 }
18168
18173 eProsima_user_DllExport EnumTypeFlag& enum_flags()
18174 {
18175 return m_enum_flags;
18176 }
18177
18178
18183 eProsima_user_DllExport void header(
18184 const MinimalEnumeratedHeader& _header)
18185 {
18186 m_header = _header;
18187 }
18188
18193 eProsima_user_DllExport void header(
18194 MinimalEnumeratedHeader&& _header)
18195 {
18196 m_header = std::move(_header);
18197 }
18198
18203 eProsima_user_DllExport const MinimalEnumeratedHeader& header() const
18204 {
18205 return m_header;
18206 }
18207
18212 eProsima_user_DllExport MinimalEnumeratedHeader& header()
18213 {
18214 return m_header;
18215 }
18216
18217
18222 eProsima_user_DllExport void literal_seq(
18223 const MinimalEnumeratedLiteralSeq& _literal_seq)
18224 {
18225 m_literal_seq = _literal_seq;
18226 }
18227
18232 eProsima_user_DllExport void literal_seq(
18233 MinimalEnumeratedLiteralSeq&& _literal_seq)
18234 {
18235 m_literal_seq = std::move(_literal_seq);
18236 }
18237
18242 eProsima_user_DllExport const MinimalEnumeratedLiteralSeq& literal_seq() const
18243 {
18244 return m_literal_seq;
18245 }
18246
18251 eProsima_user_DllExport MinimalEnumeratedLiteralSeq& literal_seq()
18252 {
18253 return m_literal_seq;
18254 }
18255
18256
18257
18258 private:
18259
18260 EnumTypeFlag m_enum_flags{0};
18261 MinimalEnumeratedHeader m_header;
18262 MinimalEnumeratedLiteralSeq m_literal_seq;
18263
18264};
18265
18269 class CommonBitflag
18270{
18271 public:
18272
18276 eProsima_user_DllExport CommonBitflag()
18277 {
18278 }
18279
18283 eProsima_user_DllExport ~CommonBitflag()
18284 {
18285 }
18286
18291 eProsima_user_DllExport CommonBitflag(
18292 const CommonBitflag& x)
18293 {
18294 m_position = x.m_position;
18295
18296 m_flags = x.m_flags;
18297
18298 }
18299
18304 eProsima_user_DllExport CommonBitflag(
18305 CommonBitflag&& x) noexcept
18306 {
18307 m_position = x.m_position;
18308 m_flags = std::move(x.m_flags);
18309 }
18310
18315 eProsima_user_DllExport CommonBitflag& operator =(
18316 const CommonBitflag& x)
18317 {
18318
18319 m_position = x.m_position;
18320
18321 m_flags = x.m_flags;
18322
18323 return *this;
18324 }
18325
18330 eProsima_user_DllExport CommonBitflag& operator =(
18331 CommonBitflag&& x) noexcept
18332 {
18333
18334 m_position = x.m_position;
18335 m_flags = std::move(x.m_flags);
18336 return *this;
18337 }
18338
18343 eProsima_user_DllExport bool operator ==(
18344 const CommonBitflag& x) const
18345 {
18346 return (m_position == x.m_position &&
18347 m_flags == x.m_flags);
18348 }
18349
18354 eProsima_user_DllExport bool operator !=(
18355 const CommonBitflag& x) const
18356 {
18357 return !(*this == x);
18358 }
18359
18364 eProsima_user_DllExport void position(
18365 uint16_t _position)
18366 {
18367 m_position = _position;
18368 }
18369
18374 eProsima_user_DllExport uint16_t position() const
18375 {
18376 return m_position;
18377 }
18378
18383 eProsima_user_DllExport uint16_t& position()
18384 {
18385 return m_position;
18386 }
18387
18388
18393 eProsima_user_DllExport void flags(
18394 const BitflagFlag& _flags)
18395 {
18396 m_flags = _flags;
18397 }
18398
18403 eProsima_user_DllExport void flags(
18404 BitflagFlag&& _flags)
18405 {
18406 m_flags = std::move(_flags);
18407 }
18408
18413 eProsima_user_DllExport const BitflagFlag& flags() const
18414 {
18415 return m_flags;
18416 }
18417
18422 eProsima_user_DllExport BitflagFlag& flags()
18423 {
18424 return m_flags;
18425 }
18426
18427
18428
18429 private:
18430
18431 uint16_t m_position{0};
18432 BitflagFlag m_flags{0};
18433
18434};
18435
18439 class CompleteBitflag
18440{
18441 public:
18442
18446 eProsima_user_DllExport CompleteBitflag()
18447 {
18448 }
18449
18453 eProsima_user_DllExport ~CompleteBitflag()
18454 {
18455 }
18456
18461 eProsima_user_DllExport CompleteBitflag(
18462 const CompleteBitflag& x)
18463 {
18464 m_common = x.m_common;
18465
18466 m_detail = x.m_detail;
18467
18468 }
18469
18474 eProsima_user_DllExport CompleteBitflag(
18475 CompleteBitflag&& x) noexcept
18476 {
18477 m_common = std::move(x.m_common);
18478 m_detail = std::move(x.m_detail);
18479 }
18480
18485 eProsima_user_DllExport CompleteBitflag& operator =(
18486 const CompleteBitflag& x)
18487 {
18488
18489 m_common = x.m_common;
18490
18491 m_detail = x.m_detail;
18492
18493 return *this;
18494 }
18495
18500 eProsima_user_DllExport CompleteBitflag& operator =(
18501 CompleteBitflag&& x) noexcept
18502 {
18503
18504 m_common = std::move(x.m_common);
18505 m_detail = std::move(x.m_detail);
18506 return *this;
18507 }
18508
18513 eProsima_user_DllExport bool operator ==(
18514 const CompleteBitflag& x) const
18515 {
18516 return (m_common == x.m_common &&
18517 m_detail == x.m_detail);
18518 }
18519
18524 eProsima_user_DllExport bool operator !=(
18525 const CompleteBitflag& x) const
18526 {
18527 return !(*this == x);
18528 }
18529
18534 eProsima_user_DllExport void common(
18535 const CommonBitflag& _common)
18536 {
18537 m_common = _common;
18538 }
18539
18544 eProsima_user_DllExport void common(
18545 CommonBitflag&& _common)
18546 {
18547 m_common = std::move(_common);
18548 }
18549
18554 eProsima_user_DllExport const CommonBitflag& common() const
18555 {
18556 return m_common;
18557 }
18558
18563 eProsima_user_DllExport CommonBitflag& common()
18564 {
18565 return m_common;
18566 }
18567
18568
18573 eProsima_user_DllExport void detail(
18574 const CompleteMemberDetail& _detail)
18575 {
18576 m_detail = _detail;
18577 }
18578
18583 eProsima_user_DllExport void detail(
18584 CompleteMemberDetail&& _detail)
18585 {
18586 m_detail = std::move(_detail);
18587 }
18588
18593 eProsima_user_DllExport const CompleteMemberDetail& detail() const
18594 {
18595 return m_detail;
18596 }
18597
18602 eProsima_user_DllExport CompleteMemberDetail& detail()
18603 {
18604 return m_detail;
18605 }
18606
18607
18608
18609 private:
18610
18611 CommonBitflag m_common;
18612 CompleteMemberDetail m_detail;
18613
18614};
18615 typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
18616
18621 class MinimalBitflag
18622{
18623 public:
18624
18628 eProsima_user_DllExport MinimalBitflag()
18629 {
18630 }
18631
18635 eProsima_user_DllExport ~MinimalBitflag()
18636 {
18637 }
18638
18643 eProsima_user_DllExport MinimalBitflag(
18644 const MinimalBitflag& x)
18645 {
18646 m_common = x.m_common;
18647
18648 m_detail = x.m_detail;
18649
18650 }
18651
18656 eProsima_user_DllExport MinimalBitflag(
18657 MinimalBitflag&& x) noexcept
18658 {
18659 m_common = std::move(x.m_common);
18660 m_detail = std::move(x.m_detail);
18661 }
18662
18667 eProsima_user_DllExport MinimalBitflag& operator =(
18668 const MinimalBitflag& x)
18669 {
18670
18671 m_common = x.m_common;
18672
18673 m_detail = x.m_detail;
18674
18675 return *this;
18676 }
18677
18682 eProsima_user_DllExport MinimalBitflag& operator =(
18683 MinimalBitflag&& x) noexcept
18684 {
18685
18686 m_common = std::move(x.m_common);
18687 m_detail = std::move(x.m_detail);
18688 return *this;
18689 }
18690
18695 eProsima_user_DllExport bool operator ==(
18696 const MinimalBitflag& x) const
18697 {
18698 return (m_common == x.m_common &&
18699 m_detail == x.m_detail);
18700 }
18701
18706 eProsima_user_DllExport bool operator !=(
18707 const MinimalBitflag& x) const
18708 {
18709 return !(*this == x);
18710 }
18711
18716 eProsima_user_DllExport void common(
18717 const CommonBitflag& _common)
18718 {
18719 m_common = _common;
18720 }
18721
18726 eProsima_user_DllExport void common(
18727 CommonBitflag&& _common)
18728 {
18729 m_common = std::move(_common);
18730 }
18731
18736 eProsima_user_DllExport const CommonBitflag& common() const
18737 {
18738 return m_common;
18739 }
18740
18745 eProsima_user_DllExport CommonBitflag& common()
18746 {
18747 return m_common;
18748 }
18749
18750
18755 eProsima_user_DllExport void detail(
18756 const MinimalMemberDetail& _detail)
18757 {
18758 m_detail = _detail;
18759 }
18760
18765 eProsima_user_DllExport void detail(
18766 MinimalMemberDetail&& _detail)
18767 {
18768 m_detail = std::move(_detail);
18769 }
18770
18775 eProsima_user_DllExport const MinimalMemberDetail& detail() const
18776 {
18777 return m_detail;
18778 }
18779
18784 eProsima_user_DllExport MinimalMemberDetail& detail()
18785 {
18786 return m_detail;
18787 }
18788
18789
18790
18791 private:
18792
18793 CommonBitflag m_common;
18794 MinimalMemberDetail m_detail;
18795
18796};
18797 typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
18798
18803 class CommonBitmaskHeader
18804{
18805 public:
18806
18810 eProsima_user_DllExport CommonBitmaskHeader()
18811 {
18812 }
18813
18817 eProsima_user_DllExport ~CommonBitmaskHeader()
18818 {
18819 }
18820
18825 eProsima_user_DllExport CommonBitmaskHeader(
18826 const CommonBitmaskHeader& x)
18827 {
18828 m_bit_bound = x.m_bit_bound;
18829
18830 }
18831
18836 eProsima_user_DllExport CommonBitmaskHeader(
18837 CommonBitmaskHeader&& x) noexcept
18838 {
18839 m_bit_bound = x.m_bit_bound;
18840 }
18841
18846 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18847 const CommonBitmaskHeader& x)
18848 {
18849
18850 m_bit_bound = x.m_bit_bound;
18851
18852 return *this;
18853 }
18854
18859 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18860 CommonBitmaskHeader&& x) noexcept
18861 {
18862
18863 m_bit_bound = x.m_bit_bound;
18864 return *this;
18865 }
18866
18871 eProsima_user_DllExport bool operator ==(
18872 const CommonBitmaskHeader& x) const
18873 {
18874 return (m_bit_bound == x.m_bit_bound);
18875 }
18876
18881 eProsima_user_DllExport bool operator !=(
18882 const CommonBitmaskHeader& x) const
18883 {
18884 return !(*this == x);
18885 }
18886
18891 eProsima_user_DllExport void bit_bound(
18892 BitBound _bit_bound)
18893 {
18894 m_bit_bound = _bit_bound;
18895 }
18896
18901 eProsima_user_DllExport BitBound bit_bound() const
18902 {
18903 return m_bit_bound;
18904 }
18905
18910 eProsima_user_DllExport BitBound& bit_bound()
18911 {
18912 return m_bit_bound;
18913 }
18914
18915
18916
18917 private:
18918
18919 BitBound m_bit_bound{0};
18920
18921};
18922 typedef CompleteEnumeratedHeader CompleteBitmaskHeader;
18923
18924 typedef MinimalEnumeratedHeader MinimalBitmaskHeader;
18925
18930 class CompleteBitmaskType
18931{
18932 public:
18933
18937 eProsima_user_DllExport CompleteBitmaskType()
18938 {
18939 }
18940
18944 eProsima_user_DllExport ~CompleteBitmaskType()
18945 {
18946 }
18947
18952 eProsima_user_DllExport CompleteBitmaskType(
18953 const CompleteBitmaskType& x)
18954 {
18955 m_bitmask_flags = x.m_bitmask_flags;
18956
18957 m_header = x.m_header;
18958
18959 m_flag_seq = x.m_flag_seq;
18960
18961 }
18962
18967 eProsima_user_DllExport CompleteBitmaskType(
18968 CompleteBitmaskType&& x) noexcept
18969 {
18970 m_bitmask_flags = std::move(x.m_bitmask_flags);
18971 m_header = std::move(x.m_header);
18972 m_flag_seq = std::move(x.m_flag_seq);
18973 }
18974
18979 eProsima_user_DllExport CompleteBitmaskType& operator =(
18980 const CompleteBitmaskType& x)
18981 {
18982
18983 m_bitmask_flags = x.m_bitmask_flags;
18984
18985 m_header = x.m_header;
18986
18987 m_flag_seq = x.m_flag_seq;
18988
18989 return *this;
18990 }
18991
18996 eProsima_user_DllExport CompleteBitmaskType& operator =(
18997 CompleteBitmaskType&& x) noexcept
18998 {
18999
19000 m_bitmask_flags = std::move(x.m_bitmask_flags);
19001 m_header = std::move(x.m_header);
19002 m_flag_seq = std::move(x.m_flag_seq);
19003 return *this;
19004 }
19005
19010 eProsima_user_DllExport bool operator ==(
19011 const CompleteBitmaskType& x) const
19012 {
19013 return (m_bitmask_flags == x.m_bitmask_flags &&
19014 m_header == x.m_header &&
19015 m_flag_seq == x.m_flag_seq);
19016 }
19017
19022 eProsima_user_DllExport bool operator !=(
19023 const CompleteBitmaskType& x) const
19024 {
19025 return !(*this == x);
19026 }
19027
19032 eProsima_user_DllExport void bitmask_flags(
19033 const BitmaskTypeFlag& _bitmask_flags)
19034 {
19035 m_bitmask_flags = _bitmask_flags;
19036 }
19037
19042 eProsima_user_DllExport void bitmask_flags(
19043 BitmaskTypeFlag&& _bitmask_flags)
19044 {
19045 m_bitmask_flags = std::move(_bitmask_flags);
19046 }
19047
19052 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
19053 {
19054 return m_bitmask_flags;
19055 }
19056
19061 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
19062 {
19063 return m_bitmask_flags;
19064 }
19065
19066
19071 eProsima_user_DllExport void header(
19072 const CompleteBitmaskHeader& _header)
19073 {
19074 m_header = _header;
19075 }
19076
19081 eProsima_user_DllExport void header(
19082 CompleteBitmaskHeader&& _header)
19083 {
19084 m_header = std::move(_header);
19085 }
19086
19091 eProsima_user_DllExport const CompleteBitmaskHeader& header() const
19092 {
19093 return m_header;
19094 }
19095
19100 eProsima_user_DllExport CompleteBitmaskHeader& header()
19101 {
19102 return m_header;
19103 }
19104
19105
19110 eProsima_user_DllExport void flag_seq(
19111 const CompleteBitflagSeq& _flag_seq)
19112 {
19113 m_flag_seq = _flag_seq;
19114 }
19115
19120 eProsima_user_DllExport void flag_seq(
19121 CompleteBitflagSeq&& _flag_seq)
19122 {
19123 m_flag_seq = std::move(_flag_seq);
19124 }
19125
19130 eProsima_user_DllExport const CompleteBitflagSeq& flag_seq() const
19131 {
19132 return m_flag_seq;
19133 }
19134
19139 eProsima_user_DllExport CompleteBitflagSeq& flag_seq()
19140 {
19141 return m_flag_seq;
19142 }
19143
19144
19145
19146 private:
19147
19148 BitmaskTypeFlag m_bitmask_flags{0};
19149 CompleteBitmaskHeader m_header;
19150 CompleteBitflagSeq m_flag_seq;
19151
19152};
19153
19157 class MinimalBitmaskType
19158{
19159 public:
19160
19164 eProsima_user_DllExport MinimalBitmaskType()
19165 {
19166 }
19167
19171 eProsima_user_DllExport ~MinimalBitmaskType()
19172 {
19173 }
19174
19179 eProsima_user_DllExport MinimalBitmaskType(
19180 const MinimalBitmaskType& x)
19181 {
19182 m_bitmask_flags = x.m_bitmask_flags;
19183
19184 m_header = x.m_header;
19185
19186 m_flag_seq = x.m_flag_seq;
19187
19188 }
19189
19194 eProsima_user_DllExport MinimalBitmaskType(
19195 MinimalBitmaskType&& x) noexcept
19196 {
19197 m_bitmask_flags = std::move(x.m_bitmask_flags);
19198 m_header = std::move(x.m_header);
19199 m_flag_seq = std::move(x.m_flag_seq);
19200 }
19201
19206 eProsima_user_DllExport MinimalBitmaskType& operator =(
19207 const MinimalBitmaskType& x)
19208 {
19209
19210 m_bitmask_flags = x.m_bitmask_flags;
19211
19212 m_header = x.m_header;
19213
19214 m_flag_seq = x.m_flag_seq;
19215
19216 return *this;
19217 }
19218
19223 eProsima_user_DllExport MinimalBitmaskType& operator =(
19224 MinimalBitmaskType&& x) noexcept
19225 {
19226
19227 m_bitmask_flags = std::move(x.m_bitmask_flags);
19228 m_header = std::move(x.m_header);
19229 m_flag_seq = std::move(x.m_flag_seq);
19230 return *this;
19231 }
19232
19237 eProsima_user_DllExport bool operator ==(
19238 const MinimalBitmaskType& x) const
19239 {
19240 return (m_bitmask_flags == x.m_bitmask_flags &&
19241 m_header == x.m_header &&
19242 m_flag_seq == x.m_flag_seq);
19243 }
19244
19249 eProsima_user_DllExport bool operator !=(
19250 const MinimalBitmaskType& x) const
19251 {
19252 return !(*this == x);
19253 }
19254
19259 eProsima_user_DllExport void bitmask_flags(
19260 const BitmaskTypeFlag& _bitmask_flags)
19261 {
19262 m_bitmask_flags = _bitmask_flags;
19263 }
19264
19269 eProsima_user_DllExport void bitmask_flags(
19270 BitmaskTypeFlag&& _bitmask_flags)
19271 {
19272 m_bitmask_flags = std::move(_bitmask_flags);
19273 }
19274
19279 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
19280 {
19281 return m_bitmask_flags;
19282 }
19283
19288 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
19289 {
19290 return m_bitmask_flags;
19291 }
19292
19293
19298 eProsima_user_DllExport void header(
19299 const MinimalBitmaskHeader& _header)
19300 {
19301 m_header = _header;
19302 }
19303
19308 eProsima_user_DllExport void header(
19309 MinimalBitmaskHeader&& _header)
19310 {
19311 m_header = std::move(_header);
19312 }
19313
19318 eProsima_user_DllExport const MinimalBitmaskHeader& header() const
19319 {
19320 return m_header;
19321 }
19322
19327 eProsima_user_DllExport MinimalBitmaskHeader& header()
19328 {
19329 return m_header;
19330 }
19331
19332
19337 eProsima_user_DllExport void flag_seq(
19338 const MinimalBitflagSeq& _flag_seq)
19339 {
19340 m_flag_seq = _flag_seq;
19341 }
19342
19347 eProsima_user_DllExport void flag_seq(
19348 MinimalBitflagSeq&& _flag_seq)
19349 {
19350 m_flag_seq = std::move(_flag_seq);
19351 }
19352
19357 eProsima_user_DllExport const MinimalBitflagSeq& flag_seq() const
19358 {
19359 return m_flag_seq;
19360 }
19361
19366 eProsima_user_DllExport MinimalBitflagSeq& flag_seq()
19367 {
19368 return m_flag_seq;
19369 }
19370
19371
19372
19373 private:
19374
19375 BitmaskTypeFlag m_bitmask_flags{0};
19376 MinimalBitmaskHeader m_header;
19377 MinimalBitflagSeq m_flag_seq;
19378
19379};
19380
19384 class CommonBitfield
19385{
19386 public:
19387
19391 eProsima_user_DllExport CommonBitfield()
19392 {
19393 }
19394
19398 eProsima_user_DllExport ~CommonBitfield()
19399 {
19400 }
19401
19406 eProsima_user_DllExport CommonBitfield(
19407 const CommonBitfield& x)
19408 {
19409 m_position = x.m_position;
19410
19411 m_flags = x.m_flags;
19412
19413 m_bitcount = x.m_bitcount;
19414
19415 m_holder_type = x.m_holder_type;
19416
19417 }
19418
19423 eProsima_user_DllExport CommonBitfield(
19424 CommonBitfield&& x) noexcept
19425 {
19426 m_position = x.m_position;
19427 m_flags = std::move(x.m_flags);
19428 m_bitcount = x.m_bitcount;
19429 m_holder_type = x.m_holder_type;
19430 }
19431
19436 eProsima_user_DllExport CommonBitfield& operator =(
19437 const CommonBitfield& x)
19438 {
19439
19440 m_position = x.m_position;
19441
19442 m_flags = x.m_flags;
19443
19444 m_bitcount = x.m_bitcount;
19445
19446 m_holder_type = x.m_holder_type;
19447
19448 return *this;
19449 }
19450
19455 eProsima_user_DllExport CommonBitfield& operator =(
19456 CommonBitfield&& x) noexcept
19457 {
19458
19459 m_position = x.m_position;
19460 m_flags = std::move(x.m_flags);
19461 m_bitcount = x.m_bitcount;
19462 m_holder_type = x.m_holder_type;
19463 return *this;
19464 }
19465
19470 eProsima_user_DllExport bool operator ==(
19471 const CommonBitfield& x) const
19472 {
19473 return (m_position == x.m_position &&
19474 m_flags == x.m_flags &&
19475 m_bitcount == x.m_bitcount &&
19476 m_holder_type == x.m_holder_type);
19477 }
19478
19483 eProsima_user_DllExport bool operator !=(
19484 const CommonBitfield& x) const
19485 {
19486 return !(*this == x);
19487 }
19488
19493 eProsima_user_DllExport void position(
19494 uint16_t _position)
19495 {
19496 m_position = _position;
19497 }
19498
19503 eProsima_user_DllExport uint16_t position() const
19504 {
19505 return m_position;
19506 }
19507
19512 eProsima_user_DllExport uint16_t& position()
19513 {
19514 return m_position;
19515 }
19516
19517
19522 eProsima_user_DllExport void flags(
19523 const BitsetMemberFlag& _flags)
19524 {
19525 m_flags = _flags;
19526 }
19527
19532 eProsima_user_DllExport void flags(
19533 BitsetMemberFlag&& _flags)
19534 {
19535 m_flags = std::move(_flags);
19536 }
19537
19542 eProsima_user_DllExport const BitsetMemberFlag& flags() const
19543 {
19544 return m_flags;
19545 }
19546
19551 eProsima_user_DllExport BitsetMemberFlag& flags()
19552 {
19553 return m_flags;
19554 }
19555
19556
19561 eProsima_user_DllExport void bitcount(
19562 uint8_t _bitcount)
19563 {
19564 m_bitcount = _bitcount;
19565 }
19566
19571 eProsima_user_DllExport uint8_t bitcount() const
19572 {
19573 return m_bitcount;
19574 }
19575
19580 eProsima_user_DllExport uint8_t& bitcount()
19581 {
19582 return m_bitcount;
19583 }
19584
19585
19590 eProsima_user_DllExport void holder_type(
19591 TypeKind _holder_type)
19592 {
19593 m_holder_type = _holder_type;
19594 }
19595
19600 eProsima_user_DllExport TypeKind holder_type() const
19601 {
19602 return m_holder_type;
19603 }
19604
19609 eProsima_user_DllExport TypeKind& holder_type()
19610 {
19611 return m_holder_type;
19612 }
19613
19614
19615
19616 private:
19617
19618 uint16_t m_position{0};
19619 BitsetMemberFlag m_flags{0};
19620 uint8_t m_bitcount{0};
19621 TypeKind m_holder_type{0};
19622
19623};
19624
19628 class CompleteBitfield
19629{
19630 public:
19631
19635 eProsima_user_DllExport CompleteBitfield()
19636 {
19637 }
19638
19642 eProsima_user_DllExport ~CompleteBitfield()
19643 {
19644 }
19645
19650 eProsima_user_DllExport CompleteBitfield(
19651 const CompleteBitfield& x)
19652 {
19653 m_common = x.m_common;
19654
19655 m_detail = x.m_detail;
19656
19657 }
19658
19663 eProsima_user_DllExport CompleteBitfield(
19664 CompleteBitfield&& x) noexcept
19665 {
19666 m_common = std::move(x.m_common);
19667 m_detail = std::move(x.m_detail);
19668 }
19669
19674 eProsima_user_DllExport CompleteBitfield& operator =(
19675 const CompleteBitfield& x)
19676 {
19677
19678 m_common = x.m_common;
19679
19680 m_detail = x.m_detail;
19681
19682 return *this;
19683 }
19684
19689 eProsima_user_DllExport CompleteBitfield& operator =(
19690 CompleteBitfield&& x) noexcept
19691 {
19692
19693 m_common = std::move(x.m_common);
19694 m_detail = std::move(x.m_detail);
19695 return *this;
19696 }
19697
19702 eProsima_user_DllExport bool operator ==(
19703 const CompleteBitfield& x) const
19704 {
19705 return (m_common == x.m_common &&
19706 m_detail == x.m_detail);
19707 }
19708
19713 eProsima_user_DllExport bool operator !=(
19714 const CompleteBitfield& x) const
19715 {
19716 return !(*this == x);
19717 }
19718
19723 eProsima_user_DllExport void common(
19724 const CommonBitfield& _common)
19725 {
19726 m_common = _common;
19727 }
19728
19733 eProsima_user_DllExport void common(
19734 CommonBitfield&& _common)
19735 {
19736 m_common = std::move(_common);
19737 }
19738
19743 eProsima_user_DllExport const CommonBitfield& common() const
19744 {
19745 return m_common;
19746 }
19747
19752 eProsima_user_DllExport CommonBitfield& common()
19753 {
19754 return m_common;
19755 }
19756
19757
19762 eProsima_user_DllExport void detail(
19763 const CompleteMemberDetail& _detail)
19764 {
19765 m_detail = _detail;
19766 }
19767
19772 eProsima_user_DllExport void detail(
19773 CompleteMemberDetail&& _detail)
19774 {
19775 m_detail = std::move(_detail);
19776 }
19777
19782 eProsima_user_DllExport const CompleteMemberDetail& detail() const
19783 {
19784 return m_detail;
19785 }
19786
19791 eProsima_user_DllExport CompleteMemberDetail& detail()
19792 {
19793 return m_detail;
19794 }
19795
19796
19797
19798 private:
19799
19800 CommonBitfield m_common;
19801 CompleteMemberDetail m_detail;
19802
19803};
19804 typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
19805
19810 class MinimalBitfield
19811{
19812 public:
19813
19817 eProsima_user_DllExport MinimalBitfield()
19818 {
19819 }
19820
19824 eProsima_user_DllExport ~MinimalBitfield()
19825 {
19826 }
19827
19832 eProsima_user_DllExport MinimalBitfield(
19833 const MinimalBitfield& x)
19834 {
19835 m_common = x.m_common;
19836
19837 m_name_hash = x.m_name_hash;
19838
19839 }
19840
19845 eProsima_user_DllExport MinimalBitfield(
19846 MinimalBitfield&& x) noexcept
19847 {
19848 m_common = std::move(x.m_common);
19849 m_name_hash = std::move(x.m_name_hash);
19850 }
19851
19856 eProsima_user_DllExport MinimalBitfield& operator =(
19857 const MinimalBitfield& x)
19858 {
19859
19860 m_common = x.m_common;
19861
19862 m_name_hash = x.m_name_hash;
19863
19864 return *this;
19865 }
19866
19871 eProsima_user_DllExport MinimalBitfield& operator =(
19872 MinimalBitfield&& x) noexcept
19873 {
19874
19875 m_common = std::move(x.m_common);
19876 m_name_hash = std::move(x.m_name_hash);
19877 return *this;
19878 }
19879
19884 eProsima_user_DllExport bool operator ==(
19885 const MinimalBitfield& x) const
19886 {
19887 return (m_common == x.m_common &&
19888 m_name_hash == x.m_name_hash);
19889 }
19890
19895 eProsima_user_DllExport bool operator !=(
19896 const MinimalBitfield& x) const
19897 {
19898 return !(*this == x);
19899 }
19900
19905 eProsima_user_DllExport void common(
19906 const CommonBitfield& _common)
19907 {
19908 m_common = _common;
19909 }
19910
19915 eProsima_user_DllExport void common(
19916 CommonBitfield&& _common)
19917 {
19918 m_common = std::move(_common);
19919 }
19920
19925 eProsima_user_DllExport const CommonBitfield& common() const
19926 {
19927 return m_common;
19928 }
19929
19934 eProsima_user_DllExport CommonBitfield& common()
19935 {
19936 return m_common;
19937 }
19938
19939
19944 eProsima_user_DllExport void name_hash(
19945 const NameHash& _name_hash)
19946 {
19947 m_name_hash = _name_hash;
19948 }
19949
19954 eProsima_user_DllExport void name_hash(
19955 NameHash&& _name_hash)
19956 {
19957 m_name_hash = std::move(_name_hash);
19958 }
19959
19964 eProsima_user_DllExport const NameHash& name_hash() const
19965 {
19966 return m_name_hash;
19967 }
19968
19973 eProsima_user_DllExport NameHash& name_hash()
19974 {
19975 return m_name_hash;
19976 }
19977
19978
19979
19980 private:
19981
19982 CommonBitfield m_common;
19983 NameHash m_name_hash{0};
19984
19985};
19986 typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
19987
19992 class CompleteBitsetHeader
19993{
19994 public:
19995
19999 eProsima_user_DllExport CompleteBitsetHeader()
20000 {
20001 }
20002
20006 eProsima_user_DllExport ~CompleteBitsetHeader()
20007 {
20008 }
20009
20014 eProsima_user_DllExport CompleteBitsetHeader(
20015 const CompleteBitsetHeader& x)
20016 {
20017 m_detail = x.m_detail;
20018
20019 }
20020
20025 eProsima_user_DllExport CompleteBitsetHeader(
20026 CompleteBitsetHeader&& x) noexcept
20027 {
20028 m_detail = std::move(x.m_detail);
20029 }
20030
20035 eProsima_user_DllExport CompleteBitsetHeader& operator =(
20036 const CompleteBitsetHeader& x)
20037 {
20038
20039 m_detail = x.m_detail;
20040
20041 return *this;
20042 }
20043
20048 eProsima_user_DllExport CompleteBitsetHeader& operator =(
20049 CompleteBitsetHeader&& x) noexcept
20050 {
20051
20052 m_detail = std::move(x.m_detail);
20053 return *this;
20054 }
20055
20060 eProsima_user_DllExport bool operator ==(
20061 const CompleteBitsetHeader& x) const
20062 {
20063 return (m_detail == x.m_detail);
20064 }
20065
20070 eProsima_user_DllExport bool operator !=(
20071 const CompleteBitsetHeader& x) const
20072 {
20073 return !(*this == x);
20074 }
20075
20080 eProsima_user_DllExport void detail(
20081 const CompleteTypeDetail& _detail)
20082 {
20083 m_detail = _detail;
20084 }
20085
20090 eProsima_user_DllExport void detail(
20091 CompleteTypeDetail&& _detail)
20092 {
20093 m_detail = std::move(_detail);
20094 }
20095
20100 eProsima_user_DllExport const CompleteTypeDetail& detail() const
20101 {
20102 return m_detail;
20103 }
20104
20109 eProsima_user_DllExport CompleteTypeDetail& detail()
20110 {
20111 return m_detail;
20112 }
20113
20114
20115
20116 private:
20117
20118 CompleteTypeDetail m_detail;
20119
20120};
20121
20125 class MinimalBitsetHeader
20126{
20127 public:
20128
20132 eProsima_user_DllExport MinimalBitsetHeader()
20133 {
20134 }
20135
20139 eProsima_user_DllExport ~MinimalBitsetHeader()
20140 {
20141 }
20142
20147 eProsima_user_DllExport MinimalBitsetHeader(
20148 const MinimalBitsetHeader& x)
20149 {
20150 static_cast<void>(x);
20151 }
20152
20157 eProsima_user_DllExport MinimalBitsetHeader(
20158 MinimalBitsetHeader&& x) noexcept
20159 {
20160 static_cast<void>(x);
20161 }
20162
20167 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20168 const MinimalBitsetHeader& x)
20169 {
20170
20171 static_cast<void>(x);
20172
20173 return *this;
20174 }
20175
20180 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20181 MinimalBitsetHeader&& x) noexcept
20182 {
20183
20184 static_cast<void>(x);
20185
20186 return *this;
20187 }
20188
20193 eProsima_user_DllExport bool operator ==(
20194 const MinimalBitsetHeader& x) const
20195 {
20196 static_cast<void>(x);
20197 return true;
20198 }
20199
20204 eProsima_user_DllExport bool operator !=(
20205 const MinimalBitsetHeader& x) const
20206 {
20207 return !(*this == x);
20208 }
20209
20210
20211
20212 private:
20213
20214
20215};
20216
20220 class CompleteBitsetType
20221{
20222 public:
20223
20227 eProsima_user_DllExport CompleteBitsetType()
20228 {
20229 }
20230
20234 eProsima_user_DllExport ~CompleteBitsetType()
20235 {
20236 }
20237
20242 eProsima_user_DllExport CompleteBitsetType(
20243 const CompleteBitsetType& x)
20244 {
20245 m_bitset_flags = x.m_bitset_flags;
20246
20247 m_header = x.m_header;
20248
20249 m_field_seq = x.m_field_seq;
20250
20251 }
20252
20257 eProsima_user_DllExport CompleteBitsetType(
20258 CompleteBitsetType&& x) noexcept
20259 {
20260 m_bitset_flags = std::move(x.m_bitset_flags);
20261 m_header = std::move(x.m_header);
20262 m_field_seq = std::move(x.m_field_seq);
20263 }
20264
20269 eProsima_user_DllExport CompleteBitsetType& operator =(
20270 const CompleteBitsetType& x)
20271 {
20272
20273 m_bitset_flags = x.m_bitset_flags;
20274
20275 m_header = x.m_header;
20276
20277 m_field_seq = x.m_field_seq;
20278
20279 return *this;
20280 }
20281
20286 eProsima_user_DllExport CompleteBitsetType& operator =(
20287 CompleteBitsetType&& x) noexcept
20288 {
20289
20290 m_bitset_flags = std::move(x.m_bitset_flags);
20291 m_header = std::move(x.m_header);
20292 m_field_seq = std::move(x.m_field_seq);
20293 return *this;
20294 }
20295
20300 eProsima_user_DllExport bool operator ==(
20301 const CompleteBitsetType& x) const
20302 {
20303 return (m_bitset_flags == x.m_bitset_flags &&
20304 m_header == x.m_header &&
20305 m_field_seq == x.m_field_seq);
20306 }
20307
20312 eProsima_user_DllExport bool operator !=(
20313 const CompleteBitsetType& x) const
20314 {
20315 return !(*this == x);
20316 }
20317
20322 eProsima_user_DllExport void bitset_flags(
20323 const BitsetTypeFlag& _bitset_flags)
20324 {
20325 m_bitset_flags = _bitset_flags;
20326 }
20327
20332 eProsima_user_DllExport void bitset_flags(
20333 BitsetTypeFlag&& _bitset_flags)
20334 {
20335 m_bitset_flags = std::move(_bitset_flags);
20336 }
20337
20342 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20343 {
20344 return m_bitset_flags;
20345 }
20346
20351 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20352 {
20353 return m_bitset_flags;
20354 }
20355
20356
20361 eProsima_user_DllExport void header(
20362 const CompleteBitsetHeader& _header)
20363 {
20364 m_header = _header;
20365 }
20366
20371 eProsima_user_DllExport void header(
20372 CompleteBitsetHeader&& _header)
20373 {
20374 m_header = std::move(_header);
20375 }
20376
20381 eProsima_user_DllExport const CompleteBitsetHeader& header() const
20382 {
20383 return m_header;
20384 }
20385
20390 eProsima_user_DllExport CompleteBitsetHeader& header()
20391 {
20392 return m_header;
20393 }
20394
20395
20400 eProsima_user_DllExport void field_seq(
20401 const CompleteBitfieldSeq& _field_seq)
20402 {
20403 m_field_seq = _field_seq;
20404 }
20405
20410 eProsima_user_DllExport void field_seq(
20411 CompleteBitfieldSeq&& _field_seq)
20412 {
20413 m_field_seq = std::move(_field_seq);
20414 }
20415
20420 eProsima_user_DllExport const CompleteBitfieldSeq& field_seq() const
20421 {
20422 return m_field_seq;
20423 }
20424
20429 eProsima_user_DllExport CompleteBitfieldSeq& field_seq()
20430 {
20431 return m_field_seq;
20432 }
20433
20434
20435
20436 private:
20437
20438 BitsetTypeFlag m_bitset_flags{0};
20439 CompleteBitsetHeader m_header;
20440 CompleteBitfieldSeq m_field_seq;
20441
20442};
20443
20447 class MinimalBitsetType
20448{
20449 public:
20450
20454 eProsima_user_DllExport MinimalBitsetType()
20455 {
20456 }
20457
20461 eProsima_user_DllExport ~MinimalBitsetType()
20462 {
20463 }
20464
20469 eProsima_user_DllExport MinimalBitsetType(
20470 const MinimalBitsetType& x)
20471 {
20472 m_bitset_flags = x.m_bitset_flags;
20473
20474 m_header = x.m_header;
20475
20476 m_field_seq = x.m_field_seq;
20477
20478 }
20479
20484 eProsima_user_DllExport MinimalBitsetType(
20485 MinimalBitsetType&& x) noexcept
20486 {
20487 m_bitset_flags = std::move(x.m_bitset_flags);
20488 m_header = std::move(x.m_header);
20489 m_field_seq = std::move(x.m_field_seq);
20490 }
20491
20496 eProsima_user_DllExport MinimalBitsetType& operator =(
20497 const MinimalBitsetType& x)
20498 {
20499
20500 m_bitset_flags = x.m_bitset_flags;
20501
20502 m_header = x.m_header;
20503
20504 m_field_seq = x.m_field_seq;
20505
20506 return *this;
20507 }
20508
20513 eProsima_user_DllExport MinimalBitsetType& operator =(
20514 MinimalBitsetType&& x) noexcept
20515 {
20516
20517 m_bitset_flags = std::move(x.m_bitset_flags);
20518 m_header = std::move(x.m_header);
20519 m_field_seq = std::move(x.m_field_seq);
20520 return *this;
20521 }
20522
20527 eProsima_user_DllExport bool operator ==(
20528 const MinimalBitsetType& x) const
20529 {
20530 return (m_bitset_flags == x.m_bitset_flags &&
20531 m_header == x.m_header &&
20532 m_field_seq == x.m_field_seq);
20533 }
20534
20539 eProsima_user_DllExport bool operator !=(
20540 const MinimalBitsetType& x) const
20541 {
20542 return !(*this == x);
20543 }
20544
20549 eProsima_user_DllExport void bitset_flags(
20550 const BitsetTypeFlag& _bitset_flags)
20551 {
20552 m_bitset_flags = _bitset_flags;
20553 }
20554
20559 eProsima_user_DllExport void bitset_flags(
20560 BitsetTypeFlag&& _bitset_flags)
20561 {
20562 m_bitset_flags = std::move(_bitset_flags);
20563 }
20564
20569 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20570 {
20571 return m_bitset_flags;
20572 }
20573
20578 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20579 {
20580 return m_bitset_flags;
20581 }
20582
20583
20588 eProsima_user_DllExport void header(
20589 const MinimalBitsetHeader& _header)
20590 {
20591 m_header = _header;
20592 }
20593
20598 eProsima_user_DllExport void header(
20599 MinimalBitsetHeader&& _header)
20600 {
20601 m_header = std::move(_header);
20602 }
20603
20608 eProsima_user_DllExport const MinimalBitsetHeader& header() const
20609 {
20610 return m_header;
20611 }
20612
20617 eProsima_user_DllExport MinimalBitsetHeader& header()
20618 {
20619 return m_header;
20620 }
20621
20622
20627 eProsima_user_DllExport void field_seq(
20628 const MinimalBitfieldSeq& _field_seq)
20629 {
20630 m_field_seq = _field_seq;
20631 }
20632
20637 eProsima_user_DllExport void field_seq(
20638 MinimalBitfieldSeq&& _field_seq)
20639 {
20640 m_field_seq = std::move(_field_seq);
20641 }
20642
20647 eProsima_user_DllExport const MinimalBitfieldSeq& field_seq() const
20648 {
20649 return m_field_seq;
20650 }
20651
20656 eProsima_user_DllExport MinimalBitfieldSeq& field_seq()
20657 {
20658 return m_field_seq;
20659 }
20660
20661
20662
20663 private:
20664
20665 BitsetTypeFlag m_bitset_flags{0};
20666 MinimalBitsetHeader m_header;
20667 MinimalBitfieldSeq m_field_seq;
20668
20669};
20670
20674 class CompleteExtendedType
20675{
20676 public:
20677
20681 eProsima_user_DllExport CompleteExtendedType()
20682 {
20683 }
20684
20688 eProsima_user_DllExport ~CompleteExtendedType()
20689 {
20690 }
20691
20696 eProsima_user_DllExport CompleteExtendedType(
20697 const CompleteExtendedType& x)
20698 {
20699 static_cast<void>(x);
20700 }
20701
20706 eProsima_user_DllExport CompleteExtendedType(
20707 CompleteExtendedType&& x) noexcept
20708 {
20709 static_cast<void>(x);
20710 }
20711
20716 eProsima_user_DllExport CompleteExtendedType& operator =(
20717 const CompleteExtendedType& x)
20718 {
20719
20720 static_cast<void>(x);
20721
20722 return *this;
20723 }
20724
20729 eProsima_user_DllExport CompleteExtendedType& operator =(
20730 CompleteExtendedType&& x) noexcept
20731 {
20732
20733 static_cast<void>(x);
20734
20735 return *this;
20736 }
20737
20742 eProsima_user_DllExport bool operator ==(
20743 const CompleteExtendedType& x) const
20744 {
20745 static_cast<void>(x);
20746 return true;
20747 }
20748
20753 eProsima_user_DllExport bool operator !=(
20754 const CompleteExtendedType& x) const
20755 {
20756 return !(*this == x);
20757 }
20758
20759
20760
20761 private:
20762
20763
20764};
20765
20769 class CompleteTypeObject
20770{
20771 public:
20772
20776 eProsima_user_DllExport CompleteTypeObject()
20777 {
20778 selected_member_ = 0x0000000b;
20779 member_destructor_ = [&]()
20780 {
20781 m_extended_type.~CompleteExtendedType();
20782 };
20783 new(&m_extended_type) CompleteExtendedType();
20784
20785 }
20786
20790 eProsima_user_DllExport ~CompleteTypeObject()
20791 {
20792 if (member_destructor_)
20793 {
20794 member_destructor_();
20795 }
20796 }
20797
20802 eProsima_user_DllExport CompleteTypeObject(
20803 const CompleteTypeObject& x)
20804 {
20805 m__d = x.m__d;
20806
20807 switch (x.selected_member_)
20808 {
20809 case 0x00000001:
20810 alias_type_() = x.m_alias_type;
20811 break;
20812
20813 case 0x00000002:
20814 annotation_type_() = x.m_annotation_type;
20815 break;
20816
20817 case 0x00000003:
20818 struct_type_() = x.m_struct_type;
20819 break;
20820
20821 case 0x00000004:
20822 union_type_() = x.m_union_type;
20823 break;
20824
20825 case 0x00000005:
20826 bitset_type_() = x.m_bitset_type;
20827 break;
20828
20829 case 0x00000006:
20830 sequence_type_() = x.m_sequence_type;
20831 break;
20832
20833 case 0x00000007:
20834 array_type_() = x.m_array_type;
20835 break;
20836
20837 case 0x00000008:
20838 map_type_() = x.m_map_type;
20839 break;
20840
20841 case 0x00000009:
20842 enumerated_type_() = x.m_enumerated_type;
20843 break;
20844
20845 case 0x0000000a:
20846 bitmask_type_() = x.m_bitmask_type;
20847 break;
20848
20849 case 0x0000000b:
20850 extended_type_() = x.m_extended_type;
20851 break;
20852
20853 }
20854 }
20855
20860 eProsima_user_DllExport CompleteTypeObject(
20861 CompleteTypeObject&& x) noexcept
20862 {
20863 m__d = x.m__d;
20864
20865 switch (x.selected_member_)
20866 {
20867 case 0x00000001:
20868 alias_type_() = std::move(x.m_alias_type);
20869 break;
20870
20871 case 0x00000002:
20872 annotation_type_() = std::move(x.m_annotation_type);
20873 break;
20874
20875 case 0x00000003:
20876 struct_type_() = std::move(x.m_struct_type);
20877 break;
20878
20879 case 0x00000004:
20880 union_type_() = std::move(x.m_union_type);
20881 break;
20882
20883 case 0x00000005:
20884 bitset_type_() = std::move(x.m_bitset_type);
20885 break;
20886
20887 case 0x00000006:
20888 sequence_type_() = std::move(x.m_sequence_type);
20889 break;
20890
20891 case 0x00000007:
20892 array_type_() = std::move(x.m_array_type);
20893 break;
20894
20895 case 0x00000008:
20896 map_type_() = std::move(x.m_map_type);
20897 break;
20898
20899 case 0x00000009:
20900 enumerated_type_() = std::move(x.m_enumerated_type);
20901 break;
20902
20903 case 0x0000000a:
20904 bitmask_type_() = std::move(x.m_bitmask_type);
20905 break;
20906
20907 case 0x0000000b:
20908 extended_type_() = std::move(x.m_extended_type);
20909 break;
20910
20911 }
20912 }
20913
20918 eProsima_user_DllExport CompleteTypeObject& operator =(
20919 const CompleteTypeObject& x)
20920 {
20921 m__d = x.m__d;
20922
20923 switch (x.selected_member_)
20924 {
20925 case 0x00000001:
20926 alias_type_() = x.m_alias_type;
20927 break;
20928
20929 case 0x00000002:
20930 annotation_type_() = x.m_annotation_type;
20931 break;
20932
20933 case 0x00000003:
20934 struct_type_() = x.m_struct_type;
20935 break;
20936
20937 case 0x00000004:
20938 union_type_() = x.m_union_type;
20939 break;
20940
20941 case 0x00000005:
20942 bitset_type_() = x.m_bitset_type;
20943 break;
20944
20945 case 0x00000006:
20946 sequence_type_() = x.m_sequence_type;
20947 break;
20948
20949 case 0x00000007:
20950 array_type_() = x.m_array_type;
20951 break;
20952
20953 case 0x00000008:
20954 map_type_() = x.m_map_type;
20955 break;
20956
20957 case 0x00000009:
20958 enumerated_type_() = x.m_enumerated_type;
20959 break;
20960
20961 case 0x0000000a:
20962 bitmask_type_() = x.m_bitmask_type;
20963 break;
20964
20965 case 0x0000000b:
20966 extended_type_() = x.m_extended_type;
20967 break;
20968
20969 }
20970
20971 return *this;
20972 }
20973
20978 eProsima_user_DllExport CompleteTypeObject& operator =(
20979 CompleteTypeObject&& x) noexcept
20980 {
20981 m__d = x.m__d;
20982
20983 switch (x.selected_member_)
20984 {
20985 case 0x00000001:
20986 alias_type_() = std::move(x.m_alias_type);
20987 break;
20988
20989 case 0x00000002:
20990 annotation_type_() = std::move(x.m_annotation_type);
20991 break;
20992
20993 case 0x00000003:
20994 struct_type_() = std::move(x.m_struct_type);
20995 break;
20996
20997 case 0x00000004:
20998 union_type_() = std::move(x.m_union_type);
20999 break;
21000
21001 case 0x00000005:
21002 bitset_type_() = std::move(x.m_bitset_type);
21003 break;
21004
21005 case 0x00000006:
21006 sequence_type_() = std::move(x.m_sequence_type);
21007 break;
21008
21009 case 0x00000007:
21010 array_type_() = std::move(x.m_array_type);
21011 break;
21012
21013 case 0x00000008:
21014 map_type_() = std::move(x.m_map_type);
21015 break;
21016
21017 case 0x00000009:
21018 enumerated_type_() = std::move(x.m_enumerated_type);
21019 break;
21020
21021 case 0x0000000a:
21022 bitmask_type_() = std::move(x.m_bitmask_type);
21023 break;
21024
21025 case 0x0000000b:
21026 extended_type_() = std::move(x.m_extended_type);
21027 break;
21028
21029 }
21030
21031 return *this;
21032 }
21033
21038 eProsima_user_DllExport bool operator ==(
21039 const CompleteTypeObject& x) const
21040 {
21041 bool ret_value {false};
21042
21043 if (x.selected_member_ == selected_member_)
21044 {
21045 if (0x0FFFFFFFu != selected_member_)
21046 {
21047 if (x.m__d == m__d)
21048 {
21049 switch (selected_member_)
21050 {
21051 case 0x00000001:
21052 ret_value = (x.m_alias_type == m_alias_type);
21053 break;
21054
21055 case 0x00000002:
21056 ret_value = (x.m_annotation_type == m_annotation_type);
21057 break;
21058
21059 case 0x00000003:
21060 ret_value = (x.m_struct_type == m_struct_type);
21061 break;
21062
21063 case 0x00000004:
21064 ret_value = (x.m_union_type == m_union_type);
21065 break;
21066
21067 case 0x00000005:
21068 ret_value = (x.m_bitset_type == m_bitset_type);
21069 break;
21070
21071 case 0x00000006:
21072 ret_value = (x.m_sequence_type == m_sequence_type);
21073 break;
21074
21075 case 0x00000007:
21076 ret_value = (x.m_array_type == m_array_type);
21077 break;
21078
21079 case 0x00000008:
21080 ret_value = (x.m_map_type == m_map_type);
21081 break;
21082
21083 case 0x00000009:
21084 ret_value = (x.m_enumerated_type == m_enumerated_type);
21085 break;
21086
21087 case 0x0000000a:
21088 ret_value = (x.m_bitmask_type == m_bitmask_type);
21089 break;
21090
21091 case 0x0000000b:
21092 ret_value = (x.m_extended_type == m_extended_type);
21093 break;
21094
21095 }
21096 }
21097 }
21098 else
21099 {
21100 ret_value = true;
21101 }
21102 }
21103
21104 return ret_value;
21105 }
21106
21111 eProsima_user_DllExport bool operator !=(
21112 const CompleteTypeObject& x) const
21113 {
21114 return !(*this == x);
21115 }
21116
21122 eProsima_user_DllExport void _d(
21123 uint8_t __d)
21124 {
21125 bool valid_discriminator = false;
21126
21127 switch (__d)
21128 {
21129 case TK_ALIAS:
21130 if (0x00000001 == selected_member_)
21131 {
21132 valid_discriminator = true;
21133 }
21134 break;
21135
21136 case TK_ANNOTATION:
21137 if (0x00000002 == selected_member_)
21138 {
21139 valid_discriminator = true;
21140 }
21141 break;
21142
21143 case TK_STRUCTURE:
21144 if (0x00000003 == selected_member_)
21145 {
21146 valid_discriminator = true;
21147 }
21148 break;
21149
21150 case TK_UNION:
21151 if (0x00000004 == selected_member_)
21152 {
21153 valid_discriminator = true;
21154 }
21155 break;
21156
21157 case TK_BITSET:
21158 if (0x00000005 == selected_member_)
21159 {
21160 valid_discriminator = true;
21161 }
21162 break;
21163
21164 case TK_SEQUENCE:
21165 if (0x00000006 == selected_member_)
21166 {
21167 valid_discriminator = true;
21168 }
21169 break;
21170
21171 case TK_ARRAY:
21172 if (0x00000007 == selected_member_)
21173 {
21174 valid_discriminator = true;
21175 }
21176 break;
21177
21178 case TK_MAP:
21179 if (0x00000008 == selected_member_)
21180 {
21181 valid_discriminator = true;
21182 }
21183 break;
21184
21185 case TK_ENUM:
21186 if (0x00000009 == selected_member_)
21187 {
21188 valid_discriminator = true;
21189 }
21190 break;
21191
21192 case TK_BITMASK:
21193 if (0x0000000a == selected_member_)
21194 {
21195 valid_discriminator = true;
21196 }
21197 break;
21198
21199 default:
21200 if (0x0000000b == selected_member_)
21201 {
21202 valid_discriminator = true;
21203 }
21204 break;
21205
21206 }
21207
21208 if (!valid_discriminator)
21209 {
21210 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
21211 }
21212
21213 m__d = __d;
21214 }
21215
21220 eProsima_user_DllExport uint8_t _d() const
21221 {
21222 return m__d;
21223 }
21224
21229 eProsima_user_DllExport void alias_type(
21230 const CompleteAliasType& _alias_type)
21231 {
21232 alias_type_() = _alias_type;
21233 m__d = TK_ALIAS;
21234 }
21235
21240 eProsima_user_DllExport void alias_type(
21241 CompleteAliasType&& _alias_type)
21242 {
21243 alias_type_() = _alias_type;
21244 m__d = TK_ALIAS;
21245 }
21246
21252 eProsima_user_DllExport const CompleteAliasType& alias_type() const
21253 {
21254 if (0x00000001 != selected_member_)
21255 {
21256 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21257 }
21258
21259 return m_alias_type;
21260 }
21261
21267 eProsima_user_DllExport CompleteAliasType& alias_type()
21268 {
21269 if (0x00000001 != selected_member_)
21270 {
21271 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21272 }
21273
21274 return m_alias_type;
21275 }
21276
21277
21282 eProsima_user_DllExport void annotation_type(
21283 const CompleteAnnotationType& _annotation_type)
21284 {
21285 annotation_type_() = _annotation_type;
21286 m__d = TK_ANNOTATION;
21287 }
21288
21293 eProsima_user_DllExport void annotation_type(
21294 CompleteAnnotationType&& _annotation_type)
21295 {
21296 annotation_type_() = _annotation_type;
21297 m__d = TK_ANNOTATION;
21298 }
21299
21305 eProsima_user_DllExport const CompleteAnnotationType& annotation_type() const
21306 {
21307 if (0x00000002 != selected_member_)
21308 {
21309 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21310 }
21311
21312 return m_annotation_type;
21313 }
21314
21320 eProsima_user_DllExport CompleteAnnotationType& annotation_type()
21321 {
21322 if (0x00000002 != selected_member_)
21323 {
21324 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21325 }
21326
21327 return m_annotation_type;
21328 }
21329
21330
21335 eProsima_user_DllExport void struct_type(
21336 const CompleteStructType& _struct_type)
21337 {
21338 struct_type_() = _struct_type;
21339 m__d = TK_STRUCTURE;
21340 }
21341
21346 eProsima_user_DllExport void struct_type(
21347 CompleteStructType&& _struct_type)
21348 {
21349 struct_type_() = _struct_type;
21350 m__d = TK_STRUCTURE;
21351 }
21352
21358 eProsima_user_DllExport const CompleteStructType& struct_type() const
21359 {
21360 if (0x00000003 != selected_member_)
21361 {
21362 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21363 }
21364
21365 return m_struct_type;
21366 }
21367
21373 eProsima_user_DllExport CompleteStructType& struct_type()
21374 {
21375 if (0x00000003 != selected_member_)
21376 {
21377 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21378 }
21379
21380 return m_struct_type;
21381 }
21382
21383
21388 eProsima_user_DllExport void union_type(
21389 const CompleteUnionType& _union_type)
21390 {
21391 union_type_() = _union_type;
21392 m__d = TK_UNION;
21393 }
21394
21399 eProsima_user_DllExport void union_type(
21400 CompleteUnionType&& _union_type)
21401 {
21402 union_type_() = _union_type;
21403 m__d = TK_UNION;
21404 }
21405
21411 eProsima_user_DllExport const CompleteUnionType& union_type() const
21412 {
21413 if (0x00000004 != selected_member_)
21414 {
21415 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21416 }
21417
21418 return m_union_type;
21419 }
21420
21426 eProsima_user_DllExport CompleteUnionType& union_type()
21427 {
21428 if (0x00000004 != selected_member_)
21429 {
21430 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21431 }
21432
21433 return m_union_type;
21434 }
21435
21436
21441 eProsima_user_DllExport void bitset_type(
21442 const CompleteBitsetType& _bitset_type)
21443 {
21444 bitset_type_() = _bitset_type;
21445 m__d = TK_BITSET;
21446 }
21447
21452 eProsima_user_DllExport void bitset_type(
21453 CompleteBitsetType&& _bitset_type)
21454 {
21455 bitset_type_() = _bitset_type;
21456 m__d = TK_BITSET;
21457 }
21458
21464 eProsima_user_DllExport const CompleteBitsetType& bitset_type() const
21465 {
21466 if (0x00000005 != selected_member_)
21467 {
21468 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21469 }
21470
21471 return m_bitset_type;
21472 }
21473
21479 eProsima_user_DllExport CompleteBitsetType& bitset_type()
21480 {
21481 if (0x00000005 != selected_member_)
21482 {
21483 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21484 }
21485
21486 return m_bitset_type;
21487 }
21488
21489
21494 eProsima_user_DllExport void sequence_type(
21495 const CompleteSequenceType& _sequence_type)
21496 {
21497 sequence_type_() = _sequence_type;
21498 m__d = TK_SEQUENCE;
21499 }
21500
21505 eProsima_user_DllExport void sequence_type(
21506 CompleteSequenceType&& _sequence_type)
21507 {
21508 sequence_type_() = _sequence_type;
21509 m__d = TK_SEQUENCE;
21510 }
21511
21517 eProsima_user_DllExport const CompleteSequenceType& sequence_type() const
21518 {
21519 if (0x00000006 != selected_member_)
21520 {
21521 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21522 }
21523
21524 return m_sequence_type;
21525 }
21526
21532 eProsima_user_DllExport CompleteSequenceType& sequence_type()
21533 {
21534 if (0x00000006 != selected_member_)
21535 {
21536 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21537 }
21538
21539 return m_sequence_type;
21540 }
21541
21542
21547 eProsima_user_DllExport void array_type(
21548 const CompleteArrayType& _array_type)
21549 {
21550 array_type_() = _array_type;
21551 m__d = TK_ARRAY;
21552 }
21553
21558 eProsima_user_DllExport void array_type(
21559 CompleteArrayType&& _array_type)
21560 {
21561 array_type_() = _array_type;
21562 m__d = TK_ARRAY;
21563 }
21564
21570 eProsima_user_DllExport const CompleteArrayType& array_type() const
21571 {
21572 if (0x00000007 != selected_member_)
21573 {
21574 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21575 }
21576
21577 return m_array_type;
21578 }
21579
21585 eProsima_user_DllExport CompleteArrayType& array_type()
21586 {
21587 if (0x00000007 != selected_member_)
21588 {
21589 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21590 }
21591
21592 return m_array_type;
21593 }
21594
21595
21600 eProsima_user_DllExport void map_type(
21601 const CompleteMapType& _map_type)
21602 {
21603 map_type_() = _map_type;
21604 m__d = TK_MAP;
21605 }
21606
21611 eProsima_user_DllExport void map_type(
21612 CompleteMapType&& _map_type)
21613 {
21614 map_type_() = _map_type;
21615 m__d = TK_MAP;
21616 }
21617
21623 eProsima_user_DllExport const CompleteMapType& map_type() const
21624 {
21625 if (0x00000008 != selected_member_)
21626 {
21627 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21628 }
21629
21630 return m_map_type;
21631 }
21632
21638 eProsima_user_DllExport CompleteMapType& map_type()
21639 {
21640 if (0x00000008 != selected_member_)
21641 {
21642 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21643 }
21644
21645 return m_map_type;
21646 }
21647
21648
21653 eProsima_user_DllExport void enumerated_type(
21654 const CompleteEnumeratedType& _enumerated_type)
21655 {
21656 enumerated_type_() = _enumerated_type;
21657 m__d = TK_ENUM;
21658 }
21659
21664 eProsima_user_DllExport void enumerated_type(
21665 CompleteEnumeratedType&& _enumerated_type)
21666 {
21667 enumerated_type_() = _enumerated_type;
21668 m__d = TK_ENUM;
21669 }
21670
21676 eProsima_user_DllExport const CompleteEnumeratedType& enumerated_type() const
21677 {
21678 if (0x00000009 != selected_member_)
21679 {
21680 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21681 }
21682
21683 return m_enumerated_type;
21684 }
21685
21691 eProsima_user_DllExport CompleteEnumeratedType& enumerated_type()
21692 {
21693 if (0x00000009 != selected_member_)
21694 {
21695 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21696 }
21697
21698 return m_enumerated_type;
21699 }
21700
21701
21706 eProsima_user_DllExport void bitmask_type(
21707 const CompleteBitmaskType& _bitmask_type)
21708 {
21709 bitmask_type_() = _bitmask_type;
21710 m__d = TK_BITMASK;
21711 }
21712
21717 eProsima_user_DllExport void bitmask_type(
21718 CompleteBitmaskType&& _bitmask_type)
21719 {
21720 bitmask_type_() = _bitmask_type;
21721 m__d = TK_BITMASK;
21722 }
21723
21729 eProsima_user_DllExport const CompleteBitmaskType& bitmask_type() const
21730 {
21731 if (0x0000000a != selected_member_)
21732 {
21733 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21734 }
21735
21736 return m_bitmask_type;
21737 }
21738
21744 eProsima_user_DllExport CompleteBitmaskType& bitmask_type()
21745 {
21746 if (0x0000000a != selected_member_)
21747 {
21748 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21749 }
21750
21751 return m_bitmask_type;
21752 }
21753
21754
21759 eProsima_user_DllExport void extended_type(
21760 const CompleteExtendedType& _extended_type)
21761 {
21762 extended_type_() = _extended_type;
21763 m__d = 127;
21764 }
21765
21770 eProsima_user_DllExport void extended_type(
21771 CompleteExtendedType&& _extended_type)
21772 {
21773 extended_type_() = _extended_type;
21774 m__d = 127;
21775 }
21776
21782 eProsima_user_DllExport const CompleteExtendedType& extended_type() const
21783 {
21784 if (0x0000000b != selected_member_)
21785 {
21786 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21787 }
21788
21789 return m_extended_type;
21790 }
21791
21797 eProsima_user_DllExport CompleteExtendedType& extended_type()
21798 {
21799 if (0x0000000b != selected_member_)
21800 {
21801 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21802 }
21803
21804 return m_extended_type;
21805 }
21806
21807
21808
21809 private:
21810
21811 CompleteAliasType& alias_type_()
21812 {
21813 if (0x00000001 != selected_member_)
21814 {
21815 if (member_destructor_)
21816 {
21817 member_destructor_();
21818 }
21819
21820 selected_member_ = 0x00000001;
21821 member_destructor_ = [&]()
21822 {
21823 m_alias_type.~CompleteAliasType();
21824 };
21825 new(&m_alias_type) CompleteAliasType();
21826
21827 }
21828
21829 return m_alias_type;
21830 }
21831
21832 CompleteAnnotationType& annotation_type_()
21833 {
21834 if (0x00000002 != selected_member_)
21835 {
21836 if (member_destructor_)
21837 {
21838 member_destructor_();
21839 }
21840
21841 selected_member_ = 0x00000002;
21842 member_destructor_ = [&]()
21843 {
21844 m_annotation_type.~CompleteAnnotationType();
21845 };
21846 new(&m_annotation_type) CompleteAnnotationType();
21847
21848 }
21849
21850 return m_annotation_type;
21851 }
21852
21853 CompleteStructType& struct_type_()
21854 {
21855 if (0x00000003 != selected_member_)
21856 {
21857 if (member_destructor_)
21858 {
21859 member_destructor_();
21860 }
21861
21862 selected_member_ = 0x00000003;
21863 member_destructor_ = [&]()
21864 {
21865 m_struct_type.~CompleteStructType();
21866 };
21867 new(&m_struct_type) CompleteStructType();
21868
21869 }
21870
21871 return m_struct_type;
21872 }
21873
21874 CompleteUnionType& union_type_()
21875 {
21876 if (0x00000004 != selected_member_)
21877 {
21878 if (member_destructor_)
21879 {
21880 member_destructor_();
21881 }
21882
21883 selected_member_ = 0x00000004;
21884 member_destructor_ = [&]()
21885 {
21886 m_union_type.~CompleteUnionType();
21887 };
21888 new(&m_union_type) CompleteUnionType();
21889
21890 }
21891
21892 return m_union_type;
21893 }
21894
21895 CompleteBitsetType& bitset_type_()
21896 {
21897 if (0x00000005 != selected_member_)
21898 {
21899 if (member_destructor_)
21900 {
21901 member_destructor_();
21902 }
21903
21904 selected_member_ = 0x00000005;
21905 member_destructor_ = [&]()
21906 {
21907 m_bitset_type.~CompleteBitsetType();
21908 };
21909 new(&m_bitset_type) CompleteBitsetType();
21910
21911 }
21912
21913 return m_bitset_type;
21914 }
21915
21916 CompleteSequenceType& sequence_type_()
21917 {
21918 if (0x00000006 != selected_member_)
21919 {
21920 if (member_destructor_)
21921 {
21922 member_destructor_();
21923 }
21924
21925 selected_member_ = 0x00000006;
21926 member_destructor_ = [&]()
21927 {
21928 m_sequence_type.~CompleteSequenceType();
21929 };
21930 new(&m_sequence_type) CompleteSequenceType();
21931
21932 }
21933
21934 return m_sequence_type;
21935 }
21936
21937 CompleteArrayType& array_type_()
21938 {
21939 if (0x00000007 != selected_member_)
21940 {
21941 if (member_destructor_)
21942 {
21943 member_destructor_();
21944 }
21945
21946 selected_member_ = 0x00000007;
21947 member_destructor_ = [&]()
21948 {
21949 m_array_type.~CompleteArrayType();
21950 };
21951 new(&m_array_type) CompleteArrayType();
21952
21953 }
21954
21955 return m_array_type;
21956 }
21957
21958 CompleteMapType& map_type_()
21959 {
21960 if (0x00000008 != selected_member_)
21961 {
21962 if (member_destructor_)
21963 {
21964 member_destructor_();
21965 }
21966
21967 selected_member_ = 0x00000008;
21968 member_destructor_ = [&]()
21969 {
21970 m_map_type.~CompleteMapType();
21971 };
21972 new(&m_map_type) CompleteMapType();
21973
21974 }
21975
21976 return m_map_type;
21977 }
21978
21979 CompleteEnumeratedType& enumerated_type_()
21980 {
21981 if (0x00000009 != selected_member_)
21982 {
21983 if (member_destructor_)
21984 {
21985 member_destructor_();
21986 }
21987
21988 selected_member_ = 0x00000009;
21989 member_destructor_ = [&]()
21990 {
21991 m_enumerated_type.~CompleteEnumeratedType();
21992 };
21993 new(&m_enumerated_type) CompleteEnumeratedType();
21994
21995 }
21996
21997 return m_enumerated_type;
21998 }
21999
22000 CompleteBitmaskType& bitmask_type_()
22001 {
22002 if (0x0000000a != selected_member_)
22003 {
22004 if (member_destructor_)
22005 {
22006 member_destructor_();
22007 }
22008
22009 selected_member_ = 0x0000000a;
22010 member_destructor_ = [&]()
22011 {
22012 m_bitmask_type.~CompleteBitmaskType();
22013 };
22014 new(&m_bitmask_type) CompleteBitmaskType();
22015
22016 }
22017
22018 return m_bitmask_type;
22019 }
22020
22021 CompleteExtendedType& extended_type_()
22022 {
22023 if (0x0000000b != selected_member_)
22024 {
22025 if (member_destructor_)
22026 {
22027 member_destructor_();
22028 }
22029
22030 selected_member_ = 0x0000000b;
22031 member_destructor_ = [&]()
22032 {
22033 m_extended_type.~CompleteExtendedType();
22034 };
22035 new(&m_extended_type) CompleteExtendedType();
22036
22037 }
22038
22039 return m_extended_type;
22040 }
22041
22042
22043 uint8_t m__d {TK_NONE};
22044
22045 union
22046 {
22047 CompleteAliasType m_alias_type;
22048 CompleteAnnotationType m_annotation_type;
22049 CompleteStructType m_struct_type;
22050 CompleteUnionType m_union_type;
22051 CompleteBitsetType m_bitset_type;
22052 CompleteSequenceType m_sequence_type;
22053 CompleteArrayType m_array_type;
22054 CompleteMapType m_map_type;
22055 CompleteEnumeratedType m_enumerated_type;
22056 CompleteBitmaskType m_bitmask_type;
22057 CompleteExtendedType m_extended_type;
22058 };
22059
22060 uint32_t selected_member_ {0x0FFFFFFFu};
22061
22062 std::function<void()> member_destructor_;
22063};
22064
22068 class MinimalExtendedType
22069{
22070 public:
22071
22075 eProsima_user_DllExport MinimalExtendedType()
22076 {
22077 }
22078
22082 eProsima_user_DllExport ~MinimalExtendedType()
22083 {
22084 }
22085
22090 eProsima_user_DllExport MinimalExtendedType(
22091 const MinimalExtendedType& x)
22092 {
22093 static_cast<void>(x);
22094 }
22095
22100 eProsima_user_DllExport MinimalExtendedType(
22101 MinimalExtendedType&& x) noexcept
22102 {
22103 static_cast<void>(x);
22104 }
22105
22110 eProsima_user_DllExport MinimalExtendedType& operator =(
22111 const MinimalExtendedType& x)
22112 {
22113
22114 static_cast<void>(x);
22115
22116 return *this;
22117 }
22118
22123 eProsima_user_DllExport MinimalExtendedType& operator =(
22124 MinimalExtendedType&& x) noexcept
22125 {
22126
22127 static_cast<void>(x);
22128
22129 return *this;
22130 }
22131
22136 eProsima_user_DllExport bool operator ==(
22137 const MinimalExtendedType& x) const
22138 {
22139 static_cast<void>(x);
22140 return true;
22141 }
22142
22147 eProsima_user_DllExport bool operator !=(
22148 const MinimalExtendedType& x) const
22149 {
22150 return !(*this == x);
22151 }
22152
22153
22154
22155 private:
22156
22157
22158};
22159
22163 class MinimalTypeObject
22164{
22165 public:
22166
22170 eProsima_user_DllExport MinimalTypeObject()
22171 {
22172 selected_member_ = 0x0000000b;
22173 member_destructor_ = [&]()
22174 {
22175 m_extended_type.~MinimalExtendedType();
22176 };
22177 new(&m_extended_type) MinimalExtendedType();
22178
22179 }
22180
22184 eProsima_user_DllExport ~MinimalTypeObject()
22185 {
22186 if (member_destructor_)
22187 {
22188 member_destructor_();
22189 }
22190 }
22191
22196 eProsima_user_DllExport MinimalTypeObject(
22197 const MinimalTypeObject& x)
22198 {
22199 m__d = x.m__d;
22200
22201 switch (x.selected_member_)
22202 {
22203 case 0x00000001:
22204 alias_type_() = x.m_alias_type;
22205 break;
22206
22207 case 0x00000002:
22208 annotation_type_() = x.m_annotation_type;
22209 break;
22210
22211 case 0x00000003:
22212 struct_type_() = x.m_struct_type;
22213 break;
22214
22215 case 0x00000004:
22216 union_type_() = x.m_union_type;
22217 break;
22218
22219 case 0x00000005:
22220 bitset_type_() = x.m_bitset_type;
22221 break;
22222
22223 case 0x00000006:
22224 sequence_type_() = x.m_sequence_type;
22225 break;
22226
22227 case 0x00000007:
22228 array_type_() = x.m_array_type;
22229 break;
22230
22231 case 0x00000008:
22232 map_type_() = x.m_map_type;
22233 break;
22234
22235 case 0x00000009:
22236 enumerated_type_() = x.m_enumerated_type;
22237 break;
22238
22239 case 0x0000000a:
22240 bitmask_type_() = x.m_bitmask_type;
22241 break;
22242
22243 case 0x0000000b:
22244 extended_type_() = x.m_extended_type;
22245 break;
22246
22247 }
22248 }
22249
22254 eProsima_user_DllExport MinimalTypeObject(
22255 MinimalTypeObject&& x) noexcept
22256 {
22257 m__d = x.m__d;
22258
22259 switch (x.selected_member_)
22260 {
22261 case 0x00000001:
22262 alias_type_() = std::move(x.m_alias_type);
22263 break;
22264
22265 case 0x00000002:
22266 annotation_type_() = std::move(x.m_annotation_type);
22267 break;
22268
22269 case 0x00000003:
22270 struct_type_() = std::move(x.m_struct_type);
22271 break;
22272
22273 case 0x00000004:
22274 union_type_() = std::move(x.m_union_type);
22275 break;
22276
22277 case 0x00000005:
22278 bitset_type_() = std::move(x.m_bitset_type);
22279 break;
22280
22281 case 0x00000006:
22282 sequence_type_() = std::move(x.m_sequence_type);
22283 break;
22284
22285 case 0x00000007:
22286 array_type_() = std::move(x.m_array_type);
22287 break;
22288
22289 case 0x00000008:
22290 map_type_() = std::move(x.m_map_type);
22291 break;
22292
22293 case 0x00000009:
22294 enumerated_type_() = std::move(x.m_enumerated_type);
22295 break;
22296
22297 case 0x0000000a:
22298 bitmask_type_() = std::move(x.m_bitmask_type);
22299 break;
22300
22301 case 0x0000000b:
22302 extended_type_() = std::move(x.m_extended_type);
22303 break;
22304
22305 }
22306 }
22307
22312 eProsima_user_DllExport MinimalTypeObject& operator =(
22313 const MinimalTypeObject& x)
22314 {
22315 m__d = x.m__d;
22316
22317 switch (x.selected_member_)
22318 {
22319 case 0x00000001:
22320 alias_type_() = x.m_alias_type;
22321 break;
22322
22323 case 0x00000002:
22324 annotation_type_() = x.m_annotation_type;
22325 break;
22326
22327 case 0x00000003:
22328 struct_type_() = x.m_struct_type;
22329 break;
22330
22331 case 0x00000004:
22332 union_type_() = x.m_union_type;
22333 break;
22334
22335 case 0x00000005:
22336 bitset_type_() = x.m_bitset_type;
22337 break;
22338
22339 case 0x00000006:
22340 sequence_type_() = x.m_sequence_type;
22341 break;
22342
22343 case 0x00000007:
22344 array_type_() = x.m_array_type;
22345 break;
22346
22347 case 0x00000008:
22348 map_type_() = x.m_map_type;
22349 break;
22350
22351 case 0x00000009:
22352 enumerated_type_() = x.m_enumerated_type;
22353 break;
22354
22355 case 0x0000000a:
22356 bitmask_type_() = x.m_bitmask_type;
22357 break;
22358
22359 case 0x0000000b:
22360 extended_type_() = x.m_extended_type;
22361 break;
22362
22363 }
22364
22365 return *this;
22366 }
22367
22372 eProsima_user_DllExport MinimalTypeObject& operator =(
22373 MinimalTypeObject&& x) noexcept
22374 {
22375 m__d = x.m__d;
22376
22377 switch (x.selected_member_)
22378 {
22379 case 0x00000001:
22380 alias_type_() = std::move(x.m_alias_type);
22381 break;
22382
22383 case 0x00000002:
22384 annotation_type_() = std::move(x.m_annotation_type);
22385 break;
22386
22387 case 0x00000003:
22388 struct_type_() = std::move(x.m_struct_type);
22389 break;
22390
22391 case 0x00000004:
22392 union_type_() = std::move(x.m_union_type);
22393 break;
22394
22395 case 0x00000005:
22396 bitset_type_() = std::move(x.m_bitset_type);
22397 break;
22398
22399 case 0x00000006:
22400 sequence_type_() = std::move(x.m_sequence_type);
22401 break;
22402
22403 case 0x00000007:
22404 array_type_() = std::move(x.m_array_type);
22405 break;
22406
22407 case 0x00000008:
22408 map_type_() = std::move(x.m_map_type);
22409 break;
22410
22411 case 0x00000009:
22412 enumerated_type_() = std::move(x.m_enumerated_type);
22413 break;
22414
22415 case 0x0000000a:
22416 bitmask_type_() = std::move(x.m_bitmask_type);
22417 break;
22418
22419 case 0x0000000b:
22420 extended_type_() = std::move(x.m_extended_type);
22421 break;
22422
22423 }
22424
22425 return *this;
22426 }
22427
22432 eProsima_user_DllExport bool operator ==(
22433 const MinimalTypeObject& x) const
22434 {
22435 bool ret_value {false};
22436
22437 if (x.selected_member_ == selected_member_)
22438 {
22439 if (0x0FFFFFFFu != selected_member_)
22440 {
22441 if (x.m__d == m__d)
22442 {
22443 switch (selected_member_)
22444 {
22445 case 0x00000001:
22446 ret_value = (x.m_alias_type == m_alias_type);
22447 break;
22448
22449 case 0x00000002:
22450 ret_value = (x.m_annotation_type == m_annotation_type);
22451 break;
22452
22453 case 0x00000003:
22454 ret_value = (x.m_struct_type == m_struct_type);
22455 break;
22456
22457 case 0x00000004:
22458 ret_value = (x.m_union_type == m_union_type);
22459 break;
22460
22461 case 0x00000005:
22462 ret_value = (x.m_bitset_type == m_bitset_type);
22463 break;
22464
22465 case 0x00000006:
22466 ret_value = (x.m_sequence_type == m_sequence_type);
22467 break;
22468
22469 case 0x00000007:
22470 ret_value = (x.m_array_type == m_array_type);
22471 break;
22472
22473 case 0x00000008:
22474 ret_value = (x.m_map_type == m_map_type);
22475 break;
22476
22477 case 0x00000009:
22478 ret_value = (x.m_enumerated_type == m_enumerated_type);
22479 break;
22480
22481 case 0x0000000a:
22482 ret_value = (x.m_bitmask_type == m_bitmask_type);
22483 break;
22484
22485 case 0x0000000b:
22486 ret_value = (x.m_extended_type == m_extended_type);
22487 break;
22488
22489 }
22490 }
22491 }
22492 else
22493 {
22494 ret_value = true;
22495 }
22496 }
22497
22498 return ret_value;
22499 }
22500
22505 eProsima_user_DllExport bool operator !=(
22506 const MinimalTypeObject& x) const
22507 {
22508 return !(*this == x);
22509 }
22510
22516 eProsima_user_DllExport void _d(
22517 uint8_t __d)
22518 {
22519 bool valid_discriminator = false;
22520
22521 switch (__d)
22522 {
22523 case TK_ALIAS:
22524 if (0x00000001 == selected_member_)
22525 {
22526 valid_discriminator = true;
22527 }
22528 break;
22529
22530 case TK_ANNOTATION:
22531 if (0x00000002 == selected_member_)
22532 {
22533 valid_discriminator = true;
22534 }
22535 break;
22536
22537 case TK_STRUCTURE:
22538 if (0x00000003 == selected_member_)
22539 {
22540 valid_discriminator = true;
22541 }
22542 break;
22543
22544 case TK_UNION:
22545 if (0x00000004 == selected_member_)
22546 {
22547 valid_discriminator = true;
22548 }
22549 break;
22550
22551 case TK_BITSET:
22552 if (0x00000005 == selected_member_)
22553 {
22554 valid_discriminator = true;
22555 }
22556 break;
22557
22558 case TK_SEQUENCE:
22559 if (0x00000006 == selected_member_)
22560 {
22561 valid_discriminator = true;
22562 }
22563 break;
22564
22565 case TK_ARRAY:
22566 if (0x00000007 == selected_member_)
22567 {
22568 valid_discriminator = true;
22569 }
22570 break;
22571
22572 case TK_MAP:
22573 if (0x00000008 == selected_member_)
22574 {
22575 valid_discriminator = true;
22576 }
22577 break;
22578
22579 case TK_ENUM:
22580 if (0x00000009 == selected_member_)
22581 {
22582 valid_discriminator = true;
22583 }
22584 break;
22585
22586 case TK_BITMASK:
22587 if (0x0000000a == selected_member_)
22588 {
22589 valid_discriminator = true;
22590 }
22591 break;
22592
22593 default:
22594 if (0x0000000b == selected_member_)
22595 {
22596 valid_discriminator = true;
22597 }
22598 break;
22599
22600 }
22601
22602 if (!valid_discriminator)
22603 {
22604 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
22605 }
22606
22607 m__d = __d;
22608 }
22609
22614 eProsima_user_DllExport uint8_t _d() const
22615 {
22616 return m__d;
22617 }
22618
22623 eProsima_user_DllExport void alias_type(
22624 const MinimalAliasType& _alias_type)
22625 {
22626 alias_type_() = _alias_type;
22627 m__d = TK_ALIAS;
22628 }
22629
22634 eProsima_user_DllExport void alias_type(
22635 MinimalAliasType&& _alias_type)
22636 {
22637 alias_type_() = _alias_type;
22638 m__d = TK_ALIAS;
22639 }
22640
22646 eProsima_user_DllExport const MinimalAliasType& alias_type() const
22647 {
22648 if (0x00000001 != selected_member_)
22649 {
22650 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22651 }
22652
22653 return m_alias_type;
22654 }
22655
22661 eProsima_user_DllExport MinimalAliasType& alias_type()
22662 {
22663 if (0x00000001 != selected_member_)
22664 {
22665 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22666 }
22667
22668 return m_alias_type;
22669 }
22670
22671
22676 eProsima_user_DllExport void annotation_type(
22677 const MinimalAnnotationType& _annotation_type)
22678 {
22679 annotation_type_() = _annotation_type;
22680 m__d = TK_ANNOTATION;
22681 }
22682
22687 eProsima_user_DllExport void annotation_type(
22688 MinimalAnnotationType&& _annotation_type)
22689 {
22690 annotation_type_() = _annotation_type;
22691 m__d = TK_ANNOTATION;
22692 }
22693
22699 eProsima_user_DllExport const MinimalAnnotationType& annotation_type() const
22700 {
22701 if (0x00000002 != selected_member_)
22702 {
22703 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22704 }
22705
22706 return m_annotation_type;
22707 }
22708
22714 eProsima_user_DllExport MinimalAnnotationType& annotation_type()
22715 {
22716 if (0x00000002 != selected_member_)
22717 {
22718 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22719 }
22720
22721 return m_annotation_type;
22722 }
22723
22724
22729 eProsima_user_DllExport void struct_type(
22730 const MinimalStructType& _struct_type)
22731 {
22732 struct_type_() = _struct_type;
22733 m__d = TK_STRUCTURE;
22734 }
22735
22740 eProsima_user_DllExport void struct_type(
22741 MinimalStructType&& _struct_type)
22742 {
22743 struct_type_() = _struct_type;
22744 m__d = TK_STRUCTURE;
22745 }
22746
22752 eProsima_user_DllExport const MinimalStructType& struct_type() const
22753 {
22754 if (0x00000003 != selected_member_)
22755 {
22756 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22757 }
22758
22759 return m_struct_type;
22760 }
22761
22767 eProsima_user_DllExport MinimalStructType& struct_type()
22768 {
22769 if (0x00000003 != selected_member_)
22770 {
22771 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22772 }
22773
22774 return m_struct_type;
22775 }
22776
22777
22782 eProsima_user_DllExport void union_type(
22783 const MinimalUnionType& _union_type)
22784 {
22785 union_type_() = _union_type;
22786 m__d = TK_UNION;
22787 }
22788
22793 eProsima_user_DllExport void union_type(
22794 MinimalUnionType&& _union_type)
22795 {
22796 union_type_() = _union_type;
22797 m__d = TK_UNION;
22798 }
22799
22805 eProsima_user_DllExport const MinimalUnionType& union_type() const
22806 {
22807 if (0x00000004 != selected_member_)
22808 {
22809 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22810 }
22811
22812 return m_union_type;
22813 }
22814
22820 eProsima_user_DllExport MinimalUnionType& union_type()
22821 {
22822 if (0x00000004 != selected_member_)
22823 {
22824 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22825 }
22826
22827 return m_union_type;
22828 }
22829
22830
22835 eProsima_user_DllExport void bitset_type(
22836 const MinimalBitsetType& _bitset_type)
22837 {
22838 bitset_type_() = _bitset_type;
22839 m__d = TK_BITSET;
22840 }
22841
22846 eProsima_user_DllExport void bitset_type(
22847 MinimalBitsetType&& _bitset_type)
22848 {
22849 bitset_type_() = _bitset_type;
22850 m__d = TK_BITSET;
22851 }
22852
22858 eProsima_user_DllExport const MinimalBitsetType& bitset_type() const
22859 {
22860 if (0x00000005 != selected_member_)
22861 {
22862 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22863 }
22864
22865 return m_bitset_type;
22866 }
22867
22873 eProsima_user_DllExport MinimalBitsetType& bitset_type()
22874 {
22875 if (0x00000005 != selected_member_)
22876 {
22877 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22878 }
22879
22880 return m_bitset_type;
22881 }
22882
22883
22888 eProsima_user_DllExport void sequence_type(
22889 const MinimalSequenceType& _sequence_type)
22890 {
22891 sequence_type_() = _sequence_type;
22892 m__d = TK_SEQUENCE;
22893 }
22894
22899 eProsima_user_DllExport void sequence_type(
22900 MinimalSequenceType&& _sequence_type)
22901 {
22902 sequence_type_() = _sequence_type;
22903 m__d = TK_SEQUENCE;
22904 }
22905
22911 eProsima_user_DllExport const MinimalSequenceType& sequence_type() const
22912 {
22913 if (0x00000006 != selected_member_)
22914 {
22915 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22916 }
22917
22918 return m_sequence_type;
22919 }
22920
22926 eProsima_user_DllExport MinimalSequenceType& sequence_type()
22927 {
22928 if (0x00000006 != selected_member_)
22929 {
22930 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22931 }
22932
22933 return m_sequence_type;
22934 }
22935
22936
22941 eProsima_user_DllExport void array_type(
22942 const MinimalArrayType& _array_type)
22943 {
22944 array_type_() = _array_type;
22945 m__d = TK_ARRAY;
22946 }
22947
22952 eProsima_user_DllExport void array_type(
22953 MinimalArrayType&& _array_type)
22954 {
22955 array_type_() = _array_type;
22956 m__d = TK_ARRAY;
22957 }
22958
22964 eProsima_user_DllExport const MinimalArrayType& array_type() const
22965 {
22966 if (0x00000007 != selected_member_)
22967 {
22968 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22969 }
22970
22971 return m_array_type;
22972 }
22973
22979 eProsima_user_DllExport MinimalArrayType& array_type()
22980 {
22981 if (0x00000007 != selected_member_)
22982 {
22983 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22984 }
22985
22986 return m_array_type;
22987 }
22988
22989
22994 eProsima_user_DllExport void map_type(
22995 const MinimalMapType& _map_type)
22996 {
22997 map_type_() = _map_type;
22998 m__d = TK_MAP;
22999 }
23000
23005 eProsima_user_DllExport void map_type(
23006 MinimalMapType&& _map_type)
23007 {
23008 map_type_() = _map_type;
23009 m__d = TK_MAP;
23010 }
23011
23017 eProsima_user_DllExport const MinimalMapType& map_type() const
23018 {
23019 if (0x00000008 != selected_member_)
23020 {
23021 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23022 }
23023
23024 return m_map_type;
23025 }
23026
23032 eProsima_user_DllExport MinimalMapType& map_type()
23033 {
23034 if (0x00000008 != selected_member_)
23035 {
23036 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23037 }
23038
23039 return m_map_type;
23040 }
23041
23042
23047 eProsima_user_DllExport void enumerated_type(
23048 const MinimalEnumeratedType& _enumerated_type)
23049 {
23050 enumerated_type_() = _enumerated_type;
23051 m__d = TK_ENUM;
23052 }
23053
23058 eProsima_user_DllExport void enumerated_type(
23059 MinimalEnumeratedType&& _enumerated_type)
23060 {
23061 enumerated_type_() = _enumerated_type;
23062 m__d = TK_ENUM;
23063 }
23064
23070 eProsima_user_DllExport const MinimalEnumeratedType& enumerated_type() const
23071 {
23072 if (0x00000009 != selected_member_)
23073 {
23074 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23075 }
23076
23077 return m_enumerated_type;
23078 }
23079
23085 eProsima_user_DllExport MinimalEnumeratedType& enumerated_type()
23086 {
23087 if (0x00000009 != selected_member_)
23088 {
23089 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23090 }
23091
23092 return m_enumerated_type;
23093 }
23094
23095
23100 eProsima_user_DllExport void bitmask_type(
23101 const MinimalBitmaskType& _bitmask_type)
23102 {
23103 bitmask_type_() = _bitmask_type;
23104 m__d = TK_BITMASK;
23105 }
23106
23111 eProsima_user_DllExport void bitmask_type(
23112 MinimalBitmaskType&& _bitmask_type)
23113 {
23114 bitmask_type_() = _bitmask_type;
23115 m__d = TK_BITMASK;
23116 }
23117
23123 eProsima_user_DllExport const MinimalBitmaskType& bitmask_type() const
23124 {
23125 if (0x0000000a != selected_member_)
23126 {
23127 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23128 }
23129
23130 return m_bitmask_type;
23131 }
23132
23138 eProsima_user_DllExport MinimalBitmaskType& bitmask_type()
23139 {
23140 if (0x0000000a != selected_member_)
23141 {
23142 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23143 }
23144
23145 return m_bitmask_type;
23146 }
23147
23148
23153 eProsima_user_DllExport void extended_type(
23154 const MinimalExtendedType& _extended_type)
23155 {
23156 extended_type_() = _extended_type;
23157 m__d = 127;
23158 }
23159
23164 eProsima_user_DllExport void extended_type(
23165 MinimalExtendedType&& _extended_type)
23166 {
23167 extended_type_() = _extended_type;
23168 m__d = 127;
23169 }
23170
23176 eProsima_user_DllExport const MinimalExtendedType& extended_type() const
23177 {
23178 if (0x0000000b != selected_member_)
23179 {
23180 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23181 }
23182
23183 return m_extended_type;
23184 }
23185
23191 eProsima_user_DllExport MinimalExtendedType& extended_type()
23192 {
23193 if (0x0000000b != selected_member_)
23194 {
23195 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23196 }
23197
23198 return m_extended_type;
23199 }
23200
23201
23202
23203 private:
23204
23205 MinimalAliasType& alias_type_()
23206 {
23207 if (0x00000001 != selected_member_)
23208 {
23209 if (member_destructor_)
23210 {
23211 member_destructor_();
23212 }
23213
23214 selected_member_ = 0x00000001;
23215 member_destructor_ = [&]()
23216 {
23217 m_alias_type.~MinimalAliasType();
23218 };
23219 new(&m_alias_type) MinimalAliasType();
23220
23221 }
23222
23223 return m_alias_type;
23224 }
23225
23226 MinimalAnnotationType& annotation_type_()
23227 {
23228 if (0x00000002 != selected_member_)
23229 {
23230 if (member_destructor_)
23231 {
23232 member_destructor_();
23233 }
23234
23235 selected_member_ = 0x00000002;
23236 member_destructor_ = [&]()
23237 {
23238 m_annotation_type.~MinimalAnnotationType();
23239 };
23240 new(&m_annotation_type) MinimalAnnotationType();
23241
23242 }
23243
23244 return m_annotation_type;
23245 }
23246
23247 MinimalStructType& struct_type_()
23248 {
23249 if (0x00000003 != selected_member_)
23250 {
23251 if (member_destructor_)
23252 {
23253 member_destructor_();
23254 }
23255
23256 selected_member_ = 0x00000003;
23257 member_destructor_ = [&]()
23258 {
23259 m_struct_type.~MinimalStructType();
23260 };
23261 new(&m_struct_type) MinimalStructType();
23262
23263 }
23264
23265 return m_struct_type;
23266 }
23267
23268 MinimalUnionType& union_type_()
23269 {
23270 if (0x00000004 != selected_member_)
23271 {
23272 if (member_destructor_)
23273 {
23274 member_destructor_();
23275 }
23276
23277 selected_member_ = 0x00000004;
23278 member_destructor_ = [&]()
23279 {
23280 m_union_type.~MinimalUnionType();
23281 };
23282 new(&m_union_type) MinimalUnionType();
23283
23284 }
23285
23286 return m_union_type;
23287 }
23288
23289 MinimalBitsetType& bitset_type_()
23290 {
23291 if (0x00000005 != selected_member_)
23292 {
23293 if (member_destructor_)
23294 {
23295 member_destructor_();
23296 }
23297
23298 selected_member_ = 0x00000005;
23299 member_destructor_ = [&]()
23300 {
23301 m_bitset_type.~MinimalBitsetType();
23302 };
23303 new(&m_bitset_type) MinimalBitsetType();
23304
23305 }
23306
23307 return m_bitset_type;
23308 }
23309
23310 MinimalSequenceType& sequence_type_()
23311 {
23312 if (0x00000006 != selected_member_)
23313 {
23314 if (member_destructor_)
23315 {
23316 member_destructor_();
23317 }
23318
23319 selected_member_ = 0x00000006;
23320 member_destructor_ = [&]()
23321 {
23322 m_sequence_type.~MinimalSequenceType();
23323 };
23324 new(&m_sequence_type) MinimalSequenceType();
23325
23326 }
23327
23328 return m_sequence_type;
23329 }
23330
23331 MinimalArrayType& array_type_()
23332 {
23333 if (0x00000007 != selected_member_)
23334 {
23335 if (member_destructor_)
23336 {
23337 member_destructor_();
23338 }
23339
23340 selected_member_ = 0x00000007;
23341 member_destructor_ = [&]()
23342 {
23343 m_array_type.~MinimalArrayType();
23344 };
23345 new(&m_array_type) MinimalArrayType();
23346
23347 }
23348
23349 return m_array_type;
23350 }
23351
23352 MinimalMapType& map_type_()
23353 {
23354 if (0x00000008 != selected_member_)
23355 {
23356 if (member_destructor_)
23357 {
23358 member_destructor_();
23359 }
23360
23361 selected_member_ = 0x00000008;
23362 member_destructor_ = [&]()
23363 {
23364 m_map_type.~MinimalMapType();
23365 };
23366 new(&m_map_type) MinimalMapType();
23367
23368 }
23369
23370 return m_map_type;
23371 }
23372
23373 MinimalEnumeratedType& enumerated_type_()
23374 {
23375 if (0x00000009 != selected_member_)
23376 {
23377 if (member_destructor_)
23378 {
23379 member_destructor_();
23380 }
23381
23382 selected_member_ = 0x00000009;
23383 member_destructor_ = [&]()
23384 {
23385 m_enumerated_type.~MinimalEnumeratedType();
23386 };
23387 new(&m_enumerated_type) MinimalEnumeratedType();
23388
23389 }
23390
23391 return m_enumerated_type;
23392 }
23393
23394 MinimalBitmaskType& bitmask_type_()
23395 {
23396 if (0x0000000a != selected_member_)
23397 {
23398 if (member_destructor_)
23399 {
23400 member_destructor_();
23401 }
23402
23403 selected_member_ = 0x0000000a;
23404 member_destructor_ = [&]()
23405 {
23406 m_bitmask_type.~MinimalBitmaskType();
23407 };
23408 new(&m_bitmask_type) MinimalBitmaskType();
23409
23410 }
23411
23412 return m_bitmask_type;
23413 }
23414
23415 MinimalExtendedType& extended_type_()
23416 {
23417 if (0x0000000b != selected_member_)
23418 {
23419 if (member_destructor_)
23420 {
23421 member_destructor_();
23422 }
23423
23424 selected_member_ = 0x0000000b;
23425 member_destructor_ = [&]()
23426 {
23427 m_extended_type.~MinimalExtendedType();
23428 };
23429 new(&m_extended_type) MinimalExtendedType();
23430
23431 }
23432
23433 return m_extended_type;
23434 }
23435
23436
23437 uint8_t m__d {TK_NONE};
23438
23439 union
23440 {
23441 MinimalAliasType m_alias_type;
23442 MinimalAnnotationType m_annotation_type;
23443 MinimalStructType m_struct_type;
23444 MinimalUnionType m_union_type;
23445 MinimalBitsetType m_bitset_type;
23446 MinimalSequenceType m_sequence_type;
23447 MinimalArrayType m_array_type;
23448 MinimalMapType m_map_type;
23449 MinimalEnumeratedType m_enumerated_type;
23450 MinimalBitmaskType m_bitmask_type;
23451 MinimalExtendedType m_extended_type;
23452 };
23453
23454 uint32_t selected_member_ {0x0FFFFFFFu};
23455
23456 std::function<void()> member_destructor_;
23457};
23458
23462 class TypeObject
23463{
23464 public:
23465
23469 eProsima_user_DllExport TypeObject()
23470 {
23471 }
23472
23476 eProsima_user_DllExport ~TypeObject()
23477 {
23478 if (member_destructor_)
23479 {
23480 member_destructor_();
23481 }
23482 }
23483
23488 eProsima_user_DllExport TypeObject(
23489 const TypeObject& x)
23490 {
23491 m__d = x.m__d;
23492
23493 switch (x.selected_member_)
23494 {
23495 case 0x00000001:
23496 complete_() = x.m_complete;
23497 break;
23498
23499 case 0x00000002:
23500 minimal_() = x.m_minimal;
23501 break;
23502
23503 }
23504 }
23505
23510 eProsima_user_DllExport TypeObject(
23511 TypeObject&& x) noexcept
23512 {
23513 m__d = x.m__d;
23514
23515 switch (x.selected_member_)
23516 {
23517 case 0x00000001:
23518 complete_() = std::move(x.m_complete);
23519 break;
23520
23521 case 0x00000002:
23522 minimal_() = std::move(x.m_minimal);
23523 break;
23524
23525 }
23526 }
23527
23532 eProsima_user_DllExport TypeObject& operator =(
23533 const TypeObject& x)
23534 {
23535 m__d = x.m__d;
23536
23537 switch (x.selected_member_)
23538 {
23539 case 0x00000001:
23540 complete_() = x.m_complete;
23541 break;
23542
23543 case 0x00000002:
23544 minimal_() = x.m_minimal;
23545 break;
23546
23547 }
23548
23549 return *this;
23550 }
23551
23556 eProsima_user_DllExport TypeObject& operator =(
23557 TypeObject&& x) noexcept
23558 {
23559 m__d = x.m__d;
23560
23561 switch (x.selected_member_)
23562 {
23563 case 0x00000001:
23564 complete_() = std::move(x.m_complete);
23565 break;
23566
23567 case 0x00000002:
23568 minimal_() = std::move(x.m_minimal);
23569 break;
23570
23571 }
23572
23573 return *this;
23574 }
23575
23580 eProsima_user_DllExport bool operator ==(
23581 const TypeObject& x) const
23582 {
23583 bool ret_value {false};
23584
23585 if (x.selected_member_ == selected_member_)
23586 {
23587 if (0x0FFFFFFFu != selected_member_)
23588 {
23589 if (x.m__d == m__d)
23590 {
23591 switch (selected_member_)
23592 {
23593 case 0x00000001:
23594 ret_value = (x.m_complete == m_complete);
23595 break;
23596
23597 case 0x00000002:
23598 ret_value = (x.m_minimal == m_minimal);
23599 break;
23600
23601 }
23602 }
23603 }
23604 else
23605 {
23606 ret_value = true;
23607 }
23608 }
23609
23610 return ret_value;
23611 }
23612
23617 eProsima_user_DllExport bool operator !=(
23618 const TypeObject& x) const
23619 {
23620 return !(*this == x);
23621 }
23622
23628 eProsima_user_DllExport void _d(
23629 uint8_t __d)
23630 {
23631 bool valid_discriminator = false;
23632
23633 switch (__d)
23634 {
23635 case EK_COMPLETE:
23636 if (0x00000001 == selected_member_)
23637 {
23638 valid_discriminator = true;
23639 }
23640 break;
23641
23642 case EK_MINIMAL:
23643 if (0x00000002 == selected_member_)
23644 {
23645 valid_discriminator = true;
23646 }
23647 break;
23648
23649 }
23650
23651 if (!valid_discriminator)
23652 {
23653 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
23654 }
23655
23656 m__d = __d;
23657 }
23658
23663 eProsima_user_DllExport uint8_t _d() const
23664 {
23665 return m__d;
23666 }
23667
23672 eProsima_user_DllExport void complete(
23673 const CompleteTypeObject& _complete)
23674 {
23675 complete_() = _complete;
23676 m__d = EK_COMPLETE;
23677 }
23678
23683 eProsima_user_DllExport void complete(
23684 CompleteTypeObject&& _complete)
23685 {
23686 complete_() = _complete;
23687 m__d = EK_COMPLETE;
23688 }
23689
23695 eProsima_user_DllExport const CompleteTypeObject& complete() const
23696 {
23697 if (0x00000001 != selected_member_)
23698 {
23699 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23700 }
23701
23702 return m_complete;
23703 }
23704
23710 eProsima_user_DllExport CompleteTypeObject& complete()
23711 {
23712 if (0x00000001 != selected_member_)
23713 {
23714 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23715 }
23716
23717 return m_complete;
23718 }
23719
23720
23725 eProsima_user_DllExport void minimal(
23726 const MinimalTypeObject& _minimal)
23727 {
23728 minimal_() = _minimal;
23729 m__d = EK_MINIMAL;
23730 }
23731
23736 eProsima_user_DllExport void minimal(
23737 MinimalTypeObject&& _minimal)
23738 {
23739 minimal_() = _minimal;
23740 m__d = EK_MINIMAL;
23741 }
23742
23748 eProsima_user_DllExport const MinimalTypeObject& minimal() const
23749 {
23750 if (0x00000002 != selected_member_)
23751 {
23752 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23753 }
23754
23755 return m_minimal;
23756 }
23757
23763 eProsima_user_DllExport MinimalTypeObject& minimal()
23764 {
23765 if (0x00000002 != selected_member_)
23766 {
23767 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23768 }
23769
23770 return m_minimal;
23771 }
23772
23773
23774 void _default()
23775 {
23776 if (member_destructor_)
23777 {
23778 member_destructor_();
23779 }
23780
23781 selected_member_ = 0x0FFFFFFFu;
23782 }
23783
23784
23785 private:
23786
23787 CompleteTypeObject& complete_()
23788 {
23789 if (0x00000001 != selected_member_)
23790 {
23791 if (member_destructor_)
23792 {
23793 member_destructor_();
23794 }
23795
23796 selected_member_ = 0x00000001;
23797 member_destructor_ = [&]()
23798 {
23799 m_complete.~CompleteTypeObject();
23800 };
23801 new(&m_complete) CompleteTypeObject();
23802
23803 }
23804
23805 return m_complete;
23806 }
23807
23808 MinimalTypeObject& minimal_()
23809 {
23810 if (0x00000002 != selected_member_)
23811 {
23812 if (member_destructor_)
23813 {
23814 member_destructor_();
23815 }
23816
23817 selected_member_ = 0x00000002;
23818 member_destructor_ = [&]()
23819 {
23820 m_minimal.~MinimalTypeObject();
23821 };
23822 new(&m_minimal) MinimalTypeObject();
23823
23824 }
23825
23826 return m_minimal;
23827 }
23828
23829
23830 uint8_t m__d {TK_NONE};
23831
23832 union
23833 {
23834 CompleteTypeObject m_complete;
23835 MinimalTypeObject m_minimal;
23836 };
23837
23838 uint32_t selected_member_ {0x0FFFFFFFu};
23839
23840 std::function<void()> member_destructor_;
23841};
23842 typedef std::vector<TypeObject> TypeObjectSeq;
23843
23844 typedef TypeObjectSeq StronglyConnectedComponent;
23845
23850 class TypeIdentifierTypeObjectPair
23851{
23852 public:
23853
23857 eProsima_user_DllExport TypeIdentifierTypeObjectPair()
23858 {
23859 }
23860
23864 eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
23865 {
23866 }
23867
23872 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23873 const TypeIdentifierTypeObjectPair& x)
23874 {
23875 m_type_identifier = x.m_type_identifier;
23876
23877 m_type_object = x.m_type_object;
23878
23879 }
23880
23885 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23886 TypeIdentifierTypeObjectPair&& x) noexcept
23887 {
23888 m_type_identifier = std::move(x.m_type_identifier);
23889 m_type_object = std::move(x.m_type_object);
23890 }
23891
23896 eProsima_user_DllExport TypeIdentifierTypeObjectPair& operator =(
23897 const TypeIdentifierTypeObjectPair& x)
23898 {
23899
23900 m_type_identifier = x.m_type_identifier;
23901
23902 m_type_object = x.m_type_object;
23903
23904 return *this;
23905 }
23906
23911 eProsima_user_DllExport TypeIdentifierTypeObjectPair& operator =(
23912 TypeIdentifierTypeObjectPair&& x) noexcept
23913 {
23914
23915 m_type_identifier = std::move(x.m_type_identifier);
23916 m_type_object = std::move(x.m_type_object);
23917 return *this;
23918 }
23919
23924 eProsima_user_DllExport bool operator ==(
23925 const TypeIdentifierTypeObjectPair& x) const
23926 {
23927 return (m_type_identifier == x.m_type_identifier &&
23928 m_type_object == x.m_type_object);
23929 }
23930
23935 eProsima_user_DllExport bool operator !=(
23936 const TypeIdentifierTypeObjectPair& x) const
23937 {
23938 return !(*this == x);
23939 }
23940
23945 eProsima_user_DllExport void type_identifier(
23946 const TypeIdentifier& _type_identifier)
23947 {
23948 m_type_identifier = _type_identifier;
23949 }
23950
23955 eProsima_user_DllExport void type_identifier(
23956 TypeIdentifier&& _type_identifier)
23957 {
23958 m_type_identifier = std::move(_type_identifier);
23959 }
23960
23965 eProsima_user_DllExport const TypeIdentifier& type_identifier() const
23966 {
23967 return m_type_identifier;
23968 }
23969
23974 eProsima_user_DllExport TypeIdentifier& type_identifier()
23975 {
23976 return m_type_identifier;
23977 }
23978
23979
23984 eProsima_user_DllExport void type_object(
23985 const TypeObject& _type_object)
23986 {
23987 m_type_object = _type_object;
23988 }
23989
23994 eProsima_user_DllExport void type_object(
23995 TypeObject&& _type_object)
23996 {
23997 m_type_object = std::move(_type_object);
23998 }
23999
24004 eProsima_user_DllExport const TypeObject& type_object() const
24005 {
24006 return m_type_object;
24007 }
24008
24013 eProsima_user_DllExport TypeObject& type_object()
24014 {
24015 return m_type_object;
24016 }
24017
24018
24019
24020 private:
24021
24022 TypeIdentifier m_type_identifier;
24023 TypeObject m_type_object;
24024
24025};
24026 typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
24027
24032 class TypeIdentifierPair
24033{
24034 public:
24035
24039 eProsima_user_DllExport TypeIdentifierPair()
24040 {
24041 }
24042
24046 eProsima_user_DllExport ~TypeIdentifierPair()
24047 {
24048 }
24049
24054 eProsima_user_DllExport TypeIdentifierPair(
24055 const TypeIdentifierPair& x)
24056 {
24057 m_type_identifier1 = x.m_type_identifier1;
24058
24059 m_type_identifier2 = x.m_type_identifier2;
24060
24061 }
24062
24067 eProsima_user_DllExport TypeIdentifierPair(
24068 TypeIdentifierPair&& x) noexcept
24069 {
24070 m_type_identifier1 = std::move(x.m_type_identifier1);
24071 m_type_identifier2 = std::move(x.m_type_identifier2);
24072 }
24073
24078 eProsima_user_DllExport TypeIdentifierPair& operator =(
24079 const TypeIdentifierPair& x)
24080 {
24081
24082 m_type_identifier1 = x.m_type_identifier1;
24083
24084 m_type_identifier2 = x.m_type_identifier2;
24085
24086 return *this;
24087 }
24088
24093 eProsima_user_DllExport TypeIdentifierPair& operator =(
24094 TypeIdentifierPair&& x) noexcept
24095 {
24096
24097 m_type_identifier1 = std::move(x.m_type_identifier1);
24098 m_type_identifier2 = std::move(x.m_type_identifier2);
24099 return *this;
24100 }
24101
24106 eProsima_user_DllExport bool operator ==(
24107 const TypeIdentifierPair& x) const
24108 {
24109 return (m_type_identifier1 == x.m_type_identifier1 &&
24110 m_type_identifier2 == x.m_type_identifier2);
24111 }
24112
24117 eProsima_user_DllExport bool operator !=(
24118 const TypeIdentifierPair& x) const
24119 {
24120 return !(*this == x);
24121 }
24122
24127 eProsima_user_DllExport void type_identifier1(
24128 const TypeIdentifier& _type_identifier1)
24129 {
24130 m_type_identifier1 = _type_identifier1;
24131 }
24132
24137 eProsima_user_DllExport void type_identifier1(
24138 TypeIdentifier&& _type_identifier1)
24139 {
24140 m_type_identifier1 = std::move(_type_identifier1);
24141 }
24142
24147 eProsima_user_DllExport const TypeIdentifier& type_identifier1() const
24148 {
24149 return m_type_identifier1;
24150 }
24151
24156 eProsima_user_DllExport TypeIdentifier& type_identifier1()
24157 {
24158 return m_type_identifier1;
24159 }
24160
24161
24166 eProsima_user_DllExport void type_identifier2(
24167 const TypeIdentifier& _type_identifier2)
24168 {
24169 m_type_identifier2 = _type_identifier2;
24170 }
24171
24176 eProsima_user_DllExport void type_identifier2(
24177 TypeIdentifier&& _type_identifier2)
24178 {
24179 m_type_identifier2 = std::move(_type_identifier2);
24180 }
24181
24186 eProsima_user_DllExport const TypeIdentifier& type_identifier2() const
24187 {
24188 return m_type_identifier2;
24189 }
24190
24195 eProsima_user_DllExport TypeIdentifier& type_identifier2()
24196 {
24197 return m_type_identifier2;
24198 }
24199
24200
24201
24202 private:
24203
24204 TypeIdentifier m_type_identifier1;
24205 TypeIdentifier m_type_identifier2;
24206
24207};
24208 typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
24209
24214 class TypeIdentfierWithSize
24215{
24216 public:
24217
24221 eProsima_user_DllExport TypeIdentfierWithSize()
24222 {
24223 }
24224
24228 eProsima_user_DllExport ~TypeIdentfierWithSize()
24229 {
24230 }
24231
24236 eProsima_user_DllExport TypeIdentfierWithSize(
24237 const TypeIdentfierWithSize& x)
24238 {
24239 m_type_id = x.m_type_id;
24240
24241 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24242
24243 }
24244
24249 eProsima_user_DllExport TypeIdentfierWithSize(
24250 TypeIdentfierWithSize&& x) noexcept
24251 {
24252 m_type_id = std::move(x.m_type_id);
24253 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24254 }
24255
24260 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24261 const TypeIdentfierWithSize& x)
24262 {
24263
24264 m_type_id = x.m_type_id;
24265
24266 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24267
24268 return *this;
24269 }
24270
24275 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24276 TypeIdentfierWithSize&& x) noexcept
24277 {
24278
24279 m_type_id = std::move(x.m_type_id);
24280 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24281 return *this;
24282 }
24283
24288 eProsima_user_DllExport bool operator ==(
24289 const TypeIdentfierWithSize& x) const
24290 {
24291 return (m_type_id == x.m_type_id &&
24292 m_typeobject_serialized_size == x.m_typeobject_serialized_size);
24293 }
24294
24299 eProsima_user_DllExport bool operator !=(
24300 const TypeIdentfierWithSize& x) const
24301 {
24302 return !(*this == x);
24303 }
24304
24309 eProsima_user_DllExport void type_id(
24310 const TypeIdentifier& _type_id)
24311 {
24312 m_type_id = _type_id;
24313 }
24314
24319 eProsima_user_DllExport void type_id(
24320 TypeIdentifier&& _type_id)
24321 {
24322 m_type_id = std::move(_type_id);
24323 }
24324
24329 eProsima_user_DllExport const TypeIdentifier& type_id() const
24330 {
24331 return m_type_id;
24332 }
24333
24338 eProsima_user_DllExport TypeIdentifier& type_id()
24339 {
24340 return m_type_id;
24341 }
24342
24343
24348 eProsima_user_DllExport void typeobject_serialized_size(
24349 uint32_t _typeobject_serialized_size)
24350 {
24351 m_typeobject_serialized_size = _typeobject_serialized_size;
24352 }
24353
24358 eProsima_user_DllExport uint32_t typeobject_serialized_size() const
24359 {
24360 return m_typeobject_serialized_size;
24361 }
24362
24367 eProsima_user_DllExport uint32_t& typeobject_serialized_size()
24368 {
24369 return m_typeobject_serialized_size;
24370 }
24371
24372
24373
24374 private:
24375
24376 TypeIdentifier m_type_id;
24377 uint32_t m_typeobject_serialized_size{0};
24378
24379};
24380 typedef std::vector<TypeIdentfierWithSize> TypeIdentfierWithSizeSeq;
24381
24386 class TypeIdentifierWithDependencies
24387{
24388 public:
24389
24393 eProsima_user_DllExport TypeIdentifierWithDependencies()
24394 {
24395 }
24396
24400 eProsima_user_DllExport ~TypeIdentifierWithDependencies()
24401 {
24402 }
24403
24408 eProsima_user_DllExport TypeIdentifierWithDependencies(
24409 const TypeIdentifierWithDependencies& x)
24410 {
24411 m_typeid_with_size = x.m_typeid_with_size;
24412
24413 m_dependent_typeid_count = x.m_dependent_typeid_count;
24414
24415 m_dependent_typeids = x.m_dependent_typeids;
24416
24417 }
24418
24423 eProsima_user_DllExport TypeIdentifierWithDependencies(
24424 TypeIdentifierWithDependencies&& x) noexcept
24425 {
24426 m_typeid_with_size = std::move(x.m_typeid_with_size);
24427 m_dependent_typeid_count = x.m_dependent_typeid_count;
24428 m_dependent_typeids = std::move(x.m_dependent_typeids);
24429 }
24430
24435 eProsima_user_DllExport TypeIdentifierWithDependencies& operator =(
24436 const TypeIdentifierWithDependencies& x)
24437 {
24438
24439 m_typeid_with_size = x.m_typeid_with_size;
24440
24441 m_dependent_typeid_count = x.m_dependent_typeid_count;
24442
24443 m_dependent_typeids = x.m_dependent_typeids;
24444
24445 return *this;
24446 }
24447
24452 eProsima_user_DllExport TypeIdentifierWithDependencies& operator =(
24453 TypeIdentifierWithDependencies&& x) noexcept
24454 {
24455
24456 m_typeid_with_size = std::move(x.m_typeid_with_size);
24457 m_dependent_typeid_count = x.m_dependent_typeid_count;
24458 m_dependent_typeids = std::move(x.m_dependent_typeids);
24459 return *this;
24460 }
24461
24466 eProsima_user_DllExport bool operator ==(
24467 const TypeIdentifierWithDependencies& x) const
24468 {
24469 return (m_typeid_with_size == x.m_typeid_with_size &&
24470 m_dependent_typeid_count == x.m_dependent_typeid_count &&
24471 m_dependent_typeids == x.m_dependent_typeids);
24472 }
24473
24478 eProsima_user_DllExport bool operator !=(
24479 const TypeIdentifierWithDependencies& x) const
24480 {
24481 return !(*this == x);
24482 }
24483
24488 eProsima_user_DllExport void typeid_with_size(
24489 const TypeIdentfierWithSize& _typeid_with_size)
24490 {
24491 m_typeid_with_size = _typeid_with_size;
24492 }
24493
24498 eProsima_user_DllExport void typeid_with_size(
24499 TypeIdentfierWithSize&& _typeid_with_size)
24500 {
24501 m_typeid_with_size = std::move(_typeid_with_size);
24502 }
24503
24508 eProsima_user_DllExport const TypeIdentfierWithSize& typeid_with_size() const
24509 {
24510 return m_typeid_with_size;
24511 }
24512
24517 eProsima_user_DllExport TypeIdentfierWithSize& typeid_with_size()
24518 {
24519 return m_typeid_with_size;
24520 }
24521
24522
24527 eProsima_user_DllExport void dependent_typeid_count(
24528 int32_t _dependent_typeid_count)
24529 {
24530 m_dependent_typeid_count = _dependent_typeid_count;
24531 }
24532
24537 eProsima_user_DllExport int32_t dependent_typeid_count() const
24538 {
24539 return m_dependent_typeid_count;
24540 }
24541
24546 eProsima_user_DllExport int32_t& dependent_typeid_count()
24547 {
24548 return m_dependent_typeid_count;
24549 }
24550
24551
24556 eProsima_user_DllExport void dependent_typeids(
24557 const std::vector<TypeIdentfierWithSize>& _dependent_typeids)
24558 {
24559 m_dependent_typeids = _dependent_typeids;
24560 }
24561
24566 eProsima_user_DllExport void dependent_typeids(
24567 std::vector<TypeIdentfierWithSize>&& _dependent_typeids)
24568 {
24569 m_dependent_typeids = std::move(_dependent_typeids);
24570 }
24571
24576 eProsima_user_DllExport const std::vector<TypeIdentfierWithSize>& dependent_typeids() const
24577 {
24578 return m_dependent_typeids;
24579 }
24580
24585 eProsima_user_DllExport std::vector<TypeIdentfierWithSize>& dependent_typeids()
24586 {
24587 return m_dependent_typeids;
24588 }
24589
24590
24591
24592 private:
24593
24594 TypeIdentfierWithSize m_typeid_with_size;
24595 int32_t m_dependent_typeid_count{0};
24596 std::vector<TypeIdentfierWithSize> m_dependent_typeids;
24597
24598};
24599 typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
24600
24605 class TypeInformation
24606{
24607 public:
24608
24612 eProsima_user_DllExport TypeInformation()
24613 {
24614 }
24615
24619 eProsima_user_DllExport ~TypeInformation()
24620 {
24621 }
24622
24627 eProsima_user_DllExport TypeInformation(
24628 const TypeInformation& x)
24629 {
24630 m_minimal = x.m_minimal;
24631
24632 m_complete = x.m_complete;
24633
24634 }
24635
24640 eProsima_user_DllExport TypeInformation(
24641 TypeInformation&& x) noexcept
24642 {
24643 m_minimal = std::move(x.m_minimal);
24644 m_complete = std::move(x.m_complete);
24645 }
24646
24651 eProsima_user_DllExport TypeInformation& operator =(
24652 const TypeInformation& x)
24653 {
24654
24655 m_minimal = x.m_minimal;
24656
24657 m_complete = x.m_complete;
24658
24659 return *this;
24660 }
24661
24666 eProsima_user_DllExport TypeInformation& operator =(
24667 TypeInformation&& x) noexcept
24668 {
24669
24670 m_minimal = std::move(x.m_minimal);
24671 m_complete = std::move(x.m_complete);
24672 return *this;
24673 }
24674
24679 eProsima_user_DllExport bool operator ==(
24680 const TypeInformation& x) const
24681 {
24682 return (m_minimal == x.m_minimal &&
24683 m_complete == x.m_complete);
24684 }
24685
24690 eProsima_user_DllExport bool operator !=(
24691 const TypeInformation& x) const
24692 {
24693 return !(*this == x);
24694 }
24695
24700 eProsima_user_DllExport void minimal(
24701 const TypeIdentifierWithDependencies& _minimal)
24702 {
24703 m_minimal = _minimal;
24704 }
24705
24710 eProsima_user_DllExport void minimal(
24711 TypeIdentifierWithDependencies&& _minimal)
24712 {
24713 m_minimal = std::move(_minimal);
24714 }
24715
24720 eProsima_user_DllExport const TypeIdentifierWithDependencies& minimal() const
24721 {
24722 return m_minimal;
24723 }
24724
24729 eProsima_user_DllExport TypeIdentifierWithDependencies& minimal()
24730 {
24731 return m_minimal;
24732 }
24733
24734
24739 eProsima_user_DllExport void complete(
24740 const TypeIdentifierWithDependencies& _complete)
24741 {
24742 m_complete = _complete;
24743 }
24744
24749 eProsima_user_DllExport void complete(
24750 TypeIdentifierWithDependencies&& _complete)
24751 {
24752 m_complete = std::move(_complete);
24753 }
24754
24759 eProsima_user_DllExport const TypeIdentifierWithDependencies& complete() const
24760 {
24761 return m_complete;
24762 }
24763
24768 eProsima_user_DllExport TypeIdentifierWithDependencies& complete()
24769 {
24770 return m_complete;
24771 }
24772
24773
24774
24775 private:
24776
24777 TypeIdentifierWithDependencies m_minimal;
24778 TypeIdentifierWithDependencies m_complete;
24779
24780};
24781 typedef std::vector<TypeInformation> TypeInformationSeq;
24782
24783
24784} // namespace xtypes
24785
24786
24787} // namespace dds
24788
24789} // namespace fastdds
24790
24791} // namespace eprosima
24792
24793
24794#endif // _FAST_DDS_GENERATED_DDS_XTYPES_TYPEOBJECT_HPP_
24795
24796
eprosima::fastdds::dds::xtypes::AnnotationParameterValue
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:4341
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::operator!=
eProsima_user_DllExport bool operator!=(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4842
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string16_value
eProsima_user_DllExport void string16_value(const std::wstring &_string16_value)
This function copies the value in member string16_value.
Definition dds_xtypes_typeobject.hpp:5741
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::boolean_value
eProsima_user_DllExport void boolean_value(bool _boolean_value)
This function sets a value in member boolean_value.
Definition dds_xtypes_typeobject.hpp:5016
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_extended_value
ExtendedAnnotationParameterValue m_extended_value
Definition dds_xtypes_typeobject.hpp:6220
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_string8_value
eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > m_string8_value
Definition dds_xtypes_typeobject.hpp:6218
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_wchar_value
wchar_t m_wchar_value
Definition dds_xtypes_typeobject.hpp:6216
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int8_value
eProsima_user_DllExport void int8_value(int8_t _int8_value)
This function sets a value in member int8_value.
Definition dds_xtypes_typeobject.hpp:5100
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float32_value
eProsima_user_DllExport void float32_value(float _float32_value)
This function sets a value in member float32_value.
Definition dds_xtypes_typeobject.hpp:5436
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint8_value
eProsima_user_DllExport void uint8_value(uint8_t _uint8_value)
This function sets a value in member uint8_value.
Definition dds_xtypes_typeobject.hpp:5142
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_float32_value
float m_float32_value
Definition dds_xtypes_typeobject.hpp:6212
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float64_value
eProsima_user_DllExport double & float64_value()
This function returns a reference to member float64_value.
Definition dds_xtypes_typeobject.hpp:5505
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint64_value
eProsima_user_DllExport uint64_t & uint64_value()
This function returns a reference to member uint64_value.
Definition dds_xtypes_typeobject.hpp:5421
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string16_value
eProsima_user_DllExport const std::wstring & string16_value() const
This function returns a constant reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5764
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint32_value
eProsima_user_DllExport void uint32_value(uint32_t _uint32_value)
This function sets a value in member uint32_value.
Definition dds_xtypes_typeobject.hpp:5310
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::extended_value
eProsima_user_DllExport void extended_value(const ExtendedAnnotationParameterValue &_extended_value)
This function copies the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5794
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::enumerated_value
eProsima_user_DllExport int32_t enumerated_value() const
This function returns the value of member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5658
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::wchar_value
eProsima_user_DllExport void wchar_value(wchar_t _wchar_value)
This function sets a value in member wchar_value.
Definition dds_xtypes_typeobject.hpp:5604
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float128_value
eProsima_user_DllExport void float128_value(long double _float128_value)
This function sets a value in member float128_value.
Definition dds_xtypes_typeobject.hpp:5520
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::char_value
eProsima_user_DllExport void char_value(char _char_value)
This function sets a value in member char_value.
Definition dds_xtypes_typeobject.hpp:5562
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_boolean_value
bool m_boolean_value
Definition dds_xtypes_typeobject.hpp:6202
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string8_value
eProsima_user_DllExport void string8_value(eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > &&_string8_value)
This function moves the value in member string8_value.
Definition dds_xtypes_typeobject.hpp:5699
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_enumerated_value
int32_t m_enumerated_value
Definition dds_xtypes_typeobject.hpp:6217
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::extended_value
eProsima_user_DllExport void extended_value(ExtendedAnnotationParameterValue &&_extended_value)
This function moves the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5805
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float32_value
eProsima_user_DllExport float float32_value() const
This function returns the value of member float32_value.
Definition dds_xtypes_typeobject.hpp:5448
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::char_value
eProsima_user_DllExport char char_value() const
This function returns the value of member char_value.
Definition dds_xtypes_typeobject.hpp:5574
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::byte_value
eProsima_user_DllExport void byte_value(uint8_t _byte_value)
This function sets a value in member byte_value.
Definition dds_xtypes_typeobject.hpp:5058
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string16_value
eProsima_user_DllExport void string16_value(std::wstring &&_string16_value)
This function moves the value in member string16_value.
Definition dds_xtypes_typeobject.hpp:5752
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_int8_value
int8_t m_int8_value
Definition dds_xtypes_typeobject.hpp:6204
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int16_value
eProsima_user_DllExport int16_t & int16_value()
This function returns a reference to member int16_value.
Definition dds_xtypes_typeobject.hpp:5211
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_uint8_value
uint8_t m_uint8_value
Definition dds_xtypes_typeobject.hpp:6205
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int8_value
eProsima_user_DllExport int8_t & int8_value()
This function returns a reference to member int8_value.
Definition dds_xtypes_typeobject.hpp:5127
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::byte_value
eProsima_user_DllExport uint8_t byte_value() const
This function returns the value of member byte_value.
Definition dds_xtypes_typeobject.hpp:5070
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::enumerated_value
eProsima_user_DllExport int32_t & enumerated_value()
This function returns a reference to member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5673
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_byte_value
uint8_t m_byte_value
Definition dds_xtypes_typeobject.hpp:6203
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint_16_value
eProsima_user_DllExport uint16_t uint_16_value() const
This function returns the value of member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5238
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::extended_value
eProsima_user_DllExport ExtendedAnnotationParameterValue & extended_value()
This function returns a reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5832
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_char_value
char m_char_value
Definition dds_xtypes_typeobject.hpp:6215
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint_16_value
eProsima_user_DllExport uint16_t & uint_16_value()
This function returns a reference to member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5253
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float64_value
eProsima_user_DllExport void float64_value(double _float64_value)
This function sets a value in member float64_value.
Definition dds_xtypes_typeobject.hpp:5478
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::operator==
eProsima_user_DllExport bool operator==(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4737
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string8_value
eProsima_user_DllExport const eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > & string8_value() const
This function returns a constant reference to member string8_value.
Definition dds_xtypes_typeobject.hpp:5711
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string16_value
eProsima_user_DllExport std::wstring & string16_value()
This function returns a reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5779
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float128_value
eProsima_user_DllExport long double float128_value() const
This function returns the value of member float128_value.
Definition dds_xtypes_typeobject.hpp:5532
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int32_value
eProsima_user_DllExport int32_t int32_value() const
This function returns the value of member int32_value.
Definition dds_xtypes_typeobject.hpp:5280
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::wchar_value
eProsima_user_DllExport wchar_t & wchar_value()
This function returns a reference to member wchar_value.
Definition dds_xtypes_typeobject.hpp:5631
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint_16_value
eProsima_user_DllExport void uint_16_value(uint16_t _uint_16_value)
This function sets a value in member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5226
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::operator=
eProsima_user_DllExport AnnotationParameterValue & operator=(const AnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4553
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint32_value
eProsima_user_DllExport uint32_t uint32_value() const
This function returns the value of member uint32_value.
Definition dds_xtypes_typeobject.hpp:5322
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_int64_value
int64_t m_int64_value
Definition dds_xtypes_typeobject.hpp:6210
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string8_value
eProsima_user_DllExport eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > & string8_value()
This function returns a reference to member string8_value.
Definition dds_xtypes_typeobject.hpp:5726
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::char_value
eProsima_user_DllExport char & char_value()
This function returns a reference to member char_value.
Definition dds_xtypes_typeobject.hpp:5589
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::extended_value
eProsima_user_DllExport const ExtendedAnnotationParameterValue & extended_value() const
This function returns a constant reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5817
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::AnnotationParameterValue
eProsima_user_DllExport AnnotationParameterValue(AnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4463
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint64_value
eProsima_user_DllExport uint64_t uint64_value() const
This function returns the value of member uint64_value.
Definition dds_xtypes_typeobject.hpp:5406
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint8_value
eProsima_user_DllExport uint8_t & uint8_value()
This function returns a reference to member uint8_value.
Definition dds_xtypes_typeobject.hpp:5169
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_string16_value
std::wstring m_string16_value
Definition dds_xtypes_typeobject.hpp:6219
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_int16_value
int16_t m_int16_value
Definition dds_xtypes_typeobject.hpp:6206
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint64_value
eProsima_user_DllExport void uint64_value(uint64_t _uint64_value)
This function sets a value in member uint64_value.
Definition dds_xtypes_typeobject.hpp:5394
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float64_value
eProsima_user_DllExport double float64_value() const
This function returns the value of member float64_value.
Definition dds_xtypes_typeobject.hpp:5490
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::byte_value
eProsima_user_DllExport uint8_t & byte_value()
This function returns a reference to member byte_value.
Definition dds_xtypes_typeobject.hpp:5085
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::~AnnotationParameterValue
eProsima_user_DllExport ~AnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4361
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_uint64_value
uint64_t m_uint64_value
Definition dds_xtypes_typeobject.hpp:6211
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_float128_value
long double m_float128_value
Definition dds_xtypes_typeobject.hpp:6214
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::wchar_value
eProsima_user_DllExport wchar_t wchar_value() const
This function returns the value of member wchar_value.
Definition dds_xtypes_typeobject.hpp:5616
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float32_value
eProsima_user_DllExport float & float32_value()
This function returns a reference to member float32_value.
Definition dds_xtypes_typeobject.hpp:5463
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::boolean_value
eProsima_user_DllExport bool & boolean_value()
This function returns a reference to member boolean_value.
Definition dds_xtypes_typeobject.hpp:5043
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::AnnotationParameterValue
eProsima_user_DllExport AnnotationParameterValue(const AnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4373
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::float128_value
eProsima_user_DllExport long double & float128_value()
This function returns a reference to member float128_value.
Definition dds_xtypes_typeobject.hpp:5547
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int16_value
eProsima_user_DllExport void int16_value(int16_t _int16_value)
This function sets a value in member int16_value.
Definition dds_xtypes_typeobject.hpp:5184
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int16_value
eProsima_user_DllExport int16_t int16_value() const
This function returns the value of member int16_value.
Definition dds_xtypes_typeobject.hpp:5196
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int32_value
eProsima_user_DllExport void int32_value(int32_t _int32_value)
This function sets a value in member int32_value.
Definition dds_xtypes_typeobject.hpp:5268
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int64_value
eProsima_user_DllExport void int64_value(int64_t _int64_value)
This function sets a value in member int64_value.
Definition dds_xtypes_typeobject.hpp:5352
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int8_value
eProsima_user_DllExport int8_t int8_value() const
This function returns the value of member int8_value.
Definition dds_xtypes_typeobject.hpp:5112
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::enumerated_value
eProsima_user_DllExport void enumerated_value(int32_t _enumerated_value)
This function sets a value in member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5646
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::AnnotationParameterValue
eProsima_user_DllExport AnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4347
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int64_value
eProsima_user_DllExport int64_t int64_value() const
This function returns the value of member int64_value.
Definition dds_xtypes_typeobject.hpp:5364
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_int32_value
int32_t m_int32_value
Definition dds_xtypes_typeobject.hpp:6208
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint32_value
eProsima_user_DllExport uint32_t & uint32_value()
This function returns a reference to member uint32_value.
Definition dds_xtypes_typeobject.hpp:5337
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::_d
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:4853
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_uint_16_value
uint16_t m_uint_16_value
Definition dds_xtypes_typeobject.hpp:6207
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int32_value
eProsima_user_DllExport int32_t & int32_value()
This function returns a reference to member int32_value.
Definition dds_xtypes_typeobject.hpp:5295
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::uint8_value
eProsima_user_DllExport uint8_t uint8_value() const
This function returns the value of member uint8_value.
Definition dds_xtypes_typeobject.hpp:5154
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::string8_value
eProsima_user_DllExport void string8_value(const eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > &_string8_value)
This function copies the value in member string8_value.
Definition dds_xtypes_typeobject.hpp:5688
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::boolean_value
eProsima_user_DllExport bool boolean_value() const
This function returns the value of member boolean_value.
Definition dds_xtypes_typeobject.hpp:5028
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::_d
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:5007
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_uint32_value
uint32_t m_uint32_value
Definition dds_xtypes_typeobject.hpp:6209
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::int64_value
eProsima_user_DllExport int64_t & int64_value()
This function returns a reference to member int64_value.
Definition dds_xtypes_typeobject.hpp:5379
eprosima::fastdds::dds::xtypes::AnnotationParameterValue::m_float64_value
double m_float64_value
Definition dds_xtypes_typeobject.hpp:6213
eprosima::fastdds::dds::xtypes::AppliedAnnotation::AppliedAnnotation
eProsima_user_DllExport AppliedAnnotation(AppliedAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6448
eprosima::fastdds::dds::xtypes::AppliedAnnotation::param_seq
eProsima_user_DllExport void param_seq(eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > &&_param_seq)
This function moves the value in member param_seq.
Definition dds_xtypes_typeobject.hpp:6557
eprosima::fastdds::dds::xtypes::AppliedAnnotation::~AppliedAnnotation
eProsima_user_DllExport ~AppliedAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6427
eprosima::fastdds::dds::xtypes::AppliedAnnotation::annotation_typeid
eProsima_user_DllExport const TypeIdentifier & annotation_typeid() const
This function returns a constant reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6528
eprosima::fastdds::dds::xtypes::AppliedAnnotation::annotation_typeid
eProsima_user_DllExport void annotation_typeid(TypeIdentifier &&_annotation_typeid)
This function moves the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6518
eprosima::fastdds::dds::xtypes::AppliedAnnotation::operator!=
eProsima_user_DllExport bool operator!=(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6498
eprosima::fastdds::dds::xtypes::AppliedAnnotation::operator=
eProsima_user_DllExport AppliedAnnotation & operator=(const AppliedAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6459
eprosima::fastdds::dds::xtypes::AppliedAnnotation::AppliedAnnotation
eProsima_user_DllExport AppliedAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6420
eprosima::fastdds::dds::xtypes::AppliedAnnotation::param_seq
eProsima_user_DllExport void param_seq(const eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > &_param_seq)
This function copies the value in member param_seq.
Definition dds_xtypes_typeobject.hpp:6547
eprosima::fastdds::dds::xtypes::AppliedAnnotation::annotation_typeid
eProsima_user_DllExport TypeIdentifier & annotation_typeid()
This function returns a reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6537
eprosima::fastdds::dds::xtypes::AppliedAnnotation::param_seq
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > & param_seq() const
This function returns a constant reference to member param_seq.
Definition dds_xtypes_typeobject.hpp:6567
eprosima::fastdds::dds::xtypes::AppliedAnnotation::AppliedAnnotation
eProsima_user_DllExport AppliedAnnotation(const AppliedAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6435
eprosima::fastdds::dds::xtypes::AppliedAnnotation::param_seq
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > & param_seq()
This function returns a reference to member param_seq.
Definition dds_xtypes_typeobject.hpp:6576
eprosima::fastdds::dds::xtypes::AppliedAnnotation::operator==
eProsima_user_DllExport bool operator==(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6487
eprosima::fastdds::dds::xtypes::AppliedAnnotation::annotation_typeid
eProsima_user_DllExport void annotation_typeid(const TypeIdentifier &_annotation_typeid)
This function copies the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6508
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::operator==
eProsima_user_DllExport bool operator==(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6305
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::operator!=
eProsima_user_DllExport bool operator!=(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6316
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::operator=
eProsima_user_DllExport AppliedAnnotationParameter & operator=(const AppliedAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6277
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::AppliedAnnotationParameter
eProsima_user_DllExport AppliedAnnotationParameter(AppliedAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6266
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::value
eProsima_user_DllExport const AnnotationParameterValue & value() const
This function returns a constant reference to member value.
Definition dds_xtypes_typeobject.hpp:6385
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::paramname_hash
eProsima_user_DllExport void paramname_hash(const NameHash &_paramname_hash)
This function copies the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6326
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::value
eProsima_user_DllExport void value(AnnotationParameterValue &&_value)
This function moves the value in member value.
Definition dds_xtypes_typeobject.hpp:6375
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::paramname_hash
eProsima_user_DllExport const NameHash & paramname_hash() const
This function returns a constant reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6346
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::value
eProsima_user_DllExport AnnotationParameterValue & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:6394
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::AppliedAnnotationParameter
eProsima_user_DllExport AppliedAnnotationParameter(const AppliedAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6253
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::paramname_hash
eProsima_user_DllExport void paramname_hash(NameHash &&_paramname_hash)
This function moves the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6336
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::value
eProsima_user_DllExport void value(const AnnotationParameterValue &_value)
This function copies the value in member value.
Definition dds_xtypes_typeobject.hpp:6365
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::~AppliedAnnotationParameter
eProsima_user_DllExport ~AppliedAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6245
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::paramname_hash
eProsima_user_DllExport NameHash & paramname_hash()
This function returns a reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6355
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameter::AppliedAnnotationParameter
eProsima_user_DllExport AppliedAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6238
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::min
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & min()
This function returns a reference to member min.
Definition dds_xtypes_typeobject.hpp:6999
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::AppliedBuiltinMemberAnnotations
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(const AppliedBuiltinMemberAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6844
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::hash_id
eProsima_user_DllExport const eprosima::fastcdr::optional< std::string > & hash_id() const
This function returns a constant reference to member hash_id.
Definition dds_xtypes_typeobject.hpp:7068
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::max
eProsima_user_DllExport void max(eprosima::fastcdr::optional< AnnotationParameterValue > &&_max)
This function moves the value in member max.
Definition dds_xtypes_typeobject.hpp:7019
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::~AppliedBuiltinMemberAnnotations
eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6836
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::unit
eProsima_user_DllExport void unit(const eprosima::fastcdr::optional< std::string > &_unit)
This function copies the value in member unit.
Definition dds_xtypes_typeobject.hpp:6931
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::min
eProsima_user_DllExport void min(eprosima::fastcdr::optional< AnnotationParameterValue > &&_min)
This function moves the value in member min.
Definition dds_xtypes_typeobject.hpp:6980
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::hash_id
eProsima_user_DllExport void hash_id(eprosima::fastcdr::optional< std::string > &&_hash_id)
This function moves the value in member hash_id.
Definition dds_xtypes_typeobject.hpp:7058
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::max
eProsima_user_DllExport void max(const eprosima::fastcdr::optional< AnnotationParameterValue > &_max)
This function copies the value in member max.
Definition dds_xtypes_typeobject.hpp:7009
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::max
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & max()
This function returns a reference to member max.
Definition dds_xtypes_typeobject.hpp:7038
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::hash_id
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & hash_id()
This function returns a reference to member hash_id.
Definition dds_xtypes_typeobject.hpp:7077
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::unit
eProsima_user_DllExport const eprosima::fastcdr::optional< std::string > & unit() const
This function returns a constant reference to member unit.
Definition dds_xtypes_typeobject.hpp:6951
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::max
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & max() const
This function returns a constant reference to member max.
Definition dds_xtypes_typeobject.hpp:7029
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::min
eProsima_user_DllExport void min(const eprosima::fastcdr::optional< AnnotationParameterValue > &_min)
This function copies the value in member min.
Definition dds_xtypes_typeobject.hpp:6970
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::AppliedBuiltinMemberAnnotations
eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6829
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::min
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & min() const
This function returns a constant reference to member min.
Definition dds_xtypes_typeobject.hpp:6990
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::unit
eProsima_user_DllExport void unit(eprosima::fastcdr::optional< std::string > &&_unit)
This function moves the value in member unit.
Definition dds_xtypes_typeobject.hpp:6941
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::operator==
eProsima_user_DllExport bool operator==(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6908
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::AppliedBuiltinMemberAnnotations
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(AppliedBuiltinMemberAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6861
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::hash_id
eProsima_user_DllExport void hash_id(const eprosima::fastcdr::optional< std::string > &_hash_id)
This function copies the value in member hash_id.
Definition dds_xtypes_typeobject.hpp:7048
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::operator=
eProsima_user_DllExport AppliedBuiltinMemberAnnotations & operator=(const AppliedBuiltinMemberAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6874
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::unit
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & unit()
This function returns a reference to member unit.
Definition dds_xtypes_typeobject.hpp:6960
eprosima::fastdds::dds::xtypes::AppliedBuiltinMemberAnnotations::operator!=
eProsima_user_DllExport bool operator!=(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6921
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::operator!=
eProsima_user_DllExport bool operator!=(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8115
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::AppliedBuiltinTypeAnnotations
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8070
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::verbatim
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim() const
This function returns a constant reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8145
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::verbatim
eProsima_user_DllExport void verbatim(const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &_verbatim)
This function copies the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8125
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::verbatim
eProsima_user_DllExport void verbatim(eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &&_verbatim)
This function moves the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8135
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::AppliedBuiltinTypeAnnotations
eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8044
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::AppliedBuiltinTypeAnnotations
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8059
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::operator==
eProsima_user_DllExport bool operator==(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8105
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::verbatim
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim()
This function returns a reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8154
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::operator=
eProsima_user_DllExport AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8080
eprosima::fastdds::dds::xtypes::AppliedBuiltinTypeAnnotations::~AppliedBuiltinTypeAnnotations
eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8051
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::placement
eProsima_user_DllExport const eprosima::fastcdr::fixed_string< 32 > & placement() const
This function returns a constant reference to member placement.
Definition dds_xtypes_typeobject.hpp:6717
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::operator!=
eProsima_user_DllExport bool operator!=(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6687
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::text
eProsima_user_DllExport void text(const std::string &_text)
This function copies the value in member text.
Definition dds_xtypes_typeobject.hpp:6775
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::language
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & language()
This function returns a reference to member language.
Definition dds_xtypes_typeobject.hpp:6765
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::language
eProsima_user_DllExport void language(const eprosima::fastcdr::fixed_string< 32 > &_language)
This function copies the value in member language.
Definition dds_xtypes_typeobject.hpp:6736
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::AppliedVerbatimAnnotation
eProsima_user_DllExport AppliedVerbatimAnnotation(AppliedVerbatimAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6632
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::language
eProsima_user_DllExport void language(eprosima::fastcdr::fixed_string< 32 > &&_language)
This function moves the value in member language.
Definition dds_xtypes_typeobject.hpp:6746
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::placement
eProsima_user_DllExport void placement(const eprosima::fastcdr::fixed_string< 32 > &_placement)
This function copies the value in member placement.
Definition dds_xtypes_typeobject.hpp:6697
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::placement
eProsima_user_DllExport void placement(eprosima::fastcdr::fixed_string< 32 > &&_placement)
This function moves the value in member placement.
Definition dds_xtypes_typeobject.hpp:6707
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::operator=
eProsima_user_DllExport AppliedVerbatimAnnotation & operator=(const AppliedVerbatimAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6644
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::AppliedVerbatimAnnotation
eProsima_user_DllExport AppliedVerbatimAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6602
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::placement
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & placement()
This function returns a reference to member placement.
Definition dds_xtypes_typeobject.hpp:6726
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::AppliedVerbatimAnnotation
eProsima_user_DllExport AppliedVerbatimAnnotation(const AppliedVerbatimAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6617
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::~AppliedVerbatimAnnotation
eProsima_user_DllExport ~AppliedVerbatimAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6609
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::language
eProsima_user_DllExport const eprosima::fastcdr::fixed_string< 32 > & language() const
This function returns a constant reference to member language.
Definition dds_xtypes_typeobject.hpp:6756
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::text
eProsima_user_DllExport std::string & text()
This function returns a reference to member text.
Definition dds_xtypes_typeobject.hpp:6804
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::operator==
eProsima_user_DllExport bool operator==(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6675
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::text
eProsima_user_DllExport void text(std::string &&_text)
This function moves the value in member text.
Definition dds_xtypes_typeobject.hpp:6785
eprosima::fastdds::dds::xtypes::AppliedVerbatimAnnotation::text
eProsima_user_DllExport const std::string & text() const
This function returns a constant reference to member text.
Definition dds_xtypes_typeobject.hpp:6795
eprosima::fastdds::dds::xtypes::CommonAliasBody
This class represents the structure CommonAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12611
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_flags
eProsima_user_DllExport const AliasMemberFlag & related_flags() const
This function returns a constant reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12725
eprosima::fastdds::dds::xtypes::CommonAliasBody::CommonAliasBody
eProsima_user_DllExport CommonAliasBody(const CommonAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12632
eprosima::fastdds::dds::xtypes::CommonAliasBody::operator=
eProsima_user_DllExport CommonAliasBody & operator=(const CommonAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12656
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_flags
eProsima_user_DllExport void related_flags(const AliasMemberFlag &_related_flags)
This function copies the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12705
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_type
eProsima_user_DllExport void related_type(TypeIdentifier &&_related_type)
This function moves the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12754
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_type
eProsima_user_DllExport const TypeIdentifier & related_type() const
This function returns a constant reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12764
eprosima::fastdds::dds::xtypes::CommonAliasBody::operator!=
eProsima_user_DllExport bool operator!=(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12695
eprosima::fastdds::dds::xtypes::CommonAliasBody::~CommonAliasBody
eProsima_user_DllExport ~CommonAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12624
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_type
eProsima_user_DllExport void related_type(const TypeIdentifier &_related_type)
This function copies the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12744
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_flags
eProsima_user_DllExport void related_flags(AliasMemberFlag &&_related_flags)
This function moves the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12715
eprosima::fastdds::dds::xtypes::CommonAliasBody::operator==
eProsima_user_DllExport bool operator==(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12684
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_flags
eProsima_user_DllExport AliasMemberFlag & related_flags()
This function returns a reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12734
eprosima::fastdds::dds::xtypes::CommonAliasBody::related_type
eProsima_user_DllExport TypeIdentifier & related_type()
This function returns a reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12773
eprosima::fastdds::dds::xtypes::CommonAliasBody::CommonAliasBody
eProsima_user_DllExport CommonAliasBody(CommonAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12645
eprosima::fastdds::dds::xtypes::CommonAliasBody::CommonAliasBody
eProsima_user_DllExport CommonAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12617
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter
This class represents the structure CommonAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11291
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_flags
eProsima_user_DllExport AnnotationParameterFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11414
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_flags
eProsima_user_DllExport void member_flags(const AnnotationParameterFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11385
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::operator!=
eProsima_user_DllExport bool operator!=(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11375
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::CommonAnnotationParameter
eProsima_user_DllExport CommonAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11297
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_flags
eProsima_user_DllExport const AnnotationParameterFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11405
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_type_id
eProsima_user_DllExport void member_type_id(TypeIdentifier &&_member_type_id)
This function moves the value in member member_type_id.
Definition dds_xtypes_typeobject.hpp:11434
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_type_id
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:11453
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_flags
eProsima_user_DllExport void member_flags(AnnotationParameterFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11395
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_type_id
eProsima_user_DllExport void member_type_id(const TypeIdentifier &_member_type_id)
This function copies the value in member member_type_id.
Definition dds_xtypes_typeobject.hpp:11424
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::~CommonAnnotationParameter
eProsima_user_DllExport ~CommonAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11304
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::member_type_id
eProsima_user_DllExport const TypeIdentifier & member_type_id() const
This function returns a constant reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:11444
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::CommonAnnotationParameter
eProsima_user_DllExport CommonAnnotationParameter(CommonAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11325
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::CommonAnnotationParameter
eProsima_user_DllExport CommonAnnotationParameter(const CommonAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11312
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::operator==
eProsima_user_DllExport bool operator==(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11364
eprosima::fastdds::dds::xtypes::CommonAnnotationParameter::operator=
eProsima_user_DllExport CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11336
eprosima::fastdds::dds::xtypes::CommonArrayHeader
This class represents the structure CommonArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15396
eprosima::fastdds::dds::xtypes::CommonArrayHeader::bound_seq
eProsima_user_DllExport LBoundSeq & bound_seq()
This function returns a reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15512
eprosima::fastdds::dds::xtypes::CommonArrayHeader::bound_seq
eProsima_user_DllExport const LBoundSeq & bound_seq() const
This function returns a constant reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15503
eprosima::fastdds::dds::xtypes::CommonArrayHeader::operator!=
eProsima_user_DllExport bool operator!=(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15473
eprosima::fastdds::dds::xtypes::CommonArrayHeader::CommonArrayHeader
eProsima_user_DllExport CommonArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15402
eprosima::fastdds::dds::xtypes::CommonArrayHeader::CommonArrayHeader
eProsima_user_DllExport CommonArrayHeader(const CommonArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15417
eprosima::fastdds::dds::xtypes::CommonArrayHeader::bound_seq
eProsima_user_DllExport void bound_seq(const LBoundSeq &_bound_seq)
This function copies the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15483
eprosima::fastdds::dds::xtypes::CommonArrayHeader::bound_seq
eProsima_user_DllExport void bound_seq(LBoundSeq &&_bound_seq)
This function moves the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15493
eprosima::fastdds::dds::xtypes::CommonArrayHeader::operator=
eProsima_user_DllExport CommonArrayHeader & operator=(const CommonArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15438
eprosima::fastdds::dds::xtypes::CommonArrayHeader::~CommonArrayHeader
eProsima_user_DllExport ~CommonArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15409
eprosima::fastdds::dds::xtypes::CommonArrayHeader::CommonArrayHeader
eProsima_user_DllExport CommonArrayHeader(CommonArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15428
eprosima::fastdds::dds::xtypes::CommonArrayHeader::operator==
eProsima_user_DllExport bool operator==(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15463
eprosima::fastdds::dds::xtypes::CommonBitfield
This class represents the structure CommonBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19385
eprosima::fastdds::dds::xtypes::CommonBitfield::bitcount
eProsima_user_DllExport uint8_t & bitcount()
This function returns a reference to member bitcount.
Definition dds_xtypes_typeobject.hpp:19580
eprosima::fastdds::dds::xtypes::CommonBitfield::flags
eProsima_user_DllExport const BitsetMemberFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:19542
eprosima::fastdds::dds::xtypes::CommonBitfield::operator!=
eProsima_user_DllExport bool operator!=(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19483
eprosima::fastdds::dds::xtypes::CommonBitfield::flags
eProsima_user_DllExport BitsetMemberFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:19551
eprosima::fastdds::dds::xtypes::CommonBitfield::operator==
eProsima_user_DllExport bool operator==(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19470
eprosima::fastdds::dds::xtypes::CommonBitfield::bitcount
eProsima_user_DllExport void bitcount(uint8_t _bitcount)
This function sets a value in member bitcount.
Definition dds_xtypes_typeobject.hpp:19561
eprosima::fastdds::dds::xtypes::CommonBitfield::CommonBitfield
eProsima_user_DllExport CommonBitfield(CommonBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19423
eprosima::fastdds::dds::xtypes::CommonBitfield::CommonBitfield
eProsima_user_DllExport CommonBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19391
eprosima::fastdds::dds::xtypes::CommonBitfield::bitcount
eProsima_user_DllExport uint8_t bitcount() const
This function returns the value of member bitcount.
Definition dds_xtypes_typeobject.hpp:19571
eprosima::fastdds::dds::xtypes::CommonBitfield::holder_type
eProsima_user_DllExport void holder_type(TypeKind _holder_type)
This function sets a value in member holder_type.
Definition dds_xtypes_typeobject.hpp:19590
eprosima::fastdds::dds::xtypes::CommonBitfield::flags
eProsima_user_DllExport void flags(BitsetMemberFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:19532
eprosima::fastdds::dds::xtypes::CommonBitfield::position
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:19512
eprosima::fastdds::dds::xtypes::CommonBitfield::position
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:19503
eprosima::fastdds::dds::xtypes::CommonBitfield::~CommonBitfield
eProsima_user_DllExport ~CommonBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19398
eprosima::fastdds::dds::xtypes::CommonBitfield::flags
eProsima_user_DllExport void flags(const BitsetMemberFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:19522
eprosima::fastdds::dds::xtypes::CommonBitfield::CommonBitfield
eProsima_user_DllExport CommonBitfield(const CommonBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19406
eprosima::fastdds::dds::xtypes::CommonBitfield::holder_type
eProsima_user_DllExport TypeKind & holder_type()
This function returns a reference to member holder_type.
Definition dds_xtypes_typeobject.hpp:19609
eprosima::fastdds::dds::xtypes::CommonBitfield::position
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:19493
eprosima::fastdds::dds::xtypes::CommonBitfield::holder_type
eProsima_user_DllExport TypeKind holder_type() const
This function returns the value of member holder_type.
Definition dds_xtypes_typeobject.hpp:19600
eprosima::fastdds::dds::xtypes::CommonBitfield::operator=
eProsima_user_DllExport CommonBitfield & operator=(const CommonBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19436
eprosima::fastdds::dds::xtypes::CommonBitflag
This class represents the structure CommonBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18270
eprosima::fastdds::dds::xtypes::CommonBitflag::flags
eProsima_user_DllExport void flags(BitflagFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:18403
eprosima::fastdds::dds::xtypes::CommonBitflag::operator=
eProsima_user_DllExport CommonBitflag & operator=(const CommonBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18315
eprosima::fastdds::dds::xtypes::CommonBitflag::CommonBitflag
eProsima_user_DllExport CommonBitflag(CommonBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18304
eprosima::fastdds::dds::xtypes::CommonBitflag::operator==
eProsima_user_DllExport bool operator==(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18343
eprosima::fastdds::dds::xtypes::CommonBitflag::flags
eProsima_user_DllExport const BitflagFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:18413
eprosima::fastdds::dds::xtypes::CommonBitflag::CommonBitflag
eProsima_user_DllExport CommonBitflag(const CommonBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18291
eprosima::fastdds::dds::xtypes::CommonBitflag::position
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:18383
eprosima::fastdds::dds::xtypes::CommonBitflag::operator!=
eProsima_user_DllExport bool operator!=(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18354
eprosima::fastdds::dds::xtypes::CommonBitflag::CommonBitflag
eProsima_user_DllExport CommonBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18276
eprosima::fastdds::dds::xtypes::CommonBitflag::flags
eProsima_user_DllExport void flags(const BitflagFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:18393
eprosima::fastdds::dds::xtypes::CommonBitflag::position
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:18374
eprosima::fastdds::dds::xtypes::CommonBitflag::flags
eProsima_user_DllExport BitflagFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:18422
eprosima::fastdds::dds::xtypes::CommonBitflag::~CommonBitflag
eProsima_user_DllExport ~CommonBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18283
eprosima::fastdds::dds::xtypes::CommonBitflag::position
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:18364
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::CommonBitmaskHeader
eProsima_user_DllExport CommonBitmaskHeader(const CommonBitmaskHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18825
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::~CommonBitmaskHeader
eProsima_user_DllExport ~CommonBitmaskHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18817
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::bit_bound
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:18891
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::CommonBitmaskHeader
eProsima_user_DllExport CommonBitmaskHeader(CommonBitmaskHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18836
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::bit_bound
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:18901
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::CommonBitmaskHeader
eProsima_user_DllExport CommonBitmaskHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18810
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::operator==
eProsima_user_DllExport bool operator==(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18871
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::bit_bound
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:18910
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::operator!=
eProsima_user_DllExport bool operator!=(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18881
eprosima::fastdds::dds::xtypes::CommonBitmaskHeader::operator=
eProsima_user_DllExport CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18846
eprosima::fastdds::dds::xtypes::CommonCollectionElement
This class represents the structure CommonCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14013
eprosima::fastdds::dds::xtypes::CommonCollectionElement::type
eProsima_user_DllExport const TypeIdentifier & type() const
This function returns a constant reference to member type.
Definition dds_xtypes_typeobject.hpp:14166
eprosima::fastdds::dds::xtypes::CommonCollectionElement::element_flags
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14136
eprosima::fastdds::dds::xtypes::CommonCollectionElement::element_flags
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14117
eprosima::fastdds::dds::xtypes::CommonCollectionElement::operator=
eProsima_user_DllExport CommonCollectionElement & operator=(const CommonCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14058
eprosima::fastdds::dds::xtypes::CommonCollectionElement::operator!=
eProsima_user_DllExport bool operator!=(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14097
eprosima::fastdds::dds::xtypes::CommonCollectionElement::CommonCollectionElement
eProsima_user_DllExport CommonCollectionElement(const CommonCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14034
eprosima::fastdds::dds::xtypes::CommonCollectionElement::type
eProsima_user_DllExport void type(const TypeIdentifier &_type)
This function copies the value in member type.
Definition dds_xtypes_typeobject.hpp:14146
eprosima::fastdds::dds::xtypes::CommonCollectionElement::type
eProsima_user_DllExport TypeIdentifier & type()
This function returns a reference to member type.
Definition dds_xtypes_typeobject.hpp:14175
eprosima::fastdds::dds::xtypes::CommonCollectionElement::CommonCollectionElement
eProsima_user_DllExport CommonCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14019
eprosima::fastdds::dds::xtypes::CommonCollectionElement::~CommonCollectionElement
eProsima_user_DllExport ~CommonCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14026
eprosima::fastdds::dds::xtypes::CommonCollectionElement::operator==
eProsima_user_DllExport bool operator==(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14086
eprosima::fastdds::dds::xtypes::CommonCollectionElement::type
eProsima_user_DllExport void type(TypeIdentifier &&_type)
This function moves the value in member type.
Definition dds_xtypes_typeobject.hpp:14156
eprosima::fastdds::dds::xtypes::CommonCollectionElement::CommonCollectionElement
eProsima_user_DllExport CommonCollectionElement(CommonCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14047
eprosima::fastdds::dds::xtypes::CommonCollectionElement::element_flags
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14107
eprosima::fastdds::dds::xtypes::CommonCollectionElement::element_flags
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14127
eprosima::fastdds::dds::xtypes::CommonCollectionHeader
This class represents the structure CommonCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14506
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::bound
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:14612
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::operator!=
eProsima_user_DllExport bool operator!=(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14583
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::operator=
eProsima_user_DllExport CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14548
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::bound
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:14593
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::CommonCollectionHeader
eProsima_user_DllExport CommonCollectionHeader(CommonCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14538
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::CommonCollectionHeader
eProsima_user_DllExport CommonCollectionHeader(const CommonCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14527
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::~CommonCollectionHeader
eProsima_user_DllExport ~CommonCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14519
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::bound
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:14603
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::CommonCollectionHeader
eProsima_user_DllExport CommonCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14512
eprosima::fastdds::dds::xtypes::CommonCollectionHeader::operator==
eProsima_user_DllExport bool operator==(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14573
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember
This class represents the structure CommonDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9937
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::type_id
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10090
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::member_flags
eProsima_user_DllExport void member_flags(UnionDiscriminatorFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:10041
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::member_flags
eProsima_user_DllExport void member_flags(const UnionDiscriminatorFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:10031
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::type_id
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10099
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::operator==
eProsima_user_DllExport bool operator==(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10010
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::member_flags
eProsima_user_DllExport const UnionDiscriminatorFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:10051
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::~CommonDiscriminatorMember
eProsima_user_DllExport ~CommonDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9950
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::type_id
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:10080
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::member_flags
eProsima_user_DllExport UnionDiscriminatorFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:10060
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::operator!=
eProsima_user_DllExport bool operator!=(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10021
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::operator=
eProsima_user_DllExport CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9982
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::CommonDiscriminatorMember
eProsima_user_DllExport CommonDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9943
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::CommonDiscriminatorMember
eProsima_user_DllExport CommonDiscriminatorMember(CommonDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9971
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::CommonDiscriminatorMember
eProsima_user_DllExport CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9958
eprosima::fastdds::dds::xtypes::CommonDiscriminatorMember::type_id
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:10070
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader
This class represents the structure CommonEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17380
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::operator==
eProsima_user_DllExport bool operator==(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17447
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::bit_bound
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:17467
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::bit_bound
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:17477
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::CommonEnumeratedHeader
eProsima_user_DllExport CommonEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17386
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::operator!=
eProsima_user_DllExport bool operator!=(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17457
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::CommonEnumeratedHeader
eProsima_user_DllExport CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17401
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::CommonEnumeratedHeader
eProsima_user_DllExport CommonEnumeratedHeader(CommonEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17412
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::~CommonEnumeratedHeader
eProsima_user_DllExport ~CommonEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17393
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::operator=
eProsima_user_DllExport CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17422
eprosima::fastdds::dds::xtypes::CommonEnumeratedHeader::bit_bound
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:17486
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral
This class represents the structure CommonEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16846
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::flags
eProsima_user_DllExport void flags(EnumeratedLiteralFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:16979
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::flags
eProsima_user_DllExport const EnumeratedLiteralFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:16989
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::value
eProsima_user_DllExport int32_t & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:16959
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::value
eProsima_user_DllExport void value(int32_t _value)
This function sets a value in member value.
Definition dds_xtypes_typeobject.hpp:16940
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::CommonEnumeratedLiteral
eProsima_user_DllExport CommonEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16852
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::~CommonEnumeratedLiteral
eProsima_user_DllExport ~CommonEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16859
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::flags
eProsima_user_DllExport void flags(const EnumeratedLiteralFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:16969
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::flags
eProsima_user_DllExport EnumeratedLiteralFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:16998
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::value
eProsima_user_DllExport int32_t value() const
This function returns the value of member value.
Definition dds_xtypes_typeobject.hpp:16950
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::operator==
eProsima_user_DllExport bool operator==(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16919
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::CommonEnumeratedLiteral
eProsima_user_DllExport CommonEnumeratedLiteral(CommonEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16880
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::CommonEnumeratedLiteral
eProsima_user_DllExport CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16867
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::operator=
eProsima_user_DllExport CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16891
eprosima::fastdds::dds::xtypes::CommonEnumeratedLiteral::operator!=
eProsima_user_DllExport bool operator!=(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16930
eprosima::fastdds::dds::xtypes::CommonStructMember
This class represents the structure CommonStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7097
eprosima::fastdds::dds::xtypes::CommonStructMember::member_flags
eProsima_user_DllExport void member_flags(const StructMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7227
eprosima::fastdds::dds::xtypes::CommonStructMember::member_type_id
eProsima_user_DllExport void member_type_id(TypeIdentifier &&_member_type_id)
This function moves the value in member member_type_id.
Definition dds_xtypes_typeobject.hpp:7276
eprosima::fastdds::dds::xtypes::CommonStructMember::member_type_id
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:7295
eprosima::fastdds::dds::xtypes::CommonStructMember::member_type_id
eProsima_user_DllExport void member_type_id(const TypeIdentifier &_member_type_id)
This function copies the value in member member_type_id.
Definition dds_xtypes_typeobject.hpp:7266
eprosima::fastdds::dds::xtypes::CommonStructMember::member_type_id
eProsima_user_DllExport const TypeIdentifier & member_type_id() const
This function returns a constant reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:7286
eprosima::fastdds::dds::xtypes::CommonStructMember::member_id
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:7217
eprosima::fastdds::dds::xtypes::CommonStructMember::operator=
eProsima_user_DllExport CommonStructMember & operator=(const CommonStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7145
eprosima::fastdds::dds::xtypes::CommonStructMember::operator==
eProsima_user_DllExport bool operator==(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7176
eprosima::fastdds::dds::xtypes::CommonStructMember::~CommonStructMember
eProsima_user_DllExport ~CommonStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7110
eprosima::fastdds::dds::xtypes::CommonStructMember::CommonStructMember
eProsima_user_DllExport CommonStructMember(CommonStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7133
eprosima::fastdds::dds::xtypes::CommonStructMember::CommonStructMember
eProsima_user_DllExport CommonStructMember(const CommonStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7118
eprosima::fastdds::dds::xtypes::CommonStructMember::member_flags
eProsima_user_DllExport StructMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7256
eprosima::fastdds::dds::xtypes::CommonStructMember::CommonStructMember
eProsima_user_DllExport CommonStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7103
eprosima::fastdds::dds::xtypes::CommonStructMember::member_id
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:7198
eprosima::fastdds::dds::xtypes::CommonStructMember::member_flags
eProsima_user_DllExport const StructMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7247
eprosima::fastdds::dds::xtypes::CommonStructMember::member_id
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:7208
eprosima::fastdds::dds::xtypes::CommonStructMember::operator!=
eProsima_user_DllExport bool operator!=(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7188
eprosima::fastdds::dds::xtypes::CommonStructMember::member_flags
eProsima_user_DllExport void member_flags(StructMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7237
eprosima::fastdds::dds::xtypes::CommonUnionMember
This class represents the structure CommonUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9309
eprosima::fastdds::dds::xtypes::CommonUnionMember::operator=
eProsima_user_DllExport CommonUnionMember & operator=(const CommonUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9360
eprosima::fastdds::dds::xtypes::CommonUnionMember::CommonUnionMember
eProsima_user_DllExport CommonUnionMember(CommonUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9347
eprosima::fastdds::dds::xtypes::CommonUnionMember::type_id
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9505
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_flags
eProsima_user_DllExport void member_flags(const UnionMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9446
eprosima::fastdds::dds::xtypes::CommonUnionMember::type_id
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9514
eprosima::fastdds::dds::xtypes::CommonUnionMember::type_id
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9495
eprosima::fastdds::dds::xtypes::CommonUnionMember::operator==
eProsima_user_DllExport bool operator==(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9394
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_flags
eProsima_user_DllExport UnionMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9475
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_flags
eProsima_user_DllExport const UnionMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9466
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_flags
eProsima_user_DllExport void member_flags(UnionMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9456
eprosima::fastdds::dds::xtypes::CommonUnionMember::label_seq
eProsima_user_DllExport const UnionCaseLabelSeq & label_seq() const
This function returns a constant reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9544
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_id
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:9436
eprosima::fastdds::dds::xtypes::CommonUnionMember::CommonUnionMember
eProsima_user_DllExport CommonUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9315
eprosima::fastdds::dds::xtypes::CommonUnionMember::label_seq
eProsima_user_DllExport UnionCaseLabelSeq & label_seq()
This function returns a reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9553
eprosima::fastdds::dds::xtypes::CommonUnionMember::label_seq
eProsima_user_DllExport void label_seq(const UnionCaseLabelSeq &_label_seq)
This function copies the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9524
eprosima::fastdds::dds::xtypes::CommonUnionMember::~CommonUnionMember
eProsima_user_DllExport ~CommonUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9322
eprosima::fastdds::dds::xtypes::CommonUnionMember::operator!=
eProsima_user_DllExport bool operator!=(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9407
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_id
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:9417
eprosima::fastdds::dds::xtypes::CommonUnionMember::member_id
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:9427
eprosima::fastdds::dds::xtypes::CommonUnionMember::label_seq
eProsima_user_DllExport void label_seq(UnionCaseLabelSeq &&_label_seq)
This function moves the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9534
eprosima::fastdds::dds::xtypes::CommonUnionMember::CommonUnionMember
eProsima_user_DllExport CommonUnionMember(const CommonUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9330
eprosima::fastdds::dds::xtypes::CommonUnionMember::type_id
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9485
eprosima::fastdds::dds::xtypes::CompleteAliasBody
This class represents the structure CompleteAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12791
eprosima::fastdds::dds::xtypes::CompleteAliasBody::common
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:12912
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_custom
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:12999
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_builtin
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12960
eprosima::fastdds::dds::xtypes::CompleteAliasBody::common
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:12892
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_builtin
eProsima_user_DllExport void ann_builtin(eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > &&_ann_builtin)
This function moves the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12941
eprosima::fastdds::dds::xtypes::CompleteAliasBody::common
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:12902
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_custom
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom() const
This function returns a constant reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:12990
eprosima::fastdds::dds::xtypes::CompleteAliasBody::CompleteAliasBody
eProsima_user_DllExport CompleteAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12797
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_builtin
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin() const
This function returns a constant reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12951
eprosima::fastdds::dds::xtypes::CompleteAliasBody::CompleteAliasBody
eProsima_user_DllExport CompleteAliasBody(CompleteAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12827
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_custom
eProsima_user_DllExport void ann_custom(const eprosima::fastcdr::optional< AppliedAnnotationSeq > &_ann_custom)
This function copies the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:12970
eprosima::fastdds::dds::xtypes::CompleteAliasBody::~CompleteAliasBody
eProsima_user_DllExport ~CompleteAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12804
eprosima::fastdds::dds::xtypes::CompleteAliasBody::common
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:12921
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_builtin
eProsima_user_DllExport void ann_builtin(const eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > &_ann_builtin)
This function copies the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12931
eprosima::fastdds::dds::xtypes::CompleteAliasBody::operator=
eProsima_user_DllExport CompleteAliasBody & operator=(const CompleteAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12839
eprosima::fastdds::dds::xtypes::CompleteAliasBody::CompleteAliasBody
eProsima_user_DllExport CompleteAliasBody(const CompleteAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12812
eprosima::fastdds::dds::xtypes::CompleteAliasBody::ann_custom
eProsima_user_DllExport void ann_custom(eprosima::fastcdr::optional< AppliedAnnotationSeq > &&_ann_custom)
This function moves the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:12980
eprosima::fastdds::dds::xtypes::CompleteAliasBody::operator==
eProsima_user_DllExport bool operator==(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12870
eprosima::fastdds::dds::xtypes::CompleteAliasBody::operator!=
eProsima_user_DllExport bool operator!=(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12882
eprosima::fastdds::dds::xtypes::CompleteAliasHeader
This class represents the structure CompleteAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13151
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::detail
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:13248
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13228
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::CompleteAliasHeader
eProsima_user_DllExport CompleteAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13157
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::detail
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:13267
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::~CompleteAliasHeader
eProsima_user_DllExport ~CompleteAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13164
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::detail
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:13238
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::CompleteAliasHeader
eProsima_user_DllExport CompleteAliasHeader(const CompleteAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13172
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::detail
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:13258
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13218
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::operator=
eProsima_user_DllExport CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13193
eprosima::fastdds::dds::xtypes::CompleteAliasHeader::CompleteAliasHeader
eProsima_user_DllExport CompleteAliasHeader(CompleteAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13183
eprosima::fastdds::dds::xtypes::CompleteAliasType
This class represents the structure CompleteAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13379
eprosima::fastdds::dds::xtypes::CompleteAliasType::alias_flags
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13500
eprosima::fastdds::dds::xtypes::CompleteAliasType::header
eProsima_user_DllExport void header(const CompleteAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13519
eprosima::fastdds::dds::xtypes::CompleteAliasType::CompleteAliasType
eProsima_user_DllExport CompleteAliasType(CompleteAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13415
eprosima::fastdds::dds::xtypes::CompleteAliasType::header
eProsima_user_DllExport void header(CompleteAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13529
eprosima::fastdds::dds::xtypes::CompleteAliasType::body
eProsima_user_DllExport const CompleteAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13578
eprosima::fastdds::dds::xtypes::CompleteAliasType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13470
eprosima::fastdds::dds::xtypes::CompleteAliasType::operator==
eProsima_user_DllExport bool operator==(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13458
eprosima::fastdds::dds::xtypes::CompleteAliasType::alias_flags
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13480
eprosima::fastdds::dds::xtypes::CompleteAliasType::alias_flags
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13490
eprosima::fastdds::dds::xtypes::CompleteAliasType::CompleteAliasType
eProsima_user_DllExport CompleteAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13385
eprosima::fastdds::dds::xtypes::CompleteAliasType::alias_flags
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13509
eprosima::fastdds::dds::xtypes::CompleteAliasType::CompleteAliasType
eProsima_user_DllExport CompleteAliasType(const CompleteAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13400
eprosima::fastdds::dds::xtypes::CompleteAliasType::~CompleteAliasType
eProsima_user_DllExport ~CompleteAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13392
eprosima::fastdds::dds::xtypes::CompleteAliasType::body
eProsima_user_DllExport CompleteAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13587
eprosima::fastdds::dds::xtypes::CompleteAliasType::header
eProsima_user_DllExport const CompleteAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13539
eprosima::fastdds::dds::xtypes::CompleteAliasType::operator=
eProsima_user_DllExport CompleteAliasType & operator=(const CompleteAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13427
eprosima::fastdds::dds::xtypes::CompleteAliasType::body
eProsima_user_DllExport void body(CompleteAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13568
eprosima::fastdds::dds::xtypes::CompleteAliasType::body
eProsima_user_DllExport void body(const CompleteAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13558
eprosima::fastdds::dds::xtypes::CompleteAliasType::header
eProsima_user_DllExport CompleteAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13548
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader
This class represents the structure CompleteAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11929
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::operator=
eProsima_user_DllExport CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11971
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::CompleteAnnotationHeader
eProsima_user_DllExport CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11950
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12006
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::annotation_name
eProsima_user_DllExport void annotation_name(QualifiedTypeName &&_annotation_name)
This function moves the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:12026
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::annotation_name
eProsima_user_DllExport const QualifiedTypeName & annotation_name() const
This function returns a constant reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:12036
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::annotation_name
eProsima_user_DllExport void annotation_name(const QualifiedTypeName &_annotation_name)
This function copies the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:12016
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11996
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::annotation_name
eProsima_user_DllExport QualifiedTypeName & annotation_name()
This function returns a reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:12045
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::CompleteAnnotationHeader
eProsima_user_DllExport CompleteAnnotationHeader(CompleteAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11961
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::CompleteAnnotationHeader
eProsima_user_DllExport CompleteAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11935
eprosima::fastdds::dds::xtypes::CompleteAnnotationHeader::~CompleteAnnotationHeader
eProsima_user_DllExport ~CompleteAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11942
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::common
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11592
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::common
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11572
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::name
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:11611
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::name
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:11640
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::default_value
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11670
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::CompleteAnnotationParameter
eProsima_user_DllExport CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11492
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::operator==
eProsima_user_DllExport bool operator==(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11550
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::common
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11582
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::name
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:11631
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::common
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11601
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::default_value
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11679
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::operator=
eProsima_user_DllExport CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11519
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::CompleteAnnotationParameter
eProsima_user_DllExport CompleteAnnotationParameter(CompleteAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11507
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::default_value
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11660
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::operator!=
eProsima_user_DllExport bool operator!=(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11562
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::~CompleteAnnotationParameter
eProsima_user_DllExport ~CompleteAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11484
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::CompleteAnnotationParameter
eProsima_user_DllExport CompleteAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11477
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::default_value
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11650
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameter::name
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:11621
eprosima::fastdds::dds::xtypes::CompleteAnnotationType
This class represents the structure CompleteAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12157
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::operator==
eProsima_user_DllExport bool operator==(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12236
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::~CompleteAnnotationType
eProsima_user_DllExport ~CompleteAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12170
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::header
eProsima_user_DllExport const CompleteAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12317
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::CompleteAnnotationType
eProsima_user_DllExport CompleteAnnotationType(const CompleteAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12178
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::operator=
eProsima_user_DllExport CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12205
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::annotation_flag
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12287
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::member_seq
eProsima_user_DllExport const CompleteAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12356
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::CompleteAnnotationType
eProsima_user_DllExport CompleteAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12163
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::annotation_flag
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12268
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::header
eProsima_user_DllExport void header(const CompleteAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12297
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::annotation_flag
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12258
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::member_seq
eProsima_user_DllExport void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12336
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::header
eProsima_user_DllExport CompleteAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12326
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::header
eProsima_user_DllExport void header(CompleteAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12307
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::annotation_flag
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12278
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::CompleteAnnotationType
eProsima_user_DllExport CompleteAnnotationType(CompleteAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12193
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::member_seq
eProsima_user_DllExport CompleteAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12365
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::member_seq
eProsima_user_DllExport void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12346
eprosima::fastdds::dds::xtypes::CompleteAnnotationType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12248
eprosima::fastdds::dds::xtypes::CompleteArrayHeader
This class represents the structure CompleteArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15529
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15602
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::detail
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:15672
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::detail
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:15691
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::operator=
eProsima_user_DllExport CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15574
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::~CompleteArrayHeader
eProsima_user_DllExport ~CompleteArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15542
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::CompleteArrayHeader
eProsima_user_DllExport CompleteArrayHeader(CompleteArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15563
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::CompleteArrayHeader
eProsima_user_DllExport CompleteArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15535
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::detail
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:15662
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::common
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15633
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::common
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15652
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::common
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15643
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::detail
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:15682
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::common
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15623
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15613
eprosima::fastdds::dds::xtypes::CompleteArrayHeader::CompleteArrayHeader
eProsima_user_DllExport CompleteArrayHeader(const CompleteArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15550
eprosima::fastdds::dds::xtypes::CompleteArrayType
This class represents the structure CompleteArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15842
eprosima::fastdds::dds::xtypes::CompleteArrayType::header
eProsima_user_DllExport CompleteArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16011
eprosima::fastdds::dds::xtypes::CompleteArrayType::operator=
eProsima_user_DllExport CompleteArrayType & operator=(const CompleteArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15890
eprosima::fastdds::dds::xtypes::CompleteArrayType::collection_flag
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15953
eprosima::fastdds::dds::xtypes::CompleteArrayType::header
eProsima_user_DllExport const CompleteArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16002
eprosima::fastdds::dds::xtypes::CompleteArrayType::operator==
eProsima_user_DllExport bool operator==(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15921
eprosima::fastdds::dds::xtypes::CompleteArrayType::element
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16031
eprosima::fastdds::dds::xtypes::CompleteArrayType::collection_flag
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15972
eprosima::fastdds::dds::xtypes::CompleteArrayType::element
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16021
eprosima::fastdds::dds::xtypes::CompleteArrayType::collection_flag
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15943
eprosima::fastdds::dds::xtypes::CompleteArrayType::element
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16041
eprosima::fastdds::dds::xtypes::CompleteArrayType::CompleteArrayType
eProsima_user_DllExport CompleteArrayType(const CompleteArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15863
eprosima::fastdds::dds::xtypes::CompleteArrayType::CompleteArrayType
eProsima_user_DllExport CompleteArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15848
eprosima::fastdds::dds::xtypes::CompleteArrayType::CompleteArrayType
eProsima_user_DllExport CompleteArrayType(CompleteArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15878
eprosima::fastdds::dds::xtypes::CompleteArrayType::collection_flag
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15963
eprosima::fastdds::dds::xtypes::CompleteArrayType::~CompleteArrayType
eProsima_user_DllExport ~CompleteArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15855
eprosima::fastdds::dds::xtypes::CompleteArrayType::element
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16050
eprosima::fastdds::dds::xtypes::CompleteArrayType::header
eProsima_user_DllExport void header(const CompleteArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15982
eprosima::fastdds::dds::xtypes::CompleteArrayType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15933
eprosima::fastdds::dds::xtypes::CompleteArrayType::header
eProsima_user_DllExport void header(CompleteArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15992
eprosima::fastdds::dds::xtypes::CompleteBitfield::common
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19752
eprosima::fastdds::dds::xtypes::CompleteBitfield::CompleteBitfield
eProsima_user_DllExport CompleteBitfield(const CompleteBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19650
eprosima::fastdds::dds::xtypes::CompleteBitfield::detail
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:19762
eprosima::fastdds::dds::xtypes::CompleteBitfield::common
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19743
eprosima::fastdds::dds::xtypes::CompleteBitfield::detail
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:19772
eprosima::fastdds::dds::xtypes::CompleteBitfield::CompleteBitfield
eProsima_user_DllExport CompleteBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19635
eprosima::fastdds::dds::xtypes::CompleteBitfield::operator==
eProsima_user_DllExport bool operator==(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19702
eprosima::fastdds::dds::xtypes::CompleteBitfield::operator=
eProsima_user_DllExport CompleteBitfield & operator=(const CompleteBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19674
eprosima::fastdds::dds::xtypes::CompleteBitfield::common
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19723
eprosima::fastdds::dds::xtypes::CompleteBitfield::CompleteBitfield
eProsima_user_DllExport CompleteBitfield(CompleteBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19663
eprosima::fastdds::dds::xtypes::CompleteBitfield::detail
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:19791
eprosima::fastdds::dds::xtypes::CompleteBitfield::operator!=
eProsima_user_DllExport bool operator!=(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19713
eprosima::fastdds::dds::xtypes::CompleteBitfield::common
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19733
eprosima::fastdds::dds::xtypes::CompleteBitfield::detail
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:19782
eprosima::fastdds::dds::xtypes::CompleteBitfield::~CompleteBitfield
eProsima_user_DllExport ~CompleteBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19642
eprosima::fastdds::dds::xtypes::CompleteBitflag::CompleteBitflag
eProsima_user_DllExport CompleteBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18446
eprosima::fastdds::dds::xtypes::CompleteBitflag::common
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18563
eprosima::fastdds::dds::xtypes::CompleteBitflag::~CompleteBitflag
eProsima_user_DllExport ~CompleteBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18453
eprosima::fastdds::dds::xtypes::CompleteBitflag::detail
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18573
eprosima::fastdds::dds::xtypes::CompleteBitflag::common
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18534
eprosima::fastdds::dds::xtypes::CompleteBitflag::operator==
eProsima_user_DllExport bool operator==(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18513
eprosima::fastdds::dds::xtypes::CompleteBitflag::CompleteBitflag
eProsima_user_DllExport CompleteBitflag(CompleteBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18474
eprosima::fastdds::dds::xtypes::CompleteBitflag::common
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18544
eprosima::fastdds::dds::xtypes::CompleteBitflag::detail
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18583
eprosima::fastdds::dds::xtypes::CompleteBitflag::common
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18554
eprosima::fastdds::dds::xtypes::CompleteBitflag::operator!=
eProsima_user_DllExport bool operator!=(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18524
eprosima::fastdds::dds::xtypes::CompleteBitflag::detail
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18602
eprosima::fastdds::dds::xtypes::CompleteBitflag::CompleteBitflag
eProsima_user_DllExport CompleteBitflag(const CompleteBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18461
eprosima::fastdds::dds::xtypes::CompleteBitflag::operator=
eProsima_user_DllExport CompleteBitflag & operator=(const CompleteBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18485
eprosima::fastdds::dds::xtypes::CompleteBitflag::detail
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18593
eprosima::fastdds::dds::xtypes::CompleteBitmaskType
This class represents the structure CompleteBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18931
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::flag_seq
eProsima_user_DllExport CompleteBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19139
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::header
eProsima_user_DllExport void header(CompleteBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:19081
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::bitmask_flags
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19052
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::header
eProsima_user_DllExport const CompleteBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19091
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::~CompleteBitmaskType
eProsima_user_DllExport ~CompleteBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18944
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::flag_seq
eProsima_user_DllExport void flag_seq(const CompleteBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19110
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::bitmask_flags
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19032
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19022
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::header
eProsima_user_DllExport CompleteBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19100
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::CompleteBitmaskType
eProsima_user_DllExport CompleteBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18937
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::flag_seq
eProsima_user_DllExport void flag_seq(CompleteBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19120
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::flag_seq
eProsima_user_DllExport const CompleteBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19130
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::operator==
eProsima_user_DllExport bool operator==(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19010
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::header
eProsima_user_DllExport void header(const CompleteBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:19071
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::CompleteBitmaskType
eProsima_user_DllExport CompleteBitmaskType(CompleteBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18967
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::operator=
eProsima_user_DllExport CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18979
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::CompleteBitmaskType
eProsima_user_DllExport CompleteBitmaskType(const CompleteBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18952
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::bitmask_flags
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19061
eprosima::fastdds::dds::xtypes::CompleteBitmaskType::bitmask_flags
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19042
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader
This class represents the structure CompleteBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19993
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::detail
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:20090
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::CompleteBitsetHeader
eProsima_user_DllExport CompleteBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19999
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::CompleteBitsetHeader
eProsima_user_DllExport CompleteBitsetHeader(const CompleteBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20014
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20070
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::detail
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:20109
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::CompleteBitsetHeader
eProsima_user_DllExport CompleteBitsetHeader(CompleteBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20025
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::operator=
eProsima_user_DllExport CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20035
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::detail
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:20080
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::~CompleteBitsetHeader
eProsima_user_DllExport ~CompleteBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20006
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20060
eprosima::fastdds::dds::xtypes::CompleteBitsetHeader::detail
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:20100
eprosima::fastdds::dds::xtypes::CompleteBitsetType
This class represents the structure CompleteBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20221
eprosima::fastdds::dds::xtypes::CompleteBitsetType::operator==
eProsima_user_DllExport bool operator==(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20300
eprosima::fastdds::dds::xtypes::CompleteBitsetType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20312
eprosima::fastdds::dds::xtypes::CompleteBitsetType::field_seq
eProsima_user_DllExport void field_seq(const CompleteBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20400
eprosima::fastdds::dds::xtypes::CompleteBitsetType::bitset_flags
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20322
eprosima::fastdds::dds::xtypes::CompleteBitsetType::CompleteBitsetType
eProsima_user_DllExport CompleteBitsetType(const CompleteBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20242
eprosima::fastdds::dds::xtypes::CompleteBitsetType::bitset_flags
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20342
eprosima::fastdds::dds::xtypes::CompleteBitsetType::field_seq
eProsima_user_DllExport const CompleteBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20420
eprosima::fastdds::dds::xtypes::CompleteBitsetType::field_seq
eProsima_user_DllExport void field_seq(CompleteBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20410
eprosima::fastdds::dds::xtypes::CompleteBitsetType::header
eProsima_user_DllExport const CompleteBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20381
eprosima::fastdds::dds::xtypes::CompleteBitsetType::header
eProsima_user_DllExport void header(CompleteBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20371
eprosima::fastdds::dds::xtypes::CompleteBitsetType::CompleteBitsetType
eProsima_user_DllExport CompleteBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20227
eprosima::fastdds::dds::xtypes::CompleteBitsetType::CompleteBitsetType
eProsima_user_DllExport CompleteBitsetType(CompleteBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20257
eprosima::fastdds::dds::xtypes::CompleteBitsetType::~CompleteBitsetType
eProsima_user_DllExport ~CompleteBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20234
eprosima::fastdds::dds::xtypes::CompleteBitsetType::bitset_flags
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20332
eprosima::fastdds::dds::xtypes::CompleteBitsetType::header
eProsima_user_DllExport CompleteBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20390
eprosima::fastdds::dds::xtypes::CompleteBitsetType::bitset_flags
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20351
eprosima::fastdds::dds::xtypes::CompleteBitsetType::operator=
eProsima_user_DllExport CompleteBitsetType & operator=(const CompleteBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20269
eprosima::fastdds::dds::xtypes::CompleteBitsetType::field_seq
eProsima_user_DllExport CompleteBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20429
eprosima::fastdds::dds::xtypes::CompleteBitsetType::header
eProsima_user_DllExport void header(const CompleteBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20361
eprosima::fastdds::dds::xtypes::CompleteCollectionElement
This class represents the structure CompleteCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14193
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::detail
eProsima_user_DllExport CompleteElementDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14355
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::operator!=
eProsima_user_DllExport bool operator!=(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14277
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::~CompleteCollectionElement
eProsima_user_DllExport ~CompleteCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14206
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::operator=
eProsima_user_DllExport CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14238
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::detail
eProsima_user_DllExport void detail(const CompleteElementDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14326
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::common
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14287
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::CompleteCollectionElement
eProsima_user_DllExport CompleteCollectionElement(const CompleteCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14214
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::detail
eProsima_user_DllExport void detail(CompleteElementDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14336
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::common
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14307
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::detail
eProsima_user_DllExport const CompleteElementDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14346
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::CompleteCollectionElement
eProsima_user_DllExport CompleteCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14199
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::CompleteCollectionElement
eProsima_user_DllExport CompleteCollectionElement(CompleteCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14227
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::common
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14316
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::common
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14297
eprosima::fastdds::dds::xtypes::CompleteCollectionElement::operator==
eProsima_user_DllExport bool operator==(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14266
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader
This class represents the structure CompleteCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14629
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14702
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::CompleteCollectionHeader
eProsima_user_DllExport CompleteCollectionHeader(const CompleteCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14650
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::common
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14752
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::~CompleteCollectionHeader
eProsima_user_DllExport ~CompleteCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14642
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::common
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14743
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::CompleteCollectionHeader
eProsima_user_DllExport CompleteCollectionHeader(CompleteCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14663
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::CompleteCollectionHeader
eProsima_user_DllExport CompleteCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14635
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::common
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14723
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::common
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14733
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::detail
eProsima_user_DllExport void detail(eprosima::fastcdr::optional< CompleteTypeDetail > &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14772
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::detail
eProsima_user_DllExport const eprosima::fastcdr::optional< CompleteTypeDetail > & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14782
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::operator=
eProsima_user_DllExport CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14674
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::detail
eProsima_user_DllExport void detail(const eprosima::fastcdr::optional< CompleteTypeDetail > &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14762
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14713
eprosima::fastdds::dds::xtypes::CompleteCollectionHeader::detail
eProsima_user_DllExport eprosima::fastcdr::optional< CompleteTypeDetail > & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14791
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember
This class represents the structure CompleteDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10117
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_builtin
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10286
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_builtin
eProsima_user_DllExport void ann_builtin(const eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > &_ann_builtin)
This function copies the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10257
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_custom
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:10325
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::common
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10247
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::~CompleteDiscriminatorMember
eProsima_user_DllExport ~CompleteDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10130
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_builtin
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin() const
This function returns a constant reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10277
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_custom
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom() const
This function returns a constant reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:10316
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::common
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10238
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::operator==
eProsima_user_DllExport bool operator==(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10196
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_builtin
eProsima_user_DllExport void ann_builtin(eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > &&_ann_builtin)
This function moves the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10267
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::CompleteDiscriminatorMember
eProsima_user_DllExport CompleteDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10123
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::CompleteDiscriminatorMember
eProsima_user_DllExport CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10153
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_custom
eProsima_user_DllExport void ann_custom(const eprosima::fastcdr::optional< AppliedAnnotationSeq > &_ann_custom)
This function copies the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:10296
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::ann_custom
eProsima_user_DllExport void ann_custom(eprosima::fastcdr::optional< AppliedAnnotationSeq > &&_ann_custom)
This function moves the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:10306
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::CompleteDiscriminatorMember
eProsima_user_DllExport CompleteDiscriminatorMember(const CompleteDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10138
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::common
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10228
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::common
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10218
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::operator=
eProsima_user_DllExport CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10165
eprosima::fastdds::dds::xtypes::CompleteDiscriminatorMember::operator!=
eProsima_user_DllExport bool operator!=(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10208
eprosima::fastdds::dds::xtypes::CompleteElementDetail
This class represents the structure CompleteElementDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13833
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_custom
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:13995
eprosima::fastdds::dds::xtypes::CompleteElementDetail::CompleteElementDetail
eProsima_user_DllExport CompleteElementDetail(CompleteElementDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13867
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_builtin
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13956
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_builtin
eProsima_user_DllExport void ann_builtin(eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > &&_ann_builtin)
This function moves the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13937
eprosima::fastdds::dds::xtypes::CompleteElementDetail::operator!=
eProsima_user_DllExport bool operator!=(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13917
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_custom
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom() const
This function returns a constant reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:13986
eprosima::fastdds::dds::xtypes::CompleteElementDetail::CompleteElementDetail
eProsima_user_DllExport CompleteElementDetail(const CompleteElementDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13854
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_builtin
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin() const
This function returns a constant reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13947
eprosima::fastdds::dds::xtypes::CompleteElementDetail::CompleteElementDetail
eProsima_user_DllExport CompleteElementDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13839
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_custom
eProsima_user_DllExport void ann_custom(const eprosima::fastcdr::optional< AppliedAnnotationSeq > &_ann_custom)
This function copies the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:13966
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_builtin
eProsima_user_DllExport void ann_builtin(const eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > &_ann_builtin)
This function copies the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13927
eprosima::fastdds::dds::xtypes::CompleteElementDetail::~CompleteElementDetail
eProsima_user_DllExport ~CompleteElementDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13846
eprosima::fastdds::dds::xtypes::CompleteElementDetail::ann_custom
eProsima_user_DllExport void ann_custom(eprosima::fastcdr::optional< AppliedAnnotationSeq > &&_ann_custom)
This function moves the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:13976
eprosima::fastdds::dds::xtypes::CompleteElementDetail::operator=
eProsima_user_DllExport CompleteElementDetail & operator=(const CompleteElementDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13878
eprosima::fastdds::dds::xtypes::CompleteElementDetail::operator==
eProsima_user_DllExport bool operator==(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13906
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader
This class represents the structure CompleteEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17503
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::detail
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17646
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::detail
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17665
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::common
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17626
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::~CompleteEnumeratedHeader
eProsima_user_DllExport ~CompleteEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17516
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::detail
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17636
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::common
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17617
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::operator=
eProsima_user_DllExport CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17548
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::common
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17597
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::CompleteEnumeratedHeader
eProsima_user_DllExport CompleteEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17509
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::detail
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17656
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17576
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::CompleteEnumeratedHeader
eProsima_user_DllExport CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17537
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17587
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::common
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17607
eprosima::fastdds::dds::xtypes::CompleteEnumeratedHeader::CompleteEnumeratedHeader
eProsima_user_DllExport CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17524
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::CompleteEnumeratedLiteral
eProsima_user_DllExport CompleteEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17022
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::common
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17130
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::detail
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17149
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::operator!=
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17100
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::operator=
eProsima_user_DllExport CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17061
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::detail
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17159
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::common
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17139
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::detail
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17178
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::common
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17110
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::~CompleteEnumeratedLiteral
eProsima_user_DllExport ~CompleteEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17029
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::CompleteEnumeratedLiteral
eProsima_user_DllExport CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17050
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::detail
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17169
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::common
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17120
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::CompleteEnumeratedLiteral
eProsima_user_DllExport CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17037
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteral::operator==
eProsima_user_DllExport bool operator==(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17089
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType
This class represents the structure CompleteEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17816
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::enum_flags
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17946
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::header
eProsima_user_DllExport const CompleteEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:17976
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::literal_seq
eProsima_user_DllExport void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17995
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::enum_flags
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17917
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::enum_flags
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17927
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::literal_seq
eProsima_user_DllExport const CompleteEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18015
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::CompleteEnumeratedType
eProsima_user_DllExport CompleteEnumeratedType(CompleteEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17852
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::~CompleteEnumeratedType
eProsima_user_DllExport ~CompleteEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17829
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17907
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::operator==
eProsima_user_DllExport bool operator==(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17895
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::literal_seq
eProsima_user_DllExport CompleteEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18024
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::header
eProsima_user_DllExport CompleteEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:17985
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::literal_seq
eProsima_user_DllExport void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18005
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::operator=
eProsima_user_DllExport CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17864
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::CompleteEnumeratedType
eProsima_user_DllExport CompleteEnumeratedType(const CompleteEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17837
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::header
eProsima_user_DllExport void header(CompleteEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:17966
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::CompleteEnumeratedType
eProsima_user_DllExport CompleteEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17822
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::enum_flags
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17937
eprosima::fastdds::dds::xtypes::CompleteEnumeratedType::header
eProsima_user_DllExport void header(const CompleteEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:17956
eprosima::fastdds::dds::xtypes::CompleteExtendedType
This class represents the structure CompleteExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20675
eprosima::fastdds::dds::xtypes::CompleteExtendedType::operator=
eProsima_user_DllExport CompleteExtendedType & operator=(const CompleteExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20716
eprosima::fastdds::dds::xtypes::CompleteExtendedType::CompleteExtendedType
eProsima_user_DllExport CompleteExtendedType(const CompleteExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20696
eprosima::fastdds::dds::xtypes::CompleteExtendedType::CompleteExtendedType
eProsima_user_DllExport CompleteExtendedType(CompleteExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20706
eprosima::fastdds::dds::xtypes::CompleteExtendedType::CompleteExtendedType
eProsima_user_DllExport CompleteExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20681
eprosima::fastdds::dds::xtypes::CompleteExtendedType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20753
eprosima::fastdds::dds::xtypes::CompleteExtendedType::~CompleteExtendedType
eProsima_user_DllExport ~CompleteExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20688
eprosima::fastdds::dds::xtypes::CompleteExtendedType::operator==
eProsima_user_DllExport bool operator==(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20742
eprosima::fastdds::dds::xtypes::CompleteMapType
This class represents the structure CompleteMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16296
eprosima::fastdds::dds::xtypes::CompleteMapType::collection_flag
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16414
eprosima::fastdds::dds::xtypes::CompleteMapType::element
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16531
eprosima::fastdds::dds::xtypes::CompleteMapType::header
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16453
eprosima::fastdds::dds::xtypes::CompleteMapType::key
eProsima_user_DllExport void key(CompleteCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16492
eprosima::fastdds::dds::xtypes::CompleteMapType::header
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16463
eprosima::fastdds::dds::xtypes::CompleteMapType::key
eProsima_user_DllExport const CompleteCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16502
eprosima::fastdds::dds::xtypes::CompleteMapType::header
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16443
eprosima::fastdds::dds::xtypes::CompleteMapType::operator=
eProsima_user_DllExport CompleteMapType & operator=(const CompleteMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16347
eprosima::fastdds::dds::xtypes::CompleteMapType::collection_flag
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16433
eprosima::fastdds::dds::xtypes::CompleteMapType::CompleteMapType
eProsima_user_DllExport CompleteMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16302
eprosima::fastdds::dds::xtypes::CompleteMapType::header
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16472
eprosima::fastdds::dds::xtypes::CompleteMapType::element
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16521
eprosima::fastdds::dds::xtypes::CompleteMapType::collection_flag
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16404
eprosima::fastdds::dds::xtypes::CompleteMapType::element
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16541
eprosima::fastdds::dds::xtypes::CompleteMapType::collection_flag
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16424
eprosima::fastdds::dds::xtypes::CompleteMapType::key
eProsima_user_DllExport CompleteCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16511
eprosima::fastdds::dds::xtypes::CompleteMapType::CompleteMapType
eProsima_user_DllExport CompleteMapType(const CompleteMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16317
eprosima::fastdds::dds::xtypes::CompleteMapType::element
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16550
eprosima::fastdds::dds::xtypes::CompleteMapType::key
eProsima_user_DllExport void key(const CompleteCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16482
eprosima::fastdds::dds::xtypes::CompleteMapType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16394
eprosima::fastdds::dds::xtypes::CompleteMapType::~CompleteMapType
eProsima_user_DllExport ~CompleteMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16309
eprosima::fastdds::dds::xtypes::CompleteMapType::operator==
eProsima_user_DllExport bool operator==(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16381
eprosima::fastdds::dds::xtypes::CompleteMapType::CompleteMapType
eProsima_user_DllExport CompleteMapType(CompleteMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16334
eprosima::fastdds::dds::xtypes::CompleteMemberDetail
This class represents the structure CompleteMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7314
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_custom
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:7522
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::name
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:7415
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_builtin
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7483
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_builtin
eProsima_user_DllExport void ann_builtin(eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > &&_ann_builtin)
This function moves the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7464
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::name
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:7444
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::operator!=
eProsima_user_DllExport bool operator!=(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7405
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_custom
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom() const
This function returns a constant reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:7513
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::CompleteMemberDetail
eProsima_user_DllExport CompleteMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7320
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::name
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:7435
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::CompleteMemberDetail
eProsima_user_DllExport CompleteMemberDetail(const CompleteMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7335
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_builtin
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin() const
This function returns a constant reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7474
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_custom
eProsima_user_DllExport void ann_custom(const eprosima::fastcdr::optional< AppliedAnnotationSeq > &_ann_custom)
This function copies the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:7493
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_builtin
eProsima_user_DllExport void ann_builtin(const eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > &_ann_builtin)
This function copies the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7454
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::operator=
eProsima_user_DllExport CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7362
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::ann_custom
eProsima_user_DllExport void ann_custom(eprosima::fastcdr::optional< AppliedAnnotationSeq > &&_ann_custom)
This function moves the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:7503
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::operator==
eProsima_user_DllExport bool operator==(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7393
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::~CompleteMemberDetail
eProsima_user_DllExport ~CompleteMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7327
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::CompleteMemberDetail
eProsima_user_DllExport CompleteMemberDetail(CompleteMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7350
eprosima::fastdds::dds::xtypes::CompleteMemberDetail::name
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:7425
eprosima::fastdds::dds::xtypes::CompleteSequenceType
This class represents the structure CompleteSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14942
eprosima::fastdds::dds::xtypes::CompleteSequenceType::operator=
eProsima_user_DllExport CompleteSequenceType & operator=(const CompleteSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14990
eprosima::fastdds::dds::xtypes::CompleteSequenceType::CompleteSequenceType
eProsima_user_DllExport CompleteSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14948
eprosima::fastdds::dds::xtypes::CompleteSequenceType::collection_flag
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15053
eprosima::fastdds::dds::xtypes::CompleteSequenceType::operator==
eProsima_user_DllExport bool operator==(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15021
eprosima::fastdds::dds::xtypes::CompleteSequenceType::CompleteSequenceType
eProsima_user_DllExport CompleteSequenceType(CompleteSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14978
eprosima::fastdds::dds::xtypes::CompleteSequenceType::element
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15131
eprosima::fastdds::dds::xtypes::CompleteSequenceType::header
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15092
eprosima::fastdds::dds::xtypes::CompleteSequenceType::header
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15102
eprosima::fastdds::dds::xtypes::CompleteSequenceType::header
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15082
eprosima::fastdds::dds::xtypes::CompleteSequenceType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15033
eprosima::fastdds::dds::xtypes::CompleteSequenceType::~CompleteSequenceType
eProsima_user_DllExport ~CompleteSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14955
eprosima::fastdds::dds::xtypes::CompleteSequenceType::collection_flag
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15072
eprosima::fastdds::dds::xtypes::CompleteSequenceType::header
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15111
eprosima::fastdds::dds::xtypes::CompleteSequenceType::element
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15121
eprosima::fastdds::dds::xtypes::CompleteSequenceType::collection_flag
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15043
eprosima::fastdds::dds::xtypes::CompleteSequenceType::element
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15141
eprosima::fastdds::dds::xtypes::CompleteSequenceType::collection_flag
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15063
eprosima::fastdds::dds::xtypes::CompleteSequenceType::CompleteSequenceType
eProsima_user_DllExport CompleteSequenceType(const CompleteSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14963
eprosima::fastdds::dds::xtypes::CompleteSequenceType::element
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15150
eprosima::fastdds::dds::xtypes::CompleteStructHeader
This class represents the structure CompleteStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8493
eprosima::fastdds::dds::xtypes::CompleteStructHeader::~CompleteStructHeader
eProsima_user_DllExport ~CompleteStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8506
eprosima::fastdds::dds::xtypes::CompleteStructHeader::detail
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8636
eprosima::fastdds::dds::xtypes::CompleteStructHeader::detail
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8655
eprosima::fastdds::dds::xtypes::CompleteStructHeader::CompleteStructHeader
eProsima_user_DllExport CompleteStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8499
eprosima::fastdds::dds::xtypes::CompleteStructHeader::base_type
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8597
eprosima::fastdds::dds::xtypes::CompleteStructHeader::CompleteStructHeader
eProsima_user_DllExport CompleteStructHeader(CompleteStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8527
eprosima::fastdds::dds::xtypes::CompleteStructHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8577
eprosima::fastdds::dds::xtypes::CompleteStructHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8566
eprosima::fastdds::dds::xtypes::CompleteStructHeader::detail
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8626
eprosima::fastdds::dds::xtypes::CompleteStructHeader::base_type
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8587
eprosima::fastdds::dds::xtypes::CompleteStructHeader::base_type
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8616
eprosima::fastdds::dds::xtypes::CompleteStructHeader::detail
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8646
eprosima::fastdds::dds::xtypes::CompleteStructHeader::CompleteStructHeader
eProsima_user_DllExport CompleteStructHeader(const CompleteStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8514
eprosima::fastdds::dds::xtypes::CompleteStructHeader::base_type
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8607
eprosima::fastdds::dds::xtypes::CompleteStructHeader::operator=
eProsima_user_DllExport CompleteStructHeader & operator=(const CompleteStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8538
eprosima::fastdds::dds::xtypes::CompleteStructMember::CompleteStructMember
eProsima_user_DllExport CompleteStructMember(CompleteStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7708
eprosima::fastdds::dds::xtypes::CompleteStructMember::detail
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7807
eprosima::fastdds::dds::xtypes::CompleteStructMember::common
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7768
eprosima::fastdds::dds::xtypes::CompleteStructMember::CompleteStructMember
eProsima_user_DllExport CompleteStructMember(const CompleteStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7695
eprosima::fastdds::dds::xtypes::CompleteStructMember::detail
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7817
eprosima::fastdds::dds::xtypes::CompleteStructMember::common
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7797
eprosima::fastdds::dds::xtypes::CompleteStructMember::~CompleteStructMember
eProsima_user_DllExport ~CompleteStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7687
eprosima::fastdds::dds::xtypes::CompleteStructMember::operator!=
eProsima_user_DllExport bool operator!=(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7758
eprosima::fastdds::dds::xtypes::CompleteStructMember::detail
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7836
eprosima::fastdds::dds::xtypes::CompleteStructMember::common
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7788
eprosima::fastdds::dds::xtypes::CompleteStructMember::common
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7778
eprosima::fastdds::dds::xtypes::CompleteStructMember::operator=
eProsima_user_DllExport CompleteStructMember & operator=(const CompleteStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7719
eprosima::fastdds::dds::xtypes::CompleteStructMember::CompleteStructMember
eProsima_user_DllExport CompleteStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7680
eprosima::fastdds::dds::xtypes::CompleteStructMember::detail
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7827
eprosima::fastdds::dds::xtypes::CompleteStructMember::operator==
eProsima_user_DllExport bool operator==(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7747
eprosima::fastdds::dds::xtypes::CompleteStructType
This class represents the structure CompleteStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8853
eprosima::fastdds::dds::xtypes::CompleteStructType::header
eProsima_user_DllExport const CompleteStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:9013
eprosima::fastdds::dds::xtypes::CompleteStructType::CompleteStructType
eProsima_user_DllExport CompleteStructType(CompleteStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8889
eprosima::fastdds::dds::xtypes::CompleteStructType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8944
eprosima::fastdds::dds::xtypes::CompleteStructType::header
eProsima_user_DllExport CompleteStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:9022
eprosima::fastdds::dds::xtypes::CompleteStructType::~CompleteStructType
eProsima_user_DllExport ~CompleteStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8866
eprosima::fastdds::dds::xtypes::CompleteStructType::CompleteStructType
eProsima_user_DllExport CompleteStructType(const CompleteStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8874
eprosima::fastdds::dds::xtypes::CompleteStructType::header
eProsima_user_DllExport void header(const CompleteStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:8993
eprosima::fastdds::dds::xtypes::CompleteStructType::CompleteStructType
eProsima_user_DllExport CompleteStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8859
eprosima::fastdds::dds::xtypes::CompleteStructType::member_seq
eProsima_user_DllExport CompleteStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9061
eprosima::fastdds::dds::xtypes::CompleteStructType::struct_flags
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8964
eprosima::fastdds::dds::xtypes::CompleteStructType::member_seq
eProsima_user_DllExport void member_seq(CompleteStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9042
eprosima::fastdds::dds::xtypes::CompleteStructType::struct_flags
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8954
eprosima::fastdds::dds::xtypes::CompleteStructType::operator=
eProsima_user_DllExport CompleteStructType & operator=(const CompleteStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8901
eprosima::fastdds::dds::xtypes::CompleteStructType::struct_flags
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8974
eprosima::fastdds::dds::xtypes::CompleteStructType::header
eProsima_user_DllExport void header(CompleteStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:9003
eprosima::fastdds::dds::xtypes::CompleteStructType::member_seq
eProsima_user_DllExport void member_seq(const CompleteStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9032
eprosima::fastdds::dds::xtypes::CompleteStructType::member_seq
eProsima_user_DllExport const CompleteStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9052
eprosima::fastdds::dds::xtypes::CompleteStructType::operator==
eProsima_user_DllExport bool operator==(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8932
eprosima::fastdds::dds::xtypes::CompleteStructType::struct_flags
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8983
eprosima::fastdds::dds::xtypes::CompleteTypeDetail
This class represents the structure CompleteTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8266
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::CompleteTypeDetail
eProsima_user_DllExport CompleteTypeDetail(const CompleteTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8287
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::type_name
eProsima_user_DllExport const QualifiedTypeName & type_name() const
This function returns a constant reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8465
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_builtin
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8396
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_builtin
eProsima_user_DllExport void ann_builtin(const eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > &_ann_builtin)
This function copies the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8367
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_custom
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:8435
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::operator==
eProsima_user_DllExport bool operator==(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8345
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_builtin
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin() const
This function returns a constant reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8387
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::operator=
eProsima_user_DllExport CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8314
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::type_name
eProsima_user_DllExport QualifiedTypeName & type_name()
This function returns a reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8474
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_custom
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom() const
This function returns a constant reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:8426
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_builtin
eProsima_user_DllExport void ann_builtin(eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > &&_ann_builtin)
This function moves the value in member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8377
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::type_name
eProsima_user_DllExport void type_name(const QualifiedTypeName &_type_name)
This function copies the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8445
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::CompleteTypeDetail
eProsima_user_DllExport CompleteTypeDetail(CompleteTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8302
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::type_name
eProsima_user_DllExport void type_name(QualifiedTypeName &&_type_name)
This function moves the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8455
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_custom
eProsima_user_DllExport void ann_custom(const eprosima::fastcdr::optional< AppliedAnnotationSeq > &_ann_custom)
This function copies the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:8406
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::operator!=
eProsima_user_DllExport bool operator!=(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8357
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::~CompleteTypeDetail
eProsima_user_DllExport ~CompleteTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8279
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::ann_custom
eProsima_user_DllExport void ann_custom(eprosima::fastcdr::optional< AppliedAnnotationSeq > &&_ann_custom)
This function moves the value in member ann_custom.
Definition dds_xtypes_typeobject.hpp:8416
eprosima::fastdds::dds::xtypes::CompleteTypeDetail::CompleteTypeDetail
eProsima_user_DllExport CompleteTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8272
eprosima::fastdds::dds::xtypes::CompleteTypeObject
This class represents the union CompleteTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20770
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_struct_type
CompleteStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:22049
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitmask_type
eProsima_user_DllExport const CompleteBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21729
eprosima::fastdds::dds::xtypes::CompleteTypeObject::map_type
eProsima_user_DllExport const CompleteMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21623
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitset_type
eProsima_user_DllExport CompleteBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21479
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_extended_type
CompleteExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:22057
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_alias_type
CompleteAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:22047
eprosima::fastdds::dds::xtypes::CompleteTypeObject::array_type
eProsima_user_DllExport void array_type(CompleteArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21558
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitset_type
eProsima_user_DllExport void bitset_type(CompleteBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21452
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitset_type
eProsima_user_DllExport const CompleteBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21464
eprosima::fastdds::dds::xtypes::CompleteTypeObject::annotation_type
eProsima_user_DllExport CompleteAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21320
eprosima::fastdds::dds::xtypes::CompleteTypeObject::alias_type
eProsima_user_DllExport CompleteAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21267
eprosima::fastdds::dds::xtypes::CompleteTypeObject::map_type
eProsima_user_DllExport void map_type(const CompleteMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21600
eprosima::fastdds::dds::xtypes::CompleteTypeObject::annotation_type
eProsima_user_DllExport void annotation_type(CompleteAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21293
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_bitset_type
CompleteBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:22051
eprosima::fastdds::dds::xtypes::CompleteTypeObject::struct_type
eProsima_user_DllExport void struct_type(const CompleteStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21335
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitmask_type
eProsima_user_DllExport void bitmask_type(CompleteBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21717
eprosima::fastdds::dds::xtypes::CompleteTypeObject::annotation_type
eProsima_user_DllExport const CompleteAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21305
eprosima::fastdds::dds::xtypes::CompleteTypeObject::struct_type
eProsima_user_DllExport void struct_type(CompleteStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21346
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitmask_type
eProsima_user_DllExport void bitmask_type(const CompleteBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21706
eprosima::fastdds::dds::xtypes::CompleteTypeObject::struct_type
eProsima_user_DllExport const CompleteStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21358
eprosima::fastdds::dds::xtypes::CompleteTypeObject::CompleteTypeObject
eProsima_user_DllExport CompleteTypeObject(const CompleteTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20802
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_annotation_type
CompleteAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:22048
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitmask_type
eProsima_user_DllExport CompleteBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21744
eprosima::fastdds::dds::xtypes::CompleteTypeObject::struct_type
eProsima_user_DllExport CompleteStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21373
eprosima::fastdds::dds::xtypes::CompleteTypeObject::CompleteTypeObject
eProsima_user_DllExport CompleteTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20776
eprosima::fastdds::dds::xtypes::CompleteTypeObject::CompleteTypeObject
eProsima_user_DllExport CompleteTypeObject(CompleteTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20860
eprosima::fastdds::dds::xtypes::CompleteTypeObject::sequence_type
eProsima_user_DllExport void sequence_type(const CompleteSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21494
eprosima::fastdds::dds::xtypes::CompleteTypeObject::operator==
eProsima_user_DllExport bool operator==(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:21038
eprosima::fastdds::dds::xtypes::CompleteTypeObject::bitset_type
eProsima_user_DllExport void bitset_type(const CompleteBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21441
eprosima::fastdds::dds::xtypes::CompleteTypeObject::union_type
eProsima_user_DllExport void union_type(CompleteUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21399
eprosima::fastdds::dds::xtypes::CompleteTypeObject::union_type
eProsima_user_DllExport CompleteUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21426
eprosima::fastdds::dds::xtypes::CompleteTypeObject::~CompleteTypeObject
eProsima_user_DllExport ~CompleteTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20790
eprosima::fastdds::dds::xtypes::CompleteTypeObject::operator!=
eProsima_user_DllExport bool operator!=(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:21111
eprosima::fastdds::dds::xtypes::CompleteTypeObject::operator=
eProsima_user_DllExport CompleteTypeObject & operator=(const CompleteTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20918
eprosima::fastdds::dds::xtypes::CompleteTypeObject::alias_type
eProsima_user_DllExport void alias_type(const CompleteAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21229
eprosima::fastdds::dds::xtypes::CompleteTypeObject::sequence_type
eProsima_user_DllExport const CompleteSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21517
eprosima::fastdds::dds::xtypes::CompleteTypeObject::union_type
eProsima_user_DllExport void union_type(const CompleteUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21388
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_array_type
CompleteArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:22053
eprosima::fastdds::dds::xtypes::CompleteTypeObject::enumerated_type
eProsima_user_DllExport CompleteEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21691
eprosima::fastdds::dds::xtypes::CompleteTypeObject::enumerated_type
eProsima_user_DllExport const CompleteEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21676
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_enumerated_type
CompleteEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:22055
eprosima::fastdds::dds::xtypes::CompleteTypeObject::sequence_type
eProsima_user_DllExport void sequence_type(CompleteSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21505
eprosima::fastdds::dds::xtypes::CompleteTypeObject::extended_type
eProsima_user_DllExport CompleteExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21797
eprosima::fastdds::dds::xtypes::CompleteTypeObject::enumerated_type
eProsima_user_DllExport void enumerated_type(CompleteEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21664
eprosima::fastdds::dds::xtypes::CompleteTypeObject::array_type
eProsima_user_DllExport const CompleteArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21570
eprosima::fastdds::dds::xtypes::CompleteTypeObject::alias_type
eProsima_user_DllExport void alias_type(CompleteAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21240
eprosima::fastdds::dds::xtypes::CompleteTypeObject::_d
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:21122
eprosima::fastdds::dds::xtypes::CompleteTypeObject::array_type
eProsima_user_DllExport CompleteArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21585
eprosima::fastdds::dds::xtypes::CompleteTypeObject::extended_type
eProsima_user_DllExport void extended_type(CompleteExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21770
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_bitmask_type
CompleteBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:22056
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_map_type
CompleteMapType m_map_type
Definition dds_xtypes_typeobject.hpp:22054
eprosima::fastdds::dds::xtypes::CompleteTypeObject::map_type
eProsima_user_DllExport void map_type(CompleteMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21611
eprosima::fastdds::dds::xtypes::CompleteTypeObject::sequence_type
eProsima_user_DllExport CompleteSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21532
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_sequence_type
CompleteSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:22052
eprosima::fastdds::dds::xtypes::CompleteTypeObject::union_type
eProsima_user_DllExport const CompleteUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21411
eprosima::fastdds::dds::xtypes::CompleteTypeObject::_d
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:21220
eprosima::fastdds::dds::xtypes::CompleteTypeObject::extended_type
eProsima_user_DllExport void extended_type(const CompleteExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21759
eprosima::fastdds::dds::xtypes::CompleteTypeObject::extended_type
eProsima_user_DllExport const CompleteExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21782
eprosima::fastdds::dds::xtypes::CompleteTypeObject::map_type
eProsima_user_DllExport CompleteMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21638
eprosima::fastdds::dds::xtypes::CompleteTypeObject::enumerated_type
eProsima_user_DllExport void enumerated_type(const CompleteEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21653
eprosima::fastdds::dds::xtypes::CompleteTypeObject::annotation_type
eProsima_user_DllExport void annotation_type(const CompleteAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21282
eprosima::fastdds::dds::xtypes::CompleteTypeObject::m_union_type
CompleteUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:22050
eprosima::fastdds::dds::xtypes::CompleteTypeObject::array_type
eProsima_user_DllExport void array_type(const CompleteArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21547
eprosima::fastdds::dds::xtypes::CompleteTypeObject::alias_type
eProsima_user_DllExport const CompleteAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21252
eprosima::fastdds::dds::xtypes::CompleteUnionHeader
This class represents the structure CompleteUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10477
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::detail
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10574
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::detail
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10593
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::~CompleteUnionHeader
eProsima_user_DllExport ~CompleteUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10490
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::detail
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10564
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::operator!=
eProsima_user_DllExport bool operator!=(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10554
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::CompleteUnionHeader
eProsima_user_DllExport CompleteUnionHeader(const CompleteUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10498
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::CompleteUnionHeader
eProsima_user_DllExport CompleteUnionHeader(CompleteUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10509
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::operator==
eProsima_user_DllExport bool operator==(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10544
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::detail
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10584
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::CompleteUnionHeader
eProsima_user_DllExport CompleteUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10483
eprosima::fastdds::dds::xtypes::CompleteUnionHeader::operator=
eProsima_user_DllExport CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10519
eprosima::fastdds::dds::xtypes::CompleteUnionMember::CompleteUnionMember
eProsima_user_DllExport CompleteUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9579
eprosima::fastdds::dds::xtypes::CompleteUnionMember::CompleteUnionMember
eProsima_user_DllExport CompleteUnionMember(const CompleteUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9594
eprosima::fastdds::dds::xtypes::CompleteUnionMember::common
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9667
eprosima::fastdds::dds::xtypes::CompleteUnionMember::detail
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9706
eprosima::fastdds::dds::xtypes::CompleteUnionMember::common
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9677
eprosima::fastdds::dds::xtypes::CompleteUnionMember::~CompleteUnionMember
eProsima_user_DllExport ~CompleteUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9586
eprosima::fastdds::dds::xtypes::CompleteUnionMember::common
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9696
eprosima::fastdds::dds::xtypes::CompleteUnionMember::detail
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9716
eprosima::fastdds::dds::xtypes::CompleteUnionMember::common
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9687
eprosima::fastdds::dds::xtypes::CompleteUnionMember::operator=
eProsima_user_DllExport CompleteUnionMember & operator=(const CompleteUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9618
eprosima::fastdds::dds::xtypes::CompleteUnionMember::operator!=
eProsima_user_DllExport bool operator!=(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9657
eprosima::fastdds::dds::xtypes::CompleteUnionMember::operator==
eProsima_user_DllExport bool operator==(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9646
eprosima::fastdds::dds::xtypes::CompleteUnionMember::CompleteUnionMember
eProsima_user_DllExport CompleteUnionMember(CompleteUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9607
eprosima::fastdds::dds::xtypes::CompleteUnionMember::detail
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9735
eprosima::fastdds::dds::xtypes::CompleteUnionMember::detail
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9726
eprosima::fastdds::dds::xtypes::CompleteUnionType
This class represents the structure CompleteUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10743
eprosima::fastdds::dds::xtypes::CompleteUnionType::operator==
eProsima_user_DllExport bool operator==(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10828
eprosima::fastdds::dds::xtypes::CompleteUnionType::union_flags
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10861
eprosima::fastdds::dds::xtypes::CompleteUnionType::member_seq
eProsima_user_DllExport CompleteUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10997
eprosima::fastdds::dds::xtypes::CompleteUnionType::CompleteUnionType
eProsima_user_DllExport CompleteUnionType(CompleteUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10781
eprosima::fastdds::dds::xtypes::CompleteUnionType::union_flags
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10851
eprosima::fastdds::dds::xtypes::CompleteUnionType::CompleteUnionType
eProsima_user_DllExport CompleteUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10749
eprosima::fastdds::dds::xtypes::CompleteUnionType::member_seq
eProsima_user_DllExport const CompleteUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10988
eprosima::fastdds::dds::xtypes::CompleteUnionType::~CompleteUnionType
eProsima_user_DllExport ~CompleteUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10756
eprosima::fastdds::dds::xtypes::CompleteUnionType::discriminator
eProsima_user_DllExport void discriminator(CompleteDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10939
eprosima::fastdds::dds::xtypes::CompleteUnionType::union_flags
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10880
eprosima::fastdds::dds::xtypes::CompleteUnionType::operator=
eProsima_user_DllExport CompleteUnionType & operator=(const CompleteUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10794
eprosima::fastdds::dds::xtypes::CompleteUnionType::member_seq
eProsima_user_DllExport void member_seq(CompleteUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10978
eprosima::fastdds::dds::xtypes::CompleteUnionType::operator!=
eProsima_user_DllExport bool operator!=(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10841
eprosima::fastdds::dds::xtypes::CompleteUnionType::discriminator
eProsima_user_DllExport const CompleteDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10949
eprosima::fastdds::dds::xtypes::CompleteUnionType::discriminator
eProsima_user_DllExport void discriminator(const CompleteDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10929
eprosima::fastdds::dds::xtypes::CompleteUnionType::discriminator
eProsima_user_DllExport CompleteDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10958
eprosima::fastdds::dds::xtypes::CompleteUnionType::header
eProsima_user_DllExport const CompleteUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:10910
eprosima::fastdds::dds::xtypes::CompleteUnionType::header
eProsima_user_DllExport void header(CompleteUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:10900
eprosima::fastdds::dds::xtypes::CompleteUnionType::header
eProsima_user_DllExport void header(const CompleteUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:10890
eprosima::fastdds::dds::xtypes::CompleteUnionType::union_flags
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10871
eprosima::fastdds::dds::xtypes::CompleteUnionType::CompleteUnionType
eProsima_user_DllExport CompleteUnionType(const CompleteUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10764
eprosima::fastdds::dds::xtypes::CompleteUnionType::member_seq
eProsima_user_DllExport void member_seq(const CompleteUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10968
eprosima::fastdds::dds::xtypes::CompleteUnionType::header
eProsima_user_DllExport CompleteUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:10919
eprosima::fastdds::dds::xtypes::Dummy
This class represents the structure Dummy defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2725
eprosima::fastdds::dds::xtypes::Dummy::operator!=
eProsima_user_DllExport bool operator!=(const Dummy &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2803
eprosima::fastdds::dds::xtypes::Dummy::Dummy
eProsima_user_DllExport Dummy()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2731
eprosima::fastdds::dds::xtypes::Dummy::operator=
eProsima_user_DllExport Dummy & operator=(const Dummy &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2766
eprosima::fastdds::dds::xtypes::Dummy::Dummy
eProsima_user_DllExport Dummy(Dummy &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2756
eprosima::fastdds::dds::xtypes::Dummy::~Dummy
eProsima_user_DllExport ~Dummy()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2738
eprosima::fastdds::dds::xtypes::Dummy::Dummy
eProsima_user_DllExport Dummy(const Dummy &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2746
eprosima::fastdds::dds::xtypes::Dummy::operator==
eProsima_user_DllExport bool operator==(const Dummy &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2792
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue
This class represents the structure ExtendedAnnotationParameterValue defined by the user in the IDL f...
Definition dds_xtypes_typeobject.hpp:4246
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::ExtendedAnnotationParameterValue
eProsima_user_DllExport ExtendedAnnotationParameterValue(ExtendedAnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4277
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::operator==
eProsima_user_DllExport bool operator==(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4313
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::operator=
eProsima_user_DllExport ExtendedAnnotationParameterValue & operator=(const ExtendedAnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4287
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::operator!=
eProsima_user_DllExport bool operator!=(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4324
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::ExtendedAnnotationParameterValue
eProsima_user_DllExport ExtendedAnnotationParameterValue(const ExtendedAnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4267
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::ExtendedAnnotationParameterValue
eProsima_user_DllExport ExtendedAnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4252
eprosima::fastdds::dds::xtypes::ExtendedAnnotationParameterValue::~ExtendedAnnotationParameterValue
eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4259
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn
This class represents the structure ExtendedTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2630
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::ExtendedTypeDefn
eProsima_user_DllExport ExtendedTypeDefn(const ExtendedTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2651
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::operator!=
eProsima_user_DllExport bool operator!=(const ExtendedTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2708
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::~ExtendedTypeDefn
eProsima_user_DllExport ~ExtendedTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2643
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::ExtendedTypeDefn
eProsima_user_DllExport ExtendedTypeDefn(ExtendedTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2661
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::operator==
eProsima_user_DllExport bool operator==(const ExtendedTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2697
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::ExtendedTypeDefn
eProsima_user_DllExport ExtendedTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2636
eprosima::fastdds::dds::xtypes::ExtendedTypeDefn::operator=
eProsima_user_DllExport ExtendedTypeDefn & operator=(const ExtendedTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2671
eprosima::fastdds::dds::xtypes::MinimalAliasBody
This class represents the structure MinimalAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13018
eprosima::fastdds::dds::xtypes::MinimalAliasBody::common
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:13125
eprosima::fastdds::dds::xtypes::MinimalAliasBody::common
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:13105
eprosima::fastdds::dds::xtypes::MinimalAliasBody::MinimalAliasBody
eProsima_user_DllExport MinimalAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13024
eprosima::fastdds::dds::xtypes::MinimalAliasBody::common
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:13115
eprosima::fastdds::dds::xtypes::MinimalAliasBody::MinimalAliasBody
eProsima_user_DllExport MinimalAliasBody(MinimalAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13050
eprosima::fastdds::dds::xtypes::MinimalAliasBody::operator==
eProsima_user_DllExport bool operator==(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13085
eprosima::fastdds::dds::xtypes::MinimalAliasBody::common
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:13134
eprosima::fastdds::dds::xtypes::MinimalAliasBody::~MinimalAliasBody
eProsima_user_DllExport ~MinimalAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13031
eprosima::fastdds::dds::xtypes::MinimalAliasBody::MinimalAliasBody
eProsima_user_DllExport MinimalAliasBody(const MinimalAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13039
eprosima::fastdds::dds::xtypes::MinimalAliasBody::operator=
eProsima_user_DllExport MinimalAliasBody & operator=(const MinimalAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13060
eprosima::fastdds::dds::xtypes::MinimalAliasBody::operator!=
eProsima_user_DllExport bool operator!=(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13095
eprosima::fastdds::dds::xtypes::MinimalAliasHeader
This class represents the structure MinimalAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13284
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::operator=
eProsima_user_DllExport MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13325
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::MinimalAliasHeader
eProsima_user_DllExport MinimalAliasHeader(const MinimalAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13305
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::MinimalAliasHeader
eProsima_user_DllExport MinimalAliasHeader(MinimalAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13315
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::~MinimalAliasHeader
eProsima_user_DllExport ~MinimalAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13297
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13351
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13362
eprosima::fastdds::dds::xtypes::MinimalAliasHeader::MinimalAliasHeader
eProsima_user_DllExport MinimalAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13290
eprosima::fastdds::dds::xtypes::MinimalAliasType
This class represents the structure MinimalAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13606
eprosima::fastdds::dds::xtypes::MinimalAliasType::alias_flags
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13727
eprosima::fastdds::dds::xtypes::MinimalAliasType::operator=
eProsima_user_DllExport MinimalAliasType & operator=(const MinimalAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13654
eprosima::fastdds::dds::xtypes::MinimalAliasType::MinimalAliasType
eProsima_user_DllExport MinimalAliasType(const MinimalAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13627
eprosima::fastdds::dds::xtypes::MinimalAliasType::body
eProsima_user_DllExport void body(const MinimalAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13785
eprosima::fastdds::dds::xtypes::MinimalAliasType::MinimalAliasType
eProsima_user_DllExport MinimalAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13612
eprosima::fastdds::dds::xtypes::MinimalAliasType::header
eProsima_user_DllExport void header(const MinimalAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13746
eprosima::fastdds::dds::xtypes::MinimalAliasType::header
eProsima_user_DllExport void header(MinimalAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13756
eprosima::fastdds::dds::xtypes::MinimalAliasType::body
eProsima_user_DllExport MinimalAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13814
eprosima::fastdds::dds::xtypes::MinimalAliasType::operator==
eProsima_user_DllExport bool operator==(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13685
eprosima::fastdds::dds::xtypes::MinimalAliasType::alias_flags
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13707
eprosima::fastdds::dds::xtypes::MinimalAliasType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13697
eprosima::fastdds::dds::xtypes::MinimalAliasType::alias_flags
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13717
eprosima::fastdds::dds::xtypes::MinimalAliasType::~MinimalAliasType
eProsima_user_DllExport ~MinimalAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13619
eprosima::fastdds::dds::xtypes::MinimalAliasType::alias_flags
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13736
eprosima::fastdds::dds::xtypes::MinimalAliasType::body
eProsima_user_DllExport void body(MinimalAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13795
eprosima::fastdds::dds::xtypes::MinimalAliasType::body
eProsima_user_DllExport const MinimalAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13805
eprosima::fastdds::dds::xtypes::MinimalAliasType::header
eProsima_user_DllExport const MinimalAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13766
eprosima::fastdds::dds::xtypes::MinimalAliasType::header
eProsima_user_DllExport MinimalAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13775
eprosima::fastdds::dds::xtypes::MinimalAliasType::MinimalAliasType
eProsima_user_DllExport MinimalAliasType(MinimalAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13642
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader
This class represents the structure MinimalAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12062
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::operator=
eProsima_user_DllExport MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12103
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::MinimalAnnotationHeader
eProsima_user_DllExport MinimalAnnotationHeader(MinimalAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12093
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::MinimalAnnotationHeader
eProsima_user_DllExport MinimalAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12068
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12140
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::~MinimalAnnotationHeader
eProsima_user_DllExport ~MinimalAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12075
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::MinimalAnnotationHeader
eProsima_user_DllExport MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12083
eprosima::fastdds::dds::xtypes::MinimalAnnotationHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12129
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::common
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11821
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::operator!=
eProsima_user_DllExport bool operator!=(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11791
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::common
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11801
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::operator==
eProsima_user_DllExport bool operator==(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11779
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::MinimalAnnotationParameter
eProsima_user_DllExport MinimalAnnotationParameter(MinimalAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11736
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::operator=
eProsima_user_DllExport MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11748
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::default_value
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11899
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::name_hash
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11840
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::common
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11811
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::common
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11830
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::default_value
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11908
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::~MinimalAnnotationParameter
eProsima_user_DllExport ~MinimalAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11713
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::default_value
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11889
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::MinimalAnnotationParameter
eProsima_user_DllExport MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11721
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::default_value
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11879
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::name_hash
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11860
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::name_hash
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11850
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::MinimalAnnotationParameter
eProsima_user_DllExport MinimalAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11706
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameter::name_hash
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11869
eprosima::fastdds::dds::xtypes::MinimalAnnotationType
This class represents the structure MinimalAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12384
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::header
eProsima_user_DllExport MinimalAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12553
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::header
eProsima_user_DllExport void header(MinimalAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12534
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::member_seq
eProsima_user_DllExport MinimalAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12592
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::~MinimalAnnotationType
eProsima_user_DllExport ~MinimalAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12397
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::operator=
eProsima_user_DllExport MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12432
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::annotation_flag
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12514
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::MinimalAnnotationType
eProsima_user_DllExport MinimalAnnotationType(MinimalAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12420
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::annotation_flag
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12495
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::header
eProsima_user_DllExport const MinimalAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12544
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::operator==
eProsima_user_DllExport bool operator==(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12463
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::MinimalAnnotationType
eProsima_user_DllExport MinimalAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12390
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::MinimalAnnotationType
eProsima_user_DllExport MinimalAnnotationType(const MinimalAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12405
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::annotation_flag
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12485
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::header
eProsima_user_DllExport void header(const MinimalAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12524
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::member_seq
eProsima_user_DllExport void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12573
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::annotation_flag
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12505
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::member_seq
eProsima_user_DllExport void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12563
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12475
eprosima::fastdds::dds::xtypes::MinimalAnnotationType::member_seq
eProsima_user_DllExport const MinimalAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12583
eprosima::fastdds::dds::xtypes::MinimalArrayHeader
This class represents the structure MinimalArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15709
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::operator=
eProsima_user_DllExport MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15751
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::~MinimalArrayHeader
eProsima_user_DllExport ~MinimalArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15722
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15776
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::MinimalArrayHeader
eProsima_user_DllExport MinimalArrayHeader(MinimalArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15741
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::MinimalArrayHeader
eProsima_user_DllExport MinimalArrayHeader(const MinimalArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15730
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::common
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15806
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::common
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15825
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::common
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15816
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::common
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15796
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::MinimalArrayHeader
eProsima_user_DllExport MinimalArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15715
eprosima::fastdds::dds::xtypes::MinimalArrayHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15786
eprosima::fastdds::dds::xtypes::MinimalArrayType
This class represents the structure MinimalArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16069
eprosima::fastdds::dds::xtypes::MinimalArrayType::collection_flag
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16180
eprosima::fastdds::dds::xtypes::MinimalArrayType::header
eProsima_user_DllExport void header(MinimalArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16219
eprosima::fastdds::dds::xtypes::MinimalArrayType::operator==
eProsima_user_DllExport bool operator==(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16148
eprosima::fastdds::dds::xtypes::MinimalArrayType::element
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16258
eprosima::fastdds::dds::xtypes::MinimalArrayType::header
eProsima_user_DllExport void header(const MinimalArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16209
eprosima::fastdds::dds::xtypes::MinimalArrayType::element
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16268
eprosima::fastdds::dds::xtypes::MinimalArrayType::collection_flag
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16199
eprosima::fastdds::dds::xtypes::MinimalArrayType::header
eProsima_user_DllExport const MinimalArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16229
eprosima::fastdds::dds::xtypes::MinimalArrayType::~MinimalArrayType
eProsima_user_DllExport ~MinimalArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16082
eprosima::fastdds::dds::xtypes::MinimalArrayType::collection_flag
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16170
eprosima::fastdds::dds::xtypes::MinimalArrayType::element
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16248
eprosima::fastdds::dds::xtypes::MinimalArrayType::collection_flag
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16190
eprosima::fastdds::dds::xtypes::MinimalArrayType::MinimalArrayType
eProsima_user_DllExport MinimalArrayType(MinimalArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16105
eprosima::fastdds::dds::xtypes::MinimalArrayType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16160
eprosima::fastdds::dds::xtypes::MinimalArrayType::operator=
eProsima_user_DllExport MinimalArrayType & operator=(const MinimalArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16117
eprosima::fastdds::dds::xtypes::MinimalArrayType::element
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16277
eprosima::fastdds::dds::xtypes::MinimalArrayType::MinimalArrayType
eProsima_user_DllExport MinimalArrayType(const MinimalArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16090
eprosima::fastdds::dds::xtypes::MinimalArrayType::MinimalArrayType
eProsima_user_DllExport MinimalArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16075
eprosima::fastdds::dds::xtypes::MinimalArrayType::header
eProsima_user_DllExport MinimalArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16238
eprosima::fastdds::dds::xtypes::MinimalBitfield::MinimalBitfield
eProsima_user_DllExport MinimalBitfield(const MinimalBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19832
eprosima::fastdds::dds::xtypes::MinimalBitfield::common
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19934
eprosima::fastdds::dds::xtypes::MinimalBitfield::common
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19925
eprosima::fastdds::dds::xtypes::MinimalBitfield::name_hash
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19944
eprosima::fastdds::dds::xtypes::MinimalBitfield::operator!=
eProsima_user_DllExport bool operator!=(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19895
eprosima::fastdds::dds::xtypes::MinimalBitfield::operator=
eProsima_user_DllExport MinimalBitfield & operator=(const MinimalBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19856
eprosima::fastdds::dds::xtypes::MinimalBitfield::MinimalBitfield
eProsima_user_DllExport MinimalBitfield(MinimalBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19845
eprosima::fastdds::dds::xtypes::MinimalBitfield::~MinimalBitfield
eProsima_user_DllExport ~MinimalBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19824
eprosima::fastdds::dds::xtypes::MinimalBitfield::operator==
eProsima_user_DllExport bool operator==(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19884
eprosima::fastdds::dds::xtypes::MinimalBitfield::common
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19905
eprosima::fastdds::dds::xtypes::MinimalBitfield::common
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19915
eprosima::fastdds::dds::xtypes::MinimalBitfield::MinimalBitfield
eProsima_user_DllExport MinimalBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19817
eprosima::fastdds::dds::xtypes::MinimalBitfield::name_hash
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19964
eprosima::fastdds::dds::xtypes::MinimalBitfield::name_hash
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19954
eprosima::fastdds::dds::xtypes::MinimalBitfield::name_hash
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19973
eprosima::fastdds::dds::xtypes::MinimalBitflag::detail
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18755
eprosima::fastdds::dds::xtypes::MinimalBitflag::common
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18745
eprosima::fastdds::dds::xtypes::MinimalBitflag::detail
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18775
eprosima::fastdds::dds::xtypes::MinimalBitflag::detail
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18784
eprosima::fastdds::dds::xtypes::MinimalBitflag::MinimalBitflag
eProsima_user_DllExport MinimalBitflag(MinimalBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18656
eprosima::fastdds::dds::xtypes::MinimalBitflag::~MinimalBitflag
eProsima_user_DllExport ~MinimalBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18635
eprosima::fastdds::dds::xtypes::MinimalBitflag::common
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18716
eprosima::fastdds::dds::xtypes::MinimalBitflag::common
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18726
eprosima::fastdds::dds::xtypes::MinimalBitflag::operator!=
eProsima_user_DllExport bool operator!=(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18706
eprosima::fastdds::dds::xtypes::MinimalBitflag::common
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18736
eprosima::fastdds::dds::xtypes::MinimalBitflag::MinimalBitflag
eProsima_user_DllExport MinimalBitflag(const MinimalBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18643
eprosima::fastdds::dds::xtypes::MinimalBitflag::operator==
eProsima_user_DllExport bool operator==(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18695
eprosima::fastdds::dds::xtypes::MinimalBitflag::detail
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18765
eprosima::fastdds::dds::xtypes::MinimalBitflag::MinimalBitflag
eProsima_user_DllExport MinimalBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18628
eprosima::fastdds::dds::xtypes::MinimalBitflag::operator=
eProsima_user_DllExport MinimalBitflag & operator=(const MinimalBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18667
eprosima::fastdds::dds::xtypes::MinimalBitmaskType
This class represents the structure MinimalBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19158
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::header
eProsima_user_DllExport void header(const MinimalBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:19298
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::~MinimalBitmaskType
eProsima_user_DllExport ~MinimalBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19171
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::bitmask_flags
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19279
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::header
eProsima_user_DllExport MinimalBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19327
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::bitmask_flags
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19259
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::MinimalBitmaskType
eProsima_user_DllExport MinimalBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19164
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::flag_seq
eProsima_user_DllExport const MinimalBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19357
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::MinimalBitmaskType
eProsima_user_DllExport MinimalBitmaskType(MinimalBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19194
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::flag_seq
eProsima_user_DllExport void flag_seq(MinimalBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19347
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::operator==
eProsima_user_DllExport bool operator==(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19237
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::operator=
eProsima_user_DllExport MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19206
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::header
eProsima_user_DllExport void header(MinimalBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:19308
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::flag_seq
eProsima_user_DllExport void flag_seq(const MinimalBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19337
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::flag_seq
eProsima_user_DllExport MinimalBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19366
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19249
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::MinimalBitmaskType
eProsima_user_DllExport MinimalBitmaskType(const MinimalBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19179
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::bitmask_flags
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19288
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::header
eProsima_user_DllExport const MinimalBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19318
eprosima::fastdds::dds::xtypes::MinimalBitmaskType::bitmask_flags
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19269
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader
This class represents the structure MinimalBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20126
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::MinimalBitsetHeader
eProsima_user_DllExport MinimalBitsetHeader(MinimalBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20157
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::MinimalBitsetHeader
eProsima_user_DllExport MinimalBitsetHeader(const MinimalBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20147
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::~MinimalBitsetHeader
eProsima_user_DllExport ~MinimalBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20139
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20204
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::MinimalBitsetHeader
eProsima_user_DllExport MinimalBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20132
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::operator=
eProsima_user_DllExport MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20167
eprosima::fastdds::dds::xtypes::MinimalBitsetHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20193
eprosima::fastdds::dds::xtypes::MinimalBitsetType
This class represents the structure MinimalBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20448
eprosima::fastdds::dds::xtypes::MinimalBitsetType::MinimalBitsetType
eProsima_user_DllExport MinimalBitsetType(MinimalBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20484
eprosima::fastdds::dds::xtypes::MinimalBitsetType::~MinimalBitsetType
eProsima_user_DllExport ~MinimalBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20461
eprosima::fastdds::dds::xtypes::MinimalBitsetType::field_seq
eProsima_user_DllExport void field_seq(const MinimalBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20627
eprosima::fastdds::dds::xtypes::MinimalBitsetType::header
eProsima_user_DllExport void header(const MinimalBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20588
eprosima::fastdds::dds::xtypes::MinimalBitsetType::field_seq
eProsima_user_DllExport void field_seq(MinimalBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20637
eprosima::fastdds::dds::xtypes::MinimalBitsetType::bitset_flags
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20549
eprosima::fastdds::dds::xtypes::MinimalBitsetType::bitset_flags
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20569
eprosima::fastdds::dds::xtypes::MinimalBitsetType::operator==
eProsima_user_DllExport bool operator==(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20527
eprosima::fastdds::dds::xtypes::MinimalBitsetType::MinimalBitsetType
eProsima_user_DllExport MinimalBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20454
eprosima::fastdds::dds::xtypes::MinimalBitsetType::field_seq
eProsima_user_DllExport MinimalBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20656
eprosima::fastdds::dds::xtypes::MinimalBitsetType::field_seq
eProsima_user_DllExport const MinimalBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20647
eprosima::fastdds::dds::xtypes::MinimalBitsetType::header
eProsima_user_DllExport MinimalBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20617
eprosima::fastdds::dds::xtypes::MinimalBitsetType::bitset_flags
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20559
eprosima::fastdds::dds::xtypes::MinimalBitsetType::header
eProsima_user_DllExport const MinimalBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20608
eprosima::fastdds::dds::xtypes::MinimalBitsetType::operator=
eProsima_user_DllExport MinimalBitsetType & operator=(const MinimalBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20496
eprosima::fastdds::dds::xtypes::MinimalBitsetType::MinimalBitsetType
eProsima_user_DllExport MinimalBitsetType(const MinimalBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20469
eprosima::fastdds::dds::xtypes::MinimalBitsetType::bitset_flags
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20578
eprosima::fastdds::dds::xtypes::MinimalBitsetType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20539
eprosima::fastdds::dds::xtypes::MinimalBitsetType::header
eProsima_user_DllExport void header(MinimalBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20598
eprosima::fastdds::dds::xtypes::MinimalCollectionElement
This class represents the structure MinimalCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14373
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::MinimalCollectionElement
eProsima_user_DllExport MinimalCollectionElement(MinimalCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14405
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::MinimalCollectionElement
eProsima_user_DllExport MinimalCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14379
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::operator!=
eProsima_user_DllExport bool operator!=(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14450
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::common
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14460
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::operator=
eProsima_user_DllExport MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14415
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::MinimalCollectionElement
eProsima_user_DllExport MinimalCollectionElement(const MinimalCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14394
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::common
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14480
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::operator==
eProsima_user_DllExport bool operator==(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14440
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::common
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14489
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::~MinimalCollectionElement
eProsima_user_DllExport ~MinimalCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14386
eprosima::fastdds::dds::xtypes::MinimalCollectionElement::common
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14470
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader
This class represents the structure MinimalCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14809
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::common
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14925
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::MinimalCollectionHeader
eProsima_user_DllExport MinimalCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14815
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::common
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14916
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14876
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14886
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::~MinimalCollectionHeader
eProsima_user_DllExport ~MinimalCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14822
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::MinimalCollectionHeader
eProsima_user_DllExport MinimalCollectionHeader(MinimalCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14841
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::common
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14896
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::common
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14906
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::operator=
eProsima_user_DllExport MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14851
eprosima::fastdds::dds::xtypes::MinimalCollectionHeader::MinimalCollectionHeader
eProsima_user_DllExport MinimalCollectionHeader(const MinimalCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14830
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember
This class represents the structure MinimalDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10344
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::MinimalDiscriminatorMember
eProsima_user_DllExport MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10365
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::common
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10460
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::common
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10451
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::operator=
eProsima_user_DllExport MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10386
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::operator==
eProsima_user_DllExport bool operator==(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10411
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::~MinimalDiscriminatorMember
eProsima_user_DllExport ~MinimalDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10357
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::MinimalDiscriminatorMember
eProsima_user_DllExport MinimalDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10350
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::operator!=
eProsima_user_DllExport bool operator!=(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10421
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::common
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10441
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::common
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10431
eprosima::fastdds::dds::xtypes::MinimalDiscriminatorMember::MinimalDiscriminatorMember
eProsima_user_DllExport MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10376
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader
This class represents the structure MinimalEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17683
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::common
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17799
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::MinimalEnumeratedHeader
eProsima_user_DllExport MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17715
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::common
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17790
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17760
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::~MinimalEnumeratedHeader
eProsima_user_DllExport ~MinimalEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17696
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::common
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17770
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::MinimalEnumeratedHeader
eProsima_user_DllExport MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17704
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::operator=
eProsima_user_DllExport MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17725
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::common
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17780
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17750
eprosima::fastdds::dds::xtypes::MinimalEnumeratedHeader::MinimalEnumeratedHeader
eProsima_user_DllExport MinimalEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17689
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::detail
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17331
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::operator=
eProsima_user_DllExport MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17243
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::detail
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17351
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::detail
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17360
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::operator==
eProsima_user_DllExport bool operator==(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17271
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::common
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17312
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::common
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17321
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::~MinimalEnumeratedLiteral
eProsima_user_DllExport ~MinimalEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17211
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::detail
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17341
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::MinimalEnumeratedLiteral
eProsima_user_DllExport MinimalEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17204
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::operator!=
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17282
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::common
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17292
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::MinimalEnumeratedLiteral
eProsima_user_DllExport MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17219
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::MinimalEnumeratedLiteral
eProsima_user_DllExport MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17232
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteral::common
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17302
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType
This class represents the structure MinimalEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18043
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::header
eProsima_user_DllExport MinimalEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:18212
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::enum_flags
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18173
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::literal_seq
eProsima_user_DllExport MinimalEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18251
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::operator=
eProsima_user_DllExport MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18091
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::MinimalEnumeratedType
eProsima_user_DllExport MinimalEnumeratedType(MinimalEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18079
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::enum_flags
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18144
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::operator==
eProsima_user_DllExport bool operator==(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18122
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18134
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::literal_seq
eProsima_user_DllExport void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18232
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::enum_flags
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18154
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::header
eProsima_user_DllExport void header(MinimalEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:18193
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::literal_seq
eProsima_user_DllExport void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18222
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::~MinimalEnumeratedType
eProsima_user_DllExport ~MinimalEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18056
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::header
eProsima_user_DllExport void header(const MinimalEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:18183
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::literal_seq
eProsima_user_DllExport const MinimalEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18242
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::MinimalEnumeratedType
eProsima_user_DllExport MinimalEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18049
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::header
eProsima_user_DllExport const MinimalEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:18203
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::enum_flags
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18164
eprosima::fastdds::dds::xtypes::MinimalEnumeratedType::MinimalEnumeratedType
eProsima_user_DllExport MinimalEnumeratedType(const MinimalEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18064
eprosima::fastdds::dds::xtypes::MinimalExtendedType
This class represents the structure MinimalExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:22069
eprosima::fastdds::dds::xtypes::MinimalExtendedType::operator=
eProsima_user_DllExport MinimalExtendedType & operator=(const MinimalExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:22110
eprosima::fastdds::dds::xtypes::MinimalExtendedType::operator==
eProsima_user_DllExport bool operator==(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22136
eprosima::fastdds::dds::xtypes::MinimalExtendedType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22147
eprosima::fastdds::dds::xtypes::MinimalExtendedType::MinimalExtendedType
eProsima_user_DllExport MinimalExtendedType(MinimalExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:22100
eprosima::fastdds::dds::xtypes::MinimalExtendedType::MinimalExtendedType
eProsima_user_DllExport MinimalExtendedType(const MinimalExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:22090
eprosima::fastdds::dds::xtypes::MinimalExtendedType::MinimalExtendedType
eProsima_user_DllExport MinimalExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:22075
eprosima::fastdds::dds::xtypes::MinimalExtendedType::~MinimalExtendedType
eProsima_user_DllExport ~MinimalExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:22082
eprosima::fastdds::dds::xtypes::MinimalMapType
This class represents the structure MinimalMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16570
eprosima::fastdds::dds::xtypes::MinimalMapType::collection_flag
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16688
eprosima::fastdds::dds::xtypes::MinimalMapType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16668
eprosima::fastdds::dds::xtypes::MinimalMapType::header
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16746
eprosima::fastdds::dds::xtypes::MinimalMapType::element
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16805
eprosima::fastdds::dds::xtypes::MinimalMapType::key
eProsima_user_DllExport void key(const MinimalCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16756
eprosima::fastdds::dds::xtypes::MinimalMapType::element
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16815
eprosima::fastdds::dds::xtypes::MinimalMapType::key
eProsima_user_DllExport MinimalCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16785
eprosima::fastdds::dds::xtypes::MinimalMapType::~MinimalMapType
eProsima_user_DllExport ~MinimalMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16583
eprosima::fastdds::dds::xtypes::MinimalMapType::MinimalMapType
eProsima_user_DllExport MinimalMapType(MinimalMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16608
eprosima::fastdds::dds::xtypes::MinimalMapType::header
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16737
eprosima::fastdds::dds::xtypes::MinimalMapType::key
eProsima_user_DllExport void key(MinimalCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16766
eprosima::fastdds::dds::xtypes::MinimalMapType::collection_flag
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16707
eprosima::fastdds::dds::xtypes::MinimalMapType::MinimalMapType
eProsima_user_DllExport MinimalMapType(const MinimalMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16591
eprosima::fastdds::dds::xtypes::MinimalMapType::collection_flag
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16678
eprosima::fastdds::dds::xtypes::MinimalMapType::element
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16795
eprosima::fastdds::dds::xtypes::MinimalMapType::header
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16717
eprosima::fastdds::dds::xtypes::MinimalMapType::operator=
eProsima_user_DllExport MinimalMapType & operator=(const MinimalMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16621
eprosima::fastdds::dds::xtypes::MinimalMapType::MinimalMapType
eProsima_user_DllExport MinimalMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16576
eprosima::fastdds::dds::xtypes::MinimalMapType::key
eProsima_user_DllExport const MinimalCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16776
eprosima::fastdds::dds::xtypes::MinimalMapType::collection_flag
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16698
eprosima::fastdds::dds::xtypes::MinimalMapType::element
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16824
eprosima::fastdds::dds::xtypes::MinimalMapType::header
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16727
eprosima::fastdds::dds::xtypes::MinimalMapType::operator==
eProsima_user_DllExport bool operator==(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16655
eprosima::fastdds::dds::xtypes::MinimalMemberDetail
This class represents the structure MinimalMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7541
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::operator==
eProsima_user_DllExport bool operator==(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7608
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::name_hash
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7628
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::~MinimalMemberDetail
eProsima_user_DllExport ~MinimalMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7554
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::operator=
eProsima_user_DllExport MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7583
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::operator!=
eProsima_user_DllExport bool operator!=(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7618
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::MinimalMemberDetail
eProsima_user_DllExport MinimalMemberDetail(const MinimalMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7562
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::MinimalMemberDetail
eProsima_user_DllExport MinimalMemberDetail(MinimalMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7573
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::MinimalMemberDetail
eProsima_user_DllExport MinimalMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7547
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::name_hash
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7648
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::name_hash
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7638
eprosima::fastdds::dds::xtypes::MinimalMemberDetail::name_hash
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7657
eprosima::fastdds::dds::xtypes::MinimalSequenceType
This class represents the structure MinimalSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15169
eprosima::fastdds::dds::xtypes::MinimalSequenceType::collection_flag
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15280
eprosima::fastdds::dds::xtypes::MinimalSequenceType::header
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15338
eprosima::fastdds::dds::xtypes::MinimalSequenceType::MinimalSequenceType
eProsima_user_DllExport MinimalSequenceType(const MinimalSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15190
eprosima::fastdds::dds::xtypes::MinimalSequenceType::element
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15358
eprosima::fastdds::dds::xtypes::MinimalSequenceType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15260
eprosima::fastdds::dds::xtypes::MinimalSequenceType::element
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15368
eprosima::fastdds::dds::xtypes::MinimalSequenceType::MinimalSequenceType
eProsima_user_DllExport MinimalSequenceType(MinimalSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15205
eprosima::fastdds::dds::xtypes::MinimalSequenceType::MinimalSequenceType
eProsima_user_DllExport MinimalSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15175
eprosima::fastdds::dds::xtypes::MinimalSequenceType::operator==
eProsima_user_DllExport bool operator==(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15248
eprosima::fastdds::dds::xtypes::MinimalSequenceType::header
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15329
eprosima::fastdds::dds::xtypes::MinimalSequenceType::collection_flag
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15299
eprosima::fastdds::dds::xtypes::MinimalSequenceType::collection_flag
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15270
eprosima::fastdds::dds::xtypes::MinimalSequenceType::element
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15348
eprosima::fastdds::dds::xtypes::MinimalSequenceType::header
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15309
eprosima::fastdds::dds::xtypes::MinimalSequenceType::collection_flag
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15290
eprosima::fastdds::dds::xtypes::MinimalSequenceType::operator=
eProsima_user_DllExport MinimalSequenceType & operator=(const MinimalSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15217
eprosima::fastdds::dds::xtypes::MinimalSequenceType::element
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15377
eprosima::fastdds::dds::xtypes::MinimalSequenceType::header
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15319
eprosima::fastdds::dds::xtypes::MinimalSequenceType::~MinimalSequenceType
eProsima_user_DllExport ~MinimalSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15182
eprosima::fastdds::dds::xtypes::MinimalStructHeader
This class represents the structure MinimalStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8673
eprosima::fastdds::dds::xtypes::MinimalStructHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8746
eprosima::fastdds::dds::xtypes::MinimalStructHeader::detail
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8835
eprosima::fastdds::dds::xtypes::MinimalStructHeader::detail
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8806
eprosima::fastdds::dds::xtypes::MinimalStructHeader::base_type
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8777
eprosima::fastdds::dds::xtypes::MinimalStructHeader::detail
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8826
eprosima::fastdds::dds::xtypes::MinimalStructHeader::~MinimalStructHeader
eProsima_user_DllExport ~MinimalStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8686
eprosima::fastdds::dds::xtypes::MinimalStructHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8757
eprosima::fastdds::dds::xtypes::MinimalStructHeader::operator=
eProsima_user_DllExport MinimalStructHeader & operator=(const MinimalStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8718
eprosima::fastdds::dds::xtypes::MinimalStructHeader::MinimalStructHeader
eProsima_user_DllExport MinimalStructHeader(const MinimalStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8694
eprosima::fastdds::dds::xtypes::MinimalStructHeader::base_type
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8767
eprosima::fastdds::dds::xtypes::MinimalStructHeader::base_type
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8796
eprosima::fastdds::dds::xtypes::MinimalStructHeader::MinimalStructHeader
eProsima_user_DllExport MinimalStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8679
eprosima::fastdds::dds::xtypes::MinimalStructHeader::base_type
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8787
eprosima::fastdds::dds::xtypes::MinimalStructHeader::detail
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8816
eprosima::fastdds::dds::xtypes::MinimalStructHeader::MinimalStructHeader
eProsima_user_DllExport MinimalStructHeader(MinimalStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8707
eprosima::fastdds::dds::xtypes::MinimalStructMember::detail
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7989
eprosima::fastdds::dds::xtypes::MinimalStructMember::detail
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8009
eprosima::fastdds::dds::xtypes::MinimalStructMember::detail
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8018
eprosima::fastdds::dds::xtypes::MinimalStructMember::MinimalStructMember
eProsima_user_DllExport MinimalStructMember(MinimalStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7890
eprosima::fastdds::dds::xtypes::MinimalStructMember::MinimalStructMember
eProsima_user_DllExport MinimalStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7862
eprosima::fastdds::dds::xtypes::MinimalStructMember::common
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7950
eprosima::fastdds::dds::xtypes::MinimalStructMember::operator=
eProsima_user_DllExport MinimalStructMember & operator=(const MinimalStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7901
eprosima::fastdds::dds::xtypes::MinimalStructMember::common
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7979
eprosima::fastdds::dds::xtypes::MinimalStructMember::MinimalStructMember
eProsima_user_DllExport MinimalStructMember(const MinimalStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7877
eprosima::fastdds::dds::xtypes::MinimalStructMember::detail
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7999
eprosima::fastdds::dds::xtypes::MinimalStructMember::common
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7970
eprosima::fastdds::dds::xtypes::MinimalStructMember::common
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7960
eprosima::fastdds::dds::xtypes::MinimalStructMember::~MinimalStructMember
eProsima_user_DllExport ~MinimalStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7869
eprosima::fastdds::dds::xtypes::MinimalStructMember::operator==
eProsima_user_DllExport bool operator==(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7929
eprosima::fastdds::dds::xtypes::MinimalStructMember::operator!=
eProsima_user_DllExport bool operator!=(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7940
eprosima::fastdds::dds::xtypes::MinimalStructType
This class represents the structure MinimalStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9080
eprosima::fastdds::dds::xtypes::MinimalStructType::header
eProsima_user_DllExport void header(const MinimalStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:9220
eprosima::fastdds::dds::xtypes::MinimalStructType::member_seq
eProsima_user_DllExport const MinimalStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9279
eprosima::fastdds::dds::xtypes::MinimalStructType::header
eProsima_user_DllExport void header(MinimalStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:9230
eprosima::fastdds::dds::xtypes::MinimalStructType::operator=
eProsima_user_DllExport MinimalStructType & operator=(const MinimalStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9128
eprosima::fastdds::dds::xtypes::MinimalStructType::MinimalStructType
eProsima_user_DllExport MinimalStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9086
eprosima::fastdds::dds::xtypes::MinimalStructType::MinimalStructType
eProsima_user_DllExport MinimalStructType(const MinimalStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9101
eprosima::fastdds::dds::xtypes::MinimalStructType::member_seq
eProsima_user_DllExport MinimalStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9288
eprosima::fastdds::dds::xtypes::MinimalStructType::~MinimalStructType
eProsima_user_DllExport ~MinimalStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9093
eprosima::fastdds::dds::xtypes::MinimalStructType::member_seq
eProsima_user_DllExport void member_seq(MinimalStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9269
eprosima::fastdds::dds::xtypes::MinimalStructType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9171
eprosima::fastdds::dds::xtypes::MinimalStructType::struct_flags
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9191
eprosima::fastdds::dds::xtypes::MinimalStructType::struct_flags
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9181
eprosima::fastdds::dds::xtypes::MinimalStructType::operator==
eProsima_user_DllExport bool operator==(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9159
eprosima::fastdds::dds::xtypes::MinimalStructType::struct_flags
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9201
eprosima::fastdds::dds::xtypes::MinimalStructType::header
eProsima_user_DllExport const MinimalStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:9240
eprosima::fastdds::dds::xtypes::MinimalStructType::MinimalStructType
eProsima_user_DllExport MinimalStructType(MinimalStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9116
eprosima::fastdds::dds::xtypes::MinimalStructType::member_seq
eProsima_user_DllExport void member_seq(const MinimalStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9259
eprosima::fastdds::dds::xtypes::MinimalStructType::struct_flags
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9210
eprosima::fastdds::dds::xtypes::MinimalStructType::header
eProsima_user_DllExport MinimalStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:9249
eprosima::fastdds::dds::xtypes::MinimalTypeDetail
This class represents the structure MinimalTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8171
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::operator!=
eProsima_user_DllExport bool operator!=(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8249
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::MinimalTypeDetail
eProsima_user_DllExport MinimalTypeDetail(const MinimalTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8192
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::operator=
eProsima_user_DllExport MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8212
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::MinimalTypeDetail
eProsima_user_DllExport MinimalTypeDetail(MinimalTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8202
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::MinimalTypeDetail
eProsima_user_DllExport MinimalTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8177
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::operator==
eProsima_user_DllExport bool operator==(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8238
eprosima::fastdds::dds::xtypes::MinimalTypeDetail::~MinimalTypeDetail
eProsima_user_DllExport ~MinimalTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8184
eprosima::fastdds::dds::xtypes::MinimalTypeObject
This class represents the union MinimalTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:22164
eprosima::fastdds::dds::xtypes::MinimalTypeObject::struct_type
eProsima_user_DllExport MinimalStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22767
eprosima::fastdds::dds::xtypes::MinimalTypeObject::union_type
eProsima_user_DllExport void union_type(const MinimalUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22782
eprosima::fastdds::dds::xtypes::MinimalTypeObject::enumerated_type
eProsima_user_DllExport const MinimalEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:23070
eprosima::fastdds::dds::xtypes::MinimalTypeObject::operator=
eProsima_user_DllExport MinimalTypeObject & operator=(const MinimalTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:22312
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitmask_type
eProsima_user_DllExport void bitmask_type(MinimalBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23111
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_extended_type
MinimalExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:23451
eprosima::fastdds::dds::xtypes::MinimalTypeObject::operator==
eProsima_user_DllExport bool operator==(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22432
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_enumerated_type
MinimalEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:23449
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitset_type
eProsima_user_DllExport void bitset_type(MinimalBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22846
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitmask_type
eProsima_user_DllExport void bitmask_type(const MinimalBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23100
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_union_type
MinimalUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:23444
eprosima::fastdds::dds::xtypes::MinimalTypeObject::alias_type
eProsima_user_DllExport void alias_type(const MinimalAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22623
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_alias_type
MinimalAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:23441
eprosima::fastdds::dds::xtypes::MinimalTypeObject::extended_type
eProsima_user_DllExport MinimalExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23191
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitset_type
eProsima_user_DllExport MinimalBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22873
eprosima::fastdds::dds::xtypes::MinimalTypeObject::enumerated_type
eProsima_user_DllExport void enumerated_type(MinimalEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:23058
eprosima::fastdds::dds::xtypes::MinimalTypeObject::sequence_type
eProsima_user_DllExport MinimalSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22926
eprosima::fastdds::dds::xtypes::MinimalTypeObject::extended_type
eProsima_user_DllExport const MinimalExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23176
eprosima::fastdds::dds::xtypes::MinimalTypeObject::extended_type
eProsima_user_DllExport void extended_type(MinimalExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23164
eprosima::fastdds::dds::xtypes::MinimalTypeObject::map_type
eProsima_user_DllExport void map_type(const MinimalMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22994
eprosima::fastdds::dds::xtypes::MinimalTypeObject::array_type
eProsima_user_DllExport const MinimalArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22964
eprosima::fastdds::dds::xtypes::MinimalTypeObject::array_type
eProsima_user_DllExport void array_type(MinimalArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22952
eprosima::fastdds::dds::xtypes::MinimalTypeObject::alias_type
eProsima_user_DllExport MinimalAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22661
eprosima::fastdds::dds::xtypes::MinimalTypeObject::union_type
eProsima_user_DllExport const MinimalUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22805
eprosima::fastdds::dds::xtypes::MinimalTypeObject::struct_type
eProsima_user_DllExport const MinimalStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22752
eprosima::fastdds::dds::xtypes::MinimalTypeObject::MinimalTypeObject
eProsima_user_DllExport MinimalTypeObject(const MinimalTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:22196
eprosima::fastdds::dds::xtypes::MinimalTypeObject::MinimalTypeObject
eProsima_user_DllExport MinimalTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:22170
eprosima::fastdds::dds::xtypes::MinimalTypeObject::sequence_type
eProsima_user_DllExport void sequence_type(MinimalSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22899
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_annotation_type
MinimalAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:23442
eprosima::fastdds::dds::xtypes::MinimalTypeObject::enumerated_type
eProsima_user_DllExport MinimalEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:23085
eprosima::fastdds::dds::xtypes::MinimalTypeObject::enumerated_type
eProsima_user_DllExport void enumerated_type(const MinimalEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:23047
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitmask_type
eProsima_user_DllExport MinimalBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23138
eprosima::fastdds::dds::xtypes::MinimalTypeObject::extended_type
eProsima_user_DllExport void extended_type(const MinimalExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23153
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitmask_type
eProsima_user_DllExport const MinimalBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23123
eprosima::fastdds::dds::xtypes::MinimalTypeObject::annotation_type
eProsima_user_DllExport MinimalAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22714
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_array_type
MinimalArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:23447
eprosima::fastdds::dds::xtypes::MinimalTypeObject::sequence_type
eProsima_user_DllExport void sequence_type(const MinimalSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22888
eprosima::fastdds::dds::xtypes::MinimalTypeObject::alias_type
eProsima_user_DllExport const MinimalAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22646
eprosima::fastdds::dds::xtypes::MinimalTypeObject::annotation_type
eProsima_user_DllExport void annotation_type(MinimalAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22687
eprosima::fastdds::dds::xtypes::MinimalTypeObject::annotation_type
eProsima_user_DllExport void annotation_type(const MinimalAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22676
eprosima::fastdds::dds::xtypes::MinimalTypeObject::union_type
eProsima_user_DllExport void union_type(MinimalUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22793
eprosima::fastdds::dds::xtypes::MinimalTypeObject::sequence_type
eProsima_user_DllExport const MinimalSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22911
eprosima::fastdds::dds::xtypes::MinimalTypeObject::alias_type
eProsima_user_DllExport void alias_type(MinimalAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22634
eprosima::fastdds::dds::xtypes::MinimalTypeObject::struct_type
eProsima_user_DllExport void struct_type(MinimalStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22740
eprosima::fastdds::dds::xtypes::MinimalTypeObject::union_type
eProsima_user_DllExport MinimalUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22820
eprosima::fastdds::dds::xtypes::MinimalTypeObject::map_type
eProsima_user_DllExport void map_type(MinimalMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:23005
eprosima::fastdds::dds::xtypes::MinimalTypeObject::annotation_type
eProsima_user_DllExport const MinimalAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22699
eprosima::fastdds::dds::xtypes::MinimalTypeObject::struct_type
eProsima_user_DllExport void struct_type(const MinimalStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22729
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_map_type
MinimalMapType m_map_type
Definition dds_xtypes_typeobject.hpp:23448
eprosima::fastdds::dds::xtypes::MinimalTypeObject::_d
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:22516
eprosima::fastdds::dds::xtypes::MinimalTypeObject::MinimalTypeObject
eProsima_user_DllExport MinimalTypeObject(MinimalTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:22254
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitset_type
eProsima_user_DllExport const MinimalBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22858
eprosima::fastdds::dds::xtypes::MinimalTypeObject::array_type
eProsima_user_DllExport MinimalArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22979
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_bitmask_type
MinimalBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:23450
eprosima::fastdds::dds::xtypes::MinimalTypeObject::bitset_type
eProsima_user_DllExport void bitset_type(const MinimalBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22835
eprosima::fastdds::dds::xtypes::MinimalTypeObject::map_type
eProsima_user_DllExport MinimalMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:23032
eprosima::fastdds::dds::xtypes::MinimalTypeObject::map_type
eProsima_user_DllExport const MinimalMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:23017
eprosima::fastdds::dds::xtypes::MinimalTypeObject::~MinimalTypeObject
eProsima_user_DllExport ~MinimalTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:22184
eprosima::fastdds::dds::xtypes::MinimalTypeObject::_d
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:22614
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_struct_type
MinimalStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:23443
eprosima::fastdds::dds::xtypes::MinimalTypeObject::array_type
eProsima_user_DllExport void array_type(const MinimalArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22941
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_bitset_type
MinimalBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:23445
eprosima::fastdds::dds::xtypes::MinimalTypeObject::m_sequence_type
MinimalSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:23446
eprosima::fastdds::dds::xtypes::MinimalTypeObject::operator!=
eProsima_user_DllExport bool operator!=(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22505
eprosima::fastdds::dds::xtypes::MinimalUnionHeader
This class represents the structure MinimalUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10610
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::detail
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10726
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::detail
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10697
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::MinimalUnionHeader
eProsima_user_DllExport MinimalUnionHeader(MinimalUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10642
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::detail
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10717
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::operator=
eProsima_user_DllExport MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10652
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::operator!=
eProsima_user_DllExport bool operator!=(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10687
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::MinimalUnionHeader
eProsima_user_DllExport MinimalUnionHeader(const MinimalUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10631
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::MinimalUnionHeader
eProsima_user_DllExport MinimalUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10616
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::~MinimalUnionHeader
eProsima_user_DllExport ~MinimalUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10623
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::detail
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10707
eprosima::fastdds::dds::xtypes::MinimalUnionHeader::operator==
eProsima_user_DllExport bool operator==(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10677
eprosima::fastdds::dds::xtypes::MinimalUnionMember::detail
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9888
eprosima::fastdds::dds::xtypes::MinimalUnionMember::detail
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9908
eprosima::fastdds::dds::xtypes::MinimalUnionMember::detail
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9917
eprosima::fastdds::dds::xtypes::MinimalUnionMember::common
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9849
eprosima::fastdds::dds::xtypes::MinimalUnionMember::operator=
eProsima_user_DllExport MinimalUnionMember & operator=(const MinimalUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9800
eprosima::fastdds::dds::xtypes::MinimalUnionMember::common
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9859
eprosima::fastdds::dds::xtypes::MinimalUnionMember::common
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9878
eprosima::fastdds::dds::xtypes::MinimalUnionMember::operator!=
eProsima_user_DllExport bool operator!=(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9839
eprosima::fastdds::dds::xtypes::MinimalUnionMember::common
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9869
eprosima::fastdds::dds::xtypes::MinimalUnionMember::detail
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9898
eprosima::fastdds::dds::xtypes::MinimalUnionMember::~MinimalUnionMember
eProsima_user_DllExport ~MinimalUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9768
eprosima::fastdds::dds::xtypes::MinimalUnionMember::MinimalUnionMember
eProsima_user_DllExport MinimalUnionMember(const MinimalUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9776
eprosima::fastdds::dds::xtypes::MinimalUnionMember::operator==
eProsima_user_DllExport bool operator==(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9828
eprosima::fastdds::dds::xtypes::MinimalUnionMember::MinimalUnionMember
eProsima_user_DllExport MinimalUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9761
eprosima::fastdds::dds::xtypes::MinimalUnionMember::MinimalUnionMember
eProsima_user_DllExport MinimalUnionMember(MinimalUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9789
eprosima::fastdds::dds::xtypes::MinimalUnionType
This class represents the structure MinimalUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11017
eprosima::fastdds::dds::xtypes::MinimalUnionType::discriminator
eProsima_user_DllExport void discriminator(MinimalDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11213
eprosima::fastdds::dds::xtypes::MinimalUnionType::discriminator
eProsima_user_DllExport MinimalDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11232
eprosima::fastdds::dds::xtypes::MinimalUnionType::union_flags
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11135
eprosima::fastdds::dds::xtypes::MinimalUnionType::MinimalUnionType
eProsima_user_DllExport MinimalUnionType(const MinimalUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11038
eprosima::fastdds::dds::xtypes::MinimalUnionType::union_flags
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11125
eprosima::fastdds::dds::xtypes::MinimalUnionType::header
eProsima_user_DllExport void header(const MinimalUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:11164
eprosima::fastdds::dds::xtypes::MinimalUnionType::MinimalUnionType
eProsima_user_DllExport MinimalUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11023
eprosima::fastdds::dds::xtypes::MinimalUnionType::discriminator
eProsima_user_DllExport const MinimalDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11223
eprosima::fastdds::dds::xtypes::MinimalUnionType::discriminator
eProsima_user_DllExport void discriminator(const MinimalDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11203
eprosima::fastdds::dds::xtypes::MinimalUnionType::union_flags
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11154
eprosima::fastdds::dds::xtypes::MinimalUnionType::member_seq
eProsima_user_DllExport MinimalUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11271
eprosima::fastdds::dds::xtypes::MinimalUnionType::~MinimalUnionType
eProsima_user_DllExport ~MinimalUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11030
eprosima::fastdds::dds::xtypes::MinimalUnionType::MinimalUnionType
eProsima_user_DllExport MinimalUnionType(MinimalUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11055
eprosima::fastdds::dds::xtypes::MinimalUnionType::operator!=
eProsima_user_DllExport bool operator!=(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11115
eprosima::fastdds::dds::xtypes::MinimalUnionType::union_flags
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11145
eprosima::fastdds::dds::xtypes::MinimalUnionType::header
eProsima_user_DllExport void header(MinimalUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:11174
eprosima::fastdds::dds::xtypes::MinimalUnionType::member_seq
eProsima_user_DllExport void member_seq(MinimalUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11252
eprosima::fastdds::dds::xtypes::MinimalUnionType::header
eProsima_user_DllExport MinimalUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:11193
eprosima::fastdds::dds::xtypes::MinimalUnionType::member_seq
eProsima_user_DllExport void member_seq(const MinimalUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11242
eprosima::fastdds::dds::xtypes::MinimalUnionType::member_seq
eProsima_user_DllExport const MinimalUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11262
eprosima::fastdds::dds::xtypes::MinimalUnionType::operator=
eProsima_user_DllExport MinimalUnionType & operator=(const MinimalUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11068
eprosima::fastdds::dds::xtypes::MinimalUnionType::header
eProsima_user_DllExport const MinimalUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:11184
eprosima::fastdds::dds::xtypes::MinimalUnionType::operator==
eProsima_user_DllExport bool operator==(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11102
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn
This class represents the structure PlainArrayLElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1574
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::array_bound_seq
eProsima_user_DllExport LBoundSeq & array_bound_seq()
This function returns a reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1743
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::PlainArrayLElemDefn
eProsima_user_DllExport PlainArrayLElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1580
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_element_identifier)
This function copies the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1753
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::element_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & element_identifier() const
This function returns a constant reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1773
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::PlainArrayLElemDefn
eProsima_user_DllExport PlainArrayLElemDefn(const PlainArrayLElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1595
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_element_identifier)
This function moves the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1763
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::~PlainArrayLElemDefn
eProsima_user_DllExport ~PlainArrayLElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1587
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::header
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1685
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::operator!=
eProsima_user_DllExport bool operator!=(const PlainArrayLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1665
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::header
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1695
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::array_bound_seq
eProsima_user_DllExport const LBoundSeq & array_bound_seq() const
This function returns a constant reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1734
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::header
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1675
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::PlainArrayLElemDefn
eProsima_user_DllExport PlainArrayLElemDefn(PlainArrayLElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1610
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::array_bound_seq
eProsima_user_DllExport void array_bound_seq(LBoundSeq &&_array_bound_seq)
This function moves the value in member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1724
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::operator==
eProsima_user_DllExport bool operator==(const PlainArrayLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1653
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::header
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1704
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::operator=
eProsima_user_DllExport PlainArrayLElemDefn & operator=(const PlainArrayLElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1622
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::array_bound_seq
eProsima_user_DllExport void array_bound_seq(const LBoundSeq &_array_bound_seq)
This function copies the value in member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1714
eprosima::fastdds::dds::xtypes::PlainArrayLElemDefn::element_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1782
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn
This class represents the structure PlainArraySElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1347
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::array_bound_seq
eProsima_user_DllExport void array_bound_seq(const SBoundSeq &_array_bound_seq)
This function copies the value in member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1487
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::~PlainArraySElemDefn
eProsima_user_DllExport ~PlainArraySElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1360
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::PlainArraySElemDefn
eProsima_user_DllExport PlainArraySElemDefn(PlainArraySElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1383
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_element_identifier)
This function copies the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1526
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::element_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & element_identifier() const
This function returns a constant reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1546
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_element_identifier)
This function moves the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1536
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::array_bound_seq
eProsima_user_DllExport void array_bound_seq(SBoundSeq &&_array_bound_seq)
This function moves the value in member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1497
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::operator==
eProsima_user_DllExport bool operator==(const PlainArraySElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1426
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::header
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1458
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::header
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1468
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::header
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1448
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::array_bound_seq
eProsima_user_DllExport SBoundSeq & array_bound_seq()
This function returns a reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1516
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::header
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1477
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::operator=
eProsima_user_DllExport PlainArraySElemDefn & operator=(const PlainArraySElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1395
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::PlainArraySElemDefn
eProsima_user_DllExport PlainArraySElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1353
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::operator!=
eProsima_user_DllExport bool operator!=(const PlainArraySElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1438
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::PlainArraySElemDefn
eProsima_user_DllExport PlainArraySElemDefn(const PlainArraySElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1368
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::element_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1555
eprosima::fastdds::dds::xtypes::PlainArraySElemDefn::array_bound_seq
eProsima_user_DllExport const SBoundSeq & array_bound_seq() const
This function returns a constant reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1507
eprosima::fastdds::dds::xtypes::PlainCollectionHeader
This class represents the structure PlainCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:743
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::element_flags
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:895
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::PlainCollectionHeader
eProsima_user_DllExport PlainCollectionHeader(const PlainCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:764
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::element_flags
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:876
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::PlainCollectionHeader
eProsima_user_DllExport PlainCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:749
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::equiv_kind
eProsima_user_DllExport EquivalenceKind & equiv_kind()
This function returns a reference to member equiv_kind.
Definition dds_xtypes_typeobject.hpp:856
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::~PlainCollectionHeader
eProsima_user_DllExport ~PlainCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:756
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::PlainCollectionHeader
eProsima_user_DllExport PlainCollectionHeader(PlainCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:777
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::equiv_kind
eProsima_user_DllExport EquivalenceKind equiv_kind() const
This function returns the value of member equiv_kind.
Definition dds_xtypes_typeobject.hpp:847
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::equiv_kind
eProsima_user_DllExport void equiv_kind(EquivalenceKind _equiv_kind)
This function sets a value in member equiv_kind.
Definition dds_xtypes_typeobject.hpp:837
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::operator==
eProsima_user_DllExport bool operator==(const PlainCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:816
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::element_flags
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:866
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::operator=
eProsima_user_DllExport PlainCollectionHeader & operator=(const PlainCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:788
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::element_flags
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:886
eprosima::fastdds::dds::xtypes::PlainCollectionHeader::operator!=
eProsima_user_DllExport bool operator!=(const PlainCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:827
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn
This class represents the structure PlainMapLTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2112
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::PlainMapLTypeDefn
eProsima_user_DllExport PlainMapLTypeDefn(PlainMapLTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2152
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::bound
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:2285
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_flags
eProsima_user_DllExport CollectionElementFlag & key_flags()
This function returns a reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2363
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_identifier
eProsima_user_DllExport void key_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_key_identifier)
This function copies the value in member key_identifier.
Definition dds_xtypes_typeobject.hpp:2373
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::element_identifier
eProsima_user_DllExport void element_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_element_identifier)
This function copies the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:2295
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::element_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & element_identifier() const
This function returns a constant reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2315
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::element_identifier
eProsima_user_DllExport void element_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_element_identifier)
This function moves the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:2305
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::operator!=
eProsima_user_DllExport bool operator!=(const PlainMapLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2217
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_flags
eProsima_user_DllExport const CollectionElementFlag & key_flags() const
This function returns a constant reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2354
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::bound
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:2266
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::PlainMapLTypeDefn
eProsima_user_DllExport PlainMapLTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2118
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & key_identifier()
This function returns a reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2402
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::header
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:2237
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::header
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:2247
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::header
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:2227
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::PlainMapLTypeDefn
eProsima_user_DllExport PlainMapLTypeDefn(const PlainMapLTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2133
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::operator=
eProsima_user_DllExport PlainMapLTypeDefn & operator=(const PlainMapLTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2166
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_flags
eProsima_user_DllExport void key_flags(const CollectionElementFlag &_key_flags)
This function copies the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2334
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::operator==
eProsima_user_DllExport bool operator==(const PlainMapLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2203
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::~PlainMapLTypeDefn
eProsima_user_DllExport ~PlainMapLTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2125
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::bound
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:2276
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_identifier
eProsima_user_DllExport void key_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_key_identifier)
This function moves the value in member key_identifier.
Definition dds_xtypes_typeobject.hpp:2383
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::header
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:2256
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::element_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2324
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & key_identifier() const
This function returns a constant reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2393
eprosima::fastdds::dds::xtypes::PlainMapLTypeDefn::key_flags
eProsima_user_DllExport void key_flags(CollectionElementFlag &&_key_flags)
This function moves the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2344
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn
This class represents the structure PlainMapSTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1801
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_flags
eProsima_user_DllExport CollectionElementFlag & key_flags()
This function returns a reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2052
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::PlainMapSTypeDefn
eProsima_user_DllExport PlainMapSTypeDefn(PlainMapSTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1841
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_identifier
eProsima_user_DllExport void key_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_key_identifier)
This function copies the value in member key_identifier.
Definition dds_xtypes_typeobject.hpp:2062
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::element_identifier
eProsima_user_DllExport void element_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_element_identifier)
This function copies the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1984
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::element_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & element_identifier() const
This function returns a constant reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2004
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::operator==
eProsima_user_DllExport bool operator==(const PlainMapSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1892
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::element_identifier
eProsima_user_DllExport void element_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_element_identifier)
This function moves the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1994
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::operator=
eProsima_user_DllExport PlainMapSTypeDefn & operator=(const PlainMapSTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1855
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_flags
eProsima_user_DllExport const CollectionElementFlag & key_flags() const
This function returns a constant reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2043
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::bound
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1965
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::bound
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1955
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & key_identifier()
This function returns a reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2091
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::PlainMapSTypeDefn
eProsima_user_DllExport PlainMapSTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1807
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::header
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1926
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::header
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1936
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::header
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1916
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_flags
eProsima_user_DllExport void key_flags(const CollectionElementFlag &_key_flags)
This function copies the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2023
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::operator!=
eProsima_user_DllExport bool operator!=(const PlainMapSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1906
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::~PlainMapSTypeDefn
eProsima_user_DllExport ~PlainMapSTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1814
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_identifier
eProsima_user_DllExport void key_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_key_identifier)
This function moves the value in member key_identifier.
Definition dds_xtypes_typeobject.hpp:2072
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::header
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1945
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::PlainMapSTypeDefn
eProsima_user_DllExport PlainMapSTypeDefn(const PlainMapSTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1822
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::bound
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1974
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::element_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2013
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & key_identifier() const
This function returns a constant reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2082
eprosima::fastdds::dds::xtypes::PlainMapSTypeDefn::key_flags
eProsima_user_DllExport void key_flags(CollectionElementFlag &&_key_flags)
This function moves the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2033
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn
This class represents the structure PlainSequenceLElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1130
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::bound
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1289
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::operator=
eProsima_user_DllExport PlainSequenceLElemDefn & operator=(const PlainSequenceLElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1178
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_element_identifier)
This function copies the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1299
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::element_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & element_identifier() const
This function returns a constant reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1319
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::PlainSequenceLElemDefn
eProsima_user_DllExport PlainSequenceLElemDefn(const PlainSequenceLElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1151
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::~PlainSequenceLElemDefn
eProsima_user_DllExport ~PlainSequenceLElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1143
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_element_identifier)
This function moves the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1309
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::operator!=
eProsima_user_DllExport bool operator!=(const PlainSequenceLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1221
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::bound
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1270
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::header
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1241
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::header
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1251
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::header
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1231
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::bound
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1280
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::header
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1260
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::PlainSequenceLElemDefn
eProsima_user_DllExport PlainSequenceLElemDefn(PlainSequenceLElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1166
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::element_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1328
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::operator==
eProsima_user_DllExport bool operator==(const PlainSequenceLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1209
eprosima::fastdds::dds::xtypes::PlainSequenceLElemDefn::PlainSequenceLElemDefn
eProsima_user_DllExport PlainSequenceLElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1136
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn
This class represents the structure PlainSequenceSElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:913
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::PlainSequenceSElemDefn
eProsima_user_DllExport PlainSequenceSElemDefn(const PlainSequenceSElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:934
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(const eprosima::fastcdr::external< TypeIdentifier > &_element_identifier)
This function copies the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1082
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::element_identifier
eProsima_user_DllExport const eprosima::fastcdr::external< TypeIdentifier > & element_identifier() const
This function returns a constant reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1102
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::element_identifier
eProsima_user_DllExport void element_identifier(eprosima::fastcdr::external< TypeIdentifier > &&_element_identifier)
This function moves the value in member element_identifier.
Definition dds_xtypes_typeobject.hpp:1092
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::bound
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1063
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::operator=
eProsima_user_DllExport PlainSequenceSElemDefn & operator=(const PlainSequenceSElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:961
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::bound
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1053
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::header
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1024
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::header
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1034
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::operator!=
eProsima_user_DllExport bool operator!=(const PlainSequenceSElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1004
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::header
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1014
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::PlainSequenceSElemDefn
eProsima_user_DllExport PlainSequenceSElemDefn(PlainSequenceSElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:949
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::PlainSequenceSElemDefn
eProsima_user_DllExport PlainSequenceSElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:919
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::operator==
eProsima_user_DllExport bool operator==(const PlainSequenceSElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:992
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::~PlainSequenceSElemDefn
eProsima_user_DllExport ~PlainSequenceSElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:926
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::header
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1043
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::bound
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1072
eprosima::fastdds::dds::xtypes::PlainSequenceSElemDefn::element_identifier
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1111
eprosima::fastdds::dds::xtypes::StringLTypeDefn
This class represents the structure StringLTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:620
eprosima::fastdds::dds::xtypes::StringLTypeDefn::bound
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:726
eprosima::fastdds::dds::xtypes::StringLTypeDefn::~StringLTypeDefn
eProsima_user_DllExport ~StringLTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:633
eprosima::fastdds::dds::xtypes::StringLTypeDefn::bound
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:707
eprosima::fastdds::dds::xtypes::StringLTypeDefn::StringLTypeDefn
eProsima_user_DllExport StringLTypeDefn(StringLTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:652
eprosima::fastdds::dds::xtypes::StringLTypeDefn::operator=
eProsima_user_DllExport StringLTypeDefn & operator=(const StringLTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:662
eprosima::fastdds::dds::xtypes::StringLTypeDefn::bound
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:717
eprosima::fastdds::dds::xtypes::StringLTypeDefn::StringLTypeDefn
eProsima_user_DllExport StringLTypeDefn(const StringLTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:641
eprosima::fastdds::dds::xtypes::StringLTypeDefn::operator==
eProsima_user_DllExport bool operator==(const StringLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:687
eprosima::fastdds::dds::xtypes::StringLTypeDefn::operator!=
eProsima_user_DllExport bool operator!=(const StringLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:697
eprosima::fastdds::dds::xtypes::StringLTypeDefn::StringLTypeDefn
eProsima_user_DllExport StringLTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:626
eprosima::fastdds::dds::xtypes::StringSTypeDefn
This class represents the structure StringSTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:497
eprosima::fastdds::dds::xtypes::StringSTypeDefn::operator=
eProsima_user_DllExport StringSTypeDefn & operator=(const StringSTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:539
eprosima::fastdds::dds::xtypes::StringSTypeDefn::StringSTypeDefn
eProsima_user_DllExport StringSTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:503
eprosima::fastdds::dds::xtypes::StringSTypeDefn::bound
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:594
eprosima::fastdds::dds::xtypes::StringSTypeDefn::bound
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:584
eprosima::fastdds::dds::xtypes::StringSTypeDefn::operator==
eProsima_user_DllExport bool operator==(const StringSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:564
eprosima::fastdds::dds::xtypes::StringSTypeDefn::operator!=
eProsima_user_DllExport bool operator!=(const StringSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:574
eprosima::fastdds::dds::xtypes::StringSTypeDefn::bound
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:603
eprosima::fastdds::dds::xtypes::StringSTypeDefn::StringSTypeDefn
eProsima_user_DllExport StringSTypeDefn(const StringSTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:518
eprosima::fastdds::dds::xtypes::StringSTypeDefn::StringSTypeDefn
eProsima_user_DllExport StringSTypeDefn(StringSTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:529
eprosima::fastdds::dds::xtypes::StringSTypeDefn::~StringSTypeDefn
eProsima_user_DllExport ~StringSTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:510
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId
This class represents the structure StronglyConnectedComponentId defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2423
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::sc_component_id
eProsima_user_DllExport TypeObjectHashId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:2553
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::sc_component_id
eProsima_user_DllExport void sc_component_id(TypeObjectHashId &&_sc_component_id)
This function moves the value in member sc_component_id.
Definition dds_xtypes_typeobject.hpp:2534
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::~StronglyConnectedComponentId
eProsima_user_DllExport ~StronglyConnectedComponentId()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2436
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::scc_index
eProsima_user_DllExport int32_t scc_index() const
This function returns the value of member scc_index.
Definition dds_xtypes_typeobject.hpp:2602
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::operator!=
eProsima_user_DllExport bool operator!=(const StronglyConnectedComponentId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2514
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::scc_length
eProsima_user_DllExport int32_t & scc_length()
This function returns a reference to member scc_length.
Definition dds_xtypes_typeobject.hpp:2582
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::operator==
eProsima_user_DllExport bool operator==(const StronglyConnectedComponentId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2502
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::StronglyConnectedComponentId
eProsima_user_DllExport StronglyConnectedComponentId(const StronglyConnectedComponentId &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2444
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::StronglyConnectedComponentId
eProsima_user_DllExport StronglyConnectedComponentId()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2429
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::operator=
eProsima_user_DllExport StronglyConnectedComponentId & operator=(const StronglyConnectedComponentId &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2471
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::StronglyConnectedComponentId
eProsima_user_DllExport StronglyConnectedComponentId(StronglyConnectedComponentId &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2459
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::sc_component_id
eProsima_user_DllExport void sc_component_id(const TypeObjectHashId &_sc_component_id)
This function copies the value in member sc_component_id.
Definition dds_xtypes_typeobject.hpp:2524
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::sc_component_id
eProsima_user_DllExport const TypeObjectHashId & sc_component_id() const
This function returns a constant reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:2544
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::scc_index
eProsima_user_DllExport void scc_index(int32_t _scc_index)
This function sets a value in member scc_index.
Definition dds_xtypes_typeobject.hpp:2592
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::scc_length
eProsima_user_DllExport int32_t scc_length() const
This function returns the value of member scc_length.
Definition dds_xtypes_typeobject.hpp:2573
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::scc_index
eProsima_user_DllExport int32_t & scc_index()
This function returns a reference to member scc_index.
Definition dds_xtypes_typeobject.hpp:2611
eprosima::fastdds::dds::xtypes::StronglyConnectedComponentId::scc_length
eProsima_user_DllExport void scc_length(int32_t _scc_length)
This function sets a value in member scc_length.
Definition dds_xtypes_typeobject.hpp:2563
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize
This class represents the structure TypeIdentfierWithSize defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24215
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::type_id
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24329
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::operator==
eProsima_user_DllExport bool operator==(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24288
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::operator!=
eProsima_user_DllExport bool operator!=(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24299
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::type_id
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24338
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::TypeIdentfierWithSize
eProsima_user_DllExport TypeIdentfierWithSize(TypeIdentfierWithSize &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24249
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::type_id
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24319
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::typeobject_serialized_size
eProsima_user_DllExport uint32_t typeobject_serialized_size() const
This function returns the value of member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24358
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::~TypeIdentfierWithSize
eProsima_user_DllExport ~TypeIdentfierWithSize()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24228
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::typeobject_serialized_size
eProsima_user_DllExport uint32_t & typeobject_serialized_size()
This function returns a reference to member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24367
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::typeobject_serialized_size
eProsima_user_DllExport void typeobject_serialized_size(uint32_t _typeobject_serialized_size)
This function sets a value in member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24348
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::operator=
eProsima_user_DllExport TypeIdentfierWithSize & operator=(const TypeIdentfierWithSize &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24260
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::TypeIdentfierWithSize
eProsima_user_DllExport TypeIdentfierWithSize(const TypeIdentfierWithSize &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24236
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::TypeIdentfierWithSize
eProsima_user_DllExport TypeIdentfierWithSize()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24221
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSize::type_id
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24309
eprosima::fastdds::dds::xtypes::TypeIdentifier
This class represents the union TypeIdentifier defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2820
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_ldefn
eProsima_user_DllExport const StringLTypeDefn & string_ldefn() const
This function returns a constant reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3453
eprosima::fastdds::dds::xtypes::TypeIdentifier::TypeIdentifier
eProsima_user_DllExport TypeIdentifier(TypeIdentifier &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2914
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_no_value
Dummy m_no_value
Definition dds_xtypes_typeobject.hpp:4217
eprosima::fastdds::dds::xtypes::TypeIdentifier::equivalence_hash
eProsima_user_DllExport void equivalence_hash(EquivalenceHash &&_equivalence_hash)
This function moves the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3865
eprosima::fastdds::dds::xtypes::TypeIdentifier::equivalence_hash
eProsima_user_DllExport const EquivalenceHash & equivalence_hash() const
This function returns a constant reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3877
eprosima::fastdds::dds::xtypes::TypeIdentifier::~TypeIdentifier
eProsima_user_DllExport ~TypeIdentifier()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2840
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_sdefn
eProsima_user_DllExport PlainMapSTypeDefn & map_sdefn()
This function returns a reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3733
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_ldefn
eProsima_user_DllExport void map_ldefn(const PlainMapLTypeDefn &_map_ldefn)
This function copies the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3748
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_sc_component_id
StronglyConnectedComponentId m_sc_component_id
Definition dds_xtypes_typeobject.hpp:4226
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_sdefn
eProsima_user_DllExport const PlainMapSTypeDefn & map_sdefn() const
This function returns a constant reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3718
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_ldefn
eProsima_user_DllExport StringLTypeDefn & string_ldefn()
This function returns a reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3468
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_sdefn
eProsima_user_DllExport void seq_sdefn(PlainSequenceSElemDefn &&_seq_sdefn)
This function moves the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3494
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_sdefn
eProsima_user_DllExport void string_sdefn(StringSTypeDefn &&_string_sdefn)
This function moves the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3388
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_ldefn
eProsima_user_DllExport void array_ldefn(PlainArrayLElemDefn &&_array_ldefn)
This function moves the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3653
eprosima::fastdds::dds::xtypes::TypeIdentifier::operator==
eProsima_user_DllExport bool operator==(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3104
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_ldefn
eProsima_user_DllExport const PlainMapLTypeDefn & map_ldefn() const
This function returns a constant reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3771
eprosima::fastdds::dds::xtypes::TypeIdentifier::operator=
eProsima_user_DllExport TypeIdentifier & operator=(const TypeIdentifier &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2976
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_ldefn
eProsima_user_DllExport void map_ldefn(PlainMapLTypeDefn &&_map_ldefn)
This function moves the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3759
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_ldefn
eProsima_user_DllExport void string_ldefn(StringLTypeDefn &&_string_ldefn)
This function moves the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3441
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_ldefn
eProsima_user_DllExport void string_ldefn(const StringLTypeDefn &_string_ldefn)
This function copies the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3430
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_array_ldefn
PlainArrayLElemDefn m_array_ldefn
Definition dds_xtypes_typeobject.hpp:4223
eprosima::fastdds::dds::xtypes::TypeIdentifier::sc_component_id
eProsima_user_DllExport void sc_component_id(const StronglyConnectedComponentId &_sc_component_id)
This function copies the value in member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3801
eprosima::fastdds::dds::xtypes::TypeIdentifier::TypeIdentifier
eProsima_user_DllExport TypeIdentifier(const TypeIdentifier &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2852
eprosima::fastdds::dds::xtypes::TypeIdentifier::extended_defn
eProsima_user_DllExport ExtendedTypeDefn & extended_defn()
This function returns a reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3945
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_ldefn
eProsima_user_DllExport void seq_ldefn(const PlainSequenceLElemDefn &_seq_ldefn)
This function copies the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3536
eprosima::fastdds::dds::xtypes::TypeIdentifier::no_value
eProsima_user_DllExport void no_value(Dummy &&_no_value)
This function moves the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3335
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_sdefn
eProsima_user_DllExport const StringSTypeDefn & string_sdefn() const
This function returns a constant reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3400
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_string_sdefn
StringSTypeDefn m_string_sdefn
Definition dds_xtypes_typeobject.hpp:4218
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_seq_sdefn
PlainSequenceSElemDefn m_seq_sdefn
Definition dds_xtypes_typeobject.hpp:4220
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_ldefn
eProsima_user_DllExport const PlainArrayLElemDefn & array_ldefn() const
This function returns a constant reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3665
eprosima::fastdds::dds::xtypes::TypeIdentifier::no_value
eProsima_user_DllExport const Dummy & no_value() const
This function returns a constant reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3347
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_extended_defn
ExtendedTypeDefn m_extended_defn
Definition dds_xtypes_typeobject.hpp:4228
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_ldefn
eProsima_user_DllExport const PlainSequenceLElemDefn & seq_ldefn() const
This function returns a constant reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3559
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_sdefn
eProsima_user_DllExport void array_sdefn(const PlainArraySElemDefn &_array_sdefn)
This function copies the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3589
eprosima::fastdds::dds::xtypes::TypeIdentifier::TypeIdentifier
eProsima_user_DllExport TypeIdentifier()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2826
eprosima::fastdds::dds::xtypes::TypeIdentifier::operator!=
eProsima_user_DllExport bool operator!=(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3181
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_ldefn
eProsima_user_DllExport PlainSequenceLElemDefn & seq_ldefn()
This function returns a reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3574
eprosima::fastdds::dds::xtypes::TypeIdentifier::sc_component_id
eProsima_user_DllExport void sc_component_id(StronglyConnectedComponentId &&_sc_component_id)
This function moves the value in member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3812
eprosima::fastdds::dds::xtypes::TypeIdentifier::extended_defn
eProsima_user_DllExport const ExtendedTypeDefn & extended_defn() const
This function returns a constant reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3930
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_sdefn
eProsima_user_DllExport const PlainSequenceSElemDefn & seq_sdefn() const
This function returns a constant reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3506
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_sdefn
eProsima_user_DllExport void map_sdefn(PlainMapSTypeDefn &&_map_sdefn)
This function moves the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3706
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_seq_ldefn
PlainSequenceLElemDefn m_seq_ldefn
Definition dds_xtypes_typeobject.hpp:4221
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_ldefn
eProsima_user_DllExport void array_ldefn(const PlainArrayLElemDefn &_array_ldefn)
This function copies the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3642
eprosima::fastdds::dds::xtypes::TypeIdentifier::equivalence_hash
eProsima_user_DllExport EquivalenceHash & equivalence_hash()
This function returns a reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3892
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_sdefn
eProsima_user_DllExport StringSTypeDefn & string_sdefn()
This function returns a reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3415
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_sdefn
eProsima_user_DllExport const PlainArraySElemDefn & array_sdefn() const
This function returns a constant reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3612
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_ldefn
eProsima_user_DllExport PlainArrayLElemDefn & array_ldefn()
This function returns a reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3680
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_string_ldefn
StringLTypeDefn m_string_ldefn
Definition dds_xtypes_typeobject.hpp:4219
eprosima::fastdds::dds::xtypes::TypeIdentifier::extended_defn
eProsima_user_DllExport void extended_defn(ExtendedTypeDefn &&_extended_defn)
This function moves the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3918
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_array_sdefn
PlainArraySElemDefn m_array_sdefn
Definition dds_xtypes_typeobject.hpp:4222
eprosima::fastdds::dds::xtypes::TypeIdentifier::no_value
eProsima_user_DllExport void no_value(const Dummy &_no_value)
This function copies the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3324
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_map_sdefn
PlainMapSTypeDefn m_map_sdefn
Definition dds_xtypes_typeobject.hpp:4224
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_map_ldefn
PlainMapLTypeDefn m_map_ldefn
Definition dds_xtypes_typeobject.hpp:4225
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_sdefn
eProsima_user_DllExport void seq_sdefn(const PlainSequenceSElemDefn &_seq_sdefn)
This function copies the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3483
eprosima::fastdds::dds::xtypes::TypeIdentifier::string_sdefn
eProsima_user_DllExport void string_sdefn(const StringSTypeDefn &_string_sdefn)
This function copies the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3377
eprosima::fastdds::dds::xtypes::TypeIdentifier::_d
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:3192
eprosima::fastdds::dds::xtypes::TypeIdentifier::m_equivalence_hash
EquivalenceHash m_equivalence_hash
Definition dds_xtypes_typeobject.hpp:4227
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_ldefn
eProsima_user_DllExport void seq_ldefn(PlainSequenceLElemDefn &&_seq_ldefn)
This function moves the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3547
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_ldefn
eProsima_user_DllExport PlainMapLTypeDefn & map_ldefn()
This function returns a reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3786
eprosima::fastdds::dds::xtypes::TypeIdentifier::map_sdefn
eProsima_user_DllExport void map_sdefn(const PlainMapSTypeDefn &_map_sdefn)
This function copies the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3695
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_sdefn
eProsima_user_DllExport void array_sdefn(PlainArraySElemDefn &&_array_sdefn)
This function moves the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3600
eprosima::fastdds::dds::xtypes::TypeIdentifier::extended_defn
eProsima_user_DllExport void extended_defn(const ExtendedTypeDefn &_extended_defn)
This function copies the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3907
eprosima::fastdds::dds::xtypes::TypeIdentifier::sc_component_id
eProsima_user_DllExport const StronglyConnectedComponentId & sc_component_id() const
This function returns a constant reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3824
eprosima::fastdds::dds::xtypes::TypeIdentifier::seq_sdefn
eProsima_user_DllExport PlainSequenceSElemDefn & seq_sdefn()
This function returns a reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3521
eprosima::fastdds::dds::xtypes::TypeIdentifier::_d
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:3315
eprosima::fastdds::dds::xtypes::TypeIdentifier::sc_component_id
eProsima_user_DllExport StronglyConnectedComponentId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3839
eprosima::fastdds::dds::xtypes::TypeIdentifier::no_value
eProsima_user_DllExport Dummy & no_value()
This function returns a reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3362
eprosima::fastdds::dds::xtypes::TypeIdentifier::array_sdefn
eProsima_user_DllExport PlainArraySElemDefn & array_sdefn()
This function returns a reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3627
eprosima::fastdds::dds::xtypes::TypeIdentifier::equivalence_hash
eProsima_user_DllExport void equivalence_hash(const EquivalenceHash &_equivalence_hash)
This function copies the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3854
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::TypeIdentifierPair
eProsima_user_DllExport TypeIdentifierPair(TypeIdentifierPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24067
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::TypeIdentifierPair
eProsima_user_DllExport TypeIdentifierPair(const TypeIdentifierPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24054
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier1
eProsima_user_DllExport void type_identifier1(const TypeIdentifier &_type_identifier1)
This function copies the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24127
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::operator=
eProsima_user_DllExport TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24078
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier2
eProsima_user_DllExport void type_identifier2(TypeIdentifier &&_type_identifier2)
This function moves the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24176
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier1
eProsima_user_DllExport TypeIdentifier & type_identifier1()
This function returns a reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24156
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier1
eProsima_user_DllExport void type_identifier1(TypeIdentifier &&_type_identifier1)
This function moves the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24137
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier2
eProsima_user_DllExport const TypeIdentifier & type_identifier2() const
This function returns a constant reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24186
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::operator!=
eProsima_user_DllExport bool operator!=(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24117
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier2
eProsima_user_DllExport void type_identifier2(const TypeIdentifier &_type_identifier2)
This function copies the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24166
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::TypeIdentifierPair
eProsima_user_DllExport TypeIdentifierPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24039
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier1
eProsima_user_DllExport const TypeIdentifier & type_identifier1() const
This function returns a constant reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24147
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::~TypeIdentifierPair
eProsima_user_DllExport ~TypeIdentifierPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24046
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::type_identifier2
eProsima_user_DllExport TypeIdentifier & type_identifier2()
This function returns a reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24195
eprosima::fastdds::dds::xtypes::TypeIdentifierPair::operator==
eProsima_user_DllExport bool operator==(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24106
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_object
eProsima_user_DllExport const TypeObject & type_object() const
This function returns a constant reference to member type_object.
Definition dds_xtypes_typeobject.hpp:24004
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::TypeIdentifierTypeObjectPair
eProsima_user_DllExport TypeIdentifierTypeObjectPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23857
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_identifier
eProsima_user_DllExport void type_identifier(TypeIdentifier &&_type_identifier)
This function moves the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23955
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_object
eProsima_user_DllExport void type_object(const TypeObject &_type_object)
This function copies the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23984
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_identifier
eProsima_user_DllExport TypeIdentifier & type_identifier()
This function returns a reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23974
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::operator=
eProsima_user_DllExport TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23896
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::operator!=
eProsima_user_DllExport bool operator!=(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23935
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_identifier
eProsima_user_DllExport const TypeIdentifier & type_identifier() const
This function returns a constant reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23965
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::~TypeIdentifierTypeObjectPair
eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23864
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::TypeIdentifierTypeObjectPair
eProsima_user_DllExport TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23872
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_object
eProsima_user_DllExport TypeObject & type_object()
This function returns a reference to member type_object.
Definition dds_xtypes_typeobject.hpp:24013
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::operator==
eProsima_user_DllExport bool operator==(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23924
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::TypeIdentifierTypeObjectPair
eProsima_user_DllExport TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23885
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_identifier
eProsima_user_DllExport void type_identifier(const TypeIdentifier &_type_identifier)
This function copies the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23945
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPair::type_object
eProsima_user_DllExport void type_object(TypeObject &&_type_object)
This function moves the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23994
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies
This class represents the structure TypeIdentifierWithDependencies defined by the user in the IDL fil...
Definition dds_xtypes_typeobject.hpp:24387
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeid_count
eProsima_user_DllExport void dependent_typeid_count(int32_t _dependent_typeid_count)
This function sets a value in member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24527
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeids
eProsima_user_DllExport std::vector< TypeIdentfierWithSize > & dependent_typeids()
This function returns a reference to member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24585
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::TypeIdentifierWithDependencies
eProsima_user_DllExport TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24408
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::TypeIdentifierWithDependencies
eProsima_user_DllExport TypeIdentifierWithDependencies()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24393
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeids
eProsima_user_DllExport const std::vector< TypeIdentfierWithSize > & dependent_typeids() const
This function returns a constant reference to member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24576
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::operator=
eProsima_user_DllExport TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24435
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeid_count
eProsima_user_DllExport int32_t dependent_typeid_count() const
This function returns the value of member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24537
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::typeid_with_size
eProsima_user_DllExport const TypeIdentfierWithSize & typeid_with_size() const
This function returns a constant reference to member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24508
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeids
eProsima_user_DllExport void dependent_typeids(const std::vector< TypeIdentfierWithSize > &_dependent_typeids)
This function copies the value in member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24556
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::TypeIdentifierWithDependencies
eProsima_user_DllExport TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24423
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::typeid_with_size
eProsima_user_DllExport void typeid_with_size(const TypeIdentfierWithSize &_typeid_with_size)
This function copies the value in member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24488
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeids
eProsima_user_DllExport void dependent_typeids(std::vector< TypeIdentfierWithSize > &&_dependent_typeids)
This function moves the value in member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24566
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::operator!=
eProsima_user_DllExport bool operator!=(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24478
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::dependent_typeid_count
eProsima_user_DllExport int32_t & dependent_typeid_count()
This function returns a reference to member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24546
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::~TypeIdentifierWithDependencies
eProsima_user_DllExport ~TypeIdentifierWithDependencies()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24400
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::typeid_with_size
eProsima_user_DllExport void typeid_with_size(TypeIdentfierWithSize &&_typeid_with_size)
This function moves the value in member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24498
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::operator==
eProsima_user_DllExport bool operator==(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24466
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependencies::typeid_with_size
eProsima_user_DllExport TypeIdentfierWithSize & typeid_with_size()
This function returns a reference to member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24517
eprosima::fastdds::dds::xtypes::TypeInformation::TypeInformation
eProsima_user_DllExport TypeInformation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24612
eprosima::fastdds::dds::xtypes::TypeInformation::minimal
eProsima_user_DllExport void minimal(TypeIdentifierWithDependencies &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24710
eprosima::fastdds::dds::xtypes::TypeInformation::operator!=
eProsima_user_DllExport bool operator!=(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24690
eprosima::fastdds::dds::xtypes::TypeInformation::minimal
eProsima_user_DllExport const TypeIdentifierWithDependencies & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24720
eprosima::fastdds::dds::xtypes::TypeInformation::complete
eProsima_user_DllExport const TypeIdentifierWithDependencies & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:24759
eprosima::fastdds::dds::xtypes::TypeInformation::minimal
eProsima_user_DllExport TypeIdentifierWithDependencies & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24729
eprosima::fastdds::dds::xtypes::TypeInformation::complete
eProsima_user_DllExport void complete(const TypeIdentifierWithDependencies &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:24739
eprosima::fastdds::dds::xtypes::TypeInformation::operator=
eProsima_user_DllExport TypeInformation & operator=(const TypeInformation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24651
eprosima::fastdds::dds::xtypes::TypeInformation::complete
eProsima_user_DllExport TypeIdentifierWithDependencies & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:24768
eprosima::fastdds::dds::xtypes::TypeInformation::operator==
eProsima_user_DllExport bool operator==(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24679
eprosima::fastdds::dds::xtypes::TypeInformation::minimal
eProsima_user_DllExport void minimal(const TypeIdentifierWithDependencies &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24700
eprosima::fastdds::dds::xtypes::TypeInformation::~TypeInformation
eProsima_user_DllExport ~TypeInformation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24619
eprosima::fastdds::dds::xtypes::TypeInformation::complete
eProsima_user_DllExport void complete(TypeIdentifierWithDependencies &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:24749
eprosima::fastdds::dds::xtypes::TypeInformation::TypeInformation
eProsima_user_DllExport TypeInformation(TypeInformation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24640
eprosima::fastdds::dds::xtypes::TypeInformation::TypeInformation
eProsima_user_DllExport TypeInformation(const TypeInformation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24627
eprosima::fastdds::dds::xtypes::TypeObjectHashId
This class represents the union TypeObjectHashId defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:147
eprosima::fastdds::dds::xtypes::TypeObjectHashId::operator!=
eProsima_user_DllExport bool operator!=(const TypeObjectHashId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:281
eprosima::fastdds::dds::xtypes::TypeObjectHashId::hash
eProsima_user_DllExport EquivalenceHash & hash()
This function returns a reference to member hash.
Definition dds_xtypes_typeobject.hpp:368
eprosima::fastdds::dds::xtypes::TypeObjectHashId::hash
eProsima_user_DllExport const EquivalenceHash & hash() const
This function returns a constant reference to member hash.
Definition dds_xtypes_typeobject.hpp:353
eprosima::fastdds::dds::xtypes::TypeObjectHashId::TypeObjectHashId
eProsima_user_DllExport TypeObjectHashId(TypeObjectHashId &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:190
eprosima::fastdds::dds::xtypes::TypeObjectHashId::TypeObjectHashId
eProsima_user_DllExport TypeObjectHashId()
Default constructor.
Definition dds_xtypes_typeobject.hpp:153
eprosima::fastdds::dds::xtypes::TypeObjectHashId::_default
void _default()
Definition dds_xtypes_typeobject.hpp:379
eprosima::fastdds::dds::xtypes::TypeObjectHashId::hash
eProsima_user_DllExport void hash(const EquivalenceHash &_hash)
This function copies the value in member hash.
Definition dds_xtypes_typeobject.hpp:330
eprosima::fastdds::dds::xtypes::TypeObjectHashId::~TypeObjectHashId
eProsima_user_DllExport ~TypeObjectHashId()
Default destructor.
Definition dds_xtypes_typeobject.hpp:160
eprosima::fastdds::dds::xtypes::TypeObjectHashId::TypeObjectHashId
eProsima_user_DllExport TypeObjectHashId(const TypeObjectHashId &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:172
eprosima::fastdds::dds::xtypes::TypeObjectHashId::operator==
eProsima_user_DllExport bool operator==(const TypeObjectHashId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:248
eprosima::fastdds::dds::xtypes::TypeObjectHashId::hash
eProsima_user_DllExport void hash(EquivalenceHash &&_hash)
This function moves the value in member hash.
Definition dds_xtypes_typeobject.hpp:341
eprosima::fastdds::dds::xtypes::TypeObjectHashId::operator=
eProsima_user_DllExport TypeObjectHashId & operator=(const TypeObjectHashId &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:208
eprosima::fastdds::dds::xtypes::TypeObjectHashId::_d
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:292
eprosima::fastdds::dds::xtypes::TypeObjectHashId::_d
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:321
eprosima::fastdds::dds::xtypes::TypeObjectHashId::m_hash
EquivalenceHash m_hash
Definition dds_xtypes_typeobject.hpp:419
eprosima::fastdds::dds::xtypes::TypeObject
This class represents the union TypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23463
eprosima::fastdds::dds::xtypes::TypeObject::minimal
eProsima_user_DllExport const MinimalTypeObject & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23748
eprosima::fastdds::dds::xtypes::TypeObject::complete
eProsima_user_DllExport void complete(CompleteTypeObject &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:23683
eprosima::fastdds::dds::xtypes::TypeObject::operator!=
eProsima_user_DllExport bool operator!=(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23617
eprosima::fastdds::dds::xtypes::TypeObject::TypeObject
eProsima_user_DllExport TypeObject(const TypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23488
eprosima::fastdds::dds::xtypes::TypeObject::complete
eProsima_user_DllExport CompleteTypeObject & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:23710
eprosima::fastdds::dds::xtypes::TypeObject::~TypeObject
eProsima_user_DllExport ~TypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23476
eprosima::fastdds::dds::xtypes::TypeObject::TypeObject
eProsima_user_DllExport TypeObject(TypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23510
eprosima::fastdds::dds::xtypes::TypeObject::minimal
eProsima_user_DllExport void minimal(const MinimalTypeObject &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23725
eprosima::fastdds::dds::xtypes::TypeObject::minimal
eProsima_user_DllExport MinimalTypeObject & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23763
eprosima::fastdds::dds::xtypes::TypeObject::_default
void _default()
Definition dds_xtypes_typeobject.hpp:23774
eprosima::fastdds::dds::xtypes::TypeObject::operator=
eProsima_user_DllExport TypeObject & operator=(const TypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23532
eprosima::fastdds::dds::xtypes::TypeObject::complete
eProsima_user_DllExport const CompleteTypeObject & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:23695
eprosima::fastdds::dds::xtypes::TypeObject::m_minimal
MinimalTypeObject m_minimal
Definition dds_xtypes_typeobject.hpp:23835
eprosima::fastdds::dds::xtypes::TypeObject::minimal
eProsima_user_DllExport void minimal(MinimalTypeObject &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23736
eprosima::fastdds::dds::xtypes::TypeObject::m_complete
CompleteTypeObject m_complete
Definition dds_xtypes_typeobject.hpp:23834
eprosima::fastdds::dds::xtypes::TypeObject::_d
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:23628
eprosima::fastdds::dds::xtypes::TypeObject::_d
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:23663
eprosima::fastdds::dds::xtypes::TypeObject::TypeObject
eProsima_user_DllExport TypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23469
eprosima::fastdds::dds::xtypes::TypeObject::complete
eProsima_user_DllExport void complete(const CompleteTypeObject &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:23672
eprosima::fastdds::dds::xtypes::TypeObject::operator==
eProsima_user_DllExport bool operator==(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23580
eprosima::fastdds::dds::xtypes::TypeFlagBits
TypeFlagBits
This enumeration represents the TypeFlag bitflags defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:465
eprosima::fastdds::dds::xtypes::MemberFlagBits
MemberFlagBits
This enumeration represents the MemberFlag bitflags defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:431
eprosima::fastdds::dds::xtypes::IS_FINAL
@ IS_FINAL
Definition dds_xtypes_typeobject.hpp:466
eprosima::fastdds::dds::xtypes::IS_MUTABLE
@ IS_MUTABLE
Definition dds_xtypes_typeobject.hpp:468
eprosima::fastdds::dds::xtypes::IS_NESTED
@ IS_NESTED
Definition dds_xtypes_typeobject.hpp:469
eprosima::fastdds::dds::xtypes::IS_APPENDABLE
@ IS_APPENDABLE
Definition dds_xtypes_typeobject.hpp:467
eprosima::fastdds::dds::xtypes::IS_AUTOID_HASH
@ IS_AUTOID_HASH
Definition dds_xtypes_typeobject.hpp:470
eprosima::fastdds::dds::xtypes::IS_MUST_UNDERSTAND
@ IS_MUST_UNDERSTAND
Definition dds_xtypes_typeobject.hpp:436
eprosima::fastdds::dds::xtypes::TRY_CONSTRUCT1
@ TRY_CONSTRUCT1
Definition dds_xtypes_typeobject.hpp:432
eprosima::fastdds::dds::xtypes::TRY_CONSTRUCT2
@ TRY_CONSTRUCT2
Definition dds_xtypes_typeobject.hpp:433
eprosima::fastdds::dds::xtypes::IS_KEY
@ IS_KEY
Definition dds_xtypes_typeobject.hpp:437
eprosima::fastdds::dds::xtypes::IS_EXTERNAL
@ IS_EXTERNAL
Definition dds_xtypes_typeobject.hpp:434
eprosima::fastdds::dds::xtypes::IS_DEFAULT
@ IS_DEFAULT
Definition dds_xtypes_typeobject.hpp:438
eprosima::fastdds::dds::xtypes::IS_OPTIONAL
@ IS_OPTIONAL
Definition dds_xtypes_typeobject.hpp:435
eprosima::fastdds::dds::xtypes
Definition QosPolicies.hpp:2491
eprosima::fastdds::dds::xtypes::BitsetMemberFlag
MemberFlag BitsetMemberFlag
Definition dds_xtypes_typeobject.hpp:457
eprosima::fastdds::dds::xtypes::MinimalBitfieldSeq
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition dds_xtypes_typeobject.hpp:19986
eprosima::fastdds::dds::xtypes::MemberId
uint32_t MemberId
Definition dds_xtypes_typeobject.hpp:4237
eprosima::fastdds::dds::xtypes::TK_STRING16
const uint8_t TK_STRING16
Definition dds_xtypes_typeobject.hpp:96
eprosima::fastdds::dds::xtypes::TI_STRONGLY_CONNECTED_COMPONENT
const uint8_t TI_STRONGLY_CONNECTED_COMPONENT
Definition dds_xtypes_typeobject.hpp:119
eprosima::fastdds::dds::xtypes::CollectionElementFlag
MemberFlag CollectionElementFlag
Definition dds_xtypes_typeobject.hpp:441
eprosima::fastdds::dds::xtypes::TI_PLAIN_SEQUENCE_SMALL
const uint8_t TI_PLAIN_SEQUENCE_SMALL
Definition dds_xtypes_typeobject.hpp:113
eprosima::fastdds::dds::xtypes::TypeObjectSeq
std::vector< TypeObject > TypeObjectSeq
Definition dds_xtypes_typeobject.hpp:23842
eprosima::fastdds::dds::xtypes::TypeIdentifierWithDependenciesSeq
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition dds_xtypes_typeobject.hpp:24599
eprosima::fastdds::dds::xtypes::TK_CHAR8
const uint8_t TK_CHAR8
Definition dds_xtypes_typeobject.hpp:93
eprosima::fastdds::dds::xtypes::TI_PLAIN_MAP_SMALL
const uint8_t TI_PLAIN_MAP_SMALL
Definition dds_xtypes_typeobject.hpp:117
eprosima::fastdds::dds::xtypes::TI_STRING8_LARGE
const uint8_t TI_STRING8_LARGE
Definition dds_xtypes_typeobject.hpp:110
eprosima::fastdds::dds::xtypes::TK_BYTE
const uint8_t TK_BYTE
Definition dds_xtypes_typeobject.hpp:81
eprosima::fastdds::dds::xtypes::CompleteUnionMemberSeq
std::vector< CompleteUnionMember > CompleteUnionMemberSeq
Definition dds_xtypes_typeobject.hpp:9748
eprosima::fastdds::dds::xtypes::AppliedAnnotationSeq
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition dds_xtypes_typeobject.hpp:6589
eprosima::fastdds::dds::xtypes::TypeIdentifierPairSeq
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition dds_xtypes_typeobject.hpp:24208
eprosima::fastdds::dds::xtypes::BitsetTypeFlag
TypeFlag BitsetTypeFlag
Definition dds_xtypes_typeobject.hpp:487
eprosima::fastdds::dds::xtypes::TK_INT8
const uint8_t TK_INT8
Definition dds_xtypes_typeobject.hpp:91
eprosima::fastdds::dds::xtypes::CompleteEnumeratedLiteralSeq
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition dds_xtypes_typeobject.hpp:17191
eprosima::fastdds::dds::xtypes::MemberFlagMinimalMask
const uint16_t MemberFlagMinimalMask
Definition dds_xtypes_typeobject.hpp:459
eprosima::fastdds::dds::xtypes::TK_UINT16
const uint8_t TK_UINT16
Definition dds_xtypes_typeobject.hpp:85
eprosima::fastdds::dds::xtypes::CollectionTypeFlag
TypeFlag CollectionTypeFlag
Definition dds_xtypes_typeobject.hpp:477
eprosima::fastdds::dds::xtypes::TK_UINT32
const uint8_t TK_UINT32
Definition dds_xtypes_typeobject.hpp:86
eprosima::fastdds::dds::xtypes::MinimalStructMemberSeq
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition dds_xtypes_typeobject.hpp:8031
eprosima::fastdds::dds::xtypes::EnumTypeFlag
TypeFlag EnumTypeFlag
Definition dds_xtypes_typeobject.hpp:483
eprosima::fastdds::dds::xtypes::LBoundSeq
std::vector< LBound > LBoundSeq
Definition dds_xtypes_typeobject.hpp:134
eprosima::fastdds::dds::xtypes::MinimalEnumeratedLiteralSeq
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition dds_xtypes_typeobject.hpp:17373
eprosima::fastdds::dds::xtypes::LBound
uint32_t LBound
Definition dds_xtypes_typeobject.hpp:132
eprosima::fastdds::dds::xtypes::QualifiedTypeName
eprosima::fastcdr::fixed_string< TYPE_NAME_MAX_LENGTH > QualifiedTypeName
Definition dds_xtypes_typeobject.hpp:124
eprosima::fastdds::dds::xtypes::EnumeratedLiteralFlag
MemberFlag EnumeratedLiteralFlag
Definition dds_xtypes_typeobject.hpp:449
eprosima::fastdds::dds::xtypes::TK_ENUM
const uint8_t TK_ENUM
Definition dds_xtypes_typeobject.hpp:98
eprosima::fastdds::dds::xtypes::AliasTypeFlag
TypeFlag AliasTypeFlag
Definition dds_xtypes_typeobject.hpp:481
eprosima::fastdds::dds::xtypes::TypeFlagMinimalMask
const uint16_t TypeFlagMinimalMask
Definition dds_xtypes_typeobject.hpp:489
eprosima::fastdds::dds::xtypes::EK_COMPLETE
const uint8_t EK_COMPLETE
Definition dds_xtypes_typeobject.hpp:75
eprosima::fastdds::dds::xtypes::UnionDiscriminatorFlag
MemberFlag UnionDiscriminatorFlag
Definition dds_xtypes_typeobject.hpp:447
eprosima::fastdds::dds::xtypes::EquivalenceKind
uint8_t EquivalenceKind
Definition dds_xtypes_typeobject.hpp:72
eprosima::fastdds::dds::xtypes::UnionTypeFlag
TypeFlag UnionTypeFlag
Definition dds_xtypes_typeobject.hpp:475
eprosima::fastdds::dds::xtypes::MinimalUnionMemberSeq
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition dds_xtypes_typeobject.hpp:9930
eprosima::fastdds::dds::xtypes::TK_FLOAT64
const uint8_t TK_FLOAT64
Definition dds_xtypes_typeobject.hpp:89
eprosima::fastdds::dds::xtypes::TK_UINT8
const uint8_t TK_UINT8
Definition dds_xtypes_typeobject.hpp:92
eprosima::fastdds::dds::xtypes::TK_UINT64
const uint8_t TK_UINT64
Definition dds_xtypes_typeobject.hpp:87
eprosima::fastdds::dds::xtypes::SBoundSeq
std::vector< SBound > SBoundSeq
Definition dds_xtypes_typeobject.hpp:139
eprosima::fastdds::dds::xtypes::TK_NONE
const uint8_t TK_NONE
Definition dds_xtypes_typeobject.hpp:79
eprosima::fastdds::dds::xtypes::EK_MINIMAL
const uint8_t EK_MINIMAL
Definition dds_xtypes_typeobject.hpp:74
eprosima::fastdds::dds::xtypes::StructTypeFlag
TypeFlag StructTypeFlag
Definition dds_xtypes_typeobject.hpp:473
eprosima::fastdds::dds::xtypes::TI_PLAIN_MAP_LARGE
const uint8_t TI_PLAIN_MAP_LARGE
Definition dds_xtypes_typeobject.hpp:118
eprosima::fastdds::dds::xtypes::TypeIdentfierWithSizeSeq
std::vector< TypeIdentfierWithSize > TypeIdentfierWithSizeSeq
Definition dds_xtypes_typeobject.hpp:24380
eprosima::fastdds::dds::xtypes::AppliedAnnotationParameterSeq
std::vector< AppliedAnnotationParameter > AppliedAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:6407
eprosima::fastdds::dds::xtypes::TK_UNION
const uint8_t TK_UNION
Definition dds_xtypes_typeobject.hpp:102
eprosima::fastdds::dds::xtypes::MemberName
eprosima::fastcdr::fixed_string< MEMBER_NAME_MAX_LENGTH > MemberName
Definition dds_xtypes_typeobject.hpp:121
eprosima::fastdds::dds::xtypes::TypeIdentifierSeq
std::vector< TypeIdentifier > TypeIdentifierSeq
Definition dds_xtypes_typeobject.hpp:4235
eprosima::fastdds::dds::xtypes::MinimalAnnotationParameterSeq
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:11922
eprosima::fastdds::dds::xtypes::TI_PLAIN_ARRAY_LARGE
const uint8_t TI_PLAIN_ARRAY_LARGE
Definition dds_xtypes_typeobject.hpp:116
eprosima::fastdds::dds::xtypes::TK_MAP
const uint8_t TK_MAP
Definition dds_xtypes_typeobject.hpp:106
eprosima::fastdds::dds::xtypes::MinimalBitflagSeq
std::vector< MinimalBitflag > MinimalBitflagSeq
Definition dds_xtypes_typeobject.hpp:18797
eprosima::fastdds::dds::xtypes::NameHash
std::array< uint8_t, 4 > NameHash
Definition dds_xtypes_typeobject.hpp:130
eprosima::fastdds::dds::xtypes::StructMemberFlag
MemberFlag StructMemberFlag
Definition dds_xtypes_typeobject.hpp:443
eprosima::fastdds::dds::xtypes::EquivalenceHash
std::array< uint8_t, 14 > EquivalenceHash
Definition dds_xtypes_typeobject.hpp:128
eprosima::fastdds::dds::xtypes::TK_FLOAT128
const uint8_t TK_FLOAT128
Definition dds_xtypes_typeobject.hpp:90
eprosima::fastdds::dds::xtypes::TK_INT32
const uint8_t TK_INT32
Definition dds_xtypes_typeobject.hpp:83
eprosima::fastdds::dds::xtypes::CompleteBitfieldSeq
std::vector< CompleteBitfield > CompleteBitfieldSeq
Definition dds_xtypes_typeobject.hpp:19804
eprosima::fastdds::dds::xtypes::TK_ARRAY
const uint8_t TK_ARRAY
Definition dds_xtypes_typeobject.hpp:105
eprosima::fastdds::dds::xtypes::BitmaskTypeFlag
TypeFlag BitmaskTypeFlag
Definition dds_xtypes_typeobject.hpp:485
eprosima::fastdds::dds::xtypes::TI_PLAIN_SEQUENCE_LARGE
const uint8_t TI_PLAIN_SEQUENCE_LARGE
Definition dds_xtypes_typeobject.hpp:114
eprosima::fastdds::dds::xtypes::ANNOTATION_OCTETSEC_VALUE_MAX_LEN
const uint32_t ANNOTATION_OCTETSEC_VALUE_MAX_LEN
Definition dds_xtypes_typeobject.hpp:4240
eprosima::fastdds::dds::xtypes::TK_CHAR16
const uint8_t TK_CHAR16
Definition dds_xtypes_typeobject.hpp:94
eprosima::fastdds::dds::xtypes::MinimalBitmaskHeader
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18924
eprosima::fastdds::dds::xtypes::UnionCaseLabelSeq
std::vector< int32_t > UnionCaseLabelSeq
Definition dds_xtypes_typeobject.hpp:9302
eprosima::fastdds::dds::xtypes::UnionMemberFlag
MemberFlag UnionMemberFlag
Definition dds_xtypes_typeobject.hpp:445
eprosima::fastdds::dds::xtypes::AnnotationTypeFlag
TypeFlag AnnotationTypeFlag
Definition dds_xtypes_typeobject.hpp:479
eprosima::fastdds::dds::xtypes::TK_INT16
const uint8_t TK_INT16
Definition dds_xtypes_typeobject.hpp:82
eprosima::fastdds::dds::xtypes::TypeIdentifierTypeObjectPairSeq
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition dds_xtypes_typeobject.hpp:24026
eprosima::fastdds::dds::xtypes::TK_BOOLEAN
const uint8_t TK_BOOLEAN
Definition dds_xtypes_typeobject.hpp:80
eprosima::fastdds::dds::xtypes::INVALID_LBOUND
const LBound INVALID_LBOUND
Definition dds_xtypes_typeobject.hpp:136
eprosima::fastdds::dds::xtypes::INVALID_SBOUND
const SBound INVALID_SBOUND
Definition dds_xtypes_typeobject.hpp:141
eprosima::fastdds::dds::xtypes::TI_STRING16_SMALL
const uint8_t TI_STRING16_SMALL
Definition dds_xtypes_typeobject.hpp:111
eprosima::fastdds::dds::xtypes::BitBound
uint16_t BitBound
Definition dds_xtypes_typeobject.hpp:16839
eprosima::fastdds::dds::xtypes::AliasMemberFlag
MemberFlag AliasMemberFlag
Definition dds_xtypes_typeobject.hpp:453
eprosima::fastdds::dds::xtypes::TypeIdentiferKind
uint8_t TypeIdentiferKind
Definition dds_xtypes_typeobject.hpp:107
eprosima::fastdds::dds::xtypes::ANNOTATION_STR_VALUE_MAX_LEN
const uint32_t ANNOTATION_STR_VALUE_MAX_LEN
Definition dds_xtypes_typeobject.hpp:4239
eprosima::fastdds::dds::xtypes::TK_ALIAS
const uint8_t TK_ALIAS
Definition dds_xtypes_typeobject.hpp:97
eprosima::fastdds::dds::xtypes::PrimitiveTypeId
uint8_t PrimitiveTypeId
Definition dds_xtypes_typeobject.hpp:126
eprosima::fastdds::dds::xtypes::EK_BOTH
const uint8_t EK_BOTH
Definition dds_xtypes_typeobject.hpp:76
eprosima::fastdds::dds::xtypes::TypeInformationSeq
std::vector< TypeInformation > TypeInformationSeq
Definition dds_xtypes_typeobject.hpp:24781
eprosima::fastdds::dds::xtypes::TI_PLAIN_ARRAY_SMALL
const uint8_t TI_PLAIN_ARRAY_SMALL
Definition dds_xtypes_typeobject.hpp:115
eprosima::fastdds::dds::xtypes::CompleteBitflagSeq
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition dds_xtypes_typeobject.hpp:18615
eprosima::fastdds::dds::xtypes::TK_BITSET
const uint8_t TK_BITSET
Definition dds_xtypes_typeobject.hpp:103
eprosima::fastdds::dds::xtypes::TK_STRUCTURE
const uint8_t TK_STRUCTURE
Definition dds_xtypes_typeobject.hpp:101
eprosima::fastdds::dds::xtypes::CompleteAnnotationParameterSeq
std::vector< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:11693
eprosima::fastdds::dds::xtypes::BitflagFlag
MemberFlag BitflagFlag
Definition dds_xtypes_typeobject.hpp:455
eprosima::fastdds::dds::xtypes::TK_SEQUENCE
const uint8_t TK_SEQUENCE
Definition dds_xtypes_typeobject.hpp:104
eprosima::fastdds::dds::xtypes::TK_FLOAT32
const uint8_t TK_FLOAT32
Definition dds_xtypes_typeobject.hpp:88
eprosima::fastdds::dds::xtypes::MemberFlag
uint16_t MemberFlag
Definition dds_xtypes_typeobject.hpp:440
eprosima::fastdds::dds::xtypes::TK_ANNOTATION
const uint8_t TK_ANNOTATION
Definition dds_xtypes_typeobject.hpp:100
eprosima::fastdds::dds::xtypes::TK_STRING8
const uint8_t TK_STRING8
Definition dds_xtypes_typeobject.hpp:95
eprosima::fastdds::dds::xtypes::AnnotationParameterFlag
MemberFlag AnnotationParameterFlag
Definition dds_xtypes_typeobject.hpp:451
eprosima::fastdds::dds::xtypes::TypeFlag
uint16_t TypeFlag
Definition dds_xtypes_typeobject.hpp:472
eprosima::fastdds::dds::xtypes::TK_BITMASK
const uint8_t TK_BITMASK
Definition dds_xtypes_typeobject.hpp:99
eprosima::fastdds::dds::xtypes::CompleteBitmaskHeader
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18922
eprosima::fastdds::dds::xtypes::StronglyConnectedComponent
TypeObjectSeq StronglyConnectedComponent
Definition dds_xtypes_typeobject.hpp:23844
eprosima::fastdds::dds::xtypes::TI_STRING16_LARGE
const uint8_t TI_STRING16_LARGE
Definition dds_xtypes_typeobject.hpp:112
eprosima::fastdds::dds::xtypes::CompleteStructMemberSeq
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition dds_xtypes_typeobject.hpp:7849
eprosima::fastdds::dds::xtypes::TYPE_NAME_MAX_LENGTH
const int32_t TYPE_NAME_MAX_LENGTH
Definition dds_xtypes_typeobject.hpp:123
eprosima::fastdds::dds::xtypes::MEMBER_NAME_MAX_LENGTH
const int32_t MEMBER_NAME_MAX_LENGTH
Definition dds_xtypes_typeobject.hpp:120
eprosima::fastdds::dds::xtypes::TK_INT64
const uint8_t TK_INT64
Definition dds_xtypes_typeobject.hpp:84
eprosima::fastdds::dds::xtypes::TypeKind
uint8_t TypeKind
Definition dds_xtypes_typeobject.hpp:77
eprosima::fastdds::dds::xtypes::TI_STRING8_SMALL
const uint8_t TI_STRING8_SMALL
Definition dds_xtypes_typeobject.hpp:109
eprosima::fastdds::dds::xtypes::SBound
uint8_t SBound
Definition dds_xtypes_typeobject.hpp:137
eprosima::fastdds::dds
Definition BuiltinTopicKey.hpp:26
eprosima::fastdds
eprosima
eProsima namespace.