Fast DDS  Version 3.0.1
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
22#ifndef FAST_DDS_GENERATED__EPROSIMA_FASTDDS_DDS_XTYPES_DDS_XTYPES_TYPEOBJECT_HPP
23#define FAST_DDS_GENERATED__EPROSIMA_FASTDDS_DDS_XTYPES_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
62namespace eprosima {
63
64namespace fastdds {
65
66namespace dds {
67
68
69namespace xtypes {
70
71
72typedef uint8_t EquivalenceKind;
73
74const uint8_t EK_MINIMAL = 0xF1;
75const uint8_t EK_COMPLETE = 0xF2;
76const uint8_t EK_BOTH = 0xF3;
77typedef uint8_t TypeKind;
78
79const uint8_t TK_NONE = 0x00;
80const uint8_t TK_BOOLEAN = 0x01;
81const uint8_t TK_BYTE = 0x02;
82const uint8_t TK_INT16 = 0x03;
83const uint8_t TK_INT32 = 0x04;
84const uint8_t TK_INT64 = 0x05;
85const uint8_t TK_UINT16 = 0x06;
86const uint8_t TK_UINT32 = 0x07;
87const uint8_t TK_UINT64 = 0x08;
88const uint8_t TK_FLOAT32 = 0x09;
89const uint8_t TK_FLOAT64 = 0x0A;
90const uint8_t TK_FLOAT128 = 0x0B;
91const uint8_t TK_INT8 = 0x0C;
92const uint8_t TK_UINT8 = 0x0D;
93const uint8_t TK_CHAR8 = 0x10;
94const uint8_t TK_CHAR16 = 0x11;
95const uint8_t TK_STRING8 = 0x20;
96const uint8_t TK_STRING16 = 0x21;
97const uint8_t TK_ALIAS = 0x30;
98const uint8_t TK_ENUM = 0x40;
99const uint8_t TK_BITMASK = 0x41;
100const uint8_t TK_ANNOTATION = 0x50;
101const uint8_t TK_STRUCTURE = 0x51;
102const uint8_t TK_UNION = 0x52;
103const uint8_t TK_BITSET = 0x53;
104const uint8_t TK_SEQUENCE = 0x60;
105const uint8_t TK_ARRAY = 0x61;
106const uint8_t TK_MAP = 0x62;
107typedef uint8_t TypeIdentiferKind;
108
109const uint8_t TI_STRING8_SMALL = 0x70;
110const uint8_t TI_STRING8_LARGE = 0x71;
111const uint8_t TI_STRING16_SMALL = 0x72;
112const uint8_t TI_STRING16_LARGE = 0x73;
113const uint8_t TI_PLAIN_SEQUENCE_SMALL = 0x80;
114const uint8_t TI_PLAIN_SEQUENCE_LARGE = 0x81;
115const uint8_t TI_PLAIN_ARRAY_SMALL = 0x90;
116const uint8_t TI_PLAIN_ARRAY_LARGE = 0x91;
117const uint8_t TI_PLAIN_MAP_SMALL = 0xA0;
118const uint8_t TI_PLAIN_MAP_LARGE = 0xA1;
120const int32_t MEMBER_NAME_MAX_LENGTH = 256;
121typedef eprosima::fastcdr::fixed_string<MEMBER_NAME_MAX_LENGTH> MemberName;
122
123const int32_t TYPE_NAME_MAX_LENGTH = 256;
124typedef eprosima::fastcdr::fixed_string<TYPE_NAME_MAX_LENGTH> QualifiedTypeName;
125
126typedef uint8_t PrimitiveTypeId;
127
128typedef std::array<uint8_t, 14> EquivalenceHash;
129
130typedef std::array<uint8_t, 4> NameHash;
131
132typedef uint32_t LBound;
133
134typedef std::vector<LBound> LBoundSeq;
135
137typedef uint8_t SBound;
138
139typedef std::vector<SBound> SBoundSeq;
140
147{
148public:
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 (m__d == x.m__d &&
254 selected_member_ == x.selected_member_)
255 {
256 switch (selected_member_)
257 {
258 case 0x00000001:
259 ret_value = (m_hash == x.m_hash);
260 break;
261
262 }
263 }
264
265 return ret_value;
266 }
267
272 eProsima_user_DllExport bool operator !=(
273 const TypeObjectHashId& x) const
274 {
275 return !(*this == x);
276 }
277
283 eProsima_user_DllExport void _d(
284 uint8_t __d)
285 {
286 bool valid_discriminator = false;
287
288 switch (__d)
289 {
290 case EK_COMPLETE:
291 case EK_MINIMAL:
292 if (0x00000001 == selected_member_)
293 {
294 valid_discriminator = true;
295 }
296 break;
297
298 }
299
300 if (!valid_discriminator)
301 {
302 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
303 }
304
305 m__d = __d;
306 }
307
312 eProsima_user_DllExport uint8_t _d() const
313 {
314 return m__d;
315 }
316
321 eProsima_user_DllExport void hash(
322 const EquivalenceHash& _hash)
323 {
324 hash_() = _hash;
325 m__d = EK_COMPLETE;
326 }
327
332 eProsima_user_DllExport void hash(
333 EquivalenceHash&& _hash)
334 {
335 hash_() = _hash;
336 m__d = EK_COMPLETE;
337 }
338
344 eProsima_user_DllExport const EquivalenceHash& hash() const
345 {
346 if (0x00000001 != selected_member_)
347 {
348 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
349 }
350
351 return m_hash;
352 }
353
359 eProsima_user_DllExport EquivalenceHash& hash()
360 {
361 if (0x00000001 != selected_member_)
362 {
363 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
364 }
365
366 return m_hash;
367 }
368
369
370 void _default()
371 {
372 if (member_destructor_)
373 {
374 member_destructor_();
375 }
376
377 selected_member_ = 0x0FFFFFFFu;
378 }
379
380
381private:
382
383 EquivalenceHash& hash_()
384 {
385 if (0x00000001 != selected_member_)
386 {
387 if (member_destructor_)
388 {
389 member_destructor_();
390 }
391
392 selected_member_ = 0x00000001;
393 member_destructor_ = [&]() {m_hash.~EquivalenceHash();};
394 new(&m_hash) EquivalenceHash();
395
396 }
397
398 return m_hash;
399 }
400
401
402 uint8_t m__d {127};
403
404 union
405 {
407 };
408
409 uint32_t selected_member_ {0x0FFFFFFFu};
410
411 std::function<void()> member_destructor_;
412};
417enum MemberFlagBits : uint16_t
418{
419 TRY_CONSTRUCT1 = 0x01ull << 0,
420 TRY_CONSTRUCT2 = 0x01ull << 1,
421 IS_EXTERNAL = 0x01ull << 2,
422 IS_OPTIONAL = 0x01ull << 3,
423 IS_MUST_UNDERSTAND = 0x01ull << 4,
424 IS_KEY = 0x01ull << 5,
425 IS_DEFAULT = 0x01ull << 6
427typedef uint16_t MemberFlag;
429
431
433
435
437
439
441
443
445
446const uint16_t MemberFlagMinimalMask = 0x003f;
451enum TypeFlagBits : uint16_t
452{
453 IS_FINAL = 0x01ull << 0,
454 IS_APPENDABLE = 0x01ull << 1,
455 IS_MUTABLE = 0x01ull << 2,
456 IS_NESTED = 0x01ull << 3,
457 IS_AUTOID_HASH = 0x01ull << 4
459typedef uint16_t TypeFlag;
461
463
465
467
469
471
473
475
476const uint16_t TypeFlagMinimalMask = 0x0007;
477class TypeIdentifier;
478
484{
485public:
486
490 eProsima_user_DllExport StringSTypeDefn()
491 {
492 }
493
497 eProsima_user_DllExport ~StringSTypeDefn()
498 {
499 }
500
505 eProsima_user_DllExport StringSTypeDefn(
506 const StringSTypeDefn& x)
507 {
508 m_bound = x.m_bound;
509
510 }
511
516 eProsima_user_DllExport StringSTypeDefn(
517 StringSTypeDefn&& x) noexcept
518 {
519 m_bound = x.m_bound;
520 }
521
526 eProsima_user_DllExport StringSTypeDefn& operator =(
527 const StringSTypeDefn& x)
528 {
529
530 m_bound = x.m_bound;
531
532 return *this;
533 }
534
539 eProsima_user_DllExport StringSTypeDefn& operator =(
540 StringSTypeDefn&& x) noexcept
541 {
542
543 m_bound = x.m_bound;
544 return *this;
545 }
546
551 eProsima_user_DllExport bool operator ==(
552 const StringSTypeDefn& x) const
553 {
554 return (m_bound == x.m_bound);
555 }
556
561 eProsima_user_DllExport bool operator !=(
562 const StringSTypeDefn& x) const
563 {
564 return !(*this == x);
565 }
566
571 eProsima_user_DllExport void bound(
572 SBound _bound)
573 {
574 m_bound = _bound;
575 }
576
581 eProsima_user_DllExport SBound bound() const
582 {
583 return m_bound;
584 }
585
590 eProsima_user_DllExport SBound& bound()
591 {
592 return m_bound;
593 }
594
595
596
597private:
598
599 SBound m_bound{0};
600
601};
607{
608public:
609
613 eProsima_user_DllExport StringLTypeDefn()
614 {
615 }
616
620 eProsima_user_DllExport ~StringLTypeDefn()
621 {
622 }
623
628 eProsima_user_DllExport StringLTypeDefn(
629 const StringLTypeDefn& x)
630 {
631 m_bound = x.m_bound;
632
633 }
634
639 eProsima_user_DllExport StringLTypeDefn(
640 StringLTypeDefn&& x) noexcept
641 {
642 m_bound = x.m_bound;
643 }
644
649 eProsima_user_DllExport StringLTypeDefn& operator =(
650 const StringLTypeDefn& x)
651 {
652
653 m_bound = x.m_bound;
654
655 return *this;
656 }
657
662 eProsima_user_DllExport StringLTypeDefn& operator =(
663 StringLTypeDefn&& x) noexcept
664 {
665
666 m_bound = x.m_bound;
667 return *this;
668 }
669
674 eProsima_user_DllExport bool operator ==(
675 const StringLTypeDefn& x) const
676 {
677 return (m_bound == x.m_bound);
678 }
679
684 eProsima_user_DllExport bool operator !=(
685 const StringLTypeDefn& x) const
686 {
687 return !(*this == x);
688 }
689
694 eProsima_user_DllExport void bound(
695 LBound _bound)
696 {
697 m_bound = _bound;
698 }
699
704 eProsima_user_DllExport LBound bound() const
705 {
706 return m_bound;
707 }
708
713 eProsima_user_DllExport LBound& bound()
714 {
715 return m_bound;
716 }
717
718
719
720private:
721
722 LBound m_bound{0};
723
724};
730{
731public:
732
736 eProsima_user_DllExport PlainCollectionHeader()
737 {
738 }
739
743 eProsima_user_DllExport ~PlainCollectionHeader()
744 {
745 }
746
751 eProsima_user_DllExport PlainCollectionHeader(
752 const PlainCollectionHeader& x)
753 {
754 m_equiv_kind = x.m_equiv_kind;
755
756 m_element_flags = x.m_element_flags;
757
758 }
759
764 eProsima_user_DllExport PlainCollectionHeader(
765 PlainCollectionHeader&& x) noexcept
766 {
767 m_equiv_kind = x.m_equiv_kind;
768 m_element_flags = std::move(x.m_element_flags);
769 }
770
775 eProsima_user_DllExport PlainCollectionHeader& operator =(
776 const PlainCollectionHeader& x)
777 {
778
779 m_equiv_kind = x.m_equiv_kind;
780
781 m_element_flags = x.m_element_flags;
782
783 return *this;
784 }
785
790 eProsima_user_DllExport PlainCollectionHeader& operator =(
791 PlainCollectionHeader&& x) noexcept
792 {
793
794 m_equiv_kind = x.m_equiv_kind;
795 m_element_flags = std::move(x.m_element_flags);
796 return *this;
797 }
798
803 eProsima_user_DllExport bool operator ==(
804 const PlainCollectionHeader& x) const
805 {
806 return (m_equiv_kind == x.m_equiv_kind &&
807 m_element_flags == x.m_element_flags);
808 }
809
814 eProsima_user_DllExport bool operator !=(
815 const PlainCollectionHeader& x) const
816 {
817 return !(*this == x);
818 }
819
824 eProsima_user_DllExport void equiv_kind(
825 EquivalenceKind _equiv_kind)
826 {
827 m_equiv_kind = _equiv_kind;
828 }
829
834 eProsima_user_DllExport EquivalenceKind equiv_kind() const
835 {
836 return m_equiv_kind;
837 }
838
843 eProsima_user_DllExport EquivalenceKind& equiv_kind()
844 {
845 return m_equiv_kind;
846 }
847
848
853 eProsima_user_DllExport void element_flags(
854 const CollectionElementFlag& _element_flags)
855 {
856 m_element_flags = _element_flags;
857 }
858
863 eProsima_user_DllExport void element_flags(
864 CollectionElementFlag&& _element_flags)
865 {
866 m_element_flags = std::move(_element_flags);
867 }
868
873 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
874 {
875 return m_element_flags;
876 }
877
882 eProsima_user_DllExport CollectionElementFlag& element_flags()
883 {
884 return m_element_flags;
885 }
886
887
888
889private:
890
891 EquivalenceKind m_equiv_kind{0};
892 CollectionElementFlag m_element_flags{0};
893
894};
900{
901public:
902
906 eProsima_user_DllExport PlainSequenceSElemDefn()
907 {
908 }
909
913 eProsima_user_DllExport ~PlainSequenceSElemDefn()
914 {
915 }
916
921 eProsima_user_DllExport PlainSequenceSElemDefn(
922 const PlainSequenceSElemDefn& x)
923 {
924 m_header = x.m_header;
925
926 m_bound = x.m_bound;
927
928 m_element_identifier = x.m_element_identifier;
929
930 }
931
936 eProsima_user_DllExport PlainSequenceSElemDefn(
937 PlainSequenceSElemDefn&& x) noexcept
938 {
939 m_header = std::move(x.m_header);
940 m_bound = x.m_bound;
941 m_element_identifier = std::move(x.m_element_identifier);
942 }
943
948 eProsima_user_DllExport PlainSequenceSElemDefn& operator =(
949 const PlainSequenceSElemDefn& x)
950 {
951
952 m_header = x.m_header;
953
954 m_bound = x.m_bound;
955
956 m_element_identifier = x.m_element_identifier;
957
958 return *this;
959 }
960
965 eProsima_user_DllExport PlainSequenceSElemDefn& operator =(
966 PlainSequenceSElemDefn&& x) noexcept
967 {
968
969 m_header = std::move(x.m_header);
970 m_bound = x.m_bound;
971 m_element_identifier = std::move(x.m_element_identifier);
972 return *this;
973 }
974
979 eProsima_user_DllExport bool operator ==(
980 const PlainSequenceSElemDefn& x) const
981 {
982 return (m_header == x.m_header &&
983 m_bound == x.m_bound &&
984 m_element_identifier == x.m_element_identifier);
985 }
986
991 eProsima_user_DllExport bool operator !=(
992 const PlainSequenceSElemDefn& x) const
993 {
994 return !(*this == x);
995 }
996
1001 eProsima_user_DllExport void header(
1002 const PlainCollectionHeader& _header)
1003 {
1004 m_header = _header;
1005 }
1006
1011 eProsima_user_DllExport void header(
1012 PlainCollectionHeader&& _header)
1013 {
1014 m_header = std::move(_header);
1015 }
1016
1021 eProsima_user_DllExport const PlainCollectionHeader& header() const
1022 {
1023 return m_header;
1024 }
1025
1030 eProsima_user_DllExport PlainCollectionHeader& header()
1031 {
1032 return m_header;
1033 }
1034
1035
1040 eProsima_user_DllExport void bound(
1041 SBound _bound)
1042 {
1043 m_bound = _bound;
1044 }
1045
1050 eProsima_user_DllExport SBound bound() const
1051 {
1052 return m_bound;
1053 }
1054
1059 eProsima_user_DllExport SBound& bound()
1060 {
1061 return m_bound;
1062 }
1063
1064
1069 eProsima_user_DllExport void element_identifier(
1070 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1071 {
1072 m_element_identifier = _element_identifier;
1073 }
1074
1079 eProsima_user_DllExport void element_identifier(
1080 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1081 {
1082 m_element_identifier = std::move(_element_identifier);
1083 }
1084
1089 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1090 {
1091 return m_element_identifier;
1092 }
1093
1098 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1099 {
1100 return m_element_identifier;
1101 }
1102
1103
1104
1105private:
1106
1107 PlainCollectionHeader m_header;
1108 SBound m_bound{0};
1109 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1110
1111};
1117{
1118public:
1119
1123 eProsima_user_DllExport PlainSequenceLElemDefn()
1124 {
1125 }
1126
1130 eProsima_user_DllExport ~PlainSequenceLElemDefn()
1131 {
1132 }
1133
1138 eProsima_user_DllExport PlainSequenceLElemDefn(
1139 const PlainSequenceLElemDefn& x)
1140 {
1141 m_header = x.m_header;
1142
1143 m_bound = x.m_bound;
1144
1145 m_element_identifier = x.m_element_identifier;
1146
1147 }
1148
1153 eProsima_user_DllExport PlainSequenceLElemDefn(
1154 PlainSequenceLElemDefn&& x) noexcept
1155 {
1156 m_header = std::move(x.m_header);
1157 m_bound = x.m_bound;
1158 m_element_identifier = std::move(x.m_element_identifier);
1159 }
1160
1165 eProsima_user_DllExport PlainSequenceLElemDefn& operator =(
1166 const PlainSequenceLElemDefn& x)
1167 {
1168
1169 m_header = x.m_header;
1170
1171 m_bound = x.m_bound;
1172
1173 m_element_identifier = x.m_element_identifier;
1174
1175 return *this;
1176 }
1177
1182 eProsima_user_DllExport PlainSequenceLElemDefn& operator =(
1183 PlainSequenceLElemDefn&& x) noexcept
1184 {
1185
1186 m_header = std::move(x.m_header);
1187 m_bound = x.m_bound;
1188 m_element_identifier = std::move(x.m_element_identifier);
1189 return *this;
1190 }
1191
1196 eProsima_user_DllExport bool operator ==(
1197 const PlainSequenceLElemDefn& x) const
1198 {
1199 return (m_header == x.m_header &&
1200 m_bound == x.m_bound &&
1201 m_element_identifier == x.m_element_identifier);
1202 }
1203
1208 eProsima_user_DllExport bool operator !=(
1209 const PlainSequenceLElemDefn& x) const
1210 {
1211 return !(*this == x);
1212 }
1213
1218 eProsima_user_DllExport void header(
1219 const PlainCollectionHeader& _header)
1220 {
1221 m_header = _header;
1222 }
1223
1228 eProsima_user_DllExport void header(
1229 PlainCollectionHeader&& _header)
1230 {
1231 m_header = std::move(_header);
1232 }
1233
1238 eProsima_user_DllExport const PlainCollectionHeader& header() const
1239 {
1240 return m_header;
1241 }
1242
1247 eProsima_user_DllExport PlainCollectionHeader& header()
1248 {
1249 return m_header;
1250 }
1251
1252
1257 eProsima_user_DllExport void bound(
1258 LBound _bound)
1259 {
1260 m_bound = _bound;
1261 }
1262
1267 eProsima_user_DllExport LBound bound() const
1268 {
1269 return m_bound;
1270 }
1271
1276 eProsima_user_DllExport LBound& bound()
1277 {
1278 return m_bound;
1279 }
1280
1281
1286 eProsima_user_DllExport void element_identifier(
1287 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1288 {
1289 m_element_identifier = _element_identifier;
1290 }
1291
1296 eProsima_user_DllExport void element_identifier(
1297 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1298 {
1299 m_element_identifier = std::move(_element_identifier);
1300 }
1301
1306 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1307 {
1308 return m_element_identifier;
1309 }
1310
1315 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1316 {
1317 return m_element_identifier;
1318 }
1319
1320
1321
1322private:
1323
1324 PlainCollectionHeader m_header;
1325 LBound m_bound{0};
1326 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1327
1328};
1334{
1335public:
1336
1340 eProsima_user_DllExport PlainArraySElemDefn()
1341 {
1342 }
1343
1347 eProsima_user_DllExport ~PlainArraySElemDefn()
1348 {
1349 }
1350
1355 eProsima_user_DllExport PlainArraySElemDefn(
1356 const PlainArraySElemDefn& x)
1357 {
1358 m_header = x.m_header;
1359
1360 m_array_bound_seq = x.m_array_bound_seq;
1361
1362 m_element_identifier = x.m_element_identifier;
1363
1364 }
1365
1370 eProsima_user_DllExport PlainArraySElemDefn(
1371 PlainArraySElemDefn&& x) noexcept
1372 {
1373 m_header = std::move(x.m_header);
1374 m_array_bound_seq = std::move(x.m_array_bound_seq);
1375 m_element_identifier = std::move(x.m_element_identifier);
1376 }
1377
1382 eProsima_user_DllExport PlainArraySElemDefn& operator =(
1383 const PlainArraySElemDefn& x)
1384 {
1385
1386 m_header = x.m_header;
1387
1388 m_array_bound_seq = x.m_array_bound_seq;
1389
1390 m_element_identifier = x.m_element_identifier;
1391
1392 return *this;
1393 }
1394
1399 eProsima_user_DllExport PlainArraySElemDefn& operator =(
1400 PlainArraySElemDefn&& x) noexcept
1401 {
1402
1403 m_header = std::move(x.m_header);
1404 m_array_bound_seq = std::move(x.m_array_bound_seq);
1405 m_element_identifier = std::move(x.m_element_identifier);
1406 return *this;
1407 }
1408
1413 eProsima_user_DllExport bool operator ==(
1414 const PlainArraySElemDefn& x) const
1415 {
1416 return (m_header == x.m_header &&
1417 m_array_bound_seq == x.m_array_bound_seq &&
1418 m_element_identifier == x.m_element_identifier);
1419 }
1420
1425 eProsima_user_DllExport bool operator !=(
1426 const PlainArraySElemDefn& x) const
1427 {
1428 return !(*this == x);
1429 }
1430
1435 eProsima_user_DllExport void header(
1436 const PlainCollectionHeader& _header)
1437 {
1438 m_header = _header;
1439 }
1440
1445 eProsima_user_DllExport void header(
1446 PlainCollectionHeader&& _header)
1447 {
1448 m_header = std::move(_header);
1449 }
1450
1455 eProsima_user_DllExport const PlainCollectionHeader& header() const
1456 {
1457 return m_header;
1458 }
1459
1464 eProsima_user_DllExport PlainCollectionHeader& header()
1465 {
1466 return m_header;
1467 }
1468
1469
1474 eProsima_user_DllExport void array_bound_seq(
1475 const SBoundSeq& _array_bound_seq)
1476 {
1477 m_array_bound_seq = _array_bound_seq;
1478 }
1479
1484 eProsima_user_DllExport void array_bound_seq(
1485 SBoundSeq&& _array_bound_seq)
1486 {
1487 m_array_bound_seq = std::move(_array_bound_seq);
1488 }
1489
1494 eProsima_user_DllExport const SBoundSeq& array_bound_seq() const
1495 {
1496 return m_array_bound_seq;
1497 }
1498
1503 eProsima_user_DllExport SBoundSeq& array_bound_seq()
1504 {
1505 return m_array_bound_seq;
1506 }
1507
1508
1513 eProsima_user_DllExport void element_identifier(
1514 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1515 {
1516 m_element_identifier = _element_identifier;
1517 }
1518
1523 eProsima_user_DllExport void element_identifier(
1524 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1525 {
1526 m_element_identifier = std::move(_element_identifier);
1527 }
1528
1533 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1534 {
1535 return m_element_identifier;
1536 }
1537
1542 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1543 {
1544 return m_element_identifier;
1545 }
1546
1547
1548
1549private:
1550
1551 PlainCollectionHeader m_header;
1552 SBoundSeq m_array_bound_seq;
1553 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1554
1555};
1561{
1562public:
1563
1567 eProsima_user_DllExport PlainArrayLElemDefn()
1568 {
1569 }
1570
1574 eProsima_user_DllExport ~PlainArrayLElemDefn()
1575 {
1576 }
1577
1582 eProsima_user_DllExport PlainArrayLElemDefn(
1583 const PlainArrayLElemDefn& x)
1584 {
1585 m_header = x.m_header;
1586
1587 m_array_bound_seq = x.m_array_bound_seq;
1588
1589 m_element_identifier = x.m_element_identifier;
1590
1591 }
1592
1597 eProsima_user_DllExport PlainArrayLElemDefn(
1598 PlainArrayLElemDefn&& x) noexcept
1599 {
1600 m_header = std::move(x.m_header);
1601 m_array_bound_seq = std::move(x.m_array_bound_seq);
1602 m_element_identifier = std::move(x.m_element_identifier);
1603 }
1604
1609 eProsima_user_DllExport PlainArrayLElemDefn& operator =(
1610 const PlainArrayLElemDefn& x)
1611 {
1612
1613 m_header = x.m_header;
1614
1615 m_array_bound_seq = x.m_array_bound_seq;
1616
1617 m_element_identifier = x.m_element_identifier;
1618
1619 return *this;
1620 }
1621
1626 eProsima_user_DllExport PlainArrayLElemDefn& operator =(
1627 PlainArrayLElemDefn&& x) noexcept
1628 {
1629
1630 m_header = std::move(x.m_header);
1631 m_array_bound_seq = std::move(x.m_array_bound_seq);
1632 m_element_identifier = std::move(x.m_element_identifier);
1633 return *this;
1634 }
1635
1640 eProsima_user_DllExport bool operator ==(
1641 const PlainArrayLElemDefn& x) const
1642 {
1643 return (m_header == x.m_header &&
1644 m_array_bound_seq == x.m_array_bound_seq &&
1645 m_element_identifier == x.m_element_identifier);
1646 }
1647
1652 eProsima_user_DllExport bool operator !=(
1653 const PlainArrayLElemDefn& x) const
1654 {
1655 return !(*this == x);
1656 }
1657
1662 eProsima_user_DllExport void header(
1663 const PlainCollectionHeader& _header)
1664 {
1665 m_header = _header;
1666 }
1667
1672 eProsima_user_DllExport void header(
1673 PlainCollectionHeader&& _header)
1674 {
1675 m_header = std::move(_header);
1676 }
1677
1682 eProsima_user_DllExport const PlainCollectionHeader& header() const
1683 {
1684 return m_header;
1685 }
1686
1691 eProsima_user_DllExport PlainCollectionHeader& header()
1692 {
1693 return m_header;
1694 }
1695
1696
1701 eProsima_user_DllExport void array_bound_seq(
1702 const LBoundSeq& _array_bound_seq)
1703 {
1704 m_array_bound_seq = _array_bound_seq;
1705 }
1706
1711 eProsima_user_DllExport void array_bound_seq(
1712 LBoundSeq&& _array_bound_seq)
1713 {
1714 m_array_bound_seq = std::move(_array_bound_seq);
1715 }
1716
1721 eProsima_user_DllExport const LBoundSeq& array_bound_seq() const
1722 {
1723 return m_array_bound_seq;
1724 }
1725
1730 eProsima_user_DllExport LBoundSeq& array_bound_seq()
1731 {
1732 return m_array_bound_seq;
1733 }
1734
1735
1740 eProsima_user_DllExport void element_identifier(
1741 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1742 {
1743 m_element_identifier = _element_identifier;
1744 }
1745
1750 eProsima_user_DllExport void element_identifier(
1751 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1752 {
1753 m_element_identifier = std::move(_element_identifier);
1754 }
1755
1760 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1761 {
1762 return m_element_identifier;
1763 }
1764
1769 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1770 {
1771 return m_element_identifier;
1772 }
1773
1774
1775
1776private:
1777
1778 PlainCollectionHeader m_header;
1779 LBoundSeq m_array_bound_seq;
1780 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1781
1782};
1788{
1789public:
1790
1794 eProsima_user_DllExport PlainMapSTypeDefn()
1795 {
1796 }
1797
1801 eProsima_user_DllExport ~PlainMapSTypeDefn()
1802 {
1803 }
1804
1809 eProsima_user_DllExport PlainMapSTypeDefn(
1810 const PlainMapSTypeDefn& x)
1811 {
1812 m_header = x.m_header;
1813
1814 m_bound = x.m_bound;
1815
1816 m_element_identifier = x.m_element_identifier;
1817
1818 m_key_flags = x.m_key_flags;
1819
1820 m_key_identifier = x.m_key_identifier;
1821
1822 }
1823
1828 eProsima_user_DllExport PlainMapSTypeDefn(
1829 PlainMapSTypeDefn&& x) noexcept
1830 {
1831 m_header = std::move(x.m_header);
1832 m_bound = x.m_bound;
1833 m_element_identifier = std::move(x.m_element_identifier);
1834 m_key_flags = std::move(x.m_key_flags);
1835 m_key_identifier = std::move(x.m_key_identifier);
1836 }
1837
1842 eProsima_user_DllExport PlainMapSTypeDefn& operator =(
1843 const PlainMapSTypeDefn& x)
1844 {
1845
1846 m_header = x.m_header;
1847
1848 m_bound = x.m_bound;
1849
1850 m_element_identifier = x.m_element_identifier;
1851
1852 m_key_flags = x.m_key_flags;
1853
1854 m_key_identifier = x.m_key_identifier;
1855
1856 return *this;
1857 }
1858
1863 eProsima_user_DllExport PlainMapSTypeDefn& operator =(
1864 PlainMapSTypeDefn&& x) noexcept
1865 {
1866
1867 m_header = std::move(x.m_header);
1868 m_bound = x.m_bound;
1869 m_element_identifier = std::move(x.m_element_identifier);
1870 m_key_flags = std::move(x.m_key_flags);
1871 m_key_identifier = std::move(x.m_key_identifier);
1872 return *this;
1873 }
1874
1879 eProsima_user_DllExport bool operator ==(
1880 const PlainMapSTypeDefn& x) const
1881 {
1882 return (m_header == x.m_header &&
1883 m_bound == x.m_bound &&
1884 m_element_identifier == x.m_element_identifier &&
1885 m_key_flags == x.m_key_flags &&
1886 m_key_identifier == x.m_key_identifier);
1887 }
1888
1893 eProsima_user_DllExport bool operator !=(
1894 const PlainMapSTypeDefn& x) const
1895 {
1896 return !(*this == x);
1897 }
1898
1903 eProsima_user_DllExport void header(
1904 const PlainCollectionHeader& _header)
1905 {
1906 m_header = _header;
1907 }
1908
1913 eProsima_user_DllExport void header(
1914 PlainCollectionHeader&& _header)
1915 {
1916 m_header = std::move(_header);
1917 }
1918
1923 eProsima_user_DllExport const PlainCollectionHeader& header() const
1924 {
1925 return m_header;
1926 }
1927
1932 eProsima_user_DllExport PlainCollectionHeader& header()
1933 {
1934 return m_header;
1935 }
1936
1937
1942 eProsima_user_DllExport void bound(
1943 SBound _bound)
1944 {
1945 m_bound = _bound;
1946 }
1947
1952 eProsima_user_DllExport SBound bound() const
1953 {
1954 return m_bound;
1955 }
1956
1961 eProsima_user_DllExport SBound& bound()
1962 {
1963 return m_bound;
1964 }
1965
1966
1971 eProsima_user_DllExport void element_identifier(
1972 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1973 {
1974 m_element_identifier = _element_identifier;
1975 }
1976
1981 eProsima_user_DllExport void element_identifier(
1982 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1983 {
1984 m_element_identifier = std::move(_element_identifier);
1985 }
1986
1991 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1992 {
1993 return m_element_identifier;
1994 }
1995
2000 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
2001 {
2002 return m_element_identifier;
2003 }
2004
2005
2010 eProsima_user_DllExport void key_flags(
2011 const CollectionElementFlag& _key_flags)
2012 {
2013 m_key_flags = _key_flags;
2014 }
2015
2020 eProsima_user_DllExport void key_flags(
2021 CollectionElementFlag&& _key_flags)
2022 {
2023 m_key_flags = std::move(_key_flags);
2024 }
2025
2030 eProsima_user_DllExport const CollectionElementFlag& key_flags() const
2031 {
2032 return m_key_flags;
2033 }
2034
2039 eProsima_user_DllExport CollectionElementFlag& key_flags()
2040 {
2041 return m_key_flags;
2042 }
2043
2044
2049 eProsima_user_DllExport void key_identifier(
2050 const eprosima::fastcdr::external<TypeIdentifier>& _key_identifier)
2051 {
2052 m_key_identifier = _key_identifier;
2053 }
2054
2059 eProsima_user_DllExport void key_identifier(
2060 eprosima::fastcdr::external<TypeIdentifier>&& _key_identifier)
2061 {
2062 m_key_identifier = std::move(_key_identifier);
2063 }
2064
2069 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& key_identifier() const
2070 {
2071 return m_key_identifier;
2072 }
2073
2078 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& key_identifier()
2079 {
2080 return m_key_identifier;
2081 }
2082
2083
2084
2085private:
2086
2087 PlainCollectionHeader m_header;
2088 SBound m_bound{0};
2089 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
2090 CollectionElementFlag m_key_flags{0};
2091 eprosima::fastcdr::external<TypeIdentifier> m_key_identifier;
2092
2093};
2099{
2100public:
2101
2105 eProsima_user_DllExport PlainMapLTypeDefn()
2106 {
2107 }
2108
2112 eProsima_user_DllExport ~PlainMapLTypeDefn()
2113 {
2114 }
2115
2120 eProsima_user_DllExport PlainMapLTypeDefn(
2121 const PlainMapLTypeDefn& x)
2122 {
2123 m_header = x.m_header;
2124
2125 m_bound = x.m_bound;
2126
2127 m_element_identifier = x.m_element_identifier;
2128
2129 m_key_flags = x.m_key_flags;
2130
2131 m_key_identifier = x.m_key_identifier;
2132
2133 }
2134
2139 eProsima_user_DllExport PlainMapLTypeDefn(
2140 PlainMapLTypeDefn&& x) noexcept
2141 {
2142 m_header = std::move(x.m_header);
2143 m_bound = x.m_bound;
2144 m_element_identifier = std::move(x.m_element_identifier);
2145 m_key_flags = std::move(x.m_key_flags);
2146 m_key_identifier = std::move(x.m_key_identifier);
2147 }
2148
2153 eProsima_user_DllExport PlainMapLTypeDefn& operator =(
2154 const PlainMapLTypeDefn& x)
2155 {
2156
2157 m_header = x.m_header;
2158
2159 m_bound = x.m_bound;
2160
2161 m_element_identifier = x.m_element_identifier;
2162
2163 m_key_flags = x.m_key_flags;
2164
2165 m_key_identifier = x.m_key_identifier;
2166
2167 return *this;
2168 }
2169
2174 eProsima_user_DllExport PlainMapLTypeDefn& operator =(
2175 PlainMapLTypeDefn&& x) noexcept
2176 {
2177
2178 m_header = std::move(x.m_header);
2179 m_bound = x.m_bound;
2180 m_element_identifier = std::move(x.m_element_identifier);
2181 m_key_flags = std::move(x.m_key_flags);
2182 m_key_identifier = std::move(x.m_key_identifier);
2183 return *this;
2184 }
2185
2190 eProsima_user_DllExport bool operator ==(
2191 const PlainMapLTypeDefn& x) const
2192 {
2193 return (m_header == x.m_header &&
2194 m_bound == x.m_bound &&
2195 m_element_identifier == x.m_element_identifier &&
2196 m_key_flags == x.m_key_flags &&
2197 m_key_identifier == x.m_key_identifier);
2198 }
2199
2204 eProsima_user_DllExport bool operator !=(
2205 const PlainMapLTypeDefn& x) const
2206 {
2207 return !(*this == x);
2208 }
2209
2214 eProsima_user_DllExport void header(
2215 const PlainCollectionHeader& _header)
2216 {
2217 m_header = _header;
2218 }
2219
2224 eProsima_user_DllExport void header(
2225 PlainCollectionHeader&& _header)
2226 {
2227 m_header = std::move(_header);
2228 }
2229
2234 eProsima_user_DllExport const PlainCollectionHeader& header() const
2235 {
2236 return m_header;
2237 }
2238
2243 eProsima_user_DllExport PlainCollectionHeader& header()
2244 {
2245 return m_header;
2246 }
2247
2248
2253 eProsima_user_DllExport void bound(
2254 LBound _bound)
2255 {
2256 m_bound = _bound;
2257 }
2258
2263 eProsima_user_DllExport LBound bound() const
2264 {
2265 return m_bound;
2266 }
2267
2272 eProsima_user_DllExport LBound& bound()
2273 {
2274 return m_bound;
2275 }
2276
2277
2282 eProsima_user_DllExport void element_identifier(
2283 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
2284 {
2285 m_element_identifier = _element_identifier;
2286 }
2287
2292 eProsima_user_DllExport void element_identifier(
2293 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
2294 {
2295 m_element_identifier = std::move(_element_identifier);
2296 }
2297
2302 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
2303 {
2304 return m_element_identifier;
2305 }
2306
2311 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
2312 {
2313 return m_element_identifier;
2314 }
2315
2316
2321 eProsima_user_DllExport void key_flags(
2322 const CollectionElementFlag& _key_flags)
2323 {
2324 m_key_flags = _key_flags;
2325 }
2326
2331 eProsima_user_DllExport void key_flags(
2332 CollectionElementFlag&& _key_flags)
2333 {
2334 m_key_flags = std::move(_key_flags);
2335 }
2336
2341 eProsima_user_DllExport const CollectionElementFlag& key_flags() const
2342 {
2343 return m_key_flags;
2344 }
2345
2350 eProsima_user_DllExport CollectionElementFlag& key_flags()
2351 {
2352 return m_key_flags;
2353 }
2354
2355
2360 eProsima_user_DllExport void key_identifier(
2361 const eprosima::fastcdr::external<TypeIdentifier>& _key_identifier)
2362 {
2363 m_key_identifier = _key_identifier;
2364 }
2365
2370 eProsima_user_DllExport void key_identifier(
2371 eprosima::fastcdr::external<TypeIdentifier>&& _key_identifier)
2372 {
2373 m_key_identifier = std::move(_key_identifier);
2374 }
2375
2380 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& key_identifier() const
2381 {
2382 return m_key_identifier;
2383 }
2384
2389 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& key_identifier()
2390 {
2391 return m_key_identifier;
2392 }
2393
2394
2395
2396private:
2397
2398 PlainCollectionHeader m_header;
2399 LBound m_bound{0};
2400 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
2401 CollectionElementFlag m_key_flags{0};
2402 eprosima::fastcdr::external<TypeIdentifier> m_key_identifier;
2403
2404};
2410{
2411public:
2412
2416 eProsima_user_DllExport StronglyConnectedComponentId()
2417 {
2418 }
2419
2423 eProsima_user_DllExport ~StronglyConnectedComponentId()
2424 {
2425 }
2426
2431 eProsima_user_DllExport StronglyConnectedComponentId(
2433 {
2434 m_sc_component_id = x.m_sc_component_id;
2435
2436 m_scc_length = x.m_scc_length;
2437
2438 m_scc_index = x.m_scc_index;
2439
2440 }
2441
2446 eProsima_user_DllExport StronglyConnectedComponentId(
2447 StronglyConnectedComponentId&& x) noexcept
2448 {
2449 m_sc_component_id = std::move(x.m_sc_component_id);
2450 m_scc_length = x.m_scc_length;
2451 m_scc_index = x.m_scc_index;
2452 }
2453
2460 {
2461
2462 m_sc_component_id = x.m_sc_component_id;
2463
2464 m_scc_length = x.m_scc_length;
2465
2466 m_scc_index = x.m_scc_index;
2467
2468 return *this;
2469 }
2470
2476 StronglyConnectedComponentId&& x) noexcept
2477 {
2478
2479 m_sc_component_id = std::move(x.m_sc_component_id);
2480 m_scc_length = x.m_scc_length;
2481 m_scc_index = x.m_scc_index;
2482 return *this;
2483 }
2484
2489 eProsima_user_DllExport bool operator ==(
2490 const StronglyConnectedComponentId& x) const
2491 {
2492 return (m_sc_component_id == x.m_sc_component_id &&
2493 m_scc_length == x.m_scc_length &&
2494 m_scc_index == x.m_scc_index);
2495 }
2496
2501 eProsima_user_DllExport bool operator !=(
2502 const StronglyConnectedComponentId& x) const
2503 {
2504 return !(*this == x);
2505 }
2506
2511 eProsima_user_DllExport void sc_component_id(
2512 const TypeObjectHashId& _sc_component_id)
2513 {
2514 m_sc_component_id = _sc_component_id;
2515 }
2516
2521 eProsima_user_DllExport void sc_component_id(
2522 TypeObjectHashId&& _sc_component_id)
2523 {
2524 m_sc_component_id = std::move(_sc_component_id);
2525 }
2526
2531 eProsima_user_DllExport const TypeObjectHashId& sc_component_id() const
2532 {
2533 return m_sc_component_id;
2534 }
2535
2540 eProsima_user_DllExport TypeObjectHashId& sc_component_id()
2541 {
2542 return m_sc_component_id;
2543 }
2544
2545
2550 eProsima_user_DllExport void scc_length(
2551 int32_t _scc_length)
2552 {
2553 m_scc_length = _scc_length;
2554 }
2555
2560 eProsima_user_DllExport int32_t scc_length() const
2561 {
2562 return m_scc_length;
2563 }
2564
2569 eProsima_user_DllExport int32_t& scc_length()
2570 {
2571 return m_scc_length;
2572 }
2573
2574
2579 eProsima_user_DllExport void scc_index(
2580 int32_t _scc_index)
2581 {
2582 m_scc_index = _scc_index;
2583 }
2584
2589 eProsima_user_DllExport int32_t scc_index() const
2590 {
2591 return m_scc_index;
2592 }
2593
2598 eProsima_user_DllExport int32_t& scc_index()
2599 {
2600 return m_scc_index;
2601 }
2602
2603
2604
2605private:
2606
2607 TypeObjectHashId m_sc_component_id;
2608 int32_t m_scc_length{0};
2609 int32_t m_scc_index{0};
2610
2611};
2617{
2618public:
2619
2623 eProsima_user_DllExport ExtendedTypeDefn()
2624 {
2625 }
2626
2630 eProsima_user_DllExport ~ExtendedTypeDefn()
2631 {
2632 }
2633
2638 eProsima_user_DllExport ExtendedTypeDefn(
2639 const ExtendedTypeDefn& x)
2640 {
2641 static_cast<void>(x);
2642 }
2643
2648 eProsima_user_DllExport ExtendedTypeDefn(
2649 ExtendedTypeDefn&& x) noexcept
2650 {
2651 static_cast<void>(x);
2652 }
2653
2658 eProsima_user_DllExport ExtendedTypeDefn& operator =(
2659 const ExtendedTypeDefn& x)
2660 {
2661
2662 static_cast<void>(x);
2663
2664 return *this;
2665 }
2666
2671 eProsima_user_DllExport ExtendedTypeDefn& operator =(
2672 ExtendedTypeDefn&& x) noexcept
2673 {
2674
2675 static_cast<void>(x);
2676
2677 return *this;
2678 }
2679
2684 eProsima_user_DllExport bool operator ==(
2685 const ExtendedTypeDefn& x) const
2686 {
2687 static_cast<void>(x);
2688 return true;
2689 }
2690
2695 eProsima_user_DllExport bool operator !=(
2696 const ExtendedTypeDefn& x) const
2697 {
2698 return !(*this == x);
2699 }
2700
2701
2702
2703private:
2704
2705
2706};
2712{
2713public:
2714
2718 eProsima_user_DllExport Dummy()
2719 {
2720 }
2721
2725 eProsima_user_DllExport ~Dummy()
2726 {
2727 }
2728
2733 eProsima_user_DllExport Dummy(
2734 const Dummy& x)
2735 {
2736 static_cast<void>(x);
2737 }
2738
2743 eProsima_user_DllExport Dummy(
2744 Dummy&& x) noexcept
2745 {
2746 static_cast<void>(x);
2747 }
2748
2753 eProsima_user_DllExport Dummy& operator =(
2754 const Dummy& x)
2755 {
2756
2757 static_cast<void>(x);
2758
2759 return *this;
2760 }
2761
2766 eProsima_user_DllExport Dummy& operator =(
2767 Dummy&& x) noexcept
2768 {
2769
2770 static_cast<void>(x);
2771
2772 return *this;
2773 }
2774
2779 eProsima_user_DllExport bool operator ==(
2780 const Dummy& x) const
2781 {
2782 static_cast<void>(x);
2783 return true;
2784 }
2785
2790 eProsima_user_DllExport bool operator !=(
2791 const Dummy& x) const
2792 {
2793 return !(*this == x);
2794 }
2795
2796
2797
2798private:
2799
2800
2801};
2807{
2808public:
2809
2813 eProsima_user_DllExport TypeIdentifier()
2814 {
2815 selected_member_ = 0x00000001;
2816 member_destructor_ = [&]() {m_no_value.~Dummy();};
2817 new(&m_no_value) Dummy();
2818
2819 }
2820
2824 eProsima_user_DllExport ~TypeIdentifier()
2825 {
2826 if (member_destructor_)
2827 {
2828 member_destructor_();
2829 }
2830 }
2831
2836 eProsima_user_DllExport TypeIdentifier(
2837 const TypeIdentifier& x)
2838 {
2839 m__d = x.m__d;
2840
2841 switch (x.selected_member_)
2842 {
2843 case 0x00000001:
2844 no_value_() = x.m_no_value;
2845 break;
2846
2847 case 0x00000002:
2848 string_sdefn_() = x.m_string_sdefn;
2849 break;
2850
2851 case 0x00000003:
2852 string_ldefn_() = x.m_string_ldefn;
2853 break;
2854
2855 case 0x00000004:
2856 seq_sdefn_() = x.m_seq_sdefn;
2857 break;
2858
2859 case 0x00000005:
2860 seq_ldefn_() = x.m_seq_ldefn;
2861 break;
2862
2863 case 0x00000006:
2864 array_sdefn_() = x.m_array_sdefn;
2865 break;
2866
2867 case 0x00000007:
2868 array_ldefn_() = x.m_array_ldefn;
2869 break;
2870
2871 case 0x00000008:
2872 map_sdefn_() = x.m_map_sdefn;
2873 break;
2874
2875 case 0x00000009:
2876 map_ldefn_() = x.m_map_ldefn;
2877 break;
2878
2879 case 0x0000000a:
2880 sc_component_id_() = x.m_sc_component_id;
2881 break;
2882
2883 case 0x0000000b:
2884 equivalence_hash_() = x.m_equivalence_hash;
2885 break;
2886
2887 case 0x0000000c:
2888 extended_defn_() = x.m_extended_defn;
2889 break;
2890
2891 }
2892 }
2893
2898 eProsima_user_DllExport TypeIdentifier(
2899 TypeIdentifier&& x) noexcept
2900 {
2901 m__d = x.m__d;
2902
2903 switch (x.selected_member_)
2904 {
2905 case 0x00000001:
2906 no_value_() = std::move(x.m_no_value);
2907 break;
2908
2909 case 0x00000002:
2910 string_sdefn_() = std::move(x.m_string_sdefn);
2911 break;
2912
2913 case 0x00000003:
2914 string_ldefn_() = std::move(x.m_string_ldefn);
2915 break;
2916
2917 case 0x00000004:
2918 seq_sdefn_() = std::move(x.m_seq_sdefn);
2919 break;
2920
2921 case 0x00000005:
2922 seq_ldefn_() = std::move(x.m_seq_ldefn);
2923 break;
2924
2925 case 0x00000006:
2926 array_sdefn_() = std::move(x.m_array_sdefn);
2927 break;
2928
2929 case 0x00000007:
2930 array_ldefn_() = std::move(x.m_array_ldefn);
2931 break;
2932
2933 case 0x00000008:
2934 map_sdefn_() = std::move(x.m_map_sdefn);
2935 break;
2936
2937 case 0x00000009:
2938 map_ldefn_() = std::move(x.m_map_ldefn);
2939 break;
2940
2941 case 0x0000000a:
2942 sc_component_id_() = std::move(x.m_sc_component_id);
2943 break;
2944
2945 case 0x0000000b:
2946 equivalence_hash_() = std::move(x.m_equivalence_hash);
2947 break;
2948
2949 case 0x0000000c:
2950 extended_defn_() = std::move(x.m_extended_defn);
2951 break;
2952
2953 }
2954 }
2955
2960 eProsima_user_DllExport TypeIdentifier& operator =(
2961 const TypeIdentifier& x)
2962 {
2963 m__d = x.m__d;
2964
2965 switch (x.selected_member_)
2966 {
2967 case 0x00000001:
2968 no_value_() = x.m_no_value;
2969 break;
2970
2971 case 0x00000002:
2972 string_sdefn_() = x.m_string_sdefn;
2973 break;
2974
2975 case 0x00000003:
2976 string_ldefn_() = x.m_string_ldefn;
2977 break;
2978
2979 case 0x00000004:
2980 seq_sdefn_() = x.m_seq_sdefn;
2981 break;
2982
2983 case 0x00000005:
2984 seq_ldefn_() = x.m_seq_ldefn;
2985 break;
2986
2987 case 0x00000006:
2988 array_sdefn_() = x.m_array_sdefn;
2989 break;
2990
2991 case 0x00000007:
2992 array_ldefn_() = x.m_array_ldefn;
2993 break;
2994
2995 case 0x00000008:
2996 map_sdefn_() = x.m_map_sdefn;
2997 break;
2998
2999 case 0x00000009:
3000 map_ldefn_() = x.m_map_ldefn;
3001 break;
3002
3003 case 0x0000000a:
3004 sc_component_id_() = x.m_sc_component_id;
3005 break;
3006
3007 case 0x0000000b:
3008 equivalence_hash_() = x.m_equivalence_hash;
3009 break;
3010
3011 case 0x0000000c:
3012 extended_defn_() = x.m_extended_defn;
3013 break;
3014
3015 }
3016
3017 return *this;
3018 }
3019
3024 eProsima_user_DllExport TypeIdentifier& operator =(
3025 TypeIdentifier&& x) noexcept
3026 {
3027 m__d = x.m__d;
3028
3029 switch (x.selected_member_)
3030 {
3031 case 0x00000001:
3032 no_value_() = std::move(x.m_no_value);
3033 break;
3034
3035 case 0x00000002:
3036 string_sdefn_() = std::move(x.m_string_sdefn);
3037 break;
3038
3039 case 0x00000003:
3040 string_ldefn_() = std::move(x.m_string_ldefn);
3041 break;
3042
3043 case 0x00000004:
3044 seq_sdefn_() = std::move(x.m_seq_sdefn);
3045 break;
3046
3047 case 0x00000005:
3048 seq_ldefn_() = std::move(x.m_seq_ldefn);
3049 break;
3050
3051 case 0x00000006:
3052 array_sdefn_() = std::move(x.m_array_sdefn);
3053 break;
3054
3055 case 0x00000007:
3056 array_ldefn_() = std::move(x.m_array_ldefn);
3057 break;
3058
3059 case 0x00000008:
3060 map_sdefn_() = std::move(x.m_map_sdefn);
3061 break;
3062
3063 case 0x00000009:
3064 map_ldefn_() = std::move(x.m_map_ldefn);
3065 break;
3066
3067 case 0x0000000a:
3068 sc_component_id_() = std::move(x.m_sc_component_id);
3069 break;
3070
3071 case 0x0000000b:
3072 equivalence_hash_() = std::move(x.m_equivalence_hash);
3073 break;
3074
3075 case 0x0000000c:
3076 extended_defn_() = std::move(x.m_extended_defn);
3077 break;
3078
3079 }
3080
3081 return *this;
3082 }
3083
3088 eProsima_user_DllExport bool operator ==(
3089 const TypeIdentifier& x) const
3090 {
3091 bool ret_value {false};
3092
3093 if (m__d == x.m__d &&
3094 selected_member_ == x.selected_member_)
3095 {
3096 switch (selected_member_)
3097 {
3098 case 0x00000001:
3099 ret_value = (m_no_value == x.m_no_value);
3100 break;
3101
3102 case 0x00000002:
3103 ret_value = (m_string_sdefn == x.m_string_sdefn);
3104 break;
3105
3106 case 0x00000003:
3107 ret_value = (m_string_ldefn == x.m_string_ldefn);
3108 break;
3109
3110 case 0x00000004:
3111 ret_value = (m_seq_sdefn == x.m_seq_sdefn);
3112 break;
3113
3114 case 0x00000005:
3115 ret_value = (m_seq_ldefn == x.m_seq_ldefn);
3116 break;
3117
3118 case 0x00000006:
3119 ret_value = (m_array_sdefn == x.m_array_sdefn);
3120 break;
3121
3122 case 0x00000007:
3123 ret_value = (m_array_ldefn == x.m_array_ldefn);
3124 break;
3125
3126 case 0x00000008:
3127 ret_value = (m_map_sdefn == x.m_map_sdefn);
3128 break;
3129
3130 case 0x00000009:
3131 ret_value = (m_map_ldefn == x.m_map_ldefn);
3132 break;
3133
3134 case 0x0000000a:
3135 ret_value = (m_sc_component_id == x.m_sc_component_id);
3136 break;
3137
3138 case 0x0000000b:
3139 ret_value = (m_equivalence_hash == x.m_equivalence_hash);
3140 break;
3141
3142 case 0x0000000c:
3143 ret_value = (m_extended_defn == x.m_extended_defn);
3144 break;
3145
3146 }
3147 }
3148
3149 return ret_value;
3150 }
3151
3156 eProsima_user_DllExport bool operator !=(
3157 const TypeIdentifier& x) const
3158 {
3159 return !(*this == x);
3160 }
3161
3167 eProsima_user_DllExport void _d(
3168 uint8_t __d)
3169 {
3170 bool valid_discriminator = false;
3171
3172 switch (__d)
3173 {
3174 case TK_NONE:
3175 case TK_BOOLEAN:
3176 case TK_BYTE:
3177 case TK_INT8:
3178 case TK_INT16:
3179 case TK_INT32:
3180 case TK_INT64:
3181 case TK_UINT8:
3182 case TK_UINT16:
3183 case TK_UINT32:
3184 case TK_UINT64:
3185 case TK_FLOAT32:
3186 case TK_FLOAT64:
3187 case TK_FLOAT128:
3188 case TK_CHAR8:
3189 case TK_CHAR16:
3190 if (0x00000001 == selected_member_)
3191 {
3192 valid_discriminator = true;
3193 }
3194 break;
3195
3196 case TI_STRING8_SMALL:
3197 case TI_STRING16_SMALL:
3198 if (0x00000002 == selected_member_)
3199 {
3200 valid_discriminator = true;
3201 }
3202 break;
3203
3204 case TI_STRING8_LARGE:
3205 case TI_STRING16_LARGE:
3206 if (0x00000003 == selected_member_)
3207 {
3208 valid_discriminator = true;
3209 }
3210 break;
3211
3213 if (0x00000004 == selected_member_)
3214 {
3215 valid_discriminator = true;
3216 }
3217 break;
3218
3220 if (0x00000005 == selected_member_)
3221 {
3222 valid_discriminator = true;
3223 }
3224 break;
3225
3227 if (0x00000006 == selected_member_)
3228 {
3229 valid_discriminator = true;
3230 }
3231 break;
3232
3234 if (0x00000007 == selected_member_)
3235 {
3236 valid_discriminator = true;
3237 }
3238 break;
3239
3240 case TI_PLAIN_MAP_SMALL:
3241 if (0x00000008 == selected_member_)
3242 {
3243 valid_discriminator = true;
3244 }
3245 break;
3246
3247 case TI_PLAIN_MAP_LARGE:
3248 if (0x00000009 == selected_member_)
3249 {
3250 valid_discriminator = true;
3251 }
3252 break;
3253
3255 if (0x0000000a == selected_member_)
3256 {
3257 valid_discriminator = true;
3258 }
3259 break;
3260
3261 case EK_COMPLETE:
3262 case EK_MINIMAL:
3263 if (0x0000000b == selected_member_)
3264 {
3265 valid_discriminator = true;
3266 }
3267 break;
3268
3269 default:
3270 if (0x0000000c == selected_member_)
3271 {
3272 valid_discriminator = true;
3273 }
3274 break;
3275
3276 }
3277
3278 if (!valid_discriminator)
3279 {
3280 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
3281 }
3282
3283 m__d = __d;
3284 }
3285
3290 eProsima_user_DllExport uint8_t _d() const
3291 {
3292 return m__d;
3293 }
3294
3299 eProsima_user_DllExport void no_value(
3300 const Dummy& _no_value)
3301 {
3302 no_value_() = _no_value;
3303 m__d = TK_NONE;
3304 }
3305
3310 eProsima_user_DllExport void no_value(
3311 Dummy&& _no_value)
3312 {
3313 no_value_() = _no_value;
3314 m__d = TK_NONE;
3315 }
3316
3322 eProsima_user_DllExport const Dummy& no_value() const
3323 {
3324 if (0x00000001 != selected_member_)
3325 {
3326 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3327 }
3328
3329 return m_no_value;
3330 }
3331
3337 eProsima_user_DllExport Dummy& no_value()
3338 {
3339 if (0x00000001 != selected_member_)
3340 {
3341 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3342 }
3343
3344 return m_no_value;
3345 }
3346
3347
3352 eProsima_user_DllExport void string_sdefn(
3353 const StringSTypeDefn& _string_sdefn)
3354 {
3355 string_sdefn_() = _string_sdefn;
3356 m__d = TI_STRING8_SMALL;
3357 }
3358
3363 eProsima_user_DllExport void string_sdefn(
3364 StringSTypeDefn&& _string_sdefn)
3365 {
3366 string_sdefn_() = _string_sdefn;
3367 m__d = TI_STRING8_SMALL;
3368 }
3369
3375 eProsima_user_DllExport const StringSTypeDefn& string_sdefn() const
3376 {
3377 if (0x00000002 != selected_member_)
3378 {
3379 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3380 }
3381
3382 return m_string_sdefn;
3383 }
3384
3390 eProsima_user_DllExport StringSTypeDefn& string_sdefn()
3391 {
3392 if (0x00000002 != selected_member_)
3393 {
3394 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3395 }
3396
3397 return m_string_sdefn;
3398 }
3399
3400
3405 eProsima_user_DllExport void string_ldefn(
3406 const StringLTypeDefn& _string_ldefn)
3407 {
3408 string_ldefn_() = _string_ldefn;
3409 m__d = TI_STRING8_LARGE;
3410 }
3411
3416 eProsima_user_DllExport void string_ldefn(
3417 StringLTypeDefn&& _string_ldefn)
3418 {
3419 string_ldefn_() = _string_ldefn;
3420 m__d = TI_STRING8_LARGE;
3421 }
3422
3428 eProsima_user_DllExport const StringLTypeDefn& string_ldefn() const
3429 {
3430 if (0x00000003 != selected_member_)
3431 {
3432 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3433 }
3434
3435 return m_string_ldefn;
3436 }
3437
3443 eProsima_user_DllExport StringLTypeDefn& string_ldefn()
3444 {
3445 if (0x00000003 != selected_member_)
3446 {
3447 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3448 }
3449
3450 return m_string_ldefn;
3451 }
3452
3453
3458 eProsima_user_DllExport void seq_sdefn(
3459 const PlainSequenceSElemDefn& _seq_sdefn)
3460 {
3461 seq_sdefn_() = _seq_sdefn;
3463 }
3464
3469 eProsima_user_DllExport void seq_sdefn(
3470 PlainSequenceSElemDefn&& _seq_sdefn)
3471 {
3472 seq_sdefn_() = _seq_sdefn;
3474 }
3475
3481 eProsima_user_DllExport const PlainSequenceSElemDefn& seq_sdefn() const
3482 {
3483 if (0x00000004 != selected_member_)
3484 {
3485 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3486 }
3487
3488 return m_seq_sdefn;
3489 }
3490
3496 eProsima_user_DllExport PlainSequenceSElemDefn& seq_sdefn()
3497 {
3498 if (0x00000004 != selected_member_)
3499 {
3500 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3501 }
3502
3503 return m_seq_sdefn;
3504 }
3505
3506
3511 eProsima_user_DllExport void seq_ldefn(
3512 const PlainSequenceLElemDefn& _seq_ldefn)
3513 {
3514 seq_ldefn_() = _seq_ldefn;
3516 }
3517
3522 eProsima_user_DllExport void seq_ldefn(
3523 PlainSequenceLElemDefn&& _seq_ldefn)
3524 {
3525 seq_ldefn_() = _seq_ldefn;
3527 }
3528
3534 eProsima_user_DllExport const PlainSequenceLElemDefn& seq_ldefn() const
3535 {
3536 if (0x00000005 != selected_member_)
3537 {
3538 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3539 }
3540
3541 return m_seq_ldefn;
3542 }
3543
3549 eProsima_user_DllExport PlainSequenceLElemDefn& seq_ldefn()
3550 {
3551 if (0x00000005 != selected_member_)
3552 {
3553 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3554 }
3555
3556 return m_seq_ldefn;
3557 }
3558
3559
3564 eProsima_user_DllExport void array_sdefn(
3565 const PlainArraySElemDefn& _array_sdefn)
3566 {
3567 array_sdefn_() = _array_sdefn;
3568 m__d = TI_PLAIN_ARRAY_SMALL;
3569 }
3570
3575 eProsima_user_DllExport void array_sdefn(
3576 PlainArraySElemDefn&& _array_sdefn)
3577 {
3578 array_sdefn_() = _array_sdefn;
3579 m__d = TI_PLAIN_ARRAY_SMALL;
3580 }
3581
3587 eProsima_user_DllExport const PlainArraySElemDefn& array_sdefn() const
3588 {
3589 if (0x00000006 != selected_member_)
3590 {
3591 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3592 }
3593
3594 return m_array_sdefn;
3595 }
3596
3602 eProsima_user_DllExport PlainArraySElemDefn& array_sdefn()
3603 {
3604 if (0x00000006 != selected_member_)
3605 {
3606 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3607 }
3608
3609 return m_array_sdefn;
3610 }
3611
3612
3617 eProsima_user_DllExport void array_ldefn(
3618 const PlainArrayLElemDefn& _array_ldefn)
3619 {
3620 array_ldefn_() = _array_ldefn;
3621 m__d = TI_PLAIN_ARRAY_LARGE;
3622 }
3623
3628 eProsima_user_DllExport void array_ldefn(
3629 PlainArrayLElemDefn&& _array_ldefn)
3630 {
3631 array_ldefn_() = _array_ldefn;
3632 m__d = TI_PLAIN_ARRAY_LARGE;
3633 }
3634
3640 eProsima_user_DllExport const PlainArrayLElemDefn& array_ldefn() const
3641 {
3642 if (0x00000007 != selected_member_)
3643 {
3644 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3645 }
3646
3647 return m_array_ldefn;
3648 }
3649
3655 eProsima_user_DllExport PlainArrayLElemDefn& array_ldefn()
3656 {
3657 if (0x00000007 != selected_member_)
3658 {
3659 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3660 }
3661
3662 return m_array_ldefn;
3663 }
3664
3665
3670 eProsima_user_DllExport void map_sdefn(
3671 const PlainMapSTypeDefn& _map_sdefn)
3672 {
3673 map_sdefn_() = _map_sdefn;
3674 m__d = TI_PLAIN_MAP_SMALL;
3675 }
3676
3681 eProsima_user_DllExport void map_sdefn(
3682 PlainMapSTypeDefn&& _map_sdefn)
3683 {
3684 map_sdefn_() = _map_sdefn;
3685 m__d = TI_PLAIN_MAP_SMALL;
3686 }
3687
3693 eProsima_user_DllExport const PlainMapSTypeDefn& map_sdefn() const
3694 {
3695 if (0x00000008 != selected_member_)
3696 {
3697 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3698 }
3699
3700 return m_map_sdefn;
3701 }
3702
3708 eProsima_user_DllExport PlainMapSTypeDefn& map_sdefn()
3709 {
3710 if (0x00000008 != selected_member_)
3711 {
3712 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3713 }
3714
3715 return m_map_sdefn;
3716 }
3717
3718
3723 eProsima_user_DllExport void map_ldefn(
3724 const PlainMapLTypeDefn& _map_ldefn)
3725 {
3726 map_ldefn_() = _map_ldefn;
3727 m__d = TI_PLAIN_MAP_LARGE;
3728 }
3729
3734 eProsima_user_DllExport void map_ldefn(
3735 PlainMapLTypeDefn&& _map_ldefn)
3736 {
3737 map_ldefn_() = _map_ldefn;
3738 m__d = TI_PLAIN_MAP_LARGE;
3739 }
3740
3746 eProsima_user_DllExport const PlainMapLTypeDefn& map_ldefn() const
3747 {
3748 if (0x00000009 != selected_member_)
3749 {
3750 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3751 }
3752
3753 return m_map_ldefn;
3754 }
3755
3761 eProsima_user_DllExport PlainMapLTypeDefn& map_ldefn()
3762 {
3763 if (0x00000009 != selected_member_)
3764 {
3765 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3766 }
3767
3768 return m_map_ldefn;
3769 }
3770
3771
3776 eProsima_user_DllExport void sc_component_id(
3777 const StronglyConnectedComponentId& _sc_component_id)
3778 {
3779 sc_component_id_() = _sc_component_id;
3781 }
3782
3787 eProsima_user_DllExport void sc_component_id(
3788 StronglyConnectedComponentId&& _sc_component_id)
3789 {
3790 sc_component_id_() = _sc_component_id;
3792 }
3793
3799 eProsima_user_DllExport const StronglyConnectedComponentId& sc_component_id() const
3800 {
3801 if (0x0000000a != selected_member_)
3802 {
3803 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3804 }
3805
3806 return m_sc_component_id;
3807 }
3808
3815 {
3816 if (0x0000000a != selected_member_)
3817 {
3818 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3819 }
3820
3821 return m_sc_component_id;
3822 }
3823
3824
3829 eProsima_user_DllExport void equivalence_hash(
3830 const EquivalenceHash& _equivalence_hash)
3831 {
3832 equivalence_hash_() = _equivalence_hash;
3833 m__d = EK_COMPLETE;
3834 }
3835
3840 eProsima_user_DllExport void equivalence_hash(
3841 EquivalenceHash&& _equivalence_hash)
3842 {
3843 equivalence_hash_() = _equivalence_hash;
3844 m__d = EK_COMPLETE;
3845 }
3846
3852 eProsima_user_DllExport const EquivalenceHash& equivalence_hash() const
3853 {
3854 if (0x0000000b != selected_member_)
3855 {
3856 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3857 }
3858
3859 return m_equivalence_hash;
3860 }
3861
3867 eProsima_user_DllExport EquivalenceHash& equivalence_hash()
3868 {
3869 if (0x0000000b != selected_member_)
3870 {
3871 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3872 }
3873
3874 return m_equivalence_hash;
3875 }
3876
3877
3882 eProsima_user_DllExport void extended_defn(
3883 const ExtendedTypeDefn& _extended_defn)
3884 {
3885 extended_defn_() = _extended_defn;
3886 m__d = 127;
3887 }
3888
3893 eProsima_user_DllExport void extended_defn(
3894 ExtendedTypeDefn&& _extended_defn)
3895 {
3896 extended_defn_() = _extended_defn;
3897 m__d = 127;
3898 }
3899
3905 eProsima_user_DllExport const ExtendedTypeDefn& extended_defn() const
3906 {
3907 if (0x0000000c != selected_member_)
3908 {
3909 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3910 }
3911
3912 return m_extended_defn;
3913 }
3914
3920 eProsima_user_DllExport ExtendedTypeDefn& extended_defn()
3921 {
3922 if (0x0000000c != selected_member_)
3923 {
3924 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3925 }
3926
3927 return m_extended_defn;
3928 }
3929
3930
3931
3932private:
3933
3934 Dummy& no_value_()
3935 {
3936 if (0x00000001 != selected_member_)
3937 {
3938 if (member_destructor_)
3939 {
3940 member_destructor_();
3941 }
3942
3943 selected_member_ = 0x00000001;
3944 member_destructor_ = [&]() {m_no_value.~Dummy();};
3945 new(&m_no_value) Dummy();
3946
3947 }
3948
3949 return m_no_value;
3950 }
3951
3952 StringSTypeDefn& string_sdefn_()
3953 {
3954 if (0x00000002 != selected_member_)
3955 {
3956 if (member_destructor_)
3957 {
3958 member_destructor_();
3959 }
3960
3961 selected_member_ = 0x00000002;
3962 member_destructor_ = [&]() {m_string_sdefn.~StringSTypeDefn();};
3963 new(&m_string_sdefn) StringSTypeDefn();
3964
3965 }
3966
3967 return m_string_sdefn;
3968 }
3969
3970 StringLTypeDefn& string_ldefn_()
3971 {
3972 if (0x00000003 != selected_member_)
3973 {
3974 if (member_destructor_)
3975 {
3976 member_destructor_();
3977 }
3978
3979 selected_member_ = 0x00000003;
3980 member_destructor_ = [&]() {m_string_ldefn.~StringLTypeDefn();};
3981 new(&m_string_ldefn) StringLTypeDefn();
3982
3983 }
3984
3985 return m_string_ldefn;
3986 }
3987
3988 PlainSequenceSElemDefn& seq_sdefn_()
3989 {
3990 if (0x00000004 != selected_member_)
3991 {
3992 if (member_destructor_)
3993 {
3994 member_destructor_();
3995 }
3996
3997 selected_member_ = 0x00000004;
3998 member_destructor_ = [&]() {m_seq_sdefn.~PlainSequenceSElemDefn();};
3999 new(&m_seq_sdefn) PlainSequenceSElemDefn();
4000
4001 }
4002
4003 return m_seq_sdefn;
4004 }
4005
4006 PlainSequenceLElemDefn& seq_ldefn_()
4007 {
4008 if (0x00000005 != selected_member_)
4009 {
4010 if (member_destructor_)
4011 {
4012 member_destructor_();
4013 }
4014
4015 selected_member_ = 0x00000005;
4016 member_destructor_ = [&]() {m_seq_ldefn.~PlainSequenceLElemDefn();};
4017 new(&m_seq_ldefn) PlainSequenceLElemDefn();
4018
4019 }
4020
4021 return m_seq_ldefn;
4022 }
4023
4024 PlainArraySElemDefn& array_sdefn_()
4025 {
4026 if (0x00000006 != selected_member_)
4027 {
4028 if (member_destructor_)
4029 {
4030 member_destructor_();
4031 }
4032
4033 selected_member_ = 0x00000006;
4034 member_destructor_ = [&]() {m_array_sdefn.~PlainArraySElemDefn();};
4035 new(&m_array_sdefn) PlainArraySElemDefn();
4036
4037 }
4038
4039 return m_array_sdefn;
4040 }
4041
4042 PlainArrayLElemDefn& array_ldefn_()
4043 {
4044 if (0x00000007 != selected_member_)
4045 {
4046 if (member_destructor_)
4047 {
4048 member_destructor_();
4049 }
4050
4051 selected_member_ = 0x00000007;
4052 member_destructor_ = [&]() {m_array_ldefn.~PlainArrayLElemDefn();};
4053 new(&m_array_ldefn) PlainArrayLElemDefn();
4054
4055 }
4056
4057 return m_array_ldefn;
4058 }
4059
4060 PlainMapSTypeDefn& map_sdefn_()
4061 {
4062 if (0x00000008 != selected_member_)
4063 {
4064 if (member_destructor_)
4065 {
4066 member_destructor_();
4067 }
4068
4069 selected_member_ = 0x00000008;
4070 member_destructor_ = [&]() {m_map_sdefn.~PlainMapSTypeDefn();};
4071 new(&m_map_sdefn) PlainMapSTypeDefn();
4072
4073 }
4074
4075 return m_map_sdefn;
4076 }
4077
4078 PlainMapLTypeDefn& map_ldefn_()
4079 {
4080 if (0x00000009 != selected_member_)
4081 {
4082 if (member_destructor_)
4083 {
4084 member_destructor_();
4085 }
4086
4087 selected_member_ = 0x00000009;
4088 member_destructor_ = [&]() {m_map_ldefn.~PlainMapLTypeDefn();};
4089 new(&m_map_ldefn) PlainMapLTypeDefn();
4090
4091 }
4092
4093 return m_map_ldefn;
4094 }
4095
4096 StronglyConnectedComponentId& sc_component_id_()
4097 {
4098 if (0x0000000a != selected_member_)
4099 {
4100 if (member_destructor_)
4101 {
4102 member_destructor_();
4103 }
4104
4105 selected_member_ = 0x0000000a;
4106 member_destructor_ = [&]() {m_sc_component_id.~StronglyConnectedComponentId();};
4107 new(&m_sc_component_id) StronglyConnectedComponentId();
4108
4109 }
4110
4111 return m_sc_component_id;
4112 }
4113
4114 EquivalenceHash& equivalence_hash_()
4115 {
4116 if (0x0000000b != selected_member_)
4117 {
4118 if (member_destructor_)
4119 {
4120 member_destructor_();
4121 }
4122
4123 selected_member_ = 0x0000000b;
4124 member_destructor_ = [&]() {m_equivalence_hash.~EquivalenceHash();};
4126
4127 }
4128
4129 return m_equivalence_hash;
4130 }
4131
4132 ExtendedTypeDefn& extended_defn_()
4133 {
4134 if (0x0000000c != selected_member_)
4135 {
4136 if (member_destructor_)
4137 {
4138 member_destructor_();
4139 }
4140
4141 selected_member_ = 0x0000000c;
4142 member_destructor_ = [&]() {m_extended_defn.~ExtendedTypeDefn();};
4143 new(&m_extended_defn) ExtendedTypeDefn();
4144
4145 }
4146
4147 return m_extended_defn;
4148 }
4149
4150
4151 uint8_t m__d {TK_NONE};
4152
4153 union
4154 {
4167 };
4168
4169 uint32_t selected_member_ {0x0FFFFFFFu};
4170
4171 std::function<void()> member_destructor_;
4172};
4173typedef std::vector<TypeIdentifier> TypeIdentifierSeq;
4174
4175typedef uint32_t MemberId;
4176
4177const uint32_t ANNOTATION_STR_VALUE_MAX_LEN = 128;
4184{
4185public:
4186
4190 eProsima_user_DllExport ExtendedAnnotationParameterValue()
4191 {
4192 }
4193
4197 eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
4198 {
4199 }
4200
4205 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4207 {
4208 static_cast<void>(x);
4209 }
4210
4215 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4217 {
4218 static_cast<void>(x);
4219 }
4220
4227 {
4228
4229 static_cast<void>(x);
4230
4231 return *this;
4232 }
4233
4240 {
4241
4242 static_cast<void>(x);
4243
4244 return *this;
4245 }
4246
4251 eProsima_user_DllExport bool operator ==(
4252 const ExtendedAnnotationParameterValue& x) const
4253 {
4254 static_cast<void>(x);
4255 return true;
4256 }
4257
4262 eProsima_user_DllExport bool operator !=(
4263 const ExtendedAnnotationParameterValue& x) const
4264 {
4265 return !(*this == x);
4266 }
4267
4268
4269
4270private:
4271
4272
4273};
4279{
4280public:
4281
4285 eProsima_user_DllExport AnnotationParameterValue()
4286 {
4287 selected_member_ = 0x00000013;
4288 member_destructor_ = [&]() {m_extended_value.~ExtendedAnnotationParameterValue();};
4290
4291 }
4292
4296 eProsima_user_DllExport ~AnnotationParameterValue()
4297 {
4298 if (member_destructor_)
4299 {
4300 member_destructor_();
4301 }
4302 }
4303
4308 eProsima_user_DllExport AnnotationParameterValue(
4309 const AnnotationParameterValue& x)
4310 {
4311 m__d = x.m__d;
4312
4313 switch (x.selected_member_)
4314 {
4315 case 0x00000001:
4316 boolean_value_() = x.m_boolean_value;
4317 break;
4318
4319 case 0x00000002:
4320 byte_value_() = x.m_byte_value;
4321 break;
4322
4323 case 0x00000003:
4324 int8_value_() = x.m_int8_value;
4325 break;
4326
4327 case 0x00000004:
4328 uint8_value_() = x.m_uint8_value;
4329 break;
4330
4331 case 0x00000005:
4332 int16_value_() = x.m_int16_value;
4333 break;
4334
4335 case 0x00000006:
4336 uint_16_value_() = x.m_uint_16_value;
4337 break;
4338
4339 case 0x00000007:
4340 int32_value_() = x.m_int32_value;
4341 break;
4342
4343 case 0x00000008:
4344 uint32_value_() = x.m_uint32_value;
4345 break;
4346
4347 case 0x00000009:
4348 int64_value_() = x.m_int64_value;
4349 break;
4350
4351 case 0x0000000a:
4352 uint64_value_() = x.m_uint64_value;
4353 break;
4354
4355 case 0x0000000b:
4356 float32_value_() = x.m_float32_value;
4357 break;
4358
4359 case 0x0000000c:
4360 float64_value_() = x.m_float64_value;
4361 break;
4362
4363 case 0x0000000d:
4364 float128_value_() = x.m_float128_value;
4365 break;
4366
4367 case 0x0000000e:
4368 char_value_() = x.m_char_value;
4369 break;
4370
4371 case 0x0000000f:
4372 wchar_value_() = x.m_wchar_value;
4373 break;
4374
4375 case 0x00000010:
4376 enumerated_value_() = x.m_enumerated_value;
4377 break;
4378
4379 case 0x00000011:
4380 string8_value_() = x.m_string8_value;
4381 break;
4382
4383 case 0x00000012:
4384 string16_value_() = x.m_string16_value;
4385 break;
4386
4387 case 0x00000013:
4388 extended_value_() = x.m_extended_value;
4389 break;
4390
4391 }
4392 }
4393
4398 eProsima_user_DllExport AnnotationParameterValue(
4399 AnnotationParameterValue&& x) noexcept
4400 {
4401 m__d = x.m__d;
4402
4403 switch (x.selected_member_)
4404 {
4405 case 0x00000001:
4406 boolean_value_() = std::move(x.m_boolean_value);
4407 break;
4408
4409 case 0x00000002:
4410 byte_value_() = std::move(x.m_byte_value);
4411 break;
4412
4413 case 0x00000003:
4414 int8_value_() = std::move(x.m_int8_value);
4415 break;
4416
4417 case 0x00000004:
4418 uint8_value_() = std::move(x.m_uint8_value);
4419 break;
4420
4421 case 0x00000005:
4422 int16_value_() = std::move(x.m_int16_value);
4423 break;
4424
4425 case 0x00000006:
4426 uint_16_value_() = std::move(x.m_uint_16_value);
4427 break;
4428
4429 case 0x00000007:
4430 int32_value_() = std::move(x.m_int32_value);
4431 break;
4432
4433 case 0x00000008:
4434 uint32_value_() = std::move(x.m_uint32_value);
4435 break;
4436
4437 case 0x00000009:
4438 int64_value_() = std::move(x.m_int64_value);
4439 break;
4440
4441 case 0x0000000a:
4442 uint64_value_() = std::move(x.m_uint64_value);
4443 break;
4444
4445 case 0x0000000b:
4446 float32_value_() = std::move(x.m_float32_value);
4447 break;
4448
4449 case 0x0000000c:
4450 float64_value_() = std::move(x.m_float64_value);
4451 break;
4452
4453 case 0x0000000d:
4454 float128_value_() = std::move(x.m_float128_value);
4455 break;
4456
4457 case 0x0000000e:
4458 char_value_() = std::move(x.m_char_value);
4459 break;
4460
4461 case 0x0000000f:
4462 wchar_value_() = std::move(x.m_wchar_value);
4463 break;
4464
4465 case 0x00000010:
4466 enumerated_value_() = std::move(x.m_enumerated_value);
4467 break;
4468
4469 case 0x00000011:
4470 string8_value_() = std::move(x.m_string8_value);
4471 break;
4472
4473 case 0x00000012:
4474 string16_value_() = std::move(x.m_string16_value);
4475 break;
4476
4477 case 0x00000013:
4478 extended_value_() = std::move(x.m_extended_value);
4479 break;
4480
4481 }
4482 }
4483
4488 eProsima_user_DllExport AnnotationParameterValue& operator =(
4489 const AnnotationParameterValue& x)
4490 {
4491 m__d = x.m__d;
4492
4493 switch (x.selected_member_)
4494 {
4495 case 0x00000001:
4496 boolean_value_() = x.m_boolean_value;
4497 break;
4498
4499 case 0x00000002:
4500 byte_value_() = x.m_byte_value;
4501 break;
4502
4503 case 0x00000003:
4504 int8_value_() = x.m_int8_value;
4505 break;
4506
4507 case 0x00000004:
4508 uint8_value_() = x.m_uint8_value;
4509 break;
4510
4511 case 0x00000005:
4512 int16_value_() = x.m_int16_value;
4513 break;
4514
4515 case 0x00000006:
4516 uint_16_value_() = x.m_uint_16_value;
4517 break;
4518
4519 case 0x00000007:
4520 int32_value_() = x.m_int32_value;
4521 break;
4522
4523 case 0x00000008:
4524 uint32_value_() = x.m_uint32_value;
4525 break;
4526
4527 case 0x00000009:
4528 int64_value_() = x.m_int64_value;
4529 break;
4530
4531 case 0x0000000a:
4532 uint64_value_() = x.m_uint64_value;
4533 break;
4534
4535 case 0x0000000b:
4536 float32_value_() = x.m_float32_value;
4537 break;
4538
4539 case 0x0000000c:
4540 float64_value_() = x.m_float64_value;
4541 break;
4542
4543 case 0x0000000d:
4544 float128_value_() = x.m_float128_value;
4545 break;
4546
4547 case 0x0000000e:
4548 char_value_() = x.m_char_value;
4549 break;
4550
4551 case 0x0000000f:
4552 wchar_value_() = x.m_wchar_value;
4553 break;
4554
4555 case 0x00000010:
4556 enumerated_value_() = x.m_enumerated_value;
4557 break;
4558
4559 case 0x00000011:
4560 string8_value_() = x.m_string8_value;
4561 break;
4562
4563 case 0x00000012:
4564 string16_value_() = x.m_string16_value;
4565 break;
4566
4567 case 0x00000013:
4568 extended_value_() = x.m_extended_value;
4569 break;
4570
4571 }
4572
4573 return *this;
4574 }
4575
4580 eProsima_user_DllExport AnnotationParameterValue& operator =(
4581 AnnotationParameterValue&& x) noexcept
4582 {
4583 m__d = x.m__d;
4584
4585 switch (x.selected_member_)
4586 {
4587 case 0x00000001:
4588 boolean_value_() = std::move(x.m_boolean_value);
4589 break;
4590
4591 case 0x00000002:
4592 byte_value_() = std::move(x.m_byte_value);
4593 break;
4594
4595 case 0x00000003:
4596 int8_value_() = std::move(x.m_int8_value);
4597 break;
4598
4599 case 0x00000004:
4600 uint8_value_() = std::move(x.m_uint8_value);
4601 break;
4602
4603 case 0x00000005:
4604 int16_value_() = std::move(x.m_int16_value);
4605 break;
4606
4607 case 0x00000006:
4608 uint_16_value_() = std::move(x.m_uint_16_value);
4609 break;
4610
4611 case 0x00000007:
4612 int32_value_() = std::move(x.m_int32_value);
4613 break;
4614
4615 case 0x00000008:
4616 uint32_value_() = std::move(x.m_uint32_value);
4617 break;
4618
4619 case 0x00000009:
4620 int64_value_() = std::move(x.m_int64_value);
4621 break;
4622
4623 case 0x0000000a:
4624 uint64_value_() = std::move(x.m_uint64_value);
4625 break;
4626
4627 case 0x0000000b:
4628 float32_value_() = std::move(x.m_float32_value);
4629 break;
4630
4631 case 0x0000000c:
4632 float64_value_() = std::move(x.m_float64_value);
4633 break;
4634
4635 case 0x0000000d:
4636 float128_value_() = std::move(x.m_float128_value);
4637 break;
4638
4639 case 0x0000000e:
4640 char_value_() = std::move(x.m_char_value);
4641 break;
4642
4643 case 0x0000000f:
4644 wchar_value_() = std::move(x.m_wchar_value);
4645 break;
4646
4647 case 0x00000010:
4648 enumerated_value_() = std::move(x.m_enumerated_value);
4649 break;
4650
4651 case 0x00000011:
4652 string8_value_() = std::move(x.m_string8_value);
4653 break;
4654
4655 case 0x00000012:
4656 string16_value_() = std::move(x.m_string16_value);
4657 break;
4658
4659 case 0x00000013:
4660 extended_value_() = std::move(x.m_extended_value);
4661 break;
4662
4663 }
4664
4665 return *this;
4666 }
4667
4672 eProsima_user_DllExport bool operator ==(
4673 const AnnotationParameterValue& x) const
4674 {
4675 bool ret_value {false};
4676
4677 if (m__d == x.m__d &&
4678 selected_member_ == x.selected_member_)
4679 {
4680 switch (selected_member_)
4681 {
4682 case 0x00000001:
4683 ret_value = (m_boolean_value == x.m_boolean_value);
4684 break;
4685
4686 case 0x00000002:
4687 ret_value = (m_byte_value == x.m_byte_value);
4688 break;
4689
4690 case 0x00000003:
4691 ret_value = (m_int8_value == x.m_int8_value);
4692 break;
4693
4694 case 0x00000004:
4695 ret_value = (m_uint8_value == x.m_uint8_value);
4696 break;
4697
4698 case 0x00000005:
4699 ret_value = (m_int16_value == x.m_int16_value);
4700 break;
4701
4702 case 0x00000006:
4703 ret_value = (m_uint_16_value == x.m_uint_16_value);
4704 break;
4705
4706 case 0x00000007:
4707 ret_value = (m_int32_value == x.m_int32_value);
4708 break;
4709
4710 case 0x00000008:
4711 ret_value = (m_uint32_value == x.m_uint32_value);
4712 break;
4713
4714 case 0x00000009:
4715 ret_value = (m_int64_value == x.m_int64_value);
4716 break;
4717
4718 case 0x0000000a:
4719 ret_value = (m_uint64_value == x.m_uint64_value);
4720 break;
4721
4722 case 0x0000000b:
4723 ret_value = (m_float32_value == x.m_float32_value);
4724 break;
4725
4726 case 0x0000000c:
4727 ret_value = (m_float64_value == x.m_float64_value);
4728 break;
4729
4730 case 0x0000000d:
4731 ret_value = (m_float128_value == x.m_float128_value);
4732 break;
4733
4734 case 0x0000000e:
4735 ret_value = (m_char_value == x.m_char_value);
4736 break;
4737
4738 case 0x0000000f:
4739 ret_value = (m_wchar_value == x.m_wchar_value);
4740 break;
4741
4742 case 0x00000010:
4743 ret_value = (m_enumerated_value == x.m_enumerated_value);
4744 break;
4745
4746 case 0x00000011:
4747 ret_value = (m_string8_value == x.m_string8_value);
4748 break;
4749
4750 case 0x00000012:
4751 ret_value = (m_string16_value == x.m_string16_value);
4752 break;
4753
4754 case 0x00000013:
4755 ret_value = (m_extended_value == x.m_extended_value);
4756 break;
4757
4758 }
4759 }
4760
4761 return ret_value;
4762 }
4763
4768 eProsima_user_DllExport bool operator !=(
4769 const AnnotationParameterValue& x) const
4770 {
4771 return !(*this == x);
4772 }
4773
4779 eProsima_user_DllExport void _d(
4780 uint8_t __d)
4781 {
4782 bool valid_discriminator = false;
4783
4784 switch (__d)
4785 {
4786 case TK_BOOLEAN:
4787 if (0x00000001 == selected_member_)
4788 {
4789 valid_discriminator = true;
4790 }
4791 break;
4792
4793 case TK_BYTE:
4794 if (0x00000002 == selected_member_)
4795 {
4796 valid_discriminator = true;
4797 }
4798 break;
4799
4800 case TK_INT8:
4801 if (0x00000003 == selected_member_)
4802 {
4803 valid_discriminator = true;
4804 }
4805 break;
4806
4807 case TK_UINT8:
4808 if (0x00000004 == selected_member_)
4809 {
4810 valid_discriminator = true;
4811 }
4812 break;
4813
4814 case TK_INT16:
4815 if (0x00000005 == selected_member_)
4816 {
4817 valid_discriminator = true;
4818 }
4819 break;
4820
4821 case TK_UINT16:
4822 if (0x00000006 == selected_member_)
4823 {
4824 valid_discriminator = true;
4825 }
4826 break;
4827
4828 case TK_INT32:
4829 if (0x00000007 == selected_member_)
4830 {
4831 valid_discriminator = true;
4832 }
4833 break;
4834
4835 case TK_UINT32:
4836 if (0x00000008 == selected_member_)
4837 {
4838 valid_discriminator = true;
4839 }
4840 break;
4841
4842 case TK_INT64:
4843 if (0x00000009 == selected_member_)
4844 {
4845 valid_discriminator = true;
4846 }
4847 break;
4848
4849 case TK_UINT64:
4850 if (0x0000000a == selected_member_)
4851 {
4852 valid_discriminator = true;
4853 }
4854 break;
4855
4856 case TK_FLOAT32:
4857 if (0x0000000b == selected_member_)
4858 {
4859 valid_discriminator = true;
4860 }
4861 break;
4862
4863 case TK_FLOAT64:
4864 if (0x0000000c == selected_member_)
4865 {
4866 valid_discriminator = true;
4867 }
4868 break;
4869
4870 case TK_FLOAT128:
4871 if (0x0000000d == selected_member_)
4872 {
4873 valid_discriminator = true;
4874 }
4875 break;
4876
4877 case TK_CHAR8:
4878 if (0x0000000e == selected_member_)
4879 {
4880 valid_discriminator = true;
4881 }
4882 break;
4883
4884 case TK_CHAR16:
4885 if (0x0000000f == selected_member_)
4886 {
4887 valid_discriminator = true;
4888 }
4889 break;
4890
4891 case TK_ENUM:
4892 if (0x00000010 == selected_member_)
4893 {
4894 valid_discriminator = true;
4895 }
4896 break;
4897
4898 case TK_STRING8:
4899 if (0x00000011 == selected_member_)
4900 {
4901 valid_discriminator = true;
4902 }
4903 break;
4904
4905 case TK_STRING16:
4906 if (0x00000012 == selected_member_)
4907 {
4908 valid_discriminator = true;
4909 }
4910 break;
4911
4912 default:
4913 if (0x00000013 == selected_member_)
4914 {
4915 valid_discriminator = true;
4916 }
4917 break;
4918
4919 }
4920
4921 if (!valid_discriminator)
4922 {
4923 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
4924 }
4925
4926 m__d = __d;
4927 }
4928
4933 eProsima_user_DllExport uint8_t _d() const
4934 {
4935 return m__d;
4936 }
4937
4942 eProsima_user_DllExport void boolean_value(
4943 bool _boolean_value)
4944 {
4945 boolean_value_() = _boolean_value;
4946 m__d = TK_BOOLEAN;
4947 }
4948
4954 eProsima_user_DllExport bool boolean_value() const
4955 {
4956 if (0x00000001 != selected_member_)
4957 {
4958 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
4959 }
4960
4961 return m_boolean_value;
4962 }
4963
4969 eProsima_user_DllExport bool& boolean_value()
4970 {
4971 if (0x00000001 != selected_member_)
4972 {
4973 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
4974 }
4975
4976 return m_boolean_value;
4977 }
4978
4979
4984 eProsima_user_DllExport void byte_value(
4985 uint8_t _byte_value)
4986 {
4987 byte_value_() = _byte_value;
4988 m__d = TK_BYTE;
4989 }
4990
4996 eProsima_user_DllExport uint8_t byte_value() const
4997 {
4998 if (0x00000002 != selected_member_)
4999 {
5000 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5001 }
5002
5003 return m_byte_value;
5004 }
5005
5011 eProsima_user_DllExport uint8_t& byte_value()
5012 {
5013 if (0x00000002 != selected_member_)
5014 {
5015 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5016 }
5017
5018 return m_byte_value;
5019 }
5020
5021
5026 eProsima_user_DllExport void int8_value(
5027 int8_t _int8_value)
5028 {
5029 int8_value_() = _int8_value;
5030 m__d = TK_INT8;
5031 }
5032
5038 eProsima_user_DllExport int8_t int8_value() const
5039 {
5040 if (0x00000003 != selected_member_)
5041 {
5042 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5043 }
5044
5045 return m_int8_value;
5046 }
5047
5053 eProsima_user_DllExport int8_t& int8_value()
5054 {
5055 if (0x00000003 != selected_member_)
5056 {
5057 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5058 }
5059
5060 return m_int8_value;
5061 }
5062
5063
5068 eProsima_user_DllExport void uint8_value(
5069 uint8_t _uint8_value)
5070 {
5071 uint8_value_() = _uint8_value;
5072 m__d = TK_UINT8;
5073 }
5074
5080 eProsima_user_DllExport uint8_t uint8_value() const
5081 {
5082 if (0x00000004 != selected_member_)
5083 {
5084 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5085 }
5086
5087 return m_uint8_value;
5088 }
5089
5095 eProsima_user_DllExport uint8_t& uint8_value()
5096 {
5097 if (0x00000004 != selected_member_)
5098 {
5099 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5100 }
5101
5102 return m_uint8_value;
5103 }
5104
5105
5110 eProsima_user_DllExport void int16_value(
5111 int16_t _int16_value)
5112 {
5113 int16_value_() = _int16_value;
5114 m__d = TK_INT16;
5115 }
5116
5122 eProsima_user_DllExport int16_t int16_value() const
5123 {
5124 if (0x00000005 != selected_member_)
5125 {
5126 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5127 }
5128
5129 return m_int16_value;
5130 }
5131
5137 eProsima_user_DllExport int16_t& int16_value()
5138 {
5139 if (0x00000005 != selected_member_)
5140 {
5141 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5142 }
5143
5144 return m_int16_value;
5145 }
5146
5147
5152 eProsima_user_DllExport void uint_16_value(
5153 uint16_t _uint_16_value)
5154 {
5155 uint_16_value_() = _uint_16_value;
5156 m__d = TK_UINT16;
5157 }
5158
5164 eProsima_user_DllExport uint16_t uint_16_value() const
5165 {
5166 if (0x00000006 != selected_member_)
5167 {
5168 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5169 }
5170
5171 return m_uint_16_value;
5172 }
5173
5179 eProsima_user_DllExport uint16_t& uint_16_value()
5180 {
5181 if (0x00000006 != selected_member_)
5182 {
5183 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5184 }
5185
5186 return m_uint_16_value;
5187 }
5188
5189
5194 eProsima_user_DllExport void int32_value(
5195 int32_t _int32_value)
5196 {
5197 int32_value_() = _int32_value;
5198 m__d = TK_INT32;
5199 }
5200
5206 eProsima_user_DllExport int32_t int32_value() const
5207 {
5208 if (0x00000007 != selected_member_)
5209 {
5210 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5211 }
5212
5213 return m_int32_value;
5214 }
5215
5221 eProsima_user_DllExport int32_t& int32_value()
5222 {
5223 if (0x00000007 != selected_member_)
5224 {
5225 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5226 }
5227
5228 return m_int32_value;
5229 }
5230
5231
5236 eProsima_user_DllExport void uint32_value(
5237 uint32_t _uint32_value)
5238 {
5239 uint32_value_() = _uint32_value;
5240 m__d = TK_UINT32;
5241 }
5242
5248 eProsima_user_DllExport uint32_t uint32_value() const
5249 {
5250 if (0x00000008 != selected_member_)
5251 {
5252 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5253 }
5254
5255 return m_uint32_value;
5256 }
5257
5263 eProsima_user_DllExport uint32_t& uint32_value()
5264 {
5265 if (0x00000008 != selected_member_)
5266 {
5267 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5268 }
5269
5270 return m_uint32_value;
5271 }
5272
5273
5278 eProsima_user_DllExport void int64_value(
5279 int64_t _int64_value)
5280 {
5281 int64_value_() = _int64_value;
5282 m__d = TK_INT64;
5283 }
5284
5290 eProsima_user_DllExport int64_t int64_value() const
5291 {
5292 if (0x00000009 != selected_member_)
5293 {
5294 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5295 }
5296
5297 return m_int64_value;
5298 }
5299
5305 eProsima_user_DllExport int64_t& int64_value()
5306 {
5307 if (0x00000009 != selected_member_)
5308 {
5309 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5310 }
5311
5312 return m_int64_value;
5313 }
5314
5315
5320 eProsima_user_DllExport void uint64_value(
5321 uint64_t _uint64_value)
5322 {
5323 uint64_value_() = _uint64_value;
5324 m__d = TK_UINT64;
5325 }
5326
5332 eProsima_user_DllExport uint64_t uint64_value() const
5333 {
5334 if (0x0000000a != selected_member_)
5335 {
5336 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5337 }
5338
5339 return m_uint64_value;
5340 }
5341
5347 eProsima_user_DllExport uint64_t& uint64_value()
5348 {
5349 if (0x0000000a != selected_member_)
5350 {
5351 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5352 }
5353
5354 return m_uint64_value;
5355 }
5356
5357
5362 eProsima_user_DllExport void float32_value(
5363 float _float32_value)
5364 {
5365 float32_value_() = _float32_value;
5366 m__d = TK_FLOAT32;
5367 }
5368
5374 eProsima_user_DllExport float float32_value() const
5375 {
5376 if (0x0000000b != selected_member_)
5377 {
5378 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5379 }
5380
5381 return m_float32_value;
5382 }
5383
5389 eProsima_user_DllExport float& float32_value()
5390 {
5391 if (0x0000000b != selected_member_)
5392 {
5393 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5394 }
5395
5396 return m_float32_value;
5397 }
5398
5399
5404 eProsima_user_DllExport void float64_value(
5405 double _float64_value)
5406 {
5407 float64_value_() = _float64_value;
5408 m__d = TK_FLOAT64;
5409 }
5410
5416 eProsima_user_DllExport double float64_value() const
5417 {
5418 if (0x0000000c != selected_member_)
5419 {
5420 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5421 }
5422
5423 return m_float64_value;
5424 }
5425
5431 eProsima_user_DllExport double& float64_value()
5432 {
5433 if (0x0000000c != selected_member_)
5434 {
5435 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5436 }
5437
5438 return m_float64_value;
5439 }
5440
5441
5446 eProsima_user_DllExport void float128_value(
5447 long double _float128_value)
5448 {
5449 float128_value_() = _float128_value;
5450 m__d = TK_FLOAT128;
5451 }
5452
5458 eProsima_user_DllExport long double float128_value() const
5459 {
5460 if (0x0000000d != selected_member_)
5461 {
5462 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5463 }
5464
5465 return m_float128_value;
5466 }
5467
5473 eProsima_user_DllExport long double& float128_value()
5474 {
5475 if (0x0000000d != selected_member_)
5476 {
5477 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5478 }
5479
5480 return m_float128_value;
5481 }
5482
5483
5488 eProsima_user_DllExport void char_value(
5489 char _char_value)
5490 {
5491 char_value_() = _char_value;
5492 m__d = TK_CHAR8;
5493 }
5494
5500 eProsima_user_DllExport char char_value() const
5501 {
5502 if (0x0000000e != selected_member_)
5503 {
5504 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5505 }
5506
5507 return m_char_value;
5508 }
5509
5515 eProsima_user_DllExport char& char_value()
5516 {
5517 if (0x0000000e != selected_member_)
5518 {
5519 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5520 }
5521
5522 return m_char_value;
5523 }
5524
5525
5530 eProsima_user_DllExport void wchar_value(
5531 wchar_t _wchar_value)
5532 {
5533 wchar_value_() = _wchar_value;
5534 m__d = TK_CHAR16;
5535 }
5536
5542 eProsima_user_DllExport wchar_t wchar_value() const
5543 {
5544 if (0x0000000f != selected_member_)
5545 {
5546 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5547 }
5548
5549 return m_wchar_value;
5550 }
5551
5557 eProsima_user_DllExport wchar_t& wchar_value()
5558 {
5559 if (0x0000000f != selected_member_)
5560 {
5561 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5562 }
5563
5564 return m_wchar_value;
5565 }
5566
5567
5572 eProsima_user_DllExport void enumerated_value(
5573 int32_t _enumerated_value)
5574 {
5575 enumerated_value_() = _enumerated_value;
5576 m__d = TK_ENUM;
5577 }
5578
5584 eProsima_user_DllExport int32_t enumerated_value() const
5585 {
5586 if (0x00000010 != selected_member_)
5587 {
5588 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5589 }
5590
5591 return m_enumerated_value;
5592 }
5593
5599 eProsima_user_DllExport int32_t& enumerated_value()
5600 {
5601 if (0x00000010 != selected_member_)
5602 {
5603 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5604 }
5605
5606 return m_enumerated_value;
5607 }
5608
5609
5614 eProsima_user_DllExport void string8_value(
5615 const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& _string8_value)
5616 {
5617 string8_value_() = _string8_value;
5618 m__d = TK_STRING8;
5619 }
5620
5625 eProsima_user_DllExport void string8_value(
5626 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>&& _string8_value)
5627 {
5628 string8_value_() = _string8_value;
5629 m__d = TK_STRING8;
5630 }
5631
5637 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value() const
5638 {
5639 if (0x00000011 != selected_member_)
5640 {
5641 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5642 }
5643
5644 return m_string8_value;
5645 }
5646
5652 eProsima_user_DllExport eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value()
5653 {
5654 if (0x00000011 != selected_member_)
5655 {
5656 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5657 }
5658
5659 return m_string8_value;
5660 }
5661
5662
5667 eProsima_user_DllExport void string16_value(
5668 const std::wstring& _string16_value)
5669 {
5670 string16_value_() = _string16_value;
5671 m__d = TK_STRING16;
5672 }
5673
5678 eProsima_user_DllExport void string16_value(
5679 std::wstring&& _string16_value)
5680 {
5681 string16_value_() = _string16_value;
5682 m__d = TK_STRING16;
5683 }
5684
5690 eProsima_user_DllExport const std::wstring& string16_value() const
5691 {
5692 if (0x00000012 != selected_member_)
5693 {
5694 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5695 }
5696
5697 return m_string16_value;
5698 }
5699
5705 eProsima_user_DllExport std::wstring& string16_value()
5706 {
5707 if (0x00000012 != selected_member_)
5708 {
5709 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5710 }
5711
5712 return m_string16_value;
5713 }
5714
5715
5720 eProsima_user_DllExport void extended_value(
5721 const ExtendedAnnotationParameterValue& _extended_value)
5722 {
5723 extended_value_() = _extended_value;
5724 m__d = 127;
5725 }
5726
5731 eProsima_user_DllExport void extended_value(
5732 ExtendedAnnotationParameterValue&& _extended_value)
5733 {
5734 extended_value_() = _extended_value;
5735 m__d = 127;
5736 }
5737
5743 eProsima_user_DllExport const ExtendedAnnotationParameterValue& extended_value() const
5744 {
5745 if (0x00000013 != selected_member_)
5746 {
5747 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5748 }
5749
5750 return m_extended_value;
5751 }
5752
5759 {
5760 if (0x00000013 != selected_member_)
5761 {
5762 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5763 }
5764
5765 return m_extended_value;
5766 }
5767
5768
5769
5770private:
5771
5772 bool& boolean_value_()
5773 {
5774 if (0x00000001 != selected_member_)
5775 {
5776 if (member_destructor_)
5777 {
5778 member_destructor_();
5779 }
5780
5781 selected_member_ = 0x00000001;
5782 member_destructor_ = nullptr;
5783 m_boolean_value = {false};
5784
5785 }
5786
5787 return m_boolean_value;
5788 }
5789
5790 uint8_t& byte_value_()
5791 {
5792 if (0x00000002 != selected_member_)
5793 {
5794 if (member_destructor_)
5795 {
5796 member_destructor_();
5797 }
5798
5799 selected_member_ = 0x00000002;
5800 member_destructor_ = nullptr;
5801 m_byte_value = {0};
5802
5803 }
5804
5805 return m_byte_value;
5806 }
5807
5808 int8_t& int8_value_()
5809 {
5810 if (0x00000003 != selected_member_)
5811 {
5812 if (member_destructor_)
5813 {
5814 member_destructor_();
5815 }
5816
5817 selected_member_ = 0x00000003;
5818 member_destructor_ = nullptr;
5819 m_int8_value = {0};
5820
5821 }
5822
5823 return m_int8_value;
5824 }
5825
5826 uint8_t& uint8_value_()
5827 {
5828 if (0x00000004 != selected_member_)
5829 {
5830 if (member_destructor_)
5831 {
5832 member_destructor_();
5833 }
5834
5835 selected_member_ = 0x00000004;
5836 member_destructor_ = nullptr;
5837 m_uint8_value = {0};
5838
5839 }
5840
5841 return m_uint8_value;
5842 }
5843
5844 int16_t& int16_value_()
5845 {
5846 if (0x00000005 != selected_member_)
5847 {
5848 if (member_destructor_)
5849 {
5850 member_destructor_();
5851 }
5852
5853 selected_member_ = 0x00000005;
5854 member_destructor_ = nullptr;
5855 m_int16_value = {0};
5856
5857 }
5858
5859 return m_int16_value;
5860 }
5861
5862 uint16_t& uint_16_value_()
5863 {
5864 if (0x00000006 != selected_member_)
5865 {
5866 if (member_destructor_)
5867 {
5868 member_destructor_();
5869 }
5870
5871 selected_member_ = 0x00000006;
5872 member_destructor_ = nullptr;
5873 m_uint_16_value = {0};
5874
5875 }
5876
5877 return m_uint_16_value;
5878 }
5879
5880 int32_t& int32_value_()
5881 {
5882 if (0x00000007 != selected_member_)
5883 {
5884 if (member_destructor_)
5885 {
5886 member_destructor_();
5887 }
5888
5889 selected_member_ = 0x00000007;
5890 member_destructor_ = nullptr;
5891 m_int32_value = {0};
5892
5893 }
5894
5895 return m_int32_value;
5896 }
5897
5898 uint32_t& uint32_value_()
5899 {
5900 if (0x00000008 != selected_member_)
5901 {
5902 if (member_destructor_)
5903 {
5904 member_destructor_();
5905 }
5906
5907 selected_member_ = 0x00000008;
5908 member_destructor_ = nullptr;
5909 m_uint32_value = {0};
5910
5911 }
5912
5913 return m_uint32_value;
5914 }
5915
5916 int64_t& int64_value_()
5917 {
5918 if (0x00000009 != selected_member_)
5919 {
5920 if (member_destructor_)
5921 {
5922 member_destructor_();
5923 }
5924
5925 selected_member_ = 0x00000009;
5926 member_destructor_ = nullptr;
5927 m_int64_value = {0};
5928
5929 }
5930
5931 return m_int64_value;
5932 }
5933
5934 uint64_t& uint64_value_()
5935 {
5936 if (0x0000000a != selected_member_)
5937 {
5938 if (member_destructor_)
5939 {
5940 member_destructor_();
5941 }
5942
5943 selected_member_ = 0x0000000a;
5944 member_destructor_ = nullptr;
5945 m_uint64_value = {0};
5946
5947 }
5948
5949 return m_uint64_value;
5950 }
5951
5952 float& float32_value_()
5953 {
5954 if (0x0000000b != selected_member_)
5955 {
5956 if (member_destructor_)
5957 {
5958 member_destructor_();
5959 }
5960
5961 selected_member_ = 0x0000000b;
5962 member_destructor_ = nullptr;
5963 m_float32_value = {0.0};
5964
5965 }
5966
5967 return m_float32_value;
5968 }
5969
5970 double& float64_value_()
5971 {
5972 if (0x0000000c != selected_member_)
5973 {
5974 if (member_destructor_)
5975 {
5976 member_destructor_();
5977 }
5978
5979 selected_member_ = 0x0000000c;
5980 member_destructor_ = nullptr;
5981 m_float64_value = {0.0};
5982
5983 }
5984
5985 return m_float64_value;
5986 }
5987
5988 long double& float128_value_()
5989 {
5990 if (0x0000000d != selected_member_)
5991 {
5992 if (member_destructor_)
5993 {
5994 member_destructor_();
5995 }
5996
5997 selected_member_ = 0x0000000d;
5998 member_destructor_ = nullptr;
5999 m_float128_value = {0.0};
6000
6001 }
6002
6003 return m_float128_value;
6004 }
6005
6006 char& char_value_()
6007 {
6008 if (0x0000000e != selected_member_)
6009 {
6010 if (member_destructor_)
6011 {
6012 member_destructor_();
6013 }
6014
6015 selected_member_ = 0x0000000e;
6016 member_destructor_ = nullptr;
6017 m_char_value = {0};
6018
6019 }
6020
6021 return m_char_value;
6022 }
6023
6024 wchar_t& wchar_value_()
6025 {
6026 if (0x0000000f != selected_member_)
6027 {
6028 if (member_destructor_)
6029 {
6030 member_destructor_();
6031 }
6032
6033 selected_member_ = 0x0000000f;
6034 member_destructor_ = nullptr;
6035 m_wchar_value = {0};
6036
6037 }
6038
6039 return m_wchar_value;
6040 }
6041
6042 int32_t& enumerated_value_()
6043 {
6044 if (0x00000010 != selected_member_)
6045 {
6046 if (member_destructor_)
6047 {
6048 member_destructor_();
6049 }
6050
6051 selected_member_ = 0x00000010;
6052 member_destructor_ = nullptr;
6053 m_enumerated_value = {0};
6054
6055 }
6056
6057 return m_enumerated_value;
6058 }
6059
6060 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value_()
6061 {
6062 if (0x00000011 != selected_member_)
6063 {
6064 if (member_destructor_)
6065 {
6066 member_destructor_();
6067 }
6068
6069 selected_member_ = 0x00000011;
6070 member_destructor_ = [&]() {m_string8_value.~fixed_string();};
6071 new(&m_string8_value) eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>();
6072
6073 }
6074
6075 return m_string8_value;
6076 }
6077
6078 std::wstring& string16_value_()
6079 {
6080 if (0x00000012 != selected_member_)
6081 {
6082 if (member_destructor_)
6083 {
6084 member_destructor_();
6085 }
6086
6087 selected_member_ = 0x00000012;
6088 member_destructor_ = [&]() {m_string16_value.~basic_string();};
6089 new(&m_string16_value) std::wstring();
6090
6091 }
6092
6093 return m_string16_value;
6094 }
6095
6096 ExtendedAnnotationParameterValue& extended_value_()
6097 {
6098 if (0x00000013 != selected_member_)
6099 {
6100 if (member_destructor_)
6101 {
6102 member_destructor_();
6103 }
6104
6105 selected_member_ = 0x00000013;
6106 member_destructor_ = [&]() {m_extended_value.~ExtendedAnnotationParameterValue();};
6107 new(&m_extended_value) ExtendedAnnotationParameterValue();
6108
6109 }
6110
6111 return m_extended_value;
6112 }
6113
6114
6115 uint8_t m__d {127};
6116
6117 union
6118 {
6131 long double m_float128_value;
6135 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN> m_string8_value;
6136 std::wstring m_string16_value;
6138 };
6139
6140 uint32_t selected_member_ {0x0FFFFFFFu};
6141
6142 std::function<void()> member_destructor_;
6143};
6149{
6150public:
6151
6155 eProsima_user_DllExport AppliedAnnotationParameter()
6156 {
6157 }
6158
6162 eProsima_user_DllExport ~AppliedAnnotationParameter()
6163 {
6164 }
6165
6170 eProsima_user_DllExport AppliedAnnotationParameter(
6172 {
6173 m_paramname_hash = x.m_paramname_hash;
6174
6175 m_value = x.m_value;
6176
6177 }
6178
6183 eProsima_user_DllExport AppliedAnnotationParameter(
6184 AppliedAnnotationParameter&& x) noexcept
6185 {
6186 m_paramname_hash = std::move(x.m_paramname_hash);
6187 m_value = std::move(x.m_value);
6188 }
6189
6194 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6196 {
6197
6198 m_paramname_hash = x.m_paramname_hash;
6199
6200 m_value = x.m_value;
6201
6202 return *this;
6203 }
6204
6209 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6210 AppliedAnnotationParameter&& x) noexcept
6211 {
6212
6213 m_paramname_hash = std::move(x.m_paramname_hash);
6214 m_value = std::move(x.m_value);
6215 return *this;
6216 }
6217
6222 eProsima_user_DllExport bool operator ==(
6223 const AppliedAnnotationParameter& x) const
6224 {
6225 return (m_paramname_hash == x.m_paramname_hash &&
6226 m_value == x.m_value);
6227 }
6228
6233 eProsima_user_DllExport bool operator !=(
6234 const AppliedAnnotationParameter& x) const
6235 {
6236 return !(*this == x);
6237 }
6238
6243 eProsima_user_DllExport void paramname_hash(
6244 const NameHash& _paramname_hash)
6245 {
6246 m_paramname_hash = _paramname_hash;
6247 }
6248
6253 eProsima_user_DllExport void paramname_hash(
6254 NameHash&& _paramname_hash)
6255 {
6256 m_paramname_hash = std::move(_paramname_hash);
6257 }
6258
6263 eProsima_user_DllExport const NameHash& paramname_hash() const
6264 {
6265 return m_paramname_hash;
6266 }
6267
6272 eProsima_user_DllExport NameHash& paramname_hash()
6273 {
6274 return m_paramname_hash;
6275 }
6276
6277
6282 eProsima_user_DllExport void value(
6283 const AnnotationParameterValue& _value)
6284 {
6285 m_value = _value;
6286 }
6287
6292 eProsima_user_DllExport void value(
6293 AnnotationParameterValue&& _value)
6294 {
6295 m_value = std::move(_value);
6296 }
6297
6302 eProsima_user_DllExport const AnnotationParameterValue& value() const
6303 {
6304 return m_value;
6305 }
6306
6311 eProsima_user_DllExport AnnotationParameterValue& value()
6312 {
6313 return m_value;
6314 }
6315
6316
6317
6318private:
6319
6320 NameHash m_paramname_hash{0};
6321 AnnotationParameterValue m_value;
6322
6323};
6324typedef std::vector<AppliedAnnotationParameter> AppliedAnnotationParameterSeq;
6325
6331{
6332public:
6333
6337 eProsima_user_DllExport AppliedAnnotation()
6338 {
6339 }
6340
6344 eProsima_user_DllExport ~AppliedAnnotation()
6345 {
6346 }
6347
6352 eProsima_user_DllExport AppliedAnnotation(
6353 const AppliedAnnotation& x)
6354 {
6355 m_annotation_typeid = x.m_annotation_typeid;
6356
6357 m_param_seq = x.m_param_seq;
6358
6359 }
6360
6365 eProsima_user_DllExport AppliedAnnotation(
6366 AppliedAnnotation&& x) noexcept
6367 {
6368 m_annotation_typeid = std::move(x.m_annotation_typeid);
6369 m_param_seq = std::move(x.m_param_seq);
6370 }
6371
6376 eProsima_user_DllExport AppliedAnnotation& operator =(
6377 const AppliedAnnotation& x)
6378 {
6379
6380 m_annotation_typeid = x.m_annotation_typeid;
6381
6382 m_param_seq = x.m_param_seq;
6383
6384 return *this;
6385 }
6386
6391 eProsima_user_DllExport AppliedAnnotation& operator =(
6392 AppliedAnnotation&& x) noexcept
6393 {
6394
6395 m_annotation_typeid = std::move(x.m_annotation_typeid);
6396 m_param_seq = std::move(x.m_param_seq);
6397 return *this;
6398 }
6399
6404 eProsima_user_DllExport bool operator ==(
6405 const AppliedAnnotation& x) const
6406 {
6407 return (m_annotation_typeid == x.m_annotation_typeid &&
6408 m_param_seq == x.m_param_seq);
6409 }
6410
6415 eProsima_user_DllExport bool operator !=(
6416 const AppliedAnnotation& x) const
6417 {
6418 return !(*this == x);
6419 }
6420
6425 eProsima_user_DllExport void annotation_typeid(
6426 const TypeIdentifier& _annotation_typeid)
6427 {
6428 m_annotation_typeid = _annotation_typeid;
6429 }
6430
6435 eProsima_user_DllExport void annotation_typeid(
6436 TypeIdentifier&& _annotation_typeid)
6437 {
6438 m_annotation_typeid = std::move(_annotation_typeid);
6439 }
6440
6445 eProsima_user_DllExport const TypeIdentifier& annotation_typeid() const
6446 {
6447 return m_annotation_typeid;
6448 }
6449
6454 eProsima_user_DllExport TypeIdentifier& annotation_typeid()
6455 {
6456 return m_annotation_typeid;
6457 }
6458
6459
6464 eProsima_user_DllExport void param_seq(
6465 const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& _param_seq)
6466 {
6467 m_param_seq = _param_seq;
6468 }
6469
6474 eProsima_user_DllExport void param_seq(
6475 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>&& _param_seq)
6476 {
6477 m_param_seq = std::move(_param_seq);
6478 }
6479
6484 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq() const
6485 {
6486 return m_param_seq;
6487 }
6488
6493 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq()
6494 {
6495 return m_param_seq;
6496 }
6497
6498
6499
6500private:
6501
6502 TypeIdentifier m_annotation_typeid;
6503 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq> m_param_seq;
6504
6505};
6506typedef std::vector<AppliedAnnotation> AppliedAnnotationSeq;
6507
6513{
6514public:
6515
6519 eProsima_user_DllExport AppliedVerbatimAnnotation()
6520 {
6521 }
6522
6526 eProsima_user_DllExport ~AppliedVerbatimAnnotation()
6527 {
6528 }
6529
6534 eProsima_user_DllExport AppliedVerbatimAnnotation(
6536 {
6537 m_placement = x.m_placement;
6538
6539 m_language = x.m_language;
6540
6541 m_text = x.m_text;
6542
6543 }
6544
6549 eProsima_user_DllExport AppliedVerbatimAnnotation(
6550 AppliedVerbatimAnnotation&& x) noexcept
6551 {
6552 m_placement = std::move(x.m_placement);
6553 m_language = std::move(x.m_language);
6554 m_text = std::move(x.m_text);
6555 }
6556
6561 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6563 {
6564
6565 m_placement = x.m_placement;
6566
6567 m_language = x.m_language;
6568
6569 m_text = x.m_text;
6570
6571 return *this;
6572 }
6573
6578 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6579 AppliedVerbatimAnnotation&& x) noexcept
6580 {
6581
6582 m_placement = std::move(x.m_placement);
6583 m_language = std::move(x.m_language);
6584 m_text = std::move(x.m_text);
6585 return *this;
6586 }
6587
6592 eProsima_user_DllExport bool operator ==(
6593 const AppliedVerbatimAnnotation& x) const
6594 {
6595 return (m_placement == x.m_placement &&
6596 m_language == x.m_language &&
6597 m_text == x.m_text);
6598 }
6599
6604 eProsima_user_DllExport bool operator !=(
6605 const AppliedVerbatimAnnotation& x) const
6606 {
6607 return !(*this == x);
6608 }
6609
6614 eProsima_user_DllExport void placement(
6615 const eprosima::fastcdr::fixed_string<32>& _placement)
6616 {
6617 m_placement = _placement;
6618 }
6619
6624 eProsima_user_DllExport void placement(
6625 eprosima::fastcdr::fixed_string<32>&& _placement)
6626 {
6627 m_placement = std::move(_placement);
6628 }
6629
6634 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& placement() const
6635 {
6636 return m_placement;
6637 }
6638
6643 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& placement()
6644 {
6645 return m_placement;
6646 }
6647
6648
6653 eProsima_user_DllExport void language(
6654 const eprosima::fastcdr::fixed_string<32>& _language)
6655 {
6656 m_language = _language;
6657 }
6658
6663 eProsima_user_DllExport void language(
6664 eprosima::fastcdr::fixed_string<32>&& _language)
6665 {
6666 m_language = std::move(_language);
6667 }
6668
6673 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& language() const
6674 {
6675 return m_language;
6676 }
6677
6682 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& language()
6683 {
6684 return m_language;
6685 }
6686
6687
6692 eProsima_user_DllExport void text(
6693 const std::string& _text)
6694 {
6695 m_text = _text;
6696 }
6697
6702 eProsima_user_DllExport void text(
6703 std::string&& _text)
6704 {
6705 m_text = std::move(_text);
6706 }
6707
6712 eProsima_user_DllExport const std::string& text() const
6713 {
6714 return m_text;
6715 }
6716
6721 eProsima_user_DllExport std::string& text()
6722 {
6723 return m_text;
6724 }
6725
6726
6727
6728private:
6729
6730 eprosima::fastcdr::fixed_string<32> m_placement;
6731 eprosima::fastcdr::fixed_string<32> m_language;
6732 std::string m_text;
6733
6734};
6740{
6741public:
6742
6746 eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
6747 {
6748 }
6749
6753 eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
6754 {
6755 }
6756
6761 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6763 {
6764 m_unit = x.m_unit;
6765
6766 m_min = x.m_min;
6767
6768 m_max = x.m_max;
6769
6770 m_hash_id = x.m_hash_id;
6771
6772 }
6773
6778 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6780 {
6781 m_unit = std::move(x.m_unit);
6782 m_min = std::move(x.m_min);
6783 m_max = std::move(x.m_max);
6784 m_hash_id = std::move(x.m_hash_id);
6785 }
6786
6793 {
6794
6795 m_unit = x.m_unit;
6796
6797 m_min = x.m_min;
6798
6799 m_max = x.m_max;
6800
6801 m_hash_id = x.m_hash_id;
6802
6803 return *this;
6804 }
6805
6812 {
6813
6814 m_unit = std::move(x.m_unit);
6815 m_min = std::move(x.m_min);
6816 m_max = std::move(x.m_max);
6817 m_hash_id = std::move(x.m_hash_id);
6818 return *this;
6819 }
6820
6825 eProsima_user_DllExport bool operator ==(
6826 const AppliedBuiltinMemberAnnotations& x) const
6827 {
6828 return (m_unit == x.m_unit &&
6829 m_min == x.m_min &&
6830 m_max == x.m_max &&
6831 m_hash_id == x.m_hash_id);
6832 }
6833
6838 eProsima_user_DllExport bool operator !=(
6839 const AppliedBuiltinMemberAnnotations& x) const
6840 {
6841 return !(*this == x);
6842 }
6843
6848 eProsima_user_DllExport void unit(
6849 const eprosima::fastcdr::optional<std::string>& _unit)
6850 {
6851 m_unit = _unit;
6852 }
6853
6858 eProsima_user_DllExport void unit(
6859 eprosima::fastcdr::optional<std::string>&& _unit)
6860 {
6861 m_unit = std::move(_unit);
6862 }
6863
6868 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& unit() const
6869 {
6870 return m_unit;
6871 }
6872
6877 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& unit()
6878 {
6879 return m_unit;
6880 }
6881
6882
6887 eProsima_user_DllExport void min(
6888 const eprosima::fastcdr::optional<AnnotationParameterValue>& _min)
6889 {
6890 m_min = _min;
6891 }
6892
6897 eProsima_user_DllExport void min(
6898 eprosima::fastcdr::optional<AnnotationParameterValue>&& _min)
6899 {
6900 m_min = std::move(_min);
6901 }
6902
6907 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& min() const
6908 {
6909 return m_min;
6910 }
6911
6916 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& min()
6917 {
6918 return m_min;
6919 }
6920
6921
6926 eProsima_user_DllExport void max(
6927 const eprosima::fastcdr::optional<AnnotationParameterValue>& _max)
6928 {
6929 m_max = _max;
6930 }
6931
6936 eProsima_user_DllExport void max(
6937 eprosima::fastcdr::optional<AnnotationParameterValue>&& _max)
6938 {
6939 m_max = std::move(_max);
6940 }
6941
6946 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& max() const
6947 {
6948 return m_max;
6949 }
6950
6955 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& max()
6956 {
6957 return m_max;
6958 }
6959
6960
6965 eProsima_user_DllExport void hash_id(
6966 const eprosima::fastcdr::optional<std::string>& _hash_id)
6967 {
6968 m_hash_id = _hash_id;
6969 }
6970
6975 eProsima_user_DllExport void hash_id(
6976 eprosima::fastcdr::optional<std::string>&& _hash_id)
6977 {
6978 m_hash_id = std::move(_hash_id);
6979 }
6980
6985 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& hash_id() const
6986 {
6987 return m_hash_id;
6988 }
6989
6994 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& hash_id()
6995 {
6996 return m_hash_id;
6997 }
6998
6999
7000
7001private:
7002
7003 eprosima::fastcdr::optional<std::string> m_unit;
7004 eprosima::fastcdr::optional<AnnotationParameterValue> m_min;
7005 eprosima::fastcdr::optional<AnnotationParameterValue> m_max;
7006 eprosima::fastcdr::optional<std::string> m_hash_id;
7007
7008};
7014{
7015public:
7016
7020 eProsima_user_DllExport CommonStructMember()
7021 {
7022 }
7023
7027 eProsima_user_DllExport ~CommonStructMember()
7028 {
7029 }
7030
7035 eProsima_user_DllExport CommonStructMember(
7036 const CommonStructMember& x)
7037 {
7038 m_member_id = x.m_member_id;
7039
7040 m_member_flags = x.m_member_flags;
7041
7042 m_member_type_id = x.m_member_type_id;
7043
7044 }
7045
7050 eProsima_user_DllExport CommonStructMember(
7051 CommonStructMember&& x) noexcept
7052 {
7053 m_member_id = x.m_member_id;
7054 m_member_flags = std::move(x.m_member_flags);
7055 m_member_type_id = std::move(x.m_member_type_id);
7056 }
7057
7062 eProsima_user_DllExport CommonStructMember& operator =(
7063 const CommonStructMember& x)
7064 {
7065
7066 m_member_id = x.m_member_id;
7067
7068 m_member_flags = x.m_member_flags;
7069
7070 m_member_type_id = x.m_member_type_id;
7071
7072 return *this;
7073 }
7074
7079 eProsima_user_DllExport CommonStructMember& operator =(
7080 CommonStructMember&& x) noexcept
7081 {
7082
7083 m_member_id = x.m_member_id;
7084 m_member_flags = std::move(x.m_member_flags);
7085 m_member_type_id = std::move(x.m_member_type_id);
7086 return *this;
7087 }
7088
7093 eProsima_user_DllExport bool operator ==(
7094 const CommonStructMember& x) const
7095 {
7096 return (m_member_id == x.m_member_id &&
7097 m_member_flags == x.m_member_flags &&
7098 m_member_type_id == x.m_member_type_id);
7099 }
7100
7105 eProsima_user_DllExport bool operator !=(
7106 const CommonStructMember& x) const
7107 {
7108 return !(*this == x);
7109 }
7110
7115 eProsima_user_DllExport void member_id(
7116 MemberId _member_id)
7117 {
7118 m_member_id = _member_id;
7119 }
7120
7125 eProsima_user_DllExport MemberId member_id() const
7126 {
7127 return m_member_id;
7128 }
7129
7134 eProsima_user_DllExport MemberId& member_id()
7135 {
7136 return m_member_id;
7137 }
7138
7139
7144 eProsima_user_DllExport void member_flags(
7145 const StructMemberFlag& _member_flags)
7146 {
7147 m_member_flags = _member_flags;
7148 }
7149
7154 eProsima_user_DllExport void member_flags(
7155 StructMemberFlag&& _member_flags)
7156 {
7157 m_member_flags = std::move(_member_flags);
7158 }
7159
7164 eProsima_user_DllExport const StructMemberFlag& member_flags() const
7165 {
7166 return m_member_flags;
7167 }
7168
7173 eProsima_user_DllExport StructMemberFlag& member_flags()
7174 {
7175 return m_member_flags;
7176 }
7177
7178
7183 eProsima_user_DllExport void member_type_id(
7184 const TypeIdentifier& _member_type_id)
7185 {
7186 m_member_type_id = _member_type_id;
7187 }
7188
7193 eProsima_user_DllExport void member_type_id(
7194 TypeIdentifier&& _member_type_id)
7195 {
7196 m_member_type_id = std::move(_member_type_id);
7197 }
7198
7203 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
7204 {
7205 return m_member_type_id;
7206 }
7207
7212 eProsima_user_DllExport TypeIdentifier& member_type_id()
7213 {
7214 return m_member_type_id;
7215 }
7216
7217
7218
7219private:
7220
7221 MemberId m_member_id{0};
7222 StructMemberFlag m_member_flags{0};
7223 TypeIdentifier m_member_type_id;
7224
7225};
7231{
7232public:
7233
7237 eProsima_user_DllExport CompleteMemberDetail()
7238 {
7239 }
7240
7244 eProsima_user_DllExport ~CompleteMemberDetail()
7245 {
7246 }
7247
7252 eProsima_user_DllExport CompleteMemberDetail(
7253 const CompleteMemberDetail& x)
7254 {
7255 m_name = x.m_name;
7256
7257 m_ann_builtin = x.m_ann_builtin;
7258
7259 m_ann_custom = x.m_ann_custom;
7260
7261 }
7262
7267 eProsima_user_DllExport CompleteMemberDetail(
7268 CompleteMemberDetail&& x) noexcept
7269 {
7270 m_name = std::move(x.m_name);
7271 m_ann_builtin = std::move(x.m_ann_builtin);
7272 m_ann_custom = std::move(x.m_ann_custom);
7273 }
7274
7279 eProsima_user_DllExport CompleteMemberDetail& operator =(
7280 const CompleteMemberDetail& x)
7281 {
7282
7283 m_name = x.m_name;
7284
7285 m_ann_builtin = x.m_ann_builtin;
7286
7287 m_ann_custom = x.m_ann_custom;
7288
7289 return *this;
7290 }
7291
7296 eProsima_user_DllExport CompleteMemberDetail& operator =(
7297 CompleteMemberDetail&& x) noexcept
7298 {
7299
7300 m_name = std::move(x.m_name);
7301 m_ann_builtin = std::move(x.m_ann_builtin);
7302 m_ann_custom = std::move(x.m_ann_custom);
7303 return *this;
7304 }
7305
7310 eProsima_user_DllExport bool operator ==(
7311 const CompleteMemberDetail& x) const
7312 {
7313 return (m_name == x.m_name &&
7314 m_ann_builtin == x.m_ann_builtin &&
7315 m_ann_custom == x.m_ann_custom);
7316 }
7317
7322 eProsima_user_DllExport bool operator !=(
7323 const CompleteMemberDetail& x) const
7324 {
7325 return !(*this == x);
7326 }
7327
7332 eProsima_user_DllExport void name(
7333 const MemberName& _name)
7334 {
7335 m_name = _name;
7336 }
7337
7342 eProsima_user_DllExport void name(
7343 MemberName&& _name)
7344 {
7345 m_name = std::move(_name);
7346 }
7347
7352 eProsima_user_DllExport const MemberName& name() const
7353 {
7354 return m_name;
7355 }
7356
7361 eProsima_user_DllExport MemberName& name()
7362 {
7363 return m_name;
7364 }
7365
7366
7371 eProsima_user_DllExport void ann_builtin(
7372 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
7373 {
7374 m_ann_builtin = _ann_builtin;
7375 }
7376
7381 eProsima_user_DllExport void ann_builtin(
7382 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
7383 {
7384 m_ann_builtin = std::move(_ann_builtin);
7385 }
7386
7391 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
7392 {
7393 return m_ann_builtin;
7394 }
7395
7400 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
7401 {
7402 return m_ann_builtin;
7403 }
7404
7405
7410 eProsima_user_DllExport void ann_custom(
7411 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
7412 {
7413 m_ann_custom = _ann_custom;
7414 }
7415
7420 eProsima_user_DllExport void ann_custom(
7421 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
7422 {
7423 m_ann_custom = std::move(_ann_custom);
7424 }
7425
7430 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
7431 {
7432 return m_ann_custom;
7433 }
7434
7439 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
7440 {
7441 return m_ann_custom;
7442 }
7443
7444
7445
7446private:
7447
7448 MemberName m_name;
7449 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
7450 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
7451
7452};
7458{
7459public:
7460
7464 eProsima_user_DllExport MinimalMemberDetail()
7465 {
7466 }
7467
7471 eProsima_user_DllExport ~MinimalMemberDetail()
7472 {
7473 }
7474
7479 eProsima_user_DllExport MinimalMemberDetail(
7480 const MinimalMemberDetail& x)
7481 {
7482 m_name_hash = x.m_name_hash;
7483
7484 }
7485
7490 eProsima_user_DllExport MinimalMemberDetail(
7491 MinimalMemberDetail&& x) noexcept
7492 {
7493 m_name_hash = std::move(x.m_name_hash);
7494 }
7495
7500 eProsima_user_DllExport MinimalMemberDetail& operator =(
7501 const MinimalMemberDetail& x)
7502 {
7503
7504 m_name_hash = x.m_name_hash;
7505
7506 return *this;
7507 }
7508
7513 eProsima_user_DllExport MinimalMemberDetail& operator =(
7514 MinimalMemberDetail&& x) noexcept
7515 {
7516
7517 m_name_hash = std::move(x.m_name_hash);
7518 return *this;
7519 }
7520
7525 eProsima_user_DllExport bool operator ==(
7526 const MinimalMemberDetail& x) const
7527 {
7528 return (m_name_hash == x.m_name_hash);
7529 }
7530
7535 eProsima_user_DllExport bool operator !=(
7536 const MinimalMemberDetail& x) const
7537 {
7538 return !(*this == x);
7539 }
7540
7545 eProsima_user_DllExport void name_hash(
7546 const NameHash& _name_hash)
7547 {
7548 m_name_hash = _name_hash;
7549 }
7550
7555 eProsima_user_DllExport void name_hash(
7556 NameHash&& _name_hash)
7557 {
7558 m_name_hash = std::move(_name_hash);
7559 }
7560
7565 eProsima_user_DllExport const NameHash& name_hash() const
7566 {
7567 return m_name_hash;
7568 }
7569
7574 eProsima_user_DllExport NameHash& name_hash()
7575 {
7576 return m_name_hash;
7577 }
7578
7579
7580
7581private:
7582
7583 NameHash m_name_hash{0};
7584
7585};
7591{
7592public:
7593
7597 eProsima_user_DllExport CompleteStructMember()
7598 {
7599 }
7600
7604 eProsima_user_DllExport ~CompleteStructMember()
7605 {
7606 }
7607
7612 eProsima_user_DllExport CompleteStructMember(
7613 const CompleteStructMember& x)
7614 {
7615 m_common = x.m_common;
7616
7617 m_detail = x.m_detail;
7618
7619 }
7620
7625 eProsima_user_DllExport CompleteStructMember(
7626 CompleteStructMember&& x) noexcept
7627 {
7628 m_common = std::move(x.m_common);
7629 m_detail = std::move(x.m_detail);
7630 }
7631
7636 eProsima_user_DllExport CompleteStructMember& operator =(
7637 const CompleteStructMember& x)
7638 {
7639
7640 m_common = x.m_common;
7641
7642 m_detail = x.m_detail;
7643
7644 return *this;
7645 }
7646
7651 eProsima_user_DllExport CompleteStructMember& operator =(
7652 CompleteStructMember&& x) noexcept
7653 {
7654
7655 m_common = std::move(x.m_common);
7656 m_detail = std::move(x.m_detail);
7657 return *this;
7658 }
7659
7664 eProsima_user_DllExport bool operator ==(
7665 const CompleteStructMember& x) const
7666 {
7667 return (m_common == x.m_common &&
7668 m_detail == x.m_detail);
7669 }
7670
7675 eProsima_user_DllExport bool operator !=(
7676 const CompleteStructMember& x) const
7677 {
7678 return !(*this == x);
7679 }
7680
7685 eProsima_user_DllExport void common(
7686 const CommonStructMember& _common)
7687 {
7688 m_common = _common;
7689 }
7690
7695 eProsima_user_DllExport void common(
7696 CommonStructMember&& _common)
7697 {
7698 m_common = std::move(_common);
7699 }
7700
7705 eProsima_user_DllExport const CommonStructMember& common() const
7706 {
7707 return m_common;
7708 }
7709
7714 eProsima_user_DllExport CommonStructMember& common()
7715 {
7716 return m_common;
7717 }
7718
7719
7724 eProsima_user_DllExport void detail(
7725 const CompleteMemberDetail& _detail)
7726 {
7727 m_detail = _detail;
7728 }
7729
7734 eProsima_user_DllExport void detail(
7735 CompleteMemberDetail&& _detail)
7736 {
7737 m_detail = std::move(_detail);
7738 }
7739
7744 eProsima_user_DllExport const CompleteMemberDetail& detail() const
7745 {
7746 return m_detail;
7747 }
7748
7753 eProsima_user_DllExport CompleteMemberDetail& detail()
7754 {
7755 return m_detail;
7756 }
7757
7758
7759
7760private:
7761
7762 CommonStructMember m_common;
7763 CompleteMemberDetail m_detail;
7764
7765};
7766typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
7767
7773{
7774public:
7775
7779 eProsima_user_DllExport MinimalStructMember()
7780 {
7781 }
7782
7786 eProsima_user_DllExport ~MinimalStructMember()
7787 {
7788 }
7789
7794 eProsima_user_DllExport MinimalStructMember(
7795 const MinimalStructMember& x)
7796 {
7797 m_common = x.m_common;
7798
7799 m_detail = x.m_detail;
7800
7801 }
7802
7807 eProsima_user_DllExport MinimalStructMember(
7808 MinimalStructMember&& x) noexcept
7809 {
7810 m_common = std::move(x.m_common);
7811 m_detail = std::move(x.m_detail);
7812 }
7813
7818 eProsima_user_DllExport MinimalStructMember& operator =(
7819 const MinimalStructMember& x)
7820 {
7821
7822 m_common = x.m_common;
7823
7824 m_detail = x.m_detail;
7825
7826 return *this;
7827 }
7828
7833 eProsima_user_DllExport MinimalStructMember& operator =(
7834 MinimalStructMember&& x) noexcept
7835 {
7836
7837 m_common = std::move(x.m_common);
7838 m_detail = std::move(x.m_detail);
7839 return *this;
7840 }
7841
7846 eProsima_user_DllExport bool operator ==(
7847 const MinimalStructMember& x) const
7848 {
7849 return (m_common == x.m_common &&
7850 m_detail == x.m_detail);
7851 }
7852
7857 eProsima_user_DllExport bool operator !=(
7858 const MinimalStructMember& x) const
7859 {
7860 return !(*this == x);
7861 }
7862
7867 eProsima_user_DllExport void common(
7868 const CommonStructMember& _common)
7869 {
7870 m_common = _common;
7871 }
7872
7877 eProsima_user_DllExport void common(
7878 CommonStructMember&& _common)
7879 {
7880 m_common = std::move(_common);
7881 }
7882
7887 eProsima_user_DllExport const CommonStructMember& common() const
7888 {
7889 return m_common;
7890 }
7891
7896 eProsima_user_DllExport CommonStructMember& common()
7897 {
7898 return m_common;
7899 }
7900
7901
7906 eProsima_user_DllExport void detail(
7907 const MinimalMemberDetail& _detail)
7908 {
7909 m_detail = _detail;
7910 }
7911
7916 eProsima_user_DllExport void detail(
7917 MinimalMemberDetail&& _detail)
7918 {
7919 m_detail = std::move(_detail);
7920 }
7921
7926 eProsima_user_DllExport const MinimalMemberDetail& detail() const
7927 {
7928 return m_detail;
7929 }
7930
7935 eProsima_user_DllExport MinimalMemberDetail& detail()
7936 {
7937 return m_detail;
7938 }
7939
7940
7941
7942private:
7943
7944 CommonStructMember m_common;
7945 MinimalMemberDetail m_detail;
7946
7947};
7948typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
7949
7955{
7956public:
7957
7961 eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
7962 {
7963 }
7964
7968 eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
7969 {
7970 }
7971
7976 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
7978 {
7979 m_verbatim = x.m_verbatim;
7980
7981 }
7982
7987 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
7988 AppliedBuiltinTypeAnnotations&& x) noexcept
7989 {
7990 m_verbatim = std::move(x.m_verbatim);
7991 }
7992
7999 {
8000
8001 m_verbatim = x.m_verbatim;
8002
8003 return *this;
8004 }
8005
8011 AppliedBuiltinTypeAnnotations&& x) noexcept
8012 {
8013
8014 m_verbatim = std::move(x.m_verbatim);
8015 return *this;
8016 }
8017
8022 eProsima_user_DllExport bool operator ==(
8023 const AppliedBuiltinTypeAnnotations& x) const
8024 {
8025 return (m_verbatim == x.m_verbatim);
8026 }
8027
8032 eProsima_user_DllExport bool operator !=(
8033 const AppliedBuiltinTypeAnnotations& x) const
8034 {
8035 return !(*this == x);
8036 }
8037
8042 eProsima_user_DllExport void verbatim(
8043 const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& _verbatim)
8044 {
8045 m_verbatim = _verbatim;
8046 }
8047
8052 eProsima_user_DllExport void verbatim(
8053 eprosima::fastcdr::optional<AppliedVerbatimAnnotation>&& _verbatim)
8054 {
8055 m_verbatim = std::move(_verbatim);
8056 }
8057
8062 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim() const
8063 {
8064 return m_verbatim;
8065 }
8066
8071 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim()
8072 {
8073 return m_verbatim;
8074 }
8075
8076
8077
8078private:
8079
8080 eprosima::fastcdr::optional<AppliedVerbatimAnnotation> m_verbatim;
8081
8082};
8088{
8089public:
8090
8094 eProsima_user_DllExport MinimalTypeDetail()
8095 {
8096 }
8097
8101 eProsima_user_DllExport ~MinimalTypeDetail()
8102 {
8103 }
8104
8109 eProsima_user_DllExport MinimalTypeDetail(
8110 const MinimalTypeDetail& x)
8111 {
8112 static_cast<void>(x);
8113 }
8114
8119 eProsima_user_DllExport MinimalTypeDetail(
8120 MinimalTypeDetail&& x) noexcept
8121 {
8122 static_cast<void>(x);
8123 }
8124
8129 eProsima_user_DllExport MinimalTypeDetail& operator =(
8130 const MinimalTypeDetail& x)
8131 {
8132
8133 static_cast<void>(x);
8134
8135 return *this;
8136 }
8137
8142 eProsima_user_DllExport MinimalTypeDetail& operator =(
8143 MinimalTypeDetail&& x) noexcept
8144 {
8145
8146 static_cast<void>(x);
8147
8148 return *this;
8149 }
8150
8155 eProsima_user_DllExport bool operator ==(
8156 const MinimalTypeDetail& x) const
8157 {
8158 static_cast<void>(x);
8159 return true;
8160 }
8161
8166 eProsima_user_DllExport bool operator !=(
8167 const MinimalTypeDetail& x) const
8168 {
8169 return !(*this == x);
8170 }
8171
8172
8173
8174private:
8175
8176
8177};
8183{
8184public:
8185
8189 eProsima_user_DllExport CompleteTypeDetail()
8190 {
8191 }
8192
8196 eProsima_user_DllExport ~CompleteTypeDetail()
8197 {
8198 }
8199
8204 eProsima_user_DllExport CompleteTypeDetail(
8205 const CompleteTypeDetail& x)
8206 {
8207 m_ann_builtin = x.m_ann_builtin;
8208
8209 m_ann_custom = x.m_ann_custom;
8210
8211 m_type_name = x.m_type_name;
8212
8213 }
8214
8219 eProsima_user_DllExport CompleteTypeDetail(
8220 CompleteTypeDetail&& x) noexcept
8221 {
8222 m_ann_builtin = std::move(x.m_ann_builtin);
8223 m_ann_custom = std::move(x.m_ann_custom);
8224 m_type_name = std::move(x.m_type_name);
8225 }
8226
8231 eProsima_user_DllExport CompleteTypeDetail& operator =(
8232 const CompleteTypeDetail& x)
8233 {
8234
8235 m_ann_builtin = x.m_ann_builtin;
8236
8237 m_ann_custom = x.m_ann_custom;
8238
8239 m_type_name = x.m_type_name;
8240
8241 return *this;
8242 }
8243
8248 eProsima_user_DllExport CompleteTypeDetail& operator =(
8249 CompleteTypeDetail&& x) noexcept
8250 {
8251
8252 m_ann_builtin = std::move(x.m_ann_builtin);
8253 m_ann_custom = std::move(x.m_ann_custom);
8254 m_type_name = std::move(x.m_type_name);
8255 return *this;
8256 }
8257
8262 eProsima_user_DllExport bool operator ==(
8263 const CompleteTypeDetail& x) const
8264 {
8265 return (m_ann_builtin == x.m_ann_builtin &&
8266 m_ann_custom == x.m_ann_custom &&
8267 m_type_name == x.m_type_name);
8268 }
8269
8274 eProsima_user_DllExport bool operator !=(
8275 const CompleteTypeDetail& x) const
8276 {
8277 return !(*this == x);
8278 }
8279
8284 eProsima_user_DllExport void ann_builtin(
8285 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
8286 {
8287 m_ann_builtin = _ann_builtin;
8288 }
8289
8294 eProsima_user_DllExport void ann_builtin(
8295 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
8296 {
8297 m_ann_builtin = std::move(_ann_builtin);
8298 }
8299
8304 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
8305 {
8306 return m_ann_builtin;
8307 }
8308
8313 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
8314 {
8315 return m_ann_builtin;
8316 }
8317
8318
8323 eProsima_user_DllExport void ann_custom(
8324 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
8325 {
8326 m_ann_custom = _ann_custom;
8327 }
8328
8333 eProsima_user_DllExport void ann_custom(
8334 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
8335 {
8336 m_ann_custom = std::move(_ann_custom);
8337 }
8338
8343 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
8344 {
8345 return m_ann_custom;
8346 }
8347
8352 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
8353 {
8354 return m_ann_custom;
8355 }
8356
8357
8362 eProsima_user_DllExport void type_name(
8363 const QualifiedTypeName& _type_name)
8364 {
8365 m_type_name = _type_name;
8366 }
8367
8372 eProsima_user_DllExport void type_name(
8373 QualifiedTypeName&& _type_name)
8374 {
8375 m_type_name = std::move(_type_name);
8376 }
8377
8382 eProsima_user_DllExport const QualifiedTypeName& type_name() const
8383 {
8384 return m_type_name;
8385 }
8386
8391 eProsima_user_DllExport QualifiedTypeName& type_name()
8392 {
8393 return m_type_name;
8394 }
8395
8396
8397
8398private:
8399
8400 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
8401 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
8402 QualifiedTypeName m_type_name;
8403
8404};
8410{
8411public:
8412
8416 eProsima_user_DllExport CompleteStructHeader()
8417 {
8418 }
8419
8423 eProsima_user_DllExport ~CompleteStructHeader()
8424 {
8425 }
8426
8431 eProsima_user_DllExport CompleteStructHeader(
8432 const CompleteStructHeader& x)
8433 {
8434 m_base_type = x.m_base_type;
8435
8436 m_detail = x.m_detail;
8437
8438 }
8439
8444 eProsima_user_DllExport CompleteStructHeader(
8445 CompleteStructHeader&& x) noexcept
8446 {
8447 m_base_type = std::move(x.m_base_type);
8448 m_detail = std::move(x.m_detail);
8449 }
8450
8455 eProsima_user_DllExport CompleteStructHeader& operator =(
8456 const CompleteStructHeader& x)
8457 {
8458
8459 m_base_type = x.m_base_type;
8460
8461 m_detail = x.m_detail;
8462
8463 return *this;
8464 }
8465
8470 eProsima_user_DllExport CompleteStructHeader& operator =(
8471 CompleteStructHeader&& x) noexcept
8472 {
8473
8474 m_base_type = std::move(x.m_base_type);
8475 m_detail = std::move(x.m_detail);
8476 return *this;
8477 }
8478
8483 eProsima_user_DllExport bool operator ==(
8484 const CompleteStructHeader& x) const
8485 {
8486 return (m_base_type == x.m_base_type &&
8487 m_detail == x.m_detail);
8488 }
8489
8494 eProsima_user_DllExport bool operator !=(
8495 const CompleteStructHeader& x) const
8496 {
8497 return !(*this == x);
8498 }
8499
8504 eProsima_user_DllExport void base_type(
8505 const TypeIdentifier& _base_type)
8506 {
8507 m_base_type = _base_type;
8508 }
8509
8514 eProsima_user_DllExport void base_type(
8515 TypeIdentifier&& _base_type)
8516 {
8517 m_base_type = std::move(_base_type);
8518 }
8519
8524 eProsima_user_DllExport const TypeIdentifier& base_type() const
8525 {
8526 return m_base_type;
8527 }
8528
8533 eProsima_user_DllExport TypeIdentifier& base_type()
8534 {
8535 return m_base_type;
8536 }
8537
8538
8543 eProsima_user_DllExport void detail(
8544 const CompleteTypeDetail& _detail)
8545 {
8546 m_detail = _detail;
8547 }
8548
8553 eProsima_user_DllExport void detail(
8554 CompleteTypeDetail&& _detail)
8555 {
8556 m_detail = std::move(_detail);
8557 }
8558
8563 eProsima_user_DllExport const CompleteTypeDetail& detail() const
8564 {
8565 return m_detail;
8566 }
8567
8572 eProsima_user_DllExport CompleteTypeDetail& detail()
8573 {
8574 return m_detail;
8575 }
8576
8577
8578
8579private:
8580
8581 TypeIdentifier m_base_type;
8582 CompleteTypeDetail m_detail;
8583
8584};
8590{
8591public:
8592
8596 eProsima_user_DllExport MinimalStructHeader()
8597 {
8598 }
8599
8603 eProsima_user_DllExport ~MinimalStructHeader()
8604 {
8605 }
8606
8611 eProsima_user_DllExport MinimalStructHeader(
8612 const MinimalStructHeader& x)
8613 {
8614 m_base_type = x.m_base_type;
8615
8616 m_detail = x.m_detail;
8617
8618 }
8619
8624 eProsima_user_DllExport MinimalStructHeader(
8625 MinimalStructHeader&& x) noexcept
8626 {
8627 m_base_type = std::move(x.m_base_type);
8628 m_detail = std::move(x.m_detail);
8629 }
8630
8635 eProsima_user_DllExport MinimalStructHeader& operator =(
8636 const MinimalStructHeader& x)
8637 {
8638
8639 m_base_type = x.m_base_type;
8640
8641 m_detail = x.m_detail;
8642
8643 return *this;
8644 }
8645
8650 eProsima_user_DllExport MinimalStructHeader& operator =(
8651 MinimalStructHeader&& x) noexcept
8652 {
8653
8654 m_base_type = std::move(x.m_base_type);
8655 m_detail = std::move(x.m_detail);
8656 return *this;
8657 }
8658
8663 eProsima_user_DllExport bool operator ==(
8664 const MinimalStructHeader& x) const
8665 {
8666 return (m_base_type == x.m_base_type &&
8667 m_detail == x.m_detail);
8668 }
8669
8674 eProsima_user_DllExport bool operator !=(
8675 const MinimalStructHeader& x) const
8676 {
8677 return !(*this == x);
8678 }
8679
8684 eProsima_user_DllExport void base_type(
8685 const TypeIdentifier& _base_type)
8686 {
8687 m_base_type = _base_type;
8688 }
8689
8694 eProsima_user_DllExport void base_type(
8695 TypeIdentifier&& _base_type)
8696 {
8697 m_base_type = std::move(_base_type);
8698 }
8699
8704 eProsima_user_DllExport const TypeIdentifier& base_type() const
8705 {
8706 return m_base_type;
8707 }
8708
8713 eProsima_user_DllExport TypeIdentifier& base_type()
8714 {
8715 return m_base_type;
8716 }
8717
8718
8723 eProsima_user_DllExport void detail(
8724 const MinimalTypeDetail& _detail)
8725 {
8726 m_detail = _detail;
8727 }
8728
8733 eProsima_user_DllExport void detail(
8734 MinimalTypeDetail&& _detail)
8735 {
8736 m_detail = std::move(_detail);
8737 }
8738
8743 eProsima_user_DllExport const MinimalTypeDetail& detail() const
8744 {
8745 return m_detail;
8746 }
8747
8752 eProsima_user_DllExport MinimalTypeDetail& detail()
8753 {
8754 return m_detail;
8755 }
8756
8757
8758
8759private:
8760
8761 TypeIdentifier m_base_type;
8762 MinimalTypeDetail m_detail;
8763
8764};
8770{
8771public:
8772
8776 eProsima_user_DllExport CompleteStructType()
8777 {
8778 }
8779
8783 eProsima_user_DllExport ~CompleteStructType()
8784 {
8785 }
8786
8791 eProsima_user_DllExport CompleteStructType(
8792 const CompleteStructType& x)
8793 {
8794 m_struct_flags = x.m_struct_flags;
8795
8796 m_header = x.m_header;
8797
8798 m_member_seq = x.m_member_seq;
8799
8800 }
8801
8806 eProsima_user_DllExport CompleteStructType(
8807 CompleteStructType&& x) noexcept
8808 {
8809 m_struct_flags = std::move(x.m_struct_flags);
8810 m_header = std::move(x.m_header);
8811 m_member_seq = std::move(x.m_member_seq);
8812 }
8813
8818 eProsima_user_DllExport CompleteStructType& operator =(
8819 const CompleteStructType& x)
8820 {
8821
8822 m_struct_flags = x.m_struct_flags;
8823
8824 m_header = x.m_header;
8825
8826 m_member_seq = x.m_member_seq;
8827
8828 return *this;
8829 }
8830
8835 eProsima_user_DllExport CompleteStructType& operator =(
8836 CompleteStructType&& x) noexcept
8837 {
8838
8839 m_struct_flags = std::move(x.m_struct_flags);
8840 m_header = std::move(x.m_header);
8841 m_member_seq = std::move(x.m_member_seq);
8842 return *this;
8843 }
8844
8849 eProsima_user_DllExport bool operator ==(
8850 const CompleteStructType& x) const
8851 {
8852 return (m_struct_flags == x.m_struct_flags &&
8853 m_header == x.m_header &&
8854 m_member_seq == x.m_member_seq);
8855 }
8856
8861 eProsima_user_DllExport bool operator !=(
8862 const CompleteStructType& x) const
8863 {
8864 return !(*this == x);
8865 }
8866
8871 eProsima_user_DllExport void struct_flags(
8872 const StructTypeFlag& _struct_flags)
8873 {
8874 m_struct_flags = _struct_flags;
8875 }
8876
8881 eProsima_user_DllExport void struct_flags(
8882 StructTypeFlag&& _struct_flags)
8883 {
8884 m_struct_flags = std::move(_struct_flags);
8885 }
8886
8891 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
8892 {
8893 return m_struct_flags;
8894 }
8895
8900 eProsima_user_DllExport StructTypeFlag& struct_flags()
8901 {
8902 return m_struct_flags;
8903 }
8904
8905
8910 eProsima_user_DllExport void header(
8911 const CompleteStructHeader& _header)
8912 {
8913 m_header = _header;
8914 }
8915
8920 eProsima_user_DllExport void header(
8921 CompleteStructHeader&& _header)
8922 {
8923 m_header = std::move(_header);
8924 }
8925
8930 eProsima_user_DllExport const CompleteStructHeader& header() const
8931 {
8932 return m_header;
8933 }
8934
8939 eProsima_user_DllExport CompleteStructHeader& header()
8940 {
8941 return m_header;
8942 }
8943
8944
8949 eProsima_user_DllExport void member_seq(
8950 const CompleteStructMemberSeq& _member_seq)
8951 {
8952 m_member_seq = _member_seq;
8953 }
8954
8959 eProsima_user_DllExport void member_seq(
8960 CompleteStructMemberSeq&& _member_seq)
8961 {
8962 m_member_seq = std::move(_member_seq);
8963 }
8964
8969 eProsima_user_DllExport const CompleteStructMemberSeq& member_seq() const
8970 {
8971 return m_member_seq;
8972 }
8973
8978 eProsima_user_DllExport CompleteStructMemberSeq& member_seq()
8979 {
8980 return m_member_seq;
8981 }
8982
8983
8984
8985private:
8986
8987 StructTypeFlag m_struct_flags{0};
8988 CompleteStructHeader m_header;
8989 CompleteStructMemberSeq m_member_seq;
8990
8991};
8997{
8998public:
8999
9003 eProsima_user_DllExport MinimalStructType()
9004 {
9005 }
9006
9010 eProsima_user_DllExport ~MinimalStructType()
9011 {
9012 }
9013
9018 eProsima_user_DllExport MinimalStructType(
9019 const MinimalStructType& x)
9020 {
9021 m_struct_flags = x.m_struct_flags;
9022
9023 m_header = x.m_header;
9024
9025 m_member_seq = x.m_member_seq;
9026
9027 }
9028
9033 eProsima_user_DllExport MinimalStructType(
9034 MinimalStructType&& x) noexcept
9035 {
9036 m_struct_flags = std::move(x.m_struct_flags);
9037 m_header = std::move(x.m_header);
9038 m_member_seq = std::move(x.m_member_seq);
9039 }
9040
9045 eProsima_user_DllExport MinimalStructType& operator =(
9046 const MinimalStructType& x)
9047 {
9048
9049 m_struct_flags = x.m_struct_flags;
9050
9051 m_header = x.m_header;
9052
9053 m_member_seq = x.m_member_seq;
9054
9055 return *this;
9056 }
9057
9062 eProsima_user_DllExport MinimalStructType& operator =(
9063 MinimalStructType&& x) noexcept
9064 {
9065
9066 m_struct_flags = std::move(x.m_struct_flags);
9067 m_header = std::move(x.m_header);
9068 m_member_seq = std::move(x.m_member_seq);
9069 return *this;
9070 }
9071
9076 eProsima_user_DllExport bool operator ==(
9077 const MinimalStructType& x) const
9078 {
9079 return (m_struct_flags == x.m_struct_flags &&
9080 m_header == x.m_header &&
9081 m_member_seq == x.m_member_seq);
9082 }
9083
9088 eProsima_user_DllExport bool operator !=(
9089 const MinimalStructType& x) const
9090 {
9091 return !(*this == x);
9092 }
9093
9098 eProsima_user_DllExport void struct_flags(
9099 const StructTypeFlag& _struct_flags)
9100 {
9101 m_struct_flags = _struct_flags;
9102 }
9103
9108 eProsima_user_DllExport void struct_flags(
9109 StructTypeFlag&& _struct_flags)
9110 {
9111 m_struct_flags = std::move(_struct_flags);
9112 }
9113
9118 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
9119 {
9120 return m_struct_flags;
9121 }
9122
9127 eProsima_user_DllExport StructTypeFlag& struct_flags()
9128 {
9129 return m_struct_flags;
9130 }
9131
9132
9137 eProsima_user_DllExport void header(
9138 const MinimalStructHeader& _header)
9139 {
9140 m_header = _header;
9141 }
9142
9147 eProsima_user_DllExport void header(
9148 MinimalStructHeader&& _header)
9149 {
9150 m_header = std::move(_header);
9151 }
9152
9157 eProsima_user_DllExport const MinimalStructHeader& header() const
9158 {
9159 return m_header;
9160 }
9161
9166 eProsima_user_DllExport MinimalStructHeader& header()
9167 {
9168 return m_header;
9169 }
9170
9171
9176 eProsima_user_DllExport void member_seq(
9177 const MinimalStructMemberSeq& _member_seq)
9178 {
9179 m_member_seq = _member_seq;
9180 }
9181
9186 eProsima_user_DllExport void member_seq(
9187 MinimalStructMemberSeq&& _member_seq)
9188 {
9189 m_member_seq = std::move(_member_seq);
9190 }
9191
9196 eProsima_user_DllExport const MinimalStructMemberSeq& member_seq() const
9197 {
9198 return m_member_seq;
9199 }
9200
9205 eProsima_user_DllExport MinimalStructMemberSeq& member_seq()
9206 {
9207 return m_member_seq;
9208 }
9209
9210
9211
9212private:
9213
9214 StructTypeFlag m_struct_flags{0};
9215 MinimalStructHeader m_header;
9216 MinimalStructMemberSeq m_member_seq;
9217
9218};
9219typedef std::vector<int32_t> UnionCaseLabelSeq;
9220
9226{
9227public:
9228
9232 eProsima_user_DllExport CommonUnionMember()
9233 {
9234 }
9235
9239 eProsima_user_DllExport ~CommonUnionMember()
9240 {
9241 }
9242
9247 eProsima_user_DllExport CommonUnionMember(
9248 const CommonUnionMember& x)
9249 {
9250 m_member_id = x.m_member_id;
9251
9252 m_member_flags = x.m_member_flags;
9253
9254 m_type_id = x.m_type_id;
9255
9256 m_label_seq = x.m_label_seq;
9257
9258 }
9259
9264 eProsima_user_DllExport CommonUnionMember(
9265 CommonUnionMember&& x) noexcept
9266 {
9267 m_member_id = x.m_member_id;
9268 m_member_flags = std::move(x.m_member_flags);
9269 m_type_id = std::move(x.m_type_id);
9270 m_label_seq = std::move(x.m_label_seq);
9271 }
9272
9277 eProsima_user_DllExport CommonUnionMember& operator =(
9278 const CommonUnionMember& x)
9279 {
9280
9281 m_member_id = x.m_member_id;
9282
9283 m_member_flags = x.m_member_flags;
9284
9285 m_type_id = x.m_type_id;
9286
9287 m_label_seq = x.m_label_seq;
9288
9289 return *this;
9290 }
9291
9296 eProsima_user_DllExport CommonUnionMember& operator =(
9297 CommonUnionMember&& x) noexcept
9298 {
9299
9300 m_member_id = x.m_member_id;
9301 m_member_flags = std::move(x.m_member_flags);
9302 m_type_id = std::move(x.m_type_id);
9303 m_label_seq = std::move(x.m_label_seq);
9304 return *this;
9305 }
9306
9311 eProsima_user_DllExport bool operator ==(
9312 const CommonUnionMember& x) const
9313 {
9314 return (m_member_id == x.m_member_id &&
9315 m_member_flags == x.m_member_flags &&
9316 m_type_id == x.m_type_id &&
9317 m_label_seq == x.m_label_seq);
9318 }
9319
9324 eProsima_user_DllExport bool operator !=(
9325 const CommonUnionMember& x) const
9326 {
9327 return !(*this == x);
9328 }
9329
9334 eProsima_user_DllExport void member_id(
9335 MemberId _member_id)
9336 {
9337 m_member_id = _member_id;
9338 }
9339
9344 eProsima_user_DllExport MemberId member_id() const
9345 {
9346 return m_member_id;
9347 }
9348
9353 eProsima_user_DllExport MemberId& member_id()
9354 {
9355 return m_member_id;
9356 }
9357
9358
9363 eProsima_user_DllExport void member_flags(
9364 const UnionMemberFlag& _member_flags)
9365 {
9366 m_member_flags = _member_flags;
9367 }
9368
9373 eProsima_user_DllExport void member_flags(
9374 UnionMemberFlag&& _member_flags)
9375 {
9376 m_member_flags = std::move(_member_flags);
9377 }
9378
9383 eProsima_user_DllExport const UnionMemberFlag& member_flags() const
9384 {
9385 return m_member_flags;
9386 }
9387
9392 eProsima_user_DllExport UnionMemberFlag& member_flags()
9393 {
9394 return m_member_flags;
9395 }
9396
9397
9402 eProsima_user_DllExport void type_id(
9403 const TypeIdentifier& _type_id)
9404 {
9405 m_type_id = _type_id;
9406 }
9407
9412 eProsima_user_DllExport void type_id(
9413 TypeIdentifier&& _type_id)
9414 {
9415 m_type_id = std::move(_type_id);
9416 }
9417
9422 eProsima_user_DllExport const TypeIdentifier& type_id() const
9423 {
9424 return m_type_id;
9425 }
9426
9431 eProsima_user_DllExport TypeIdentifier& type_id()
9432 {
9433 return m_type_id;
9434 }
9435
9436
9441 eProsima_user_DllExport void label_seq(
9442 const UnionCaseLabelSeq& _label_seq)
9443 {
9444 m_label_seq = _label_seq;
9445 }
9446
9451 eProsima_user_DllExport void label_seq(
9452 UnionCaseLabelSeq&& _label_seq)
9453 {
9454 m_label_seq = std::move(_label_seq);
9455 }
9456
9461 eProsima_user_DllExport const UnionCaseLabelSeq& label_seq() const
9462 {
9463 return m_label_seq;
9464 }
9465
9470 eProsima_user_DllExport UnionCaseLabelSeq& label_seq()
9471 {
9472 return m_label_seq;
9473 }
9474
9475
9476
9477private:
9478
9479 MemberId m_member_id{0};
9480 UnionMemberFlag m_member_flags{0};
9481 TypeIdentifier m_type_id;
9482 UnionCaseLabelSeq m_label_seq;
9483
9484};
9490{
9491public:
9492
9496 eProsima_user_DllExport CompleteUnionMember()
9497 {
9498 }
9499
9503 eProsima_user_DllExport ~CompleteUnionMember()
9504 {
9505 }
9506
9511 eProsima_user_DllExport CompleteUnionMember(
9512 const CompleteUnionMember& x)
9513 {
9514 m_common = x.m_common;
9515
9516 m_detail = x.m_detail;
9517
9518 }
9519
9524 eProsima_user_DllExport CompleteUnionMember(
9525 CompleteUnionMember&& x) noexcept
9526 {
9527 m_common = std::move(x.m_common);
9528 m_detail = std::move(x.m_detail);
9529 }
9530
9535 eProsima_user_DllExport CompleteUnionMember& operator =(
9536 const CompleteUnionMember& x)
9537 {
9538
9539 m_common = x.m_common;
9540
9541 m_detail = x.m_detail;
9542
9543 return *this;
9544 }
9545
9550 eProsima_user_DllExport CompleteUnionMember& operator =(
9551 CompleteUnionMember&& x) noexcept
9552 {
9553
9554 m_common = std::move(x.m_common);
9555 m_detail = std::move(x.m_detail);
9556 return *this;
9557 }
9558
9563 eProsima_user_DllExport bool operator ==(
9564 const CompleteUnionMember& x) const
9565 {
9566 return (m_common == x.m_common &&
9567 m_detail == x.m_detail);
9568 }
9569
9574 eProsima_user_DllExport bool operator !=(
9575 const CompleteUnionMember& x) const
9576 {
9577 return !(*this == x);
9578 }
9579
9584 eProsima_user_DllExport void common(
9585 const CommonUnionMember& _common)
9586 {
9587 m_common = _common;
9588 }
9589
9594 eProsima_user_DllExport void common(
9595 CommonUnionMember&& _common)
9596 {
9597 m_common = std::move(_common);
9598 }
9599
9604 eProsima_user_DllExport const CommonUnionMember& common() const
9605 {
9606 return m_common;
9607 }
9608
9613 eProsima_user_DllExport CommonUnionMember& common()
9614 {
9615 return m_common;
9616 }
9617
9618
9623 eProsima_user_DllExport void detail(
9624 const CompleteMemberDetail& _detail)
9625 {
9626 m_detail = _detail;
9627 }
9628
9633 eProsima_user_DllExport void detail(
9634 CompleteMemberDetail&& _detail)
9635 {
9636 m_detail = std::move(_detail);
9637 }
9638
9643 eProsima_user_DllExport const CompleteMemberDetail& detail() const
9644 {
9645 return m_detail;
9646 }
9647
9652 eProsima_user_DllExport CompleteMemberDetail& detail()
9653 {
9654 return m_detail;
9655 }
9656
9657
9658
9659private:
9660
9661 CommonUnionMember m_common;
9662 CompleteMemberDetail m_detail;
9663
9664};
9665typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
9666
9672{
9673public:
9674
9678 eProsima_user_DllExport MinimalUnionMember()
9679 {
9680 }
9681
9685 eProsima_user_DllExport ~MinimalUnionMember()
9686 {
9687 }
9688
9693 eProsima_user_DllExport MinimalUnionMember(
9694 const MinimalUnionMember& x)
9695 {
9696 m_common = x.m_common;
9697
9698 m_detail = x.m_detail;
9699
9700 }
9701
9706 eProsima_user_DllExport MinimalUnionMember(
9707 MinimalUnionMember&& x) noexcept
9708 {
9709 m_common = std::move(x.m_common);
9710 m_detail = std::move(x.m_detail);
9711 }
9712
9717 eProsima_user_DllExport MinimalUnionMember& operator =(
9718 const MinimalUnionMember& x)
9719 {
9720
9721 m_common = x.m_common;
9722
9723 m_detail = x.m_detail;
9724
9725 return *this;
9726 }
9727
9732 eProsima_user_DllExport MinimalUnionMember& operator =(
9733 MinimalUnionMember&& x) noexcept
9734 {
9735
9736 m_common = std::move(x.m_common);
9737 m_detail = std::move(x.m_detail);
9738 return *this;
9739 }
9740
9745 eProsima_user_DllExport bool operator ==(
9746 const MinimalUnionMember& x) const
9747 {
9748 return (m_common == x.m_common &&
9749 m_detail == x.m_detail);
9750 }
9751
9756 eProsima_user_DllExport bool operator !=(
9757 const MinimalUnionMember& x) const
9758 {
9759 return !(*this == x);
9760 }
9761
9766 eProsima_user_DllExport void common(
9767 const CommonUnionMember& _common)
9768 {
9769 m_common = _common;
9770 }
9771
9776 eProsima_user_DllExport void common(
9777 CommonUnionMember&& _common)
9778 {
9779 m_common = std::move(_common);
9780 }
9781
9786 eProsima_user_DllExport const CommonUnionMember& common() const
9787 {
9788 return m_common;
9789 }
9790
9795 eProsima_user_DllExport CommonUnionMember& common()
9796 {
9797 return m_common;
9798 }
9799
9800
9805 eProsima_user_DllExport void detail(
9806 const MinimalMemberDetail& _detail)
9807 {
9808 m_detail = _detail;
9809 }
9810
9815 eProsima_user_DllExport void detail(
9816 MinimalMemberDetail&& _detail)
9817 {
9818 m_detail = std::move(_detail);
9819 }
9820
9825 eProsima_user_DllExport const MinimalMemberDetail& detail() const
9826 {
9827 return m_detail;
9828 }
9829
9834 eProsima_user_DllExport MinimalMemberDetail& detail()
9835 {
9836 return m_detail;
9837 }
9838
9839
9840
9841private:
9842
9843 CommonUnionMember m_common;
9844 MinimalMemberDetail m_detail;
9845
9846};
9847typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
9848
9854{
9855public:
9856
9860 eProsima_user_DllExport CommonDiscriminatorMember()
9861 {
9862 }
9863
9867 eProsima_user_DllExport ~CommonDiscriminatorMember()
9868 {
9869 }
9870
9875 eProsima_user_DllExport CommonDiscriminatorMember(
9877 {
9878 m_member_flags = x.m_member_flags;
9879
9880 m_type_id = x.m_type_id;
9881
9882 }
9883
9888 eProsima_user_DllExport CommonDiscriminatorMember(
9889 CommonDiscriminatorMember&& x) noexcept
9890 {
9891 m_member_flags = std::move(x.m_member_flags);
9892 m_type_id = std::move(x.m_type_id);
9893 }
9894
9899 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9901 {
9902
9903 m_member_flags = x.m_member_flags;
9904
9905 m_type_id = x.m_type_id;
9906
9907 return *this;
9908 }
9909
9914 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9915 CommonDiscriminatorMember&& x) noexcept
9916 {
9917
9918 m_member_flags = std::move(x.m_member_flags);
9919 m_type_id = std::move(x.m_type_id);
9920 return *this;
9921 }
9922
9927 eProsima_user_DllExport bool operator ==(
9928 const CommonDiscriminatorMember& x) const
9929 {
9930 return (m_member_flags == x.m_member_flags &&
9931 m_type_id == x.m_type_id);
9932 }
9933
9938 eProsima_user_DllExport bool operator !=(
9939 const CommonDiscriminatorMember& x) const
9940 {
9941 return !(*this == x);
9942 }
9943
9948 eProsima_user_DllExport void member_flags(
9949 const UnionDiscriminatorFlag& _member_flags)
9950 {
9951 m_member_flags = _member_flags;
9952 }
9953
9958 eProsima_user_DllExport void member_flags(
9959 UnionDiscriminatorFlag&& _member_flags)
9960 {
9961 m_member_flags = std::move(_member_flags);
9962 }
9963
9968 eProsima_user_DllExport const UnionDiscriminatorFlag& member_flags() const
9969 {
9970 return m_member_flags;
9971 }
9972
9977 eProsima_user_DllExport UnionDiscriminatorFlag& member_flags()
9978 {
9979 return m_member_flags;
9980 }
9981
9982
9987 eProsima_user_DllExport void type_id(
9988 const TypeIdentifier& _type_id)
9989 {
9990 m_type_id = _type_id;
9991 }
9992
9997 eProsima_user_DllExport void type_id(
9998 TypeIdentifier&& _type_id)
9999 {
10000 m_type_id = std::move(_type_id);
10001 }
10002
10007 eProsima_user_DllExport const TypeIdentifier& type_id() const
10008 {
10009 return m_type_id;
10010 }
10011
10016 eProsima_user_DllExport TypeIdentifier& type_id()
10017 {
10018 return m_type_id;
10019 }
10020
10021
10022
10023private:
10024
10025 UnionDiscriminatorFlag m_member_flags{0};
10026 TypeIdentifier m_type_id;
10027
10028};
10034{
10035public:
10036
10040 eProsima_user_DllExport CompleteDiscriminatorMember()
10041 {
10042 }
10043
10047 eProsima_user_DllExport ~CompleteDiscriminatorMember()
10048 {
10049 }
10050
10055 eProsima_user_DllExport CompleteDiscriminatorMember(
10057 {
10058 m_common = x.m_common;
10059
10060 m_ann_builtin = x.m_ann_builtin;
10061
10062 m_ann_custom = x.m_ann_custom;
10063
10064 }
10065
10070 eProsima_user_DllExport CompleteDiscriminatorMember(
10071 CompleteDiscriminatorMember&& x) noexcept
10072 {
10073 m_common = std::move(x.m_common);
10074 m_ann_builtin = std::move(x.m_ann_builtin);
10075 m_ann_custom = std::move(x.m_ann_custom);
10076 }
10077
10082 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10084 {
10085
10086 m_common = x.m_common;
10087
10088 m_ann_builtin = x.m_ann_builtin;
10089
10090 m_ann_custom = x.m_ann_custom;
10091
10092 return *this;
10093 }
10094
10099 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10100 CompleteDiscriminatorMember&& x) noexcept
10101 {
10102
10103 m_common = std::move(x.m_common);
10104 m_ann_builtin = std::move(x.m_ann_builtin);
10105 m_ann_custom = std::move(x.m_ann_custom);
10106 return *this;
10107 }
10108
10113 eProsima_user_DllExport bool operator ==(
10114 const CompleteDiscriminatorMember& x) const
10115 {
10116 return (m_common == x.m_common &&
10117 m_ann_builtin == x.m_ann_builtin &&
10118 m_ann_custom == x.m_ann_custom);
10119 }
10120
10125 eProsima_user_DllExport bool operator !=(
10126 const CompleteDiscriminatorMember& x) const
10127 {
10128 return !(*this == x);
10129 }
10130
10135 eProsima_user_DllExport void common(
10136 const CommonDiscriminatorMember& _common)
10137 {
10138 m_common = _common;
10139 }
10140
10145 eProsima_user_DllExport void common(
10146 CommonDiscriminatorMember&& _common)
10147 {
10148 m_common = std::move(_common);
10149 }
10150
10155 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10156 {
10157 return m_common;
10158 }
10159
10164 eProsima_user_DllExport CommonDiscriminatorMember& common()
10165 {
10166 return m_common;
10167 }
10168
10169
10174 eProsima_user_DllExport void ann_builtin(
10175 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
10176 {
10177 m_ann_builtin = _ann_builtin;
10178 }
10179
10184 eProsima_user_DllExport void ann_builtin(
10185 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
10186 {
10187 m_ann_builtin = std::move(_ann_builtin);
10188 }
10189
10194 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
10195 {
10196 return m_ann_builtin;
10197 }
10198
10203 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
10204 {
10205 return m_ann_builtin;
10206 }
10207
10208
10213 eProsima_user_DllExport void ann_custom(
10214 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
10215 {
10216 m_ann_custom = _ann_custom;
10217 }
10218
10223 eProsima_user_DllExport void ann_custom(
10224 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
10225 {
10226 m_ann_custom = std::move(_ann_custom);
10227 }
10228
10233 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
10234 {
10235 return m_ann_custom;
10236 }
10237
10242 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
10243 {
10244 return m_ann_custom;
10245 }
10246
10247
10248
10249private:
10250
10252 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
10253 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
10254
10255};
10261{
10262public:
10263
10267 eProsima_user_DllExport MinimalDiscriminatorMember()
10268 {
10269 }
10270
10274 eProsima_user_DllExport ~MinimalDiscriminatorMember()
10275 {
10276 }
10277
10282 eProsima_user_DllExport MinimalDiscriminatorMember(
10284 {
10285 m_common = x.m_common;
10286
10287 }
10288
10293 eProsima_user_DllExport MinimalDiscriminatorMember(
10294 MinimalDiscriminatorMember&& x) noexcept
10295 {
10296 m_common = std::move(x.m_common);
10297 }
10298
10303 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10305 {
10306
10307 m_common = x.m_common;
10308
10309 return *this;
10310 }
10311
10316 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10317 MinimalDiscriminatorMember&& x) noexcept
10318 {
10319
10320 m_common = std::move(x.m_common);
10321 return *this;
10322 }
10323
10328 eProsima_user_DllExport bool operator ==(
10329 const MinimalDiscriminatorMember& x) const
10330 {
10331 return (m_common == x.m_common);
10332 }
10333
10338 eProsima_user_DllExport bool operator !=(
10339 const MinimalDiscriminatorMember& x) const
10340 {
10341 return !(*this == x);
10342 }
10343
10348 eProsima_user_DllExport void common(
10349 const CommonDiscriminatorMember& _common)
10350 {
10351 m_common = _common;
10352 }
10353
10358 eProsima_user_DllExport void common(
10359 CommonDiscriminatorMember&& _common)
10360 {
10361 m_common = std::move(_common);
10362 }
10363
10368 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10369 {
10370 return m_common;
10371 }
10372
10377 eProsima_user_DllExport CommonDiscriminatorMember& common()
10378 {
10379 return m_common;
10380 }
10381
10382
10383
10384private:
10385
10387
10388};
10394{
10395public:
10396
10400 eProsima_user_DllExport CompleteUnionHeader()
10401 {
10402 }
10403
10407 eProsima_user_DllExport ~CompleteUnionHeader()
10408 {
10409 }
10410
10415 eProsima_user_DllExport CompleteUnionHeader(
10416 const CompleteUnionHeader& x)
10417 {
10418 m_detail = x.m_detail;
10419
10420 }
10421
10426 eProsima_user_DllExport CompleteUnionHeader(
10427 CompleteUnionHeader&& x) noexcept
10428 {
10429 m_detail = std::move(x.m_detail);
10430 }
10431
10436 eProsima_user_DllExport CompleteUnionHeader& operator =(
10437 const CompleteUnionHeader& x)
10438 {
10439
10440 m_detail = x.m_detail;
10441
10442 return *this;
10443 }
10444
10449 eProsima_user_DllExport CompleteUnionHeader& operator =(
10450 CompleteUnionHeader&& x) noexcept
10451 {
10452
10453 m_detail = std::move(x.m_detail);
10454 return *this;
10455 }
10456
10461 eProsima_user_DllExport bool operator ==(
10462 const CompleteUnionHeader& x) const
10463 {
10464 return (m_detail == x.m_detail);
10465 }
10466
10471 eProsima_user_DllExport bool operator !=(
10472 const CompleteUnionHeader& x) const
10473 {
10474 return !(*this == x);
10475 }
10476
10481 eProsima_user_DllExport void detail(
10482 const CompleteTypeDetail& _detail)
10483 {
10484 m_detail = _detail;
10485 }
10486
10491 eProsima_user_DllExport void detail(
10492 CompleteTypeDetail&& _detail)
10493 {
10494 m_detail = std::move(_detail);
10495 }
10496
10501 eProsima_user_DllExport const CompleteTypeDetail& detail() const
10502 {
10503 return m_detail;
10504 }
10505
10510 eProsima_user_DllExport CompleteTypeDetail& detail()
10511 {
10512 return m_detail;
10513 }
10514
10515
10516
10517private:
10518
10519 CompleteTypeDetail m_detail;
10520
10521};
10527{
10528public:
10529
10533 eProsima_user_DllExport MinimalUnionHeader()
10534 {
10535 }
10536
10540 eProsima_user_DllExport ~MinimalUnionHeader()
10541 {
10542 }
10543
10548 eProsima_user_DllExport MinimalUnionHeader(
10549 const MinimalUnionHeader& x)
10550 {
10551 m_detail = x.m_detail;
10552
10553 }
10554
10559 eProsima_user_DllExport MinimalUnionHeader(
10560 MinimalUnionHeader&& x) noexcept
10561 {
10562 m_detail = std::move(x.m_detail);
10563 }
10564
10569 eProsima_user_DllExport MinimalUnionHeader& operator =(
10570 const MinimalUnionHeader& x)
10571 {
10572
10573 m_detail = x.m_detail;
10574
10575 return *this;
10576 }
10577
10582 eProsima_user_DllExport MinimalUnionHeader& operator =(
10583 MinimalUnionHeader&& x) noexcept
10584 {
10585
10586 m_detail = std::move(x.m_detail);
10587 return *this;
10588 }
10589
10594 eProsima_user_DllExport bool operator ==(
10595 const MinimalUnionHeader& x) const
10596 {
10597 return (m_detail == x.m_detail);
10598 }
10599
10604 eProsima_user_DllExport bool operator !=(
10605 const MinimalUnionHeader& x) const
10606 {
10607 return !(*this == x);
10608 }
10609
10614 eProsima_user_DllExport void detail(
10615 const MinimalTypeDetail& _detail)
10616 {
10617 m_detail = _detail;
10618 }
10619
10624 eProsima_user_DllExport void detail(
10625 MinimalTypeDetail&& _detail)
10626 {
10627 m_detail = std::move(_detail);
10628 }
10629
10634 eProsima_user_DllExport const MinimalTypeDetail& detail() const
10635 {
10636 return m_detail;
10637 }
10638
10643 eProsima_user_DllExport MinimalTypeDetail& detail()
10644 {
10645 return m_detail;
10646 }
10647
10648
10649
10650private:
10651
10652 MinimalTypeDetail m_detail;
10653
10654};
10660{
10661public:
10662
10666 eProsima_user_DllExport CompleteUnionType()
10667 {
10668 }
10669
10673 eProsima_user_DllExport ~CompleteUnionType()
10674 {
10675 }
10676
10681 eProsima_user_DllExport CompleteUnionType(
10682 const CompleteUnionType& x)
10683 {
10684 m_union_flags = x.m_union_flags;
10685
10686 m_header = x.m_header;
10687
10688 m_discriminator = x.m_discriminator;
10689
10690 m_member_seq = x.m_member_seq;
10691
10692 }
10693
10698 eProsima_user_DllExport CompleteUnionType(
10699 CompleteUnionType&& x) noexcept
10700 {
10701 m_union_flags = std::move(x.m_union_flags);
10702 m_header = std::move(x.m_header);
10703 m_discriminator = std::move(x.m_discriminator);
10704 m_member_seq = std::move(x.m_member_seq);
10705 }
10706
10711 eProsima_user_DllExport CompleteUnionType& operator =(
10712 const CompleteUnionType& x)
10713 {
10714
10715 m_union_flags = x.m_union_flags;
10716
10717 m_header = x.m_header;
10718
10719 m_discriminator = x.m_discriminator;
10720
10721 m_member_seq = x.m_member_seq;
10722
10723 return *this;
10724 }
10725
10730 eProsima_user_DllExport CompleteUnionType& operator =(
10731 CompleteUnionType&& x) noexcept
10732 {
10733
10734 m_union_flags = std::move(x.m_union_flags);
10735 m_header = std::move(x.m_header);
10736 m_discriminator = std::move(x.m_discriminator);
10737 m_member_seq = std::move(x.m_member_seq);
10738 return *this;
10739 }
10740
10745 eProsima_user_DllExport bool operator ==(
10746 const CompleteUnionType& x) const
10747 {
10748 return (m_union_flags == x.m_union_flags &&
10749 m_header == x.m_header &&
10750 m_discriminator == x.m_discriminator &&
10751 m_member_seq == x.m_member_seq);
10752 }
10753
10758 eProsima_user_DllExport bool operator !=(
10759 const CompleteUnionType& x) const
10760 {
10761 return !(*this == x);
10762 }
10763
10768 eProsima_user_DllExport void union_flags(
10769 const UnionTypeFlag& _union_flags)
10770 {
10771 m_union_flags = _union_flags;
10772 }
10773
10778 eProsima_user_DllExport void union_flags(
10779 UnionTypeFlag&& _union_flags)
10780 {
10781 m_union_flags = std::move(_union_flags);
10782 }
10783
10788 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
10789 {
10790 return m_union_flags;
10791 }
10792
10797 eProsima_user_DllExport UnionTypeFlag& union_flags()
10798 {
10799 return m_union_flags;
10800 }
10801
10802
10807 eProsima_user_DllExport void header(
10808 const CompleteUnionHeader& _header)
10809 {
10810 m_header = _header;
10811 }
10812
10817 eProsima_user_DllExport void header(
10818 CompleteUnionHeader&& _header)
10819 {
10820 m_header = std::move(_header);
10821 }
10822
10827 eProsima_user_DllExport const CompleteUnionHeader& header() const
10828 {
10829 return m_header;
10830 }
10831
10836 eProsima_user_DllExport CompleteUnionHeader& header()
10837 {
10838 return m_header;
10839 }
10840
10841
10846 eProsima_user_DllExport void discriminator(
10847 const CompleteDiscriminatorMember& _discriminator)
10848 {
10849 m_discriminator = _discriminator;
10850 }
10851
10856 eProsima_user_DllExport void discriminator(
10857 CompleteDiscriminatorMember&& _discriminator)
10858 {
10859 m_discriminator = std::move(_discriminator);
10860 }
10861
10866 eProsima_user_DllExport const CompleteDiscriminatorMember& discriminator() const
10867 {
10868 return m_discriminator;
10869 }
10870
10876 {
10877 return m_discriminator;
10878 }
10879
10880
10885 eProsima_user_DllExport void member_seq(
10886 const CompleteUnionMemberSeq& _member_seq)
10887 {
10888 m_member_seq = _member_seq;
10889 }
10890
10895 eProsima_user_DllExport void member_seq(
10896 CompleteUnionMemberSeq&& _member_seq)
10897 {
10898 m_member_seq = std::move(_member_seq);
10899 }
10900
10905 eProsima_user_DllExport const CompleteUnionMemberSeq& member_seq() const
10906 {
10907 return m_member_seq;
10908 }
10909
10914 eProsima_user_DllExport CompleteUnionMemberSeq& member_seq()
10915 {
10916 return m_member_seq;
10917 }
10918
10919
10920
10921private:
10922
10923 UnionTypeFlag m_union_flags{0};
10924 CompleteUnionHeader m_header;
10925 CompleteDiscriminatorMember m_discriminator;
10926 CompleteUnionMemberSeq m_member_seq;
10927
10928};
10934{
10935public:
10936
10940 eProsima_user_DllExport MinimalUnionType()
10941 {
10942 }
10943
10947 eProsima_user_DllExport ~MinimalUnionType()
10948 {
10949 }
10950
10955 eProsima_user_DllExport MinimalUnionType(
10956 const MinimalUnionType& x)
10957 {
10958 m_union_flags = x.m_union_flags;
10959
10960 m_header = x.m_header;
10961
10962 m_discriminator = x.m_discriminator;
10963
10964 m_member_seq = x.m_member_seq;
10965
10966 }
10967
10972 eProsima_user_DllExport MinimalUnionType(
10973 MinimalUnionType&& x) noexcept
10974 {
10975 m_union_flags = std::move(x.m_union_flags);
10976 m_header = std::move(x.m_header);
10977 m_discriminator = std::move(x.m_discriminator);
10978 m_member_seq = std::move(x.m_member_seq);
10979 }
10980
10985 eProsima_user_DllExport MinimalUnionType& operator =(
10986 const MinimalUnionType& x)
10987 {
10988
10989 m_union_flags = x.m_union_flags;
10990
10991 m_header = x.m_header;
10992
10993 m_discriminator = x.m_discriminator;
10994
10995 m_member_seq = x.m_member_seq;
10996
10997 return *this;
10998 }
10999
11004 eProsima_user_DllExport MinimalUnionType& operator =(
11005 MinimalUnionType&& x) noexcept
11006 {
11007
11008 m_union_flags = std::move(x.m_union_flags);
11009 m_header = std::move(x.m_header);
11010 m_discriminator = std::move(x.m_discriminator);
11011 m_member_seq = std::move(x.m_member_seq);
11012 return *this;
11013 }
11014
11019 eProsima_user_DllExport bool operator ==(
11020 const MinimalUnionType& x) const
11021 {
11022 return (m_union_flags == x.m_union_flags &&
11023 m_header == x.m_header &&
11024 m_discriminator == x.m_discriminator &&
11025 m_member_seq == x.m_member_seq);
11026 }
11027
11032 eProsima_user_DllExport bool operator !=(
11033 const MinimalUnionType& x) const
11034 {
11035 return !(*this == x);
11036 }
11037
11042 eProsima_user_DllExport void union_flags(
11043 const UnionTypeFlag& _union_flags)
11044 {
11045 m_union_flags = _union_flags;
11046 }
11047
11052 eProsima_user_DllExport void union_flags(
11053 UnionTypeFlag&& _union_flags)
11054 {
11055 m_union_flags = std::move(_union_flags);
11056 }
11057
11062 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
11063 {
11064 return m_union_flags;
11065 }
11066
11071 eProsima_user_DllExport UnionTypeFlag& union_flags()
11072 {
11073 return m_union_flags;
11074 }
11075
11076
11081 eProsima_user_DllExport void header(
11082 const MinimalUnionHeader& _header)
11083 {
11084 m_header = _header;
11085 }
11086
11091 eProsima_user_DllExport void header(
11092 MinimalUnionHeader&& _header)
11093 {
11094 m_header = std::move(_header);
11095 }
11096
11101 eProsima_user_DllExport const MinimalUnionHeader& header() const
11102 {
11103 return m_header;
11104 }
11105
11110 eProsima_user_DllExport MinimalUnionHeader& header()
11111 {
11112 return m_header;
11113 }
11114
11115
11120 eProsima_user_DllExport void discriminator(
11121 const MinimalDiscriminatorMember& _discriminator)
11122 {
11123 m_discriminator = _discriminator;
11124 }
11125
11130 eProsima_user_DllExport void discriminator(
11131 MinimalDiscriminatorMember&& _discriminator)
11132 {
11133 m_discriminator = std::move(_discriminator);
11134 }
11135
11140 eProsima_user_DllExport const MinimalDiscriminatorMember& discriminator() const
11141 {
11142 return m_discriminator;
11143 }
11144
11150 {
11151 return m_discriminator;
11152 }
11153
11154
11159 eProsima_user_DllExport void member_seq(
11160 const MinimalUnionMemberSeq& _member_seq)
11161 {
11162 m_member_seq = _member_seq;
11163 }
11164
11169 eProsima_user_DllExport void member_seq(
11170 MinimalUnionMemberSeq&& _member_seq)
11171 {
11172 m_member_seq = std::move(_member_seq);
11173 }
11174
11179 eProsima_user_DllExport const MinimalUnionMemberSeq& member_seq() const
11180 {
11181 return m_member_seq;
11182 }
11183
11188 eProsima_user_DllExport MinimalUnionMemberSeq& member_seq()
11189 {
11190 return m_member_seq;
11191 }
11192
11193
11194
11195private:
11196
11197 UnionTypeFlag m_union_flags{0};
11198 MinimalUnionHeader m_header;
11199 MinimalDiscriminatorMember m_discriminator;
11200 MinimalUnionMemberSeq m_member_seq;
11201
11202};
11208{
11209public:
11210
11214 eProsima_user_DllExport CommonAnnotationParameter()
11215 {
11216 }
11217
11221 eProsima_user_DllExport ~CommonAnnotationParameter()
11222 {
11223 }
11224
11229 eProsima_user_DllExport CommonAnnotationParameter(
11231 {
11232 m_member_flags = x.m_member_flags;
11233
11234 m_member_type_id = x.m_member_type_id;
11235
11236 }
11237
11242 eProsima_user_DllExport CommonAnnotationParameter(
11243 CommonAnnotationParameter&& x) noexcept
11244 {
11245 m_member_flags = std::move(x.m_member_flags);
11246 m_member_type_id = std::move(x.m_member_type_id);
11247 }
11248
11253 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11255 {
11256
11257 m_member_flags = x.m_member_flags;
11258
11259 m_member_type_id = x.m_member_type_id;
11260
11261 return *this;
11262 }
11263
11268 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11269 CommonAnnotationParameter&& x) noexcept
11270 {
11271
11272 m_member_flags = std::move(x.m_member_flags);
11273 m_member_type_id = std::move(x.m_member_type_id);
11274 return *this;
11275 }
11276
11281 eProsima_user_DllExport bool operator ==(
11282 const CommonAnnotationParameter& x) const
11283 {
11284 return (m_member_flags == x.m_member_flags &&
11285 m_member_type_id == x.m_member_type_id);
11286 }
11287
11292 eProsima_user_DllExport bool operator !=(
11293 const CommonAnnotationParameter& x) const
11294 {
11295 return !(*this == x);
11296 }
11297
11302 eProsima_user_DllExport void member_flags(
11303 const AnnotationParameterFlag& _member_flags)
11304 {
11305 m_member_flags = _member_flags;
11306 }
11307
11312 eProsima_user_DllExport void member_flags(
11313 AnnotationParameterFlag&& _member_flags)
11314 {
11315 m_member_flags = std::move(_member_flags);
11316 }
11317
11322 eProsima_user_DllExport const AnnotationParameterFlag& member_flags() const
11323 {
11324 return m_member_flags;
11325 }
11326
11331 eProsima_user_DllExport AnnotationParameterFlag& member_flags()
11332 {
11333 return m_member_flags;
11334 }
11335
11336
11341 eProsima_user_DllExport void member_type_id(
11342 const TypeIdentifier& _member_type_id)
11343 {
11344 m_member_type_id = _member_type_id;
11345 }
11346
11351 eProsima_user_DllExport void member_type_id(
11352 TypeIdentifier&& _member_type_id)
11353 {
11354 m_member_type_id = std::move(_member_type_id);
11355 }
11356
11361 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
11362 {
11363 return m_member_type_id;
11364 }
11365
11370 eProsima_user_DllExport TypeIdentifier& member_type_id()
11371 {
11372 return m_member_type_id;
11373 }
11374
11375
11376
11377private:
11378
11379 AnnotationParameterFlag m_member_flags{0};
11380 TypeIdentifier m_member_type_id;
11381
11382};
11388{
11389public:
11390
11394 eProsima_user_DllExport CompleteAnnotationParameter()
11395 {
11396 }
11397
11401 eProsima_user_DllExport ~CompleteAnnotationParameter()
11402 {
11403 }
11404
11409 eProsima_user_DllExport CompleteAnnotationParameter(
11411 {
11412 m_common = x.m_common;
11413
11414 m_name = x.m_name;
11415
11416 m_default_value = x.m_default_value;
11417
11418 }
11419
11424 eProsima_user_DllExport CompleteAnnotationParameter(
11425 CompleteAnnotationParameter&& x) noexcept
11426 {
11427 m_common = std::move(x.m_common);
11428 m_name = std::move(x.m_name);
11429 m_default_value = std::move(x.m_default_value);
11430 }
11431
11436 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11438 {
11439
11440 m_common = x.m_common;
11441
11442 m_name = x.m_name;
11443
11444 m_default_value = x.m_default_value;
11445
11446 return *this;
11447 }
11448
11453 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11454 CompleteAnnotationParameter&& x) noexcept
11455 {
11456
11457 m_common = std::move(x.m_common);
11458 m_name = std::move(x.m_name);
11459 m_default_value = std::move(x.m_default_value);
11460 return *this;
11461 }
11462
11467 eProsima_user_DllExport bool operator ==(
11468 const CompleteAnnotationParameter& x) const
11469 {
11470 return (m_common == x.m_common &&
11471 m_name == x.m_name &&
11472 m_default_value == x.m_default_value);
11473 }
11474
11479 eProsima_user_DllExport bool operator !=(
11480 const CompleteAnnotationParameter& x) const
11481 {
11482 return !(*this == x);
11483 }
11484
11489 eProsima_user_DllExport void common(
11490 const CommonAnnotationParameter& _common)
11491 {
11492 m_common = _common;
11493 }
11494
11499 eProsima_user_DllExport void common(
11500 CommonAnnotationParameter&& _common)
11501 {
11502 m_common = std::move(_common);
11503 }
11504
11509 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11510 {
11511 return m_common;
11512 }
11513
11518 eProsima_user_DllExport CommonAnnotationParameter& common()
11519 {
11520 return m_common;
11521 }
11522
11523
11528 eProsima_user_DllExport void name(
11529 const MemberName& _name)
11530 {
11531 m_name = _name;
11532 }
11533
11538 eProsima_user_DllExport void name(
11539 MemberName&& _name)
11540 {
11541 m_name = std::move(_name);
11542 }
11543
11548 eProsima_user_DllExport const MemberName& name() const
11549 {
11550 return m_name;
11551 }
11552
11557 eProsima_user_DllExport MemberName& name()
11558 {
11559 return m_name;
11560 }
11561
11562
11567 eProsima_user_DllExport void default_value(
11568 const AnnotationParameterValue& _default_value)
11569 {
11570 m_default_value = _default_value;
11571 }
11572
11577 eProsima_user_DllExport void default_value(
11578 AnnotationParameterValue&& _default_value)
11579 {
11580 m_default_value = std::move(_default_value);
11581 }
11582
11587 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11588 {
11589 return m_default_value;
11590 }
11591
11596 eProsima_user_DllExport AnnotationParameterValue& default_value()
11597 {
11598 return m_default_value;
11599 }
11600
11601
11602
11603private:
11604
11606 MemberName m_name;
11607 AnnotationParameterValue m_default_value;
11608
11609};
11610typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
11611
11617{
11618public:
11619
11623 eProsima_user_DllExport MinimalAnnotationParameter()
11624 {
11625 }
11626
11630 eProsima_user_DllExport ~MinimalAnnotationParameter()
11631 {
11632 }
11633
11638 eProsima_user_DllExport MinimalAnnotationParameter(
11640 {
11641 m_common = x.m_common;
11642
11643 m_name_hash = x.m_name_hash;
11644
11645 m_default_value = x.m_default_value;
11646
11647 }
11648
11653 eProsima_user_DllExport MinimalAnnotationParameter(
11654 MinimalAnnotationParameter&& x) noexcept
11655 {
11656 m_common = std::move(x.m_common);
11657 m_name_hash = std::move(x.m_name_hash);
11658 m_default_value = std::move(x.m_default_value);
11659 }
11660
11665 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11667 {
11668
11669 m_common = x.m_common;
11670
11671 m_name_hash = x.m_name_hash;
11672
11673 m_default_value = x.m_default_value;
11674
11675 return *this;
11676 }
11677
11682 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11683 MinimalAnnotationParameter&& x) noexcept
11684 {
11685
11686 m_common = std::move(x.m_common);
11687 m_name_hash = std::move(x.m_name_hash);
11688 m_default_value = std::move(x.m_default_value);
11689 return *this;
11690 }
11691
11696 eProsima_user_DllExport bool operator ==(
11697 const MinimalAnnotationParameter& x) const
11698 {
11699 return (m_common == x.m_common &&
11700 m_name_hash == x.m_name_hash &&
11701 m_default_value == x.m_default_value);
11702 }
11703
11708 eProsima_user_DllExport bool operator !=(
11709 const MinimalAnnotationParameter& x) const
11710 {
11711 return !(*this == x);
11712 }
11713
11718 eProsima_user_DllExport void common(
11719 const CommonAnnotationParameter& _common)
11720 {
11721 m_common = _common;
11722 }
11723
11728 eProsima_user_DllExport void common(
11729 CommonAnnotationParameter&& _common)
11730 {
11731 m_common = std::move(_common);
11732 }
11733
11738 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11739 {
11740 return m_common;
11741 }
11742
11747 eProsima_user_DllExport CommonAnnotationParameter& common()
11748 {
11749 return m_common;
11750 }
11751
11752
11757 eProsima_user_DllExport void name_hash(
11758 const NameHash& _name_hash)
11759 {
11760 m_name_hash = _name_hash;
11761 }
11762
11767 eProsima_user_DllExport void name_hash(
11768 NameHash&& _name_hash)
11769 {
11770 m_name_hash = std::move(_name_hash);
11771 }
11772
11777 eProsima_user_DllExport const NameHash& name_hash() const
11778 {
11779 return m_name_hash;
11780 }
11781
11786 eProsima_user_DllExport NameHash& name_hash()
11787 {
11788 return m_name_hash;
11789 }
11790
11791
11796 eProsima_user_DllExport void default_value(
11797 const AnnotationParameterValue& _default_value)
11798 {
11799 m_default_value = _default_value;
11800 }
11801
11806 eProsima_user_DllExport void default_value(
11807 AnnotationParameterValue&& _default_value)
11808 {
11809 m_default_value = std::move(_default_value);
11810 }
11811
11816 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11817 {
11818 return m_default_value;
11819 }
11820
11825 eProsima_user_DllExport AnnotationParameterValue& default_value()
11826 {
11827 return m_default_value;
11828 }
11829
11830
11831
11832private:
11833
11835 NameHash m_name_hash{0};
11836 AnnotationParameterValue m_default_value;
11837
11838};
11839typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
11840
11846{
11847public:
11848
11852 eProsima_user_DllExport CompleteAnnotationHeader()
11853 {
11854 }
11855
11859 eProsima_user_DllExport ~CompleteAnnotationHeader()
11860 {
11861 }
11862
11867 eProsima_user_DllExport CompleteAnnotationHeader(
11868 const CompleteAnnotationHeader& x)
11869 {
11870 m_annotation_name = x.m_annotation_name;
11871
11872 }
11873
11878 eProsima_user_DllExport CompleteAnnotationHeader(
11879 CompleteAnnotationHeader&& x) noexcept
11880 {
11881 m_annotation_name = std::move(x.m_annotation_name);
11882 }
11883
11888 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11889 const CompleteAnnotationHeader& x)
11890 {
11891
11892 m_annotation_name = x.m_annotation_name;
11893
11894 return *this;
11895 }
11896
11901 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11902 CompleteAnnotationHeader&& x) noexcept
11903 {
11904
11905 m_annotation_name = std::move(x.m_annotation_name);
11906 return *this;
11907 }
11908
11913 eProsima_user_DllExport bool operator ==(
11914 const CompleteAnnotationHeader& x) const
11915 {
11916 return (m_annotation_name == x.m_annotation_name);
11917 }
11918
11923 eProsima_user_DllExport bool operator !=(
11924 const CompleteAnnotationHeader& x) const
11925 {
11926 return !(*this == x);
11927 }
11928
11933 eProsima_user_DllExport void annotation_name(
11934 const QualifiedTypeName& _annotation_name)
11935 {
11936 m_annotation_name = _annotation_name;
11937 }
11938
11943 eProsima_user_DllExport void annotation_name(
11944 QualifiedTypeName&& _annotation_name)
11945 {
11946 m_annotation_name = std::move(_annotation_name);
11947 }
11948
11953 eProsima_user_DllExport const QualifiedTypeName& annotation_name() const
11954 {
11955 return m_annotation_name;
11956 }
11957
11962 eProsima_user_DllExport QualifiedTypeName& annotation_name()
11963 {
11964 return m_annotation_name;
11965 }
11966
11967
11968
11969private:
11970
11971 QualifiedTypeName m_annotation_name;
11972
11973};
11979{
11980public:
11981
11985 eProsima_user_DllExport MinimalAnnotationHeader()
11986 {
11987 }
11988
11992 eProsima_user_DllExport ~MinimalAnnotationHeader()
11993 {
11994 }
11995
12000 eProsima_user_DllExport MinimalAnnotationHeader(
12001 const MinimalAnnotationHeader& x)
12002 {
12003 static_cast<void>(x);
12004 }
12005
12010 eProsima_user_DllExport MinimalAnnotationHeader(
12011 MinimalAnnotationHeader&& x) noexcept
12012 {
12013 static_cast<void>(x);
12014 }
12015
12020 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12021 const MinimalAnnotationHeader& x)
12022 {
12023
12024 static_cast<void>(x);
12025
12026 return *this;
12027 }
12028
12033 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12034 MinimalAnnotationHeader&& x) noexcept
12035 {
12036
12037 static_cast<void>(x);
12038
12039 return *this;
12040 }
12041
12046 eProsima_user_DllExport bool operator ==(
12047 const MinimalAnnotationHeader& x) const
12048 {
12049 static_cast<void>(x);
12050 return true;
12051 }
12052
12057 eProsima_user_DllExport bool operator !=(
12058 const MinimalAnnotationHeader& x) const
12059 {
12060 return !(*this == x);
12061 }
12062
12063
12064
12065private:
12066
12067
12068};
12074{
12075public:
12076
12080 eProsima_user_DllExport CompleteAnnotationType()
12081 {
12082 }
12083
12087 eProsima_user_DllExport ~CompleteAnnotationType()
12088 {
12089 }
12090
12095 eProsima_user_DllExport CompleteAnnotationType(
12096 const CompleteAnnotationType& x)
12097 {
12098 m_annotation_flag = x.m_annotation_flag;
12099
12100 m_header = x.m_header;
12101
12102 m_member_seq = x.m_member_seq;
12103
12104 }
12105
12110 eProsima_user_DllExport CompleteAnnotationType(
12111 CompleteAnnotationType&& x) noexcept
12112 {
12113 m_annotation_flag = std::move(x.m_annotation_flag);
12114 m_header = std::move(x.m_header);
12115 m_member_seq = std::move(x.m_member_seq);
12116 }
12117
12122 eProsima_user_DllExport CompleteAnnotationType& operator =(
12123 const CompleteAnnotationType& x)
12124 {
12125
12126 m_annotation_flag = x.m_annotation_flag;
12127
12128 m_header = x.m_header;
12129
12130 m_member_seq = x.m_member_seq;
12131
12132 return *this;
12133 }
12134
12139 eProsima_user_DllExport CompleteAnnotationType& operator =(
12140 CompleteAnnotationType&& x) noexcept
12141 {
12142
12143 m_annotation_flag = std::move(x.m_annotation_flag);
12144 m_header = std::move(x.m_header);
12145 m_member_seq = std::move(x.m_member_seq);
12146 return *this;
12147 }
12148
12153 eProsima_user_DllExport bool operator ==(
12154 const CompleteAnnotationType& x) const
12155 {
12156 return (m_annotation_flag == x.m_annotation_flag &&
12157 m_header == x.m_header &&
12158 m_member_seq == x.m_member_seq);
12159 }
12160
12165 eProsima_user_DllExport bool operator !=(
12166 const CompleteAnnotationType& x) const
12167 {
12168 return !(*this == x);
12169 }
12170
12175 eProsima_user_DllExport void annotation_flag(
12176 const AnnotationTypeFlag& _annotation_flag)
12177 {
12178 m_annotation_flag = _annotation_flag;
12179 }
12180
12185 eProsima_user_DllExport void annotation_flag(
12186 AnnotationTypeFlag&& _annotation_flag)
12187 {
12188 m_annotation_flag = std::move(_annotation_flag);
12189 }
12190
12195 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12196 {
12197 return m_annotation_flag;
12198 }
12199
12204 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12205 {
12206 return m_annotation_flag;
12207 }
12208
12209
12214 eProsima_user_DllExport void header(
12215 const CompleteAnnotationHeader& _header)
12216 {
12217 m_header = _header;
12218 }
12219
12224 eProsima_user_DllExport void header(
12225 CompleteAnnotationHeader&& _header)
12226 {
12227 m_header = std::move(_header);
12228 }
12229
12234 eProsima_user_DllExport const CompleteAnnotationHeader& header() const
12235 {
12236 return m_header;
12237 }
12238
12243 eProsima_user_DllExport CompleteAnnotationHeader& header()
12244 {
12245 return m_header;
12246 }
12247
12248
12253 eProsima_user_DllExport void member_seq(
12254 const CompleteAnnotationParameterSeq& _member_seq)
12255 {
12256 m_member_seq = _member_seq;
12257 }
12258
12263 eProsima_user_DllExport void member_seq(
12264 CompleteAnnotationParameterSeq&& _member_seq)
12265 {
12266 m_member_seq = std::move(_member_seq);
12267 }
12268
12273 eProsima_user_DllExport const CompleteAnnotationParameterSeq& member_seq() const
12274 {
12275 return m_member_seq;
12276 }
12277
12283 {
12284 return m_member_seq;
12285 }
12286
12287
12288
12289private:
12290
12291 AnnotationTypeFlag m_annotation_flag{0};
12292 CompleteAnnotationHeader m_header;
12293 CompleteAnnotationParameterSeq m_member_seq;
12294
12295};
12301{
12302public:
12303
12307 eProsima_user_DllExport MinimalAnnotationType()
12308 {
12309 }
12310
12314 eProsima_user_DllExport ~MinimalAnnotationType()
12315 {
12316 }
12317
12322 eProsima_user_DllExport MinimalAnnotationType(
12323 const MinimalAnnotationType& x)
12324 {
12325 m_annotation_flag = x.m_annotation_flag;
12326
12327 m_header = x.m_header;
12328
12329 m_member_seq = x.m_member_seq;
12330
12331 }
12332
12337 eProsima_user_DllExport MinimalAnnotationType(
12338 MinimalAnnotationType&& x) noexcept
12339 {
12340 m_annotation_flag = std::move(x.m_annotation_flag);
12341 m_header = std::move(x.m_header);
12342 m_member_seq = std::move(x.m_member_seq);
12343 }
12344
12349 eProsima_user_DllExport MinimalAnnotationType& operator =(
12350 const MinimalAnnotationType& x)
12351 {
12352
12353 m_annotation_flag = x.m_annotation_flag;
12354
12355 m_header = x.m_header;
12356
12357 m_member_seq = x.m_member_seq;
12358
12359 return *this;
12360 }
12361
12366 eProsima_user_DllExport MinimalAnnotationType& operator =(
12367 MinimalAnnotationType&& x) noexcept
12368 {
12369
12370 m_annotation_flag = std::move(x.m_annotation_flag);
12371 m_header = std::move(x.m_header);
12372 m_member_seq = std::move(x.m_member_seq);
12373 return *this;
12374 }
12375
12380 eProsima_user_DllExport bool operator ==(
12381 const MinimalAnnotationType& x) const
12382 {
12383 return (m_annotation_flag == x.m_annotation_flag &&
12384 m_header == x.m_header &&
12385 m_member_seq == x.m_member_seq);
12386 }
12387
12392 eProsima_user_DllExport bool operator !=(
12393 const MinimalAnnotationType& x) const
12394 {
12395 return !(*this == x);
12396 }
12397
12402 eProsima_user_DllExport void annotation_flag(
12403 const AnnotationTypeFlag& _annotation_flag)
12404 {
12405 m_annotation_flag = _annotation_flag;
12406 }
12407
12412 eProsima_user_DllExport void annotation_flag(
12413 AnnotationTypeFlag&& _annotation_flag)
12414 {
12415 m_annotation_flag = std::move(_annotation_flag);
12416 }
12417
12422 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12423 {
12424 return m_annotation_flag;
12425 }
12426
12431 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12432 {
12433 return m_annotation_flag;
12434 }
12435
12436
12441 eProsima_user_DllExport void header(
12442 const MinimalAnnotationHeader& _header)
12443 {
12444 m_header = _header;
12445 }
12446
12451 eProsima_user_DllExport void header(
12452 MinimalAnnotationHeader&& _header)
12453 {
12454 m_header = std::move(_header);
12455 }
12456
12461 eProsima_user_DllExport const MinimalAnnotationHeader& header() const
12462 {
12463 return m_header;
12464 }
12465
12470 eProsima_user_DllExport MinimalAnnotationHeader& header()
12471 {
12472 return m_header;
12473 }
12474
12475
12480 eProsima_user_DllExport void member_seq(
12481 const MinimalAnnotationParameterSeq& _member_seq)
12482 {
12483 m_member_seq = _member_seq;
12484 }
12485
12490 eProsima_user_DllExport void member_seq(
12491 MinimalAnnotationParameterSeq&& _member_seq)
12492 {
12493 m_member_seq = std::move(_member_seq);
12494 }
12495
12500 eProsima_user_DllExport const MinimalAnnotationParameterSeq& member_seq() const
12501 {
12502 return m_member_seq;
12503 }
12504
12510 {
12511 return m_member_seq;
12512 }
12513
12514
12515
12516private:
12517
12518 AnnotationTypeFlag m_annotation_flag{0};
12519 MinimalAnnotationHeader m_header;
12520 MinimalAnnotationParameterSeq m_member_seq;
12521
12522};
12528{
12529public:
12530
12534 eProsima_user_DllExport CommonAliasBody()
12535 {
12536 }
12537
12541 eProsima_user_DllExport ~CommonAliasBody()
12542 {
12543 }
12544
12549 eProsima_user_DllExport CommonAliasBody(
12550 const CommonAliasBody& x)
12551 {
12552 m_related_flags = x.m_related_flags;
12553
12554 m_related_type = x.m_related_type;
12555
12556 }
12557
12562 eProsima_user_DllExport CommonAliasBody(
12563 CommonAliasBody&& x) noexcept
12564 {
12565 m_related_flags = std::move(x.m_related_flags);
12566 m_related_type = std::move(x.m_related_type);
12567 }
12568
12573 eProsima_user_DllExport CommonAliasBody& operator =(
12574 const CommonAliasBody& x)
12575 {
12576
12577 m_related_flags = x.m_related_flags;
12578
12579 m_related_type = x.m_related_type;
12580
12581 return *this;
12582 }
12583
12588 eProsima_user_DllExport CommonAliasBody& operator =(
12589 CommonAliasBody&& x) noexcept
12590 {
12591
12592 m_related_flags = std::move(x.m_related_flags);
12593 m_related_type = std::move(x.m_related_type);
12594 return *this;
12595 }
12596
12601 eProsima_user_DllExport bool operator ==(
12602 const CommonAliasBody& x) const
12603 {
12604 return (m_related_flags == x.m_related_flags &&
12605 m_related_type == x.m_related_type);
12606 }
12607
12612 eProsima_user_DllExport bool operator !=(
12613 const CommonAliasBody& x) const
12614 {
12615 return !(*this == x);
12616 }
12617
12622 eProsima_user_DllExport void related_flags(
12623 const AliasMemberFlag& _related_flags)
12624 {
12625 m_related_flags = _related_flags;
12626 }
12627
12632 eProsima_user_DllExport void related_flags(
12633 AliasMemberFlag&& _related_flags)
12634 {
12635 m_related_flags = std::move(_related_flags);
12636 }
12637
12642 eProsima_user_DllExport const AliasMemberFlag& related_flags() const
12643 {
12644 return m_related_flags;
12645 }
12646
12651 eProsima_user_DllExport AliasMemberFlag& related_flags()
12652 {
12653 return m_related_flags;
12654 }
12655
12656
12661 eProsima_user_DllExport void related_type(
12662 const TypeIdentifier& _related_type)
12663 {
12664 m_related_type = _related_type;
12665 }
12666
12671 eProsima_user_DllExport void related_type(
12672 TypeIdentifier&& _related_type)
12673 {
12674 m_related_type = std::move(_related_type);
12675 }
12676
12681 eProsima_user_DllExport const TypeIdentifier& related_type() const
12682 {
12683 return m_related_type;
12684 }
12685
12690 eProsima_user_DllExport TypeIdentifier& related_type()
12691 {
12692 return m_related_type;
12693 }
12694
12695
12696
12697private:
12698
12699 AliasMemberFlag m_related_flags{0};
12700 TypeIdentifier m_related_type;
12701
12702};
12708{
12709public:
12710
12714 eProsima_user_DllExport CompleteAliasBody()
12715 {
12716 }
12717
12721 eProsima_user_DllExport ~CompleteAliasBody()
12722 {
12723 }
12724
12729 eProsima_user_DllExport CompleteAliasBody(
12730 const CompleteAliasBody& x)
12731 {
12732 m_common = x.m_common;
12733
12734 m_ann_builtin = x.m_ann_builtin;
12735
12736 m_ann_custom = x.m_ann_custom;
12737
12738 }
12739
12744 eProsima_user_DllExport CompleteAliasBody(
12745 CompleteAliasBody&& x) noexcept
12746 {
12747 m_common = std::move(x.m_common);
12748 m_ann_builtin = std::move(x.m_ann_builtin);
12749 m_ann_custom = std::move(x.m_ann_custom);
12750 }
12751
12756 eProsima_user_DllExport CompleteAliasBody& operator =(
12757 const CompleteAliasBody& x)
12758 {
12759
12760 m_common = x.m_common;
12761
12762 m_ann_builtin = x.m_ann_builtin;
12763
12764 m_ann_custom = x.m_ann_custom;
12765
12766 return *this;
12767 }
12768
12773 eProsima_user_DllExport CompleteAliasBody& operator =(
12774 CompleteAliasBody&& x) noexcept
12775 {
12776
12777 m_common = std::move(x.m_common);
12778 m_ann_builtin = std::move(x.m_ann_builtin);
12779 m_ann_custom = std::move(x.m_ann_custom);
12780 return *this;
12781 }
12782
12787 eProsima_user_DllExport bool operator ==(
12788 const CompleteAliasBody& x) const
12789 {
12790 return (m_common == x.m_common &&
12791 m_ann_builtin == x.m_ann_builtin &&
12792 m_ann_custom == x.m_ann_custom);
12793 }
12794
12799 eProsima_user_DllExport bool operator !=(
12800 const CompleteAliasBody& x) const
12801 {
12802 return !(*this == x);
12803 }
12804
12809 eProsima_user_DllExport void common(
12810 const CommonAliasBody& _common)
12811 {
12812 m_common = _common;
12813 }
12814
12819 eProsima_user_DllExport void common(
12820 CommonAliasBody&& _common)
12821 {
12822 m_common = std::move(_common);
12823 }
12824
12829 eProsima_user_DllExport const CommonAliasBody& common() const
12830 {
12831 return m_common;
12832 }
12833
12838 eProsima_user_DllExport CommonAliasBody& common()
12839 {
12840 return m_common;
12841 }
12842
12843
12848 eProsima_user_DllExport void ann_builtin(
12849 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
12850 {
12851 m_ann_builtin = _ann_builtin;
12852 }
12853
12858 eProsima_user_DllExport void ann_builtin(
12859 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
12860 {
12861 m_ann_builtin = std::move(_ann_builtin);
12862 }
12863
12868 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
12869 {
12870 return m_ann_builtin;
12871 }
12872
12877 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
12878 {
12879 return m_ann_builtin;
12880 }
12881
12882
12887 eProsima_user_DllExport void ann_custom(
12888 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
12889 {
12890 m_ann_custom = _ann_custom;
12891 }
12892
12897 eProsima_user_DllExport void ann_custom(
12898 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
12899 {
12900 m_ann_custom = std::move(_ann_custom);
12901 }
12902
12907 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
12908 {
12909 return m_ann_custom;
12910 }
12911
12916 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
12917 {
12918 return m_ann_custom;
12919 }
12920
12921
12922
12923private:
12924
12925 CommonAliasBody m_common;
12926 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
12927 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
12928
12929};
12935{
12936public:
12937
12941 eProsima_user_DllExport MinimalAliasBody()
12942 {
12943 }
12944
12948 eProsima_user_DllExport ~MinimalAliasBody()
12949 {
12950 }
12951
12956 eProsima_user_DllExport MinimalAliasBody(
12957 const MinimalAliasBody& x)
12958 {
12959 m_common = x.m_common;
12960
12961 }
12962
12967 eProsima_user_DllExport MinimalAliasBody(
12968 MinimalAliasBody&& x) noexcept
12969 {
12970 m_common = std::move(x.m_common);
12971 }
12972
12977 eProsima_user_DllExport MinimalAliasBody& operator =(
12978 const MinimalAliasBody& x)
12979 {
12980
12981 m_common = x.m_common;
12982
12983 return *this;
12984 }
12985
12990 eProsima_user_DllExport MinimalAliasBody& operator =(
12991 MinimalAliasBody&& x) noexcept
12992 {
12993
12994 m_common = std::move(x.m_common);
12995 return *this;
12996 }
12997
13002 eProsima_user_DllExport bool operator ==(
13003 const MinimalAliasBody& x) const
13004 {
13005 return (m_common == x.m_common);
13006 }
13007
13012 eProsima_user_DllExport bool operator !=(
13013 const MinimalAliasBody& x) const
13014 {
13015 return !(*this == x);
13016 }
13017
13022 eProsima_user_DllExport void common(
13023 const CommonAliasBody& _common)
13024 {
13025 m_common = _common;
13026 }
13027
13032 eProsima_user_DllExport void common(
13033 CommonAliasBody&& _common)
13034 {
13035 m_common = std::move(_common);
13036 }
13037
13042 eProsima_user_DllExport const CommonAliasBody& common() const
13043 {
13044 return m_common;
13045 }
13046
13051 eProsima_user_DllExport CommonAliasBody& common()
13052 {
13053 return m_common;
13054 }
13055
13056
13057
13058private:
13059
13060 CommonAliasBody m_common;
13061
13062};
13068{
13069public:
13070
13074 eProsima_user_DllExport CompleteAliasHeader()
13075 {
13076 }
13077
13081 eProsima_user_DllExport ~CompleteAliasHeader()
13082 {
13083 }
13084
13089 eProsima_user_DllExport CompleteAliasHeader(
13090 const CompleteAliasHeader& x)
13091 {
13092 m_detail = x.m_detail;
13093
13094 }
13095
13100 eProsima_user_DllExport CompleteAliasHeader(
13101 CompleteAliasHeader&& x) noexcept
13102 {
13103 m_detail = std::move(x.m_detail);
13104 }
13105
13110 eProsima_user_DllExport CompleteAliasHeader& operator =(
13111 const CompleteAliasHeader& x)
13112 {
13113
13114 m_detail = x.m_detail;
13115
13116 return *this;
13117 }
13118
13123 eProsima_user_DllExport CompleteAliasHeader& operator =(
13124 CompleteAliasHeader&& x) noexcept
13125 {
13126
13127 m_detail = std::move(x.m_detail);
13128 return *this;
13129 }
13130
13135 eProsima_user_DllExport bool operator ==(
13136 const CompleteAliasHeader& x) const
13137 {
13138 return (m_detail == x.m_detail);
13139 }
13140
13145 eProsima_user_DllExport bool operator !=(
13146 const CompleteAliasHeader& x) const
13147 {
13148 return !(*this == x);
13149 }
13150
13155 eProsima_user_DllExport void detail(
13156 const CompleteTypeDetail& _detail)
13157 {
13158 m_detail = _detail;
13159 }
13160
13165 eProsima_user_DllExport void detail(
13166 CompleteTypeDetail&& _detail)
13167 {
13168 m_detail = std::move(_detail);
13169 }
13170
13175 eProsima_user_DllExport const CompleteTypeDetail& detail() const
13176 {
13177 return m_detail;
13178 }
13179
13184 eProsima_user_DllExport CompleteTypeDetail& detail()
13185 {
13186 return m_detail;
13187 }
13188
13189
13190
13191private:
13192
13193 CompleteTypeDetail m_detail;
13194
13195};
13201{
13202public:
13203
13207 eProsima_user_DllExport MinimalAliasHeader()
13208 {
13209 }
13210
13214 eProsima_user_DllExport ~MinimalAliasHeader()
13215 {
13216 }
13217
13222 eProsima_user_DllExport MinimalAliasHeader(
13223 const MinimalAliasHeader& x)
13224 {
13225 static_cast<void>(x);
13226 }
13227
13232 eProsima_user_DllExport MinimalAliasHeader(
13233 MinimalAliasHeader&& x) noexcept
13234 {
13235 static_cast<void>(x);
13236 }
13237
13242 eProsima_user_DllExport MinimalAliasHeader& operator =(
13243 const MinimalAliasHeader& x)
13244 {
13245
13246 static_cast<void>(x);
13247
13248 return *this;
13249 }
13250
13255 eProsima_user_DllExport MinimalAliasHeader& operator =(
13256 MinimalAliasHeader&& x) noexcept
13257 {
13258
13259 static_cast<void>(x);
13260
13261 return *this;
13262 }
13263
13268 eProsima_user_DllExport bool operator ==(
13269 const MinimalAliasHeader& x) const
13270 {
13271 static_cast<void>(x);
13272 return true;
13273 }
13274
13279 eProsima_user_DllExport bool operator !=(
13280 const MinimalAliasHeader& x) const
13281 {
13282 return !(*this == x);
13283 }
13284
13285
13286
13287private:
13288
13289
13290};
13296{
13297public:
13298
13302 eProsima_user_DllExport CompleteAliasType()
13303 {
13304 }
13305
13309 eProsima_user_DllExport ~CompleteAliasType()
13310 {
13311 }
13312
13317 eProsima_user_DllExport CompleteAliasType(
13318 const CompleteAliasType& x)
13319 {
13320 m_alias_flags = x.m_alias_flags;
13321
13322 m_header = x.m_header;
13323
13324 m_body = x.m_body;
13325
13326 }
13327
13332 eProsima_user_DllExport CompleteAliasType(
13333 CompleteAliasType&& x) noexcept
13334 {
13335 m_alias_flags = std::move(x.m_alias_flags);
13336 m_header = std::move(x.m_header);
13337 m_body = std::move(x.m_body);
13338 }
13339
13344 eProsima_user_DllExport CompleteAliasType& operator =(
13345 const CompleteAliasType& x)
13346 {
13347
13348 m_alias_flags = x.m_alias_flags;
13349
13350 m_header = x.m_header;
13351
13352 m_body = x.m_body;
13353
13354 return *this;
13355 }
13356
13361 eProsima_user_DllExport CompleteAliasType& operator =(
13362 CompleteAliasType&& x) noexcept
13363 {
13364
13365 m_alias_flags = std::move(x.m_alias_flags);
13366 m_header = std::move(x.m_header);
13367 m_body = std::move(x.m_body);
13368 return *this;
13369 }
13370
13375 eProsima_user_DllExport bool operator ==(
13376 const CompleteAliasType& x) const
13377 {
13378 return (m_alias_flags == x.m_alias_flags &&
13379 m_header == x.m_header &&
13380 m_body == x.m_body);
13381 }
13382
13387 eProsima_user_DllExport bool operator !=(
13388 const CompleteAliasType& x) const
13389 {
13390 return !(*this == x);
13391 }
13392
13397 eProsima_user_DllExport void alias_flags(
13398 const AliasTypeFlag& _alias_flags)
13399 {
13400 m_alias_flags = _alias_flags;
13401 }
13402
13407 eProsima_user_DllExport void alias_flags(
13408 AliasTypeFlag&& _alias_flags)
13409 {
13410 m_alias_flags = std::move(_alias_flags);
13411 }
13412
13417 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13418 {
13419 return m_alias_flags;
13420 }
13421
13426 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13427 {
13428 return m_alias_flags;
13429 }
13430
13431
13436 eProsima_user_DllExport void header(
13437 const CompleteAliasHeader& _header)
13438 {
13439 m_header = _header;
13440 }
13441
13446 eProsima_user_DllExport void header(
13447 CompleteAliasHeader&& _header)
13448 {
13449 m_header = std::move(_header);
13450 }
13451
13456 eProsima_user_DllExport const CompleteAliasHeader& header() const
13457 {
13458 return m_header;
13459 }
13460
13465 eProsima_user_DllExport CompleteAliasHeader& header()
13466 {
13467 return m_header;
13468 }
13469
13470
13475 eProsima_user_DllExport void body(
13476 const CompleteAliasBody& _body)
13477 {
13478 m_body = _body;
13479 }
13480
13485 eProsima_user_DllExport void body(
13486 CompleteAliasBody&& _body)
13487 {
13488 m_body = std::move(_body);
13489 }
13490
13495 eProsima_user_DllExport const CompleteAliasBody& body() const
13496 {
13497 return m_body;
13498 }
13499
13504 eProsima_user_DllExport CompleteAliasBody& body()
13505 {
13506 return m_body;
13507 }
13508
13509
13510
13511private:
13512
13513 AliasTypeFlag m_alias_flags{0};
13514 CompleteAliasHeader m_header;
13515 CompleteAliasBody m_body;
13516
13517};
13523{
13524public:
13525
13529 eProsima_user_DllExport MinimalAliasType()
13530 {
13531 }
13532
13536 eProsima_user_DllExport ~MinimalAliasType()
13537 {
13538 }
13539
13544 eProsima_user_DllExport MinimalAliasType(
13545 const MinimalAliasType& x)
13546 {
13547 m_alias_flags = x.m_alias_flags;
13548
13549 m_header = x.m_header;
13550
13551 m_body = x.m_body;
13552
13553 }
13554
13559 eProsima_user_DllExport MinimalAliasType(
13560 MinimalAliasType&& x) noexcept
13561 {
13562 m_alias_flags = std::move(x.m_alias_flags);
13563 m_header = std::move(x.m_header);
13564 m_body = std::move(x.m_body);
13565 }
13566
13571 eProsima_user_DllExport MinimalAliasType& operator =(
13572 const MinimalAliasType& x)
13573 {
13574
13575 m_alias_flags = x.m_alias_flags;
13576
13577 m_header = x.m_header;
13578
13579 m_body = x.m_body;
13580
13581 return *this;
13582 }
13583
13588 eProsima_user_DllExport MinimalAliasType& operator =(
13589 MinimalAliasType&& x) noexcept
13590 {
13591
13592 m_alias_flags = std::move(x.m_alias_flags);
13593 m_header = std::move(x.m_header);
13594 m_body = std::move(x.m_body);
13595 return *this;
13596 }
13597
13602 eProsima_user_DllExport bool operator ==(
13603 const MinimalAliasType& x) const
13604 {
13605 return (m_alias_flags == x.m_alias_flags &&
13606 m_header == x.m_header &&
13607 m_body == x.m_body);
13608 }
13609
13614 eProsima_user_DllExport bool operator !=(
13615 const MinimalAliasType& x) const
13616 {
13617 return !(*this == x);
13618 }
13619
13624 eProsima_user_DllExport void alias_flags(
13625 const AliasTypeFlag& _alias_flags)
13626 {
13627 m_alias_flags = _alias_flags;
13628 }
13629
13634 eProsima_user_DllExport void alias_flags(
13635 AliasTypeFlag&& _alias_flags)
13636 {
13637 m_alias_flags = std::move(_alias_flags);
13638 }
13639
13644 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13645 {
13646 return m_alias_flags;
13647 }
13648
13653 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13654 {
13655 return m_alias_flags;
13656 }
13657
13658
13663 eProsima_user_DllExport void header(
13664 const MinimalAliasHeader& _header)
13665 {
13666 m_header = _header;
13667 }
13668
13673 eProsima_user_DllExport void header(
13674 MinimalAliasHeader&& _header)
13675 {
13676 m_header = std::move(_header);
13677 }
13678
13683 eProsima_user_DllExport const MinimalAliasHeader& header() const
13684 {
13685 return m_header;
13686 }
13687
13692 eProsima_user_DllExport MinimalAliasHeader& header()
13693 {
13694 return m_header;
13695 }
13696
13697
13702 eProsima_user_DllExport void body(
13703 const MinimalAliasBody& _body)
13704 {
13705 m_body = _body;
13706 }
13707
13712 eProsima_user_DllExport void body(
13713 MinimalAliasBody&& _body)
13714 {
13715 m_body = std::move(_body);
13716 }
13717
13722 eProsima_user_DllExport const MinimalAliasBody& body() const
13723 {
13724 return m_body;
13725 }
13726
13731 eProsima_user_DllExport MinimalAliasBody& body()
13732 {
13733 return m_body;
13734 }
13735
13736
13737
13738private:
13739
13740 AliasTypeFlag m_alias_flags{0};
13741 MinimalAliasHeader m_header;
13742 MinimalAliasBody m_body;
13743
13744};
13750{
13751public:
13752
13756 eProsima_user_DllExport CompleteElementDetail()
13757 {
13758 }
13759
13763 eProsima_user_DllExport ~CompleteElementDetail()
13764 {
13765 }
13766
13771 eProsima_user_DllExport CompleteElementDetail(
13772 const CompleteElementDetail& x)
13773 {
13774 m_ann_builtin = x.m_ann_builtin;
13775
13776 m_ann_custom = x.m_ann_custom;
13777
13778 }
13779
13784 eProsima_user_DllExport CompleteElementDetail(
13785 CompleteElementDetail&& x) noexcept
13786 {
13787 m_ann_builtin = std::move(x.m_ann_builtin);
13788 m_ann_custom = std::move(x.m_ann_custom);
13789 }
13790
13795 eProsima_user_DllExport CompleteElementDetail& operator =(
13796 const CompleteElementDetail& x)
13797 {
13798
13799 m_ann_builtin = x.m_ann_builtin;
13800
13801 m_ann_custom = x.m_ann_custom;
13802
13803 return *this;
13804 }
13805
13810 eProsima_user_DllExport CompleteElementDetail& operator =(
13811 CompleteElementDetail&& x) noexcept
13812 {
13813
13814 m_ann_builtin = std::move(x.m_ann_builtin);
13815 m_ann_custom = std::move(x.m_ann_custom);
13816 return *this;
13817 }
13818
13823 eProsima_user_DllExport bool operator ==(
13824 const CompleteElementDetail& x) const
13825 {
13826 return (m_ann_builtin == x.m_ann_builtin &&
13827 m_ann_custom == x.m_ann_custom);
13828 }
13829
13834 eProsima_user_DllExport bool operator !=(
13835 const CompleteElementDetail& x) const
13836 {
13837 return !(*this == x);
13838 }
13839
13844 eProsima_user_DllExport void ann_builtin(
13845 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
13846 {
13847 m_ann_builtin = _ann_builtin;
13848 }
13849
13854 eProsima_user_DllExport void ann_builtin(
13855 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
13856 {
13857 m_ann_builtin = std::move(_ann_builtin);
13858 }
13859
13864 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
13865 {
13866 return m_ann_builtin;
13867 }
13868
13873 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
13874 {
13875 return m_ann_builtin;
13876 }
13877
13878
13883 eProsima_user_DllExport void ann_custom(
13884 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
13885 {
13886 m_ann_custom = _ann_custom;
13887 }
13888
13893 eProsima_user_DllExport void ann_custom(
13894 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
13895 {
13896 m_ann_custom = std::move(_ann_custom);
13897 }
13898
13903 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
13904 {
13905 return m_ann_custom;
13906 }
13907
13912 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
13913 {
13914 return m_ann_custom;
13915 }
13916
13917
13918
13919private:
13920
13921 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
13922 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
13923
13924};
13930{
13931public:
13932
13936 eProsima_user_DllExport CommonCollectionElement()
13937 {
13938 }
13939
13943 eProsima_user_DllExport ~CommonCollectionElement()
13944 {
13945 }
13946
13951 eProsima_user_DllExport CommonCollectionElement(
13952 const CommonCollectionElement& x)
13953 {
13954 m_element_flags = x.m_element_flags;
13955
13956 m_type = x.m_type;
13957
13958 }
13959
13964 eProsima_user_DllExport CommonCollectionElement(
13965 CommonCollectionElement&& x) noexcept
13966 {
13967 m_element_flags = std::move(x.m_element_flags);
13968 m_type = std::move(x.m_type);
13969 }
13970
13975 eProsima_user_DllExport CommonCollectionElement& operator =(
13976 const CommonCollectionElement& x)
13977 {
13978
13979 m_element_flags = x.m_element_flags;
13980
13981 m_type = x.m_type;
13982
13983 return *this;
13984 }
13985
13990 eProsima_user_DllExport CommonCollectionElement& operator =(
13991 CommonCollectionElement&& x) noexcept
13992 {
13993
13994 m_element_flags = std::move(x.m_element_flags);
13995 m_type = std::move(x.m_type);
13996 return *this;
13997 }
13998
14003 eProsima_user_DllExport bool operator ==(
14004 const CommonCollectionElement& x) const
14005 {
14006 return (m_element_flags == x.m_element_flags &&
14007 m_type == x.m_type);
14008 }
14009
14014 eProsima_user_DllExport bool operator !=(
14015 const CommonCollectionElement& x) const
14016 {
14017 return !(*this == x);
14018 }
14019
14024 eProsima_user_DllExport void element_flags(
14025 const CollectionElementFlag& _element_flags)
14026 {
14027 m_element_flags = _element_flags;
14028 }
14029
14034 eProsima_user_DllExport void element_flags(
14035 CollectionElementFlag&& _element_flags)
14036 {
14037 m_element_flags = std::move(_element_flags);
14038 }
14039
14044 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
14045 {
14046 return m_element_flags;
14047 }
14048
14053 eProsima_user_DllExport CollectionElementFlag& element_flags()
14054 {
14055 return m_element_flags;
14056 }
14057
14058
14063 eProsima_user_DllExport void type(
14064 const TypeIdentifier& _type)
14065 {
14066 m_type = _type;
14067 }
14068
14073 eProsima_user_DllExport void type(
14074 TypeIdentifier&& _type)
14075 {
14076 m_type = std::move(_type);
14077 }
14078
14083 eProsima_user_DllExport const TypeIdentifier& type() const
14084 {
14085 return m_type;
14086 }
14087
14092 eProsima_user_DllExport TypeIdentifier& type()
14093 {
14094 return m_type;
14095 }
14096
14097
14098
14099private:
14100
14101 CollectionElementFlag m_element_flags{0};
14102 TypeIdentifier m_type;
14103
14104};
14110{
14111public:
14112
14116 eProsima_user_DllExport CompleteCollectionElement()
14117 {
14118 }
14119
14123 eProsima_user_DllExport ~CompleteCollectionElement()
14124 {
14125 }
14126
14131 eProsima_user_DllExport CompleteCollectionElement(
14133 {
14134 m_common = x.m_common;
14135
14136 m_detail = x.m_detail;
14137
14138 }
14139
14144 eProsima_user_DllExport CompleteCollectionElement(
14145 CompleteCollectionElement&& x) noexcept
14146 {
14147 m_common = std::move(x.m_common);
14148 m_detail = std::move(x.m_detail);
14149 }
14150
14155 eProsima_user_DllExport CompleteCollectionElement& operator =(
14157 {
14158
14159 m_common = x.m_common;
14160
14161 m_detail = x.m_detail;
14162
14163 return *this;
14164 }
14165
14170 eProsima_user_DllExport CompleteCollectionElement& operator =(
14171 CompleteCollectionElement&& x) noexcept
14172 {
14173
14174 m_common = std::move(x.m_common);
14175 m_detail = std::move(x.m_detail);
14176 return *this;
14177 }
14178
14183 eProsima_user_DllExport bool operator ==(
14184 const CompleteCollectionElement& x) const
14185 {
14186 return (m_common == x.m_common &&
14187 m_detail == x.m_detail);
14188 }
14189
14194 eProsima_user_DllExport bool operator !=(
14195 const CompleteCollectionElement& x) const
14196 {
14197 return !(*this == x);
14198 }
14199
14204 eProsima_user_DllExport void common(
14205 const CommonCollectionElement& _common)
14206 {
14207 m_common = _common;
14208 }
14209
14214 eProsima_user_DllExport void common(
14215 CommonCollectionElement&& _common)
14216 {
14217 m_common = std::move(_common);
14218 }
14219
14224 eProsima_user_DllExport const CommonCollectionElement& common() const
14225 {
14226 return m_common;
14227 }
14228
14233 eProsima_user_DllExport CommonCollectionElement& common()
14234 {
14235 return m_common;
14236 }
14237
14238
14243 eProsima_user_DllExport void detail(
14244 const CompleteElementDetail& _detail)
14245 {
14246 m_detail = _detail;
14247 }
14248
14253 eProsima_user_DllExport void detail(
14254 CompleteElementDetail&& _detail)
14255 {
14256 m_detail = std::move(_detail);
14257 }
14258
14263 eProsima_user_DllExport const CompleteElementDetail& detail() const
14264 {
14265 return m_detail;
14266 }
14267
14272 eProsima_user_DllExport CompleteElementDetail& detail()
14273 {
14274 return m_detail;
14275 }
14276
14277
14278
14279private:
14280
14281 CommonCollectionElement m_common;
14282 CompleteElementDetail m_detail;
14283
14284};
14290{
14291public:
14292
14296 eProsima_user_DllExport MinimalCollectionElement()
14297 {
14298 }
14299
14303 eProsima_user_DllExport ~MinimalCollectionElement()
14304 {
14305 }
14306
14311 eProsima_user_DllExport MinimalCollectionElement(
14312 const MinimalCollectionElement& x)
14313 {
14314 m_common = x.m_common;
14315
14316 }
14317
14322 eProsima_user_DllExport MinimalCollectionElement(
14323 MinimalCollectionElement&& x) noexcept
14324 {
14325 m_common = std::move(x.m_common);
14326 }
14327
14332 eProsima_user_DllExport MinimalCollectionElement& operator =(
14333 const MinimalCollectionElement& x)
14334 {
14335
14336 m_common = x.m_common;
14337
14338 return *this;
14339 }
14340
14345 eProsima_user_DllExport MinimalCollectionElement& operator =(
14346 MinimalCollectionElement&& x) noexcept
14347 {
14348
14349 m_common = std::move(x.m_common);
14350 return *this;
14351 }
14352
14357 eProsima_user_DllExport bool operator ==(
14358 const MinimalCollectionElement& x) const
14359 {
14360 return (m_common == x.m_common);
14361 }
14362
14367 eProsima_user_DllExport bool operator !=(
14368 const MinimalCollectionElement& x) const
14369 {
14370 return !(*this == x);
14371 }
14372
14377 eProsima_user_DllExport void common(
14378 const CommonCollectionElement& _common)
14379 {
14380 m_common = _common;
14381 }
14382
14387 eProsima_user_DllExport void common(
14388 CommonCollectionElement&& _common)
14389 {
14390 m_common = std::move(_common);
14391 }
14392
14397 eProsima_user_DllExport const CommonCollectionElement& common() const
14398 {
14399 return m_common;
14400 }
14401
14406 eProsima_user_DllExport CommonCollectionElement& common()
14407 {
14408 return m_common;
14409 }
14410
14411
14412
14413private:
14414
14415 CommonCollectionElement m_common;
14416
14417};
14423{
14424public:
14425
14429 eProsima_user_DllExport CommonCollectionHeader()
14430 {
14431 }
14432
14436 eProsima_user_DllExport ~CommonCollectionHeader()
14437 {
14438 }
14439
14444 eProsima_user_DllExport CommonCollectionHeader(
14445 const CommonCollectionHeader& x)
14446 {
14447 m_bound = x.m_bound;
14448
14449 }
14450
14455 eProsima_user_DllExport CommonCollectionHeader(
14456 CommonCollectionHeader&& x) noexcept
14457 {
14458 m_bound = x.m_bound;
14459 }
14460
14465 eProsima_user_DllExport CommonCollectionHeader& operator =(
14466 const CommonCollectionHeader& x)
14467 {
14468
14469 m_bound = x.m_bound;
14470
14471 return *this;
14472 }
14473
14478 eProsima_user_DllExport CommonCollectionHeader& operator =(
14479 CommonCollectionHeader&& x) noexcept
14480 {
14481
14482 m_bound = x.m_bound;
14483 return *this;
14484 }
14485
14490 eProsima_user_DllExport bool operator ==(
14491 const CommonCollectionHeader& x) const
14492 {
14493 return (m_bound == x.m_bound);
14494 }
14495
14500 eProsima_user_DllExport bool operator !=(
14501 const CommonCollectionHeader& x) const
14502 {
14503 return !(*this == x);
14504 }
14505
14510 eProsima_user_DllExport void bound(
14511 LBound _bound)
14512 {
14513 m_bound = _bound;
14514 }
14515
14520 eProsima_user_DllExport LBound bound() const
14521 {
14522 return m_bound;
14523 }
14524
14529 eProsima_user_DllExport LBound& bound()
14530 {
14531 return m_bound;
14532 }
14533
14534
14535
14536private:
14537
14538 LBound m_bound{0};
14539
14540};
14546{
14547public:
14548
14552 eProsima_user_DllExport CompleteCollectionHeader()
14553 {
14554 }
14555
14559 eProsima_user_DllExport ~CompleteCollectionHeader()
14560 {
14561 }
14562
14567 eProsima_user_DllExport CompleteCollectionHeader(
14568 const CompleteCollectionHeader& x)
14569 {
14570 m_common = x.m_common;
14571
14572 m_detail = x.m_detail;
14573
14574 }
14575
14580 eProsima_user_DllExport CompleteCollectionHeader(
14581 CompleteCollectionHeader&& x) noexcept
14582 {
14583 m_common = std::move(x.m_common);
14584 m_detail = std::move(x.m_detail);
14585 }
14586
14591 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14592 const CompleteCollectionHeader& x)
14593 {
14594
14595 m_common = x.m_common;
14596
14597 m_detail = x.m_detail;
14598
14599 return *this;
14600 }
14601
14606 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14607 CompleteCollectionHeader&& x) noexcept
14608 {
14609
14610 m_common = std::move(x.m_common);
14611 m_detail = std::move(x.m_detail);
14612 return *this;
14613 }
14614
14619 eProsima_user_DllExport bool operator ==(
14620 const CompleteCollectionHeader& x) const
14621 {
14622 return (m_common == x.m_common &&
14623 m_detail == x.m_detail);
14624 }
14625
14630 eProsima_user_DllExport bool operator !=(
14631 const CompleteCollectionHeader& x) const
14632 {
14633 return !(*this == x);
14634 }
14635
14640 eProsima_user_DllExport void common(
14641 const CommonCollectionHeader& _common)
14642 {
14643 m_common = _common;
14644 }
14645
14650 eProsima_user_DllExport void common(
14651 CommonCollectionHeader&& _common)
14652 {
14653 m_common = std::move(_common);
14654 }
14655
14660 eProsima_user_DllExport const CommonCollectionHeader& common() const
14661 {
14662 return m_common;
14663 }
14664
14669 eProsima_user_DllExport CommonCollectionHeader& common()
14670 {
14671 return m_common;
14672 }
14673
14674
14679 eProsima_user_DllExport void detail(
14680 const eprosima::fastcdr::optional<CompleteTypeDetail>& _detail)
14681 {
14682 m_detail = _detail;
14683 }
14684
14689 eProsima_user_DllExport void detail(
14690 eprosima::fastcdr::optional<CompleteTypeDetail>&& _detail)
14691 {
14692 m_detail = std::move(_detail);
14693 }
14694
14699 eProsima_user_DllExport const eprosima::fastcdr::optional<CompleteTypeDetail>& detail() const
14700 {
14701 return m_detail;
14702 }
14703
14708 eProsima_user_DllExport eprosima::fastcdr::optional<CompleteTypeDetail>& detail()
14709 {
14710 return m_detail;
14711 }
14712
14713
14714
14715private:
14716
14717 CommonCollectionHeader m_common;
14718 eprosima::fastcdr::optional<CompleteTypeDetail> m_detail;
14719
14720};
14726{
14727public:
14728
14732 eProsima_user_DllExport MinimalCollectionHeader()
14733 {
14734 }
14735
14739 eProsima_user_DllExport ~MinimalCollectionHeader()
14740 {
14741 }
14742
14747 eProsima_user_DllExport MinimalCollectionHeader(
14748 const MinimalCollectionHeader& x)
14749 {
14750 m_common = x.m_common;
14751
14752 }
14753
14758 eProsima_user_DllExport MinimalCollectionHeader(
14759 MinimalCollectionHeader&& x) noexcept
14760 {
14761 m_common = std::move(x.m_common);
14762 }
14763
14768 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14769 const MinimalCollectionHeader& x)
14770 {
14771
14772 m_common = x.m_common;
14773
14774 return *this;
14775 }
14776
14781 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14782 MinimalCollectionHeader&& x) noexcept
14783 {
14784
14785 m_common = std::move(x.m_common);
14786 return *this;
14787 }
14788
14793 eProsima_user_DllExport bool operator ==(
14794 const MinimalCollectionHeader& x) const
14795 {
14796 return (m_common == x.m_common);
14797 }
14798
14803 eProsima_user_DllExport bool operator !=(
14804 const MinimalCollectionHeader& x) const
14805 {
14806 return !(*this == x);
14807 }
14808
14813 eProsima_user_DllExport void common(
14814 const CommonCollectionHeader& _common)
14815 {
14816 m_common = _common;
14817 }
14818
14823 eProsima_user_DllExport void common(
14824 CommonCollectionHeader&& _common)
14825 {
14826 m_common = std::move(_common);
14827 }
14828
14833 eProsima_user_DllExport const CommonCollectionHeader& common() const
14834 {
14835 return m_common;
14836 }
14837
14842 eProsima_user_DllExport CommonCollectionHeader& common()
14843 {
14844 return m_common;
14845 }
14846
14847
14848
14849private:
14850
14851 CommonCollectionHeader m_common;
14852
14853};
14859{
14860public:
14861
14865 eProsima_user_DllExport CompleteSequenceType()
14866 {
14867 }
14868
14872 eProsima_user_DllExport ~CompleteSequenceType()
14873 {
14874 }
14875
14880 eProsima_user_DllExport CompleteSequenceType(
14881 const CompleteSequenceType& x)
14882 {
14883 m_collection_flag = x.m_collection_flag;
14884
14885 m_header = x.m_header;
14886
14887 m_element = x.m_element;
14888
14889 }
14890
14895 eProsima_user_DllExport CompleteSequenceType(
14896 CompleteSequenceType&& x) noexcept
14897 {
14898 m_collection_flag = std::move(x.m_collection_flag);
14899 m_header = std::move(x.m_header);
14900 m_element = std::move(x.m_element);
14901 }
14902
14907 eProsima_user_DllExport CompleteSequenceType& operator =(
14908 const CompleteSequenceType& x)
14909 {
14910
14911 m_collection_flag = x.m_collection_flag;
14912
14913 m_header = x.m_header;
14914
14915 m_element = x.m_element;
14916
14917 return *this;
14918 }
14919
14924 eProsima_user_DllExport CompleteSequenceType& operator =(
14925 CompleteSequenceType&& x) noexcept
14926 {
14927
14928 m_collection_flag = std::move(x.m_collection_flag);
14929 m_header = std::move(x.m_header);
14930 m_element = std::move(x.m_element);
14931 return *this;
14932 }
14933
14938 eProsima_user_DllExport bool operator ==(
14939 const CompleteSequenceType& x) const
14940 {
14941 return (m_collection_flag == x.m_collection_flag &&
14942 m_header == x.m_header &&
14943 m_element == x.m_element);
14944 }
14945
14950 eProsima_user_DllExport bool operator !=(
14951 const CompleteSequenceType& x) const
14952 {
14953 return !(*this == x);
14954 }
14955
14960 eProsima_user_DllExport void collection_flag(
14961 const CollectionTypeFlag& _collection_flag)
14962 {
14963 m_collection_flag = _collection_flag;
14964 }
14965
14970 eProsima_user_DllExport void collection_flag(
14971 CollectionTypeFlag&& _collection_flag)
14972 {
14973 m_collection_flag = std::move(_collection_flag);
14974 }
14975
14980 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
14981 {
14982 return m_collection_flag;
14983 }
14984
14989 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
14990 {
14991 return m_collection_flag;
14992 }
14993
14994
14999 eProsima_user_DllExport void header(
15000 const CompleteCollectionHeader& _header)
15001 {
15002 m_header = _header;
15003 }
15004
15009 eProsima_user_DllExport void header(
15010 CompleteCollectionHeader&& _header)
15011 {
15012 m_header = std::move(_header);
15013 }
15014
15019 eProsima_user_DllExport const CompleteCollectionHeader& header() const
15020 {
15021 return m_header;
15022 }
15023
15028 eProsima_user_DllExport CompleteCollectionHeader& header()
15029 {
15030 return m_header;
15031 }
15032
15033
15038 eProsima_user_DllExport void element(
15039 const CompleteCollectionElement& _element)
15040 {
15041 m_element = _element;
15042 }
15043
15048 eProsima_user_DllExport void element(
15049 CompleteCollectionElement&& _element)
15050 {
15051 m_element = std::move(_element);
15052 }
15053
15058 eProsima_user_DllExport const CompleteCollectionElement& element() const
15059 {
15060 return m_element;
15061 }
15062
15067 eProsima_user_DllExport CompleteCollectionElement& element()
15068 {
15069 return m_element;
15070 }
15071
15072
15073
15074private:
15075
15076 CollectionTypeFlag m_collection_flag{0};
15077 CompleteCollectionHeader m_header;
15078 CompleteCollectionElement m_element;
15079
15080};
15086{
15087public:
15088
15092 eProsima_user_DllExport MinimalSequenceType()
15093 {
15094 }
15095
15099 eProsima_user_DllExport ~MinimalSequenceType()
15100 {
15101 }
15102
15107 eProsima_user_DllExport MinimalSequenceType(
15108 const MinimalSequenceType& x)
15109 {
15110 m_collection_flag = x.m_collection_flag;
15111
15112 m_header = x.m_header;
15113
15114 m_element = x.m_element;
15115
15116 }
15117
15122 eProsima_user_DllExport MinimalSequenceType(
15123 MinimalSequenceType&& x) noexcept
15124 {
15125 m_collection_flag = std::move(x.m_collection_flag);
15126 m_header = std::move(x.m_header);
15127 m_element = std::move(x.m_element);
15128 }
15129
15134 eProsima_user_DllExport MinimalSequenceType& operator =(
15135 const MinimalSequenceType& x)
15136 {
15137
15138 m_collection_flag = x.m_collection_flag;
15139
15140 m_header = x.m_header;
15141
15142 m_element = x.m_element;
15143
15144 return *this;
15145 }
15146
15151 eProsima_user_DllExport MinimalSequenceType& operator =(
15152 MinimalSequenceType&& x) noexcept
15153 {
15154
15155 m_collection_flag = std::move(x.m_collection_flag);
15156 m_header = std::move(x.m_header);
15157 m_element = std::move(x.m_element);
15158 return *this;
15159 }
15160
15165 eProsima_user_DllExport bool operator ==(
15166 const MinimalSequenceType& x) const
15167 {
15168 return (m_collection_flag == x.m_collection_flag &&
15169 m_header == x.m_header &&
15170 m_element == x.m_element);
15171 }
15172
15177 eProsima_user_DllExport bool operator !=(
15178 const MinimalSequenceType& x) const
15179 {
15180 return !(*this == x);
15181 }
15182
15187 eProsima_user_DllExport void collection_flag(
15188 const CollectionTypeFlag& _collection_flag)
15189 {
15190 m_collection_flag = _collection_flag;
15191 }
15192
15197 eProsima_user_DllExport void collection_flag(
15198 CollectionTypeFlag&& _collection_flag)
15199 {
15200 m_collection_flag = std::move(_collection_flag);
15201 }
15202
15207 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15208 {
15209 return m_collection_flag;
15210 }
15211
15216 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15217 {
15218 return m_collection_flag;
15219 }
15220
15221
15226 eProsima_user_DllExport void header(
15227 const MinimalCollectionHeader& _header)
15228 {
15229 m_header = _header;
15230 }
15231
15236 eProsima_user_DllExport void header(
15237 MinimalCollectionHeader&& _header)
15238 {
15239 m_header = std::move(_header);
15240 }
15241
15246 eProsima_user_DllExport const MinimalCollectionHeader& header() const
15247 {
15248 return m_header;
15249 }
15250
15255 eProsima_user_DllExport MinimalCollectionHeader& header()
15256 {
15257 return m_header;
15258 }
15259
15260
15265 eProsima_user_DllExport void element(
15266 const MinimalCollectionElement& _element)
15267 {
15268 m_element = _element;
15269 }
15270
15275 eProsima_user_DllExport void element(
15276 MinimalCollectionElement&& _element)
15277 {
15278 m_element = std::move(_element);
15279 }
15280
15285 eProsima_user_DllExport const MinimalCollectionElement& element() const
15286 {
15287 return m_element;
15288 }
15289
15294 eProsima_user_DllExport MinimalCollectionElement& element()
15295 {
15296 return m_element;
15297 }
15298
15299
15300
15301private:
15302
15303 CollectionTypeFlag m_collection_flag{0};
15304 MinimalCollectionHeader m_header;
15305 MinimalCollectionElement m_element;
15306
15307};
15313{
15314public:
15315
15319 eProsima_user_DllExport CommonArrayHeader()
15320 {
15321 }
15322
15326 eProsima_user_DllExport ~CommonArrayHeader()
15327 {
15328 }
15329
15334 eProsima_user_DllExport CommonArrayHeader(
15335 const CommonArrayHeader& x)
15336 {
15337 m_bound_seq = x.m_bound_seq;
15338
15339 }
15340
15345 eProsima_user_DllExport CommonArrayHeader(
15346 CommonArrayHeader&& x) noexcept
15347 {
15348 m_bound_seq = std::move(x.m_bound_seq);
15349 }
15350
15355 eProsima_user_DllExport CommonArrayHeader& operator =(
15356 const CommonArrayHeader& x)
15357 {
15358
15359 m_bound_seq = x.m_bound_seq;
15360
15361 return *this;
15362 }
15363
15368 eProsima_user_DllExport CommonArrayHeader& operator =(
15369 CommonArrayHeader&& x) noexcept
15370 {
15371
15372 m_bound_seq = std::move(x.m_bound_seq);
15373 return *this;
15374 }
15375
15380 eProsima_user_DllExport bool operator ==(
15381 const CommonArrayHeader& x) const
15382 {
15383 return (m_bound_seq == x.m_bound_seq);
15384 }
15385
15390 eProsima_user_DllExport bool operator !=(
15391 const CommonArrayHeader& x) const
15392 {
15393 return !(*this == x);
15394 }
15395
15400 eProsima_user_DllExport void bound_seq(
15401 const LBoundSeq& _bound_seq)
15402 {
15403 m_bound_seq = _bound_seq;
15404 }
15405
15410 eProsima_user_DllExport void bound_seq(
15411 LBoundSeq&& _bound_seq)
15412 {
15413 m_bound_seq = std::move(_bound_seq);
15414 }
15415
15420 eProsima_user_DllExport const LBoundSeq& bound_seq() const
15421 {
15422 return m_bound_seq;
15423 }
15424
15429 eProsima_user_DllExport LBoundSeq& bound_seq()
15430 {
15431 return m_bound_seq;
15432 }
15433
15434
15435
15436private:
15437
15438 LBoundSeq m_bound_seq;
15439
15440};
15446{
15447public:
15448
15452 eProsima_user_DllExport CompleteArrayHeader()
15453 {
15454 }
15455
15459 eProsima_user_DllExport ~CompleteArrayHeader()
15460 {
15461 }
15462
15467 eProsima_user_DllExport CompleteArrayHeader(
15468 const CompleteArrayHeader& x)
15469 {
15470 m_common = x.m_common;
15471
15472 m_detail = x.m_detail;
15473
15474 }
15475
15480 eProsima_user_DllExport CompleteArrayHeader(
15481 CompleteArrayHeader&& x) noexcept
15482 {
15483 m_common = std::move(x.m_common);
15484 m_detail = std::move(x.m_detail);
15485 }
15486
15491 eProsima_user_DllExport CompleteArrayHeader& operator =(
15492 const CompleteArrayHeader& x)
15493 {
15494
15495 m_common = x.m_common;
15496
15497 m_detail = x.m_detail;
15498
15499 return *this;
15500 }
15501
15506 eProsima_user_DllExport CompleteArrayHeader& operator =(
15507 CompleteArrayHeader&& x) noexcept
15508 {
15509
15510 m_common = std::move(x.m_common);
15511 m_detail = std::move(x.m_detail);
15512 return *this;
15513 }
15514
15519 eProsima_user_DllExport bool operator ==(
15520 const CompleteArrayHeader& x) const
15521 {
15522 return (m_common == x.m_common &&
15523 m_detail == x.m_detail);
15524 }
15525
15530 eProsima_user_DllExport bool operator !=(
15531 const CompleteArrayHeader& x) const
15532 {
15533 return !(*this == x);
15534 }
15535
15540 eProsima_user_DllExport void common(
15541 const CommonArrayHeader& _common)
15542 {
15543 m_common = _common;
15544 }
15545
15550 eProsima_user_DllExport void common(
15551 CommonArrayHeader&& _common)
15552 {
15553 m_common = std::move(_common);
15554 }
15555
15560 eProsima_user_DllExport const CommonArrayHeader& common() const
15561 {
15562 return m_common;
15563 }
15564
15569 eProsima_user_DllExport CommonArrayHeader& common()
15570 {
15571 return m_common;
15572 }
15573
15574
15579 eProsima_user_DllExport void detail(
15580 const CompleteTypeDetail& _detail)
15581 {
15582 m_detail = _detail;
15583 }
15584
15589 eProsima_user_DllExport void detail(
15590 CompleteTypeDetail&& _detail)
15591 {
15592 m_detail = std::move(_detail);
15593 }
15594
15599 eProsima_user_DllExport const CompleteTypeDetail& detail() const
15600 {
15601 return m_detail;
15602 }
15603
15608 eProsima_user_DllExport CompleteTypeDetail& detail()
15609 {
15610 return m_detail;
15611 }
15612
15613
15614
15615private:
15616
15617 CommonArrayHeader m_common;
15618 CompleteTypeDetail m_detail;
15619
15620};
15626{
15627public:
15628
15632 eProsima_user_DllExport MinimalArrayHeader()
15633 {
15634 }
15635
15639 eProsima_user_DllExport ~MinimalArrayHeader()
15640 {
15641 }
15642
15647 eProsima_user_DllExport MinimalArrayHeader(
15648 const MinimalArrayHeader& x)
15649 {
15650 m_common = x.m_common;
15651
15652 }
15653
15658 eProsima_user_DllExport MinimalArrayHeader(
15659 MinimalArrayHeader&& x) noexcept
15660 {
15661 m_common = std::move(x.m_common);
15662 }
15663
15668 eProsima_user_DllExport MinimalArrayHeader& operator =(
15669 const MinimalArrayHeader& x)
15670 {
15671
15672 m_common = x.m_common;
15673
15674 return *this;
15675 }
15676
15681 eProsima_user_DllExport MinimalArrayHeader& operator =(
15682 MinimalArrayHeader&& x) noexcept
15683 {
15684
15685 m_common = std::move(x.m_common);
15686 return *this;
15687 }
15688
15693 eProsima_user_DllExport bool operator ==(
15694 const MinimalArrayHeader& x) const
15695 {
15696 return (m_common == x.m_common);
15697 }
15698
15703 eProsima_user_DllExport bool operator !=(
15704 const MinimalArrayHeader& x) const
15705 {
15706 return !(*this == x);
15707 }
15708
15713 eProsima_user_DllExport void common(
15714 const CommonArrayHeader& _common)
15715 {
15716 m_common = _common;
15717 }
15718
15723 eProsima_user_DllExport void common(
15724 CommonArrayHeader&& _common)
15725 {
15726 m_common = std::move(_common);
15727 }
15728
15733 eProsima_user_DllExport const CommonArrayHeader& common() const
15734 {
15735 return m_common;
15736 }
15737
15742 eProsima_user_DllExport CommonArrayHeader& common()
15743 {
15744 return m_common;
15745 }
15746
15747
15748
15749private:
15750
15751 CommonArrayHeader m_common;
15752
15753};
15759{
15760public:
15761
15765 eProsima_user_DllExport CompleteArrayType()
15766 {
15767 }
15768
15772 eProsima_user_DllExport ~CompleteArrayType()
15773 {
15774 }
15775
15780 eProsima_user_DllExport CompleteArrayType(
15781 const CompleteArrayType& x)
15782 {
15783 m_collection_flag = x.m_collection_flag;
15784
15785 m_header = x.m_header;
15786
15787 m_element = x.m_element;
15788
15789 }
15790
15795 eProsima_user_DllExport CompleteArrayType(
15796 CompleteArrayType&& x) noexcept
15797 {
15798 m_collection_flag = std::move(x.m_collection_flag);
15799 m_header = std::move(x.m_header);
15800 m_element = std::move(x.m_element);
15801 }
15802
15807 eProsima_user_DllExport CompleteArrayType& operator =(
15808 const CompleteArrayType& x)
15809 {
15810
15811 m_collection_flag = x.m_collection_flag;
15812
15813 m_header = x.m_header;
15814
15815 m_element = x.m_element;
15816
15817 return *this;
15818 }
15819
15824 eProsima_user_DllExport CompleteArrayType& operator =(
15825 CompleteArrayType&& x) noexcept
15826 {
15827
15828 m_collection_flag = std::move(x.m_collection_flag);
15829 m_header = std::move(x.m_header);
15830 m_element = std::move(x.m_element);
15831 return *this;
15832 }
15833
15838 eProsima_user_DllExport bool operator ==(
15839 const CompleteArrayType& x) const
15840 {
15841 return (m_collection_flag == x.m_collection_flag &&
15842 m_header == x.m_header &&
15843 m_element == x.m_element);
15844 }
15845
15850 eProsima_user_DllExport bool operator !=(
15851 const CompleteArrayType& x) const
15852 {
15853 return !(*this == x);
15854 }
15855
15860 eProsima_user_DllExport void collection_flag(
15861 const CollectionTypeFlag& _collection_flag)
15862 {
15863 m_collection_flag = _collection_flag;
15864 }
15865
15870 eProsima_user_DllExport void collection_flag(
15871 CollectionTypeFlag&& _collection_flag)
15872 {
15873 m_collection_flag = std::move(_collection_flag);
15874 }
15875
15880 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15881 {
15882 return m_collection_flag;
15883 }
15884
15889 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15890 {
15891 return m_collection_flag;
15892 }
15893
15894
15899 eProsima_user_DllExport void header(
15900 const CompleteArrayHeader& _header)
15901 {
15902 m_header = _header;
15903 }
15904
15909 eProsima_user_DllExport void header(
15910 CompleteArrayHeader&& _header)
15911 {
15912 m_header = std::move(_header);
15913 }
15914
15919 eProsima_user_DllExport const CompleteArrayHeader& header() const
15920 {
15921 return m_header;
15922 }
15923
15928 eProsima_user_DllExport CompleteArrayHeader& header()
15929 {
15930 return m_header;
15931 }
15932
15933
15938 eProsima_user_DllExport void element(
15939 const CompleteCollectionElement& _element)
15940 {
15941 m_element = _element;
15942 }
15943
15948 eProsima_user_DllExport void element(
15949 CompleteCollectionElement&& _element)
15950 {
15951 m_element = std::move(_element);
15952 }
15953
15958 eProsima_user_DllExport const CompleteCollectionElement& element() const
15959 {
15960 return m_element;
15961 }
15962
15967 eProsima_user_DllExport CompleteCollectionElement& element()
15968 {
15969 return m_element;
15970 }
15971
15972
15973
15974private:
15975
15976 CollectionTypeFlag m_collection_flag{0};
15977 CompleteArrayHeader m_header;
15978 CompleteCollectionElement m_element;
15979
15980};
15986{
15987public:
15988
15992 eProsima_user_DllExport MinimalArrayType()
15993 {
15994 }
15995
15999 eProsima_user_DllExport ~MinimalArrayType()
16000 {
16001 }
16002
16007 eProsima_user_DllExport MinimalArrayType(
16008 const MinimalArrayType& x)
16009 {
16010 m_collection_flag = x.m_collection_flag;
16011
16012 m_header = x.m_header;
16013
16014 m_element = x.m_element;
16015
16016 }
16017
16022 eProsima_user_DllExport MinimalArrayType(
16023 MinimalArrayType&& x) noexcept
16024 {
16025 m_collection_flag = std::move(x.m_collection_flag);
16026 m_header = std::move(x.m_header);
16027 m_element = std::move(x.m_element);
16028 }
16029
16034 eProsima_user_DllExport MinimalArrayType& operator =(
16035 const MinimalArrayType& x)
16036 {
16037
16038 m_collection_flag = x.m_collection_flag;
16039
16040 m_header = x.m_header;
16041
16042 m_element = x.m_element;
16043
16044 return *this;
16045 }
16046
16051 eProsima_user_DllExport MinimalArrayType& operator =(
16052 MinimalArrayType&& x) noexcept
16053 {
16054
16055 m_collection_flag = std::move(x.m_collection_flag);
16056 m_header = std::move(x.m_header);
16057 m_element = std::move(x.m_element);
16058 return *this;
16059 }
16060
16065 eProsima_user_DllExport bool operator ==(
16066 const MinimalArrayType& x) const
16067 {
16068 return (m_collection_flag == x.m_collection_flag &&
16069 m_header == x.m_header &&
16070 m_element == x.m_element);
16071 }
16072
16077 eProsima_user_DllExport bool operator !=(
16078 const MinimalArrayType& x) const
16079 {
16080 return !(*this == x);
16081 }
16082
16087 eProsima_user_DllExport void collection_flag(
16088 const CollectionTypeFlag& _collection_flag)
16089 {
16090 m_collection_flag = _collection_flag;
16091 }
16092
16097 eProsima_user_DllExport void collection_flag(
16098 CollectionTypeFlag&& _collection_flag)
16099 {
16100 m_collection_flag = std::move(_collection_flag);
16101 }
16102
16107 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16108 {
16109 return m_collection_flag;
16110 }
16111
16116 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16117 {
16118 return m_collection_flag;
16119 }
16120
16121
16126 eProsima_user_DllExport void header(
16127 const MinimalArrayHeader& _header)
16128 {
16129 m_header = _header;
16130 }
16131
16136 eProsima_user_DllExport void header(
16137 MinimalArrayHeader&& _header)
16138 {
16139 m_header = std::move(_header);
16140 }
16141
16146 eProsima_user_DllExport const MinimalArrayHeader& header() const
16147 {
16148 return m_header;
16149 }
16150
16155 eProsima_user_DllExport MinimalArrayHeader& header()
16156 {
16157 return m_header;
16158 }
16159
16160
16165 eProsima_user_DllExport void element(
16166 const MinimalCollectionElement& _element)
16167 {
16168 m_element = _element;
16169 }
16170
16175 eProsima_user_DllExport void element(
16176 MinimalCollectionElement&& _element)
16177 {
16178 m_element = std::move(_element);
16179 }
16180
16185 eProsima_user_DllExport const MinimalCollectionElement& element() const
16186 {
16187 return m_element;
16188 }
16189
16194 eProsima_user_DllExport MinimalCollectionElement& element()
16195 {
16196 return m_element;
16197 }
16198
16199
16200
16201private:
16202
16203 CollectionTypeFlag m_collection_flag{0};
16204 MinimalArrayHeader m_header;
16205 MinimalCollectionElement m_element;
16206
16207};
16213{
16214public:
16215
16219 eProsima_user_DllExport CompleteMapType()
16220 {
16221 }
16222
16226 eProsima_user_DllExport ~CompleteMapType()
16227 {
16228 }
16229
16234 eProsima_user_DllExport CompleteMapType(
16235 const CompleteMapType& x)
16236 {
16237 m_collection_flag = x.m_collection_flag;
16238
16239 m_header = x.m_header;
16240
16241 m_key = x.m_key;
16242
16243 m_element = x.m_element;
16244
16245 }
16246
16251 eProsima_user_DllExport CompleteMapType(
16252 CompleteMapType&& x) noexcept
16253 {
16254 m_collection_flag = std::move(x.m_collection_flag);
16255 m_header = std::move(x.m_header);
16256 m_key = std::move(x.m_key);
16257 m_element = std::move(x.m_element);
16258 }
16259
16264 eProsima_user_DllExport CompleteMapType& operator =(
16265 const CompleteMapType& x)
16266 {
16267
16268 m_collection_flag = x.m_collection_flag;
16269
16270 m_header = x.m_header;
16271
16272 m_key = x.m_key;
16273
16274 m_element = x.m_element;
16275
16276 return *this;
16277 }
16278
16283 eProsima_user_DllExport CompleteMapType& operator =(
16284 CompleteMapType&& x) noexcept
16285 {
16286
16287 m_collection_flag = std::move(x.m_collection_flag);
16288 m_header = std::move(x.m_header);
16289 m_key = std::move(x.m_key);
16290 m_element = std::move(x.m_element);
16291 return *this;
16292 }
16293
16298 eProsima_user_DllExport bool operator ==(
16299 const CompleteMapType& x) const
16300 {
16301 return (m_collection_flag == x.m_collection_flag &&
16302 m_header == x.m_header &&
16303 m_key == x.m_key &&
16304 m_element == x.m_element);
16305 }
16306
16311 eProsima_user_DllExport bool operator !=(
16312 const CompleteMapType& x) const
16313 {
16314 return !(*this == x);
16315 }
16316
16321 eProsima_user_DllExport void collection_flag(
16322 const CollectionTypeFlag& _collection_flag)
16323 {
16324 m_collection_flag = _collection_flag;
16325 }
16326
16331 eProsima_user_DllExport void collection_flag(
16332 CollectionTypeFlag&& _collection_flag)
16333 {
16334 m_collection_flag = std::move(_collection_flag);
16335 }
16336
16341 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16342 {
16343 return m_collection_flag;
16344 }
16345
16350 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16351 {
16352 return m_collection_flag;
16353 }
16354
16355
16360 eProsima_user_DllExport void header(
16361 const CompleteCollectionHeader& _header)
16362 {
16363 m_header = _header;
16364 }
16365
16370 eProsima_user_DllExport void header(
16371 CompleteCollectionHeader&& _header)
16372 {
16373 m_header = std::move(_header);
16374 }
16375
16380 eProsima_user_DllExport const CompleteCollectionHeader& header() const
16381 {
16382 return m_header;
16383 }
16384
16389 eProsima_user_DllExport CompleteCollectionHeader& header()
16390 {
16391 return m_header;
16392 }
16393
16394
16399 eProsima_user_DllExport void key(
16400 const CompleteCollectionElement& _key)
16401 {
16402 m_key = _key;
16403 }
16404
16409 eProsima_user_DllExport void key(
16411 {
16412 m_key = std::move(_key);
16413 }
16414
16419 eProsima_user_DllExport const CompleteCollectionElement& key() const
16420 {
16421 return m_key;
16422 }
16423
16428 eProsima_user_DllExport CompleteCollectionElement& key()
16429 {
16430 return m_key;
16431 }
16432
16433
16438 eProsima_user_DllExport void element(
16439 const CompleteCollectionElement& _element)
16440 {
16441 m_element = _element;
16442 }
16443
16448 eProsima_user_DllExport void element(
16449 CompleteCollectionElement&& _element)
16450 {
16451 m_element = std::move(_element);
16452 }
16453
16458 eProsima_user_DllExport const CompleteCollectionElement& element() const
16459 {
16460 return m_element;
16461 }
16462
16467 eProsima_user_DllExport CompleteCollectionElement& element()
16468 {
16469 return m_element;
16470 }
16471
16472
16473
16474private:
16475
16476 CollectionTypeFlag m_collection_flag{0};
16477 CompleteCollectionHeader m_header;
16478 CompleteCollectionElement m_key;
16479 CompleteCollectionElement m_element;
16480
16481};
16487{
16488public:
16489
16493 eProsima_user_DllExport MinimalMapType()
16494 {
16495 }
16496
16500 eProsima_user_DllExport ~MinimalMapType()
16501 {
16502 }
16503
16508 eProsima_user_DllExport MinimalMapType(
16509 const MinimalMapType& x)
16510 {
16511 m_collection_flag = x.m_collection_flag;
16512
16513 m_header = x.m_header;
16514
16515 m_key = x.m_key;
16516
16517 m_element = x.m_element;
16518
16519 }
16520
16525 eProsima_user_DllExport MinimalMapType(
16526 MinimalMapType&& x) noexcept
16527 {
16528 m_collection_flag = std::move(x.m_collection_flag);
16529 m_header = std::move(x.m_header);
16530 m_key = std::move(x.m_key);
16531 m_element = std::move(x.m_element);
16532 }
16533
16538 eProsima_user_DllExport MinimalMapType& operator =(
16539 const MinimalMapType& x)
16540 {
16541
16542 m_collection_flag = x.m_collection_flag;
16543
16544 m_header = x.m_header;
16545
16546 m_key = x.m_key;
16547
16548 m_element = x.m_element;
16549
16550 return *this;
16551 }
16552
16557 eProsima_user_DllExport MinimalMapType& operator =(
16558 MinimalMapType&& x) noexcept
16559 {
16560
16561 m_collection_flag = std::move(x.m_collection_flag);
16562 m_header = std::move(x.m_header);
16563 m_key = std::move(x.m_key);
16564 m_element = std::move(x.m_element);
16565 return *this;
16566 }
16567
16572 eProsima_user_DllExport bool operator ==(
16573 const MinimalMapType& x) const
16574 {
16575 return (m_collection_flag == x.m_collection_flag &&
16576 m_header == x.m_header &&
16577 m_key == x.m_key &&
16578 m_element == x.m_element);
16579 }
16580
16585 eProsima_user_DllExport bool operator !=(
16586 const MinimalMapType& x) const
16587 {
16588 return !(*this == x);
16589 }
16590
16595 eProsima_user_DllExport void collection_flag(
16596 const CollectionTypeFlag& _collection_flag)
16597 {
16598 m_collection_flag = _collection_flag;
16599 }
16600
16605 eProsima_user_DllExport void collection_flag(
16606 CollectionTypeFlag&& _collection_flag)
16607 {
16608 m_collection_flag = std::move(_collection_flag);
16609 }
16610
16615 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16616 {
16617 return m_collection_flag;
16618 }
16619
16624 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16625 {
16626 return m_collection_flag;
16627 }
16628
16629
16634 eProsima_user_DllExport void header(
16635 const MinimalCollectionHeader& _header)
16636 {
16637 m_header = _header;
16638 }
16639
16644 eProsima_user_DllExport void header(
16645 MinimalCollectionHeader&& _header)
16646 {
16647 m_header = std::move(_header);
16648 }
16649
16654 eProsima_user_DllExport const MinimalCollectionHeader& header() const
16655 {
16656 return m_header;
16657 }
16658
16663 eProsima_user_DllExport MinimalCollectionHeader& header()
16664 {
16665 return m_header;
16666 }
16667
16668
16673 eProsima_user_DllExport void key(
16674 const MinimalCollectionElement& _key)
16675 {
16676 m_key = _key;
16677 }
16678
16683 eProsima_user_DllExport void key(
16685 {
16686 m_key = std::move(_key);
16687 }
16688
16693 eProsima_user_DllExport const MinimalCollectionElement& key() const
16694 {
16695 return m_key;
16696 }
16697
16702 eProsima_user_DllExport MinimalCollectionElement& key()
16703 {
16704 return m_key;
16705 }
16706
16707
16712 eProsima_user_DllExport void element(
16713 const MinimalCollectionElement& _element)
16714 {
16715 m_element = _element;
16716 }
16717
16722 eProsima_user_DllExport void element(
16723 MinimalCollectionElement&& _element)
16724 {
16725 m_element = std::move(_element);
16726 }
16727
16732 eProsima_user_DllExport const MinimalCollectionElement& element() const
16733 {
16734 return m_element;
16735 }
16736
16741 eProsima_user_DllExport MinimalCollectionElement& element()
16742 {
16743 return m_element;
16744 }
16745
16746
16747
16748private:
16749
16750 CollectionTypeFlag m_collection_flag{0};
16751 MinimalCollectionHeader m_header;
16752 MinimalCollectionElement m_key;
16753 MinimalCollectionElement m_element;
16754
16755};
16756typedef uint16_t BitBound;
16757
16763{
16764public:
16765
16769 eProsima_user_DllExport CommonEnumeratedLiteral()
16770 {
16771 }
16772
16776 eProsima_user_DllExport ~CommonEnumeratedLiteral()
16777 {
16778 }
16779
16784 eProsima_user_DllExport CommonEnumeratedLiteral(
16785 const CommonEnumeratedLiteral& x)
16786 {
16787 m_value = x.m_value;
16788
16789 m_flags = x.m_flags;
16790
16791 }
16792
16797 eProsima_user_DllExport CommonEnumeratedLiteral(
16798 CommonEnumeratedLiteral&& x) noexcept
16799 {
16800 m_value = x.m_value;
16801 m_flags = std::move(x.m_flags);
16802 }
16803
16808 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16809 const CommonEnumeratedLiteral& x)
16810 {
16811
16812 m_value = x.m_value;
16813
16814 m_flags = x.m_flags;
16815
16816 return *this;
16817 }
16818
16823 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16824 CommonEnumeratedLiteral&& x) noexcept
16825 {
16826
16827 m_value = x.m_value;
16828 m_flags = std::move(x.m_flags);
16829 return *this;
16830 }
16831
16836 eProsima_user_DllExport bool operator ==(
16837 const CommonEnumeratedLiteral& x) const
16838 {
16839 return (m_value == x.m_value &&
16840 m_flags == x.m_flags);
16841 }
16842
16847 eProsima_user_DllExport bool operator !=(
16848 const CommonEnumeratedLiteral& x) const
16849 {
16850 return !(*this == x);
16851 }
16852
16857 eProsima_user_DllExport void value(
16858 int32_t _value)
16859 {
16860 m_value = _value;
16861 }
16862
16867 eProsima_user_DllExport int32_t value() const
16868 {
16869 return m_value;
16870 }
16871
16876 eProsima_user_DllExport int32_t& value()
16877 {
16878 return m_value;
16879 }
16880
16881
16886 eProsima_user_DllExport void flags(
16887 const EnumeratedLiteralFlag& _flags)
16888 {
16889 m_flags = _flags;
16890 }
16891
16896 eProsima_user_DllExport void flags(
16897 EnumeratedLiteralFlag&& _flags)
16898 {
16899 m_flags = std::move(_flags);
16900 }
16901
16906 eProsima_user_DllExport const EnumeratedLiteralFlag& flags() const
16907 {
16908 return m_flags;
16909 }
16910
16915 eProsima_user_DllExport EnumeratedLiteralFlag& flags()
16916 {
16917 return m_flags;
16918 }
16919
16920
16921
16922private:
16923
16924 int32_t m_value{0};
16925 EnumeratedLiteralFlag m_flags{0};
16926
16927};
16933{
16934public:
16935
16939 eProsima_user_DllExport CompleteEnumeratedLiteral()
16940 {
16941 }
16942
16946 eProsima_user_DllExport ~CompleteEnumeratedLiteral()
16947 {
16948 }
16949
16954 eProsima_user_DllExport CompleteEnumeratedLiteral(
16956 {
16957 m_common = x.m_common;
16958
16959 m_detail = x.m_detail;
16960
16961 }
16962
16967 eProsima_user_DllExport CompleteEnumeratedLiteral(
16968 CompleteEnumeratedLiteral&& x) noexcept
16969 {
16970 m_common = std::move(x.m_common);
16971 m_detail = std::move(x.m_detail);
16972 }
16973
16978 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
16980 {
16981
16982 m_common = x.m_common;
16983
16984 m_detail = x.m_detail;
16985
16986 return *this;
16987 }
16988
16993 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
16994 CompleteEnumeratedLiteral&& x) noexcept
16995 {
16996
16997 m_common = std::move(x.m_common);
16998 m_detail = std::move(x.m_detail);
16999 return *this;
17000 }
17001
17006 eProsima_user_DllExport bool operator ==(
17007 const CompleteEnumeratedLiteral& x) const
17008 {
17009 return (m_common == x.m_common &&
17010 m_detail == x.m_detail);
17011 }
17012
17017 eProsima_user_DllExport bool operator !=(
17018 const CompleteEnumeratedLiteral& x) const
17019 {
17020 return !(*this == x);
17021 }
17022
17027 eProsima_user_DllExport void common(
17028 const CommonEnumeratedLiteral& _common)
17029 {
17030 m_common = _common;
17031 }
17032
17037 eProsima_user_DllExport void common(
17038 CommonEnumeratedLiteral&& _common)
17039 {
17040 m_common = std::move(_common);
17041 }
17042
17047 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17048 {
17049 return m_common;
17050 }
17051
17056 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17057 {
17058 return m_common;
17059 }
17060
17061
17066 eProsima_user_DllExport void detail(
17067 const CompleteMemberDetail& _detail)
17068 {
17069 m_detail = _detail;
17070 }
17071
17076 eProsima_user_DllExport void detail(
17077 CompleteMemberDetail&& _detail)
17078 {
17079 m_detail = std::move(_detail);
17080 }
17081
17086 eProsima_user_DllExport const CompleteMemberDetail& detail() const
17087 {
17088 return m_detail;
17089 }
17090
17095 eProsima_user_DllExport CompleteMemberDetail& detail()
17096 {
17097 return m_detail;
17098 }
17099
17100
17101
17102private:
17103
17104 CommonEnumeratedLiteral m_common;
17105 CompleteMemberDetail m_detail;
17106
17107};
17108typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
17109
17115{
17116public:
17117
17121 eProsima_user_DllExport MinimalEnumeratedLiteral()
17122 {
17123 }
17124
17128 eProsima_user_DllExport ~MinimalEnumeratedLiteral()
17129 {
17130 }
17131
17136 eProsima_user_DllExport MinimalEnumeratedLiteral(
17137 const MinimalEnumeratedLiteral& x)
17138 {
17139 m_common = x.m_common;
17140
17141 m_detail = x.m_detail;
17142
17143 }
17144
17149 eProsima_user_DllExport MinimalEnumeratedLiteral(
17150 MinimalEnumeratedLiteral&& x) noexcept
17151 {
17152 m_common = std::move(x.m_common);
17153 m_detail = std::move(x.m_detail);
17154 }
17155
17160 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17161 const MinimalEnumeratedLiteral& x)
17162 {
17163
17164 m_common = x.m_common;
17165
17166 m_detail = x.m_detail;
17167
17168 return *this;
17169 }
17170
17175 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17176 MinimalEnumeratedLiteral&& x) noexcept
17177 {
17178
17179 m_common = std::move(x.m_common);
17180 m_detail = std::move(x.m_detail);
17181 return *this;
17182 }
17183
17188 eProsima_user_DllExport bool operator ==(
17189 const MinimalEnumeratedLiteral& x) const
17190 {
17191 return (m_common == x.m_common &&
17192 m_detail == x.m_detail);
17193 }
17194
17199 eProsima_user_DllExport bool operator !=(
17200 const MinimalEnumeratedLiteral& x) const
17201 {
17202 return !(*this == x);
17203 }
17204
17209 eProsima_user_DllExport void common(
17210 const CommonEnumeratedLiteral& _common)
17211 {
17212 m_common = _common;
17213 }
17214
17219 eProsima_user_DllExport void common(
17220 CommonEnumeratedLiteral&& _common)
17221 {
17222 m_common = std::move(_common);
17223 }
17224
17229 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17230 {
17231 return m_common;
17232 }
17233
17238 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17239 {
17240 return m_common;
17241 }
17242
17243
17248 eProsima_user_DllExport void detail(
17249 const MinimalMemberDetail& _detail)
17250 {
17251 m_detail = _detail;
17252 }
17253
17258 eProsima_user_DllExport void detail(
17259 MinimalMemberDetail&& _detail)
17260 {
17261 m_detail = std::move(_detail);
17262 }
17263
17268 eProsima_user_DllExport const MinimalMemberDetail& detail() const
17269 {
17270 return m_detail;
17271 }
17272
17277 eProsima_user_DllExport MinimalMemberDetail& detail()
17278 {
17279 return m_detail;
17280 }
17281
17282
17283
17284private:
17285
17286 CommonEnumeratedLiteral m_common;
17287 MinimalMemberDetail m_detail;
17288
17289};
17290typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
17291
17297{
17298public:
17299
17303 eProsima_user_DllExport CommonEnumeratedHeader()
17304 {
17305 }
17306
17310 eProsima_user_DllExport ~CommonEnumeratedHeader()
17311 {
17312 }
17313
17318 eProsima_user_DllExport CommonEnumeratedHeader(
17319 const CommonEnumeratedHeader& x)
17320 {
17321 m_bit_bound = x.m_bit_bound;
17322
17323 }
17324
17329 eProsima_user_DllExport CommonEnumeratedHeader(
17330 CommonEnumeratedHeader&& x) noexcept
17331 {
17332 m_bit_bound = x.m_bit_bound;
17333 }
17334
17339 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17340 const CommonEnumeratedHeader& x)
17341 {
17342
17343 m_bit_bound = x.m_bit_bound;
17344
17345 return *this;
17346 }
17347
17352 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17353 CommonEnumeratedHeader&& x) noexcept
17354 {
17355
17356 m_bit_bound = x.m_bit_bound;
17357 return *this;
17358 }
17359
17364 eProsima_user_DllExport bool operator ==(
17365 const CommonEnumeratedHeader& x) const
17366 {
17367 return (m_bit_bound == x.m_bit_bound);
17368 }
17369
17374 eProsima_user_DllExport bool operator !=(
17375 const CommonEnumeratedHeader& x) const
17376 {
17377 return !(*this == x);
17378 }
17379
17384 eProsima_user_DllExport void bit_bound(
17385 BitBound _bit_bound)
17386 {
17387 m_bit_bound = _bit_bound;
17388 }
17389
17394 eProsima_user_DllExport BitBound bit_bound() const
17395 {
17396 return m_bit_bound;
17397 }
17398
17403 eProsima_user_DllExport BitBound& bit_bound()
17404 {
17405 return m_bit_bound;
17406 }
17407
17408
17409
17410private:
17411
17412 BitBound m_bit_bound{0};
17413
17414};
17420{
17421public:
17422
17426 eProsima_user_DllExport CompleteEnumeratedHeader()
17427 {
17428 }
17429
17433 eProsima_user_DllExport ~CompleteEnumeratedHeader()
17434 {
17435 }
17436
17441 eProsima_user_DllExport CompleteEnumeratedHeader(
17442 const CompleteEnumeratedHeader& x)
17443 {
17444 m_common = x.m_common;
17445
17446 m_detail = x.m_detail;
17447
17448 }
17449
17454 eProsima_user_DllExport CompleteEnumeratedHeader(
17455 CompleteEnumeratedHeader&& x) noexcept
17456 {
17457 m_common = std::move(x.m_common);
17458 m_detail = std::move(x.m_detail);
17459 }
17460
17465 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17466 const CompleteEnumeratedHeader& x)
17467 {
17468
17469 m_common = x.m_common;
17470
17471 m_detail = x.m_detail;
17472
17473 return *this;
17474 }
17475
17480 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17481 CompleteEnumeratedHeader&& x) noexcept
17482 {
17483
17484 m_common = std::move(x.m_common);
17485 m_detail = std::move(x.m_detail);
17486 return *this;
17487 }
17488
17493 eProsima_user_DllExport bool operator ==(
17494 const CompleteEnumeratedHeader& x) const
17495 {
17496 return (m_common == x.m_common &&
17497 m_detail == x.m_detail);
17498 }
17499
17504 eProsima_user_DllExport bool operator !=(
17505 const CompleteEnumeratedHeader& x) const
17506 {
17507 return !(*this == x);
17508 }
17509
17514 eProsima_user_DllExport void common(
17515 const CommonEnumeratedHeader& _common)
17516 {
17517 m_common = _common;
17518 }
17519
17524 eProsima_user_DllExport void common(
17525 CommonEnumeratedHeader&& _common)
17526 {
17527 m_common = std::move(_common);
17528 }
17529
17534 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17535 {
17536 return m_common;
17537 }
17538
17543 eProsima_user_DllExport CommonEnumeratedHeader& common()
17544 {
17545 return m_common;
17546 }
17547
17548
17553 eProsima_user_DllExport void detail(
17554 const CompleteTypeDetail& _detail)
17555 {
17556 m_detail = _detail;
17557 }
17558
17563 eProsima_user_DllExport void detail(
17564 CompleteTypeDetail&& _detail)
17565 {
17566 m_detail = std::move(_detail);
17567 }
17568
17573 eProsima_user_DllExport const CompleteTypeDetail& detail() const
17574 {
17575 return m_detail;
17576 }
17577
17582 eProsima_user_DllExport CompleteTypeDetail& detail()
17583 {
17584 return m_detail;
17585 }
17586
17587
17588
17589private:
17590
17591 CommonEnumeratedHeader m_common;
17592 CompleteTypeDetail m_detail;
17593
17594};
17600{
17601public:
17602
17606 eProsima_user_DllExport MinimalEnumeratedHeader()
17607 {
17608 }
17609
17613 eProsima_user_DllExport ~MinimalEnumeratedHeader()
17614 {
17615 }
17616
17621 eProsima_user_DllExport MinimalEnumeratedHeader(
17622 const MinimalEnumeratedHeader& x)
17623 {
17624 m_common = x.m_common;
17625
17626 }
17627
17632 eProsima_user_DllExport MinimalEnumeratedHeader(
17633 MinimalEnumeratedHeader&& x) noexcept
17634 {
17635 m_common = std::move(x.m_common);
17636 }
17637
17642 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17643 const MinimalEnumeratedHeader& x)
17644 {
17645
17646 m_common = x.m_common;
17647
17648 return *this;
17649 }
17650
17655 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17656 MinimalEnumeratedHeader&& x) noexcept
17657 {
17658
17659 m_common = std::move(x.m_common);
17660 return *this;
17661 }
17662
17667 eProsima_user_DllExport bool operator ==(
17668 const MinimalEnumeratedHeader& x) const
17669 {
17670 return (m_common == x.m_common);
17671 }
17672
17677 eProsima_user_DllExport bool operator !=(
17678 const MinimalEnumeratedHeader& x) const
17679 {
17680 return !(*this == x);
17681 }
17682
17687 eProsima_user_DllExport void common(
17688 const CommonEnumeratedHeader& _common)
17689 {
17690 m_common = _common;
17691 }
17692
17697 eProsima_user_DllExport void common(
17698 CommonEnumeratedHeader&& _common)
17699 {
17700 m_common = std::move(_common);
17701 }
17702
17707 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17708 {
17709 return m_common;
17710 }
17711
17716 eProsima_user_DllExport CommonEnumeratedHeader& common()
17717 {
17718 return m_common;
17719 }
17720
17721
17722
17723private:
17724
17725 CommonEnumeratedHeader m_common;
17726
17727};
17733{
17734public:
17735
17739 eProsima_user_DllExport CompleteEnumeratedType()
17740 {
17741 }
17742
17746 eProsima_user_DllExport ~CompleteEnumeratedType()
17747 {
17748 }
17749
17754 eProsima_user_DllExport CompleteEnumeratedType(
17755 const CompleteEnumeratedType& x)
17756 {
17757 m_enum_flags = x.m_enum_flags;
17758
17759 m_header = x.m_header;
17760
17761 m_literal_seq = x.m_literal_seq;
17762
17763 }
17764
17769 eProsima_user_DllExport CompleteEnumeratedType(
17770 CompleteEnumeratedType&& x) noexcept
17771 {
17772 m_enum_flags = std::move(x.m_enum_flags);
17773 m_header = std::move(x.m_header);
17774 m_literal_seq = std::move(x.m_literal_seq);
17775 }
17776
17781 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17782 const CompleteEnumeratedType& x)
17783 {
17784
17785 m_enum_flags = x.m_enum_flags;
17786
17787 m_header = x.m_header;
17788
17789 m_literal_seq = x.m_literal_seq;
17790
17791 return *this;
17792 }
17793
17798 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17799 CompleteEnumeratedType&& x) noexcept
17800 {
17801
17802 m_enum_flags = std::move(x.m_enum_flags);
17803 m_header = std::move(x.m_header);
17804 m_literal_seq = std::move(x.m_literal_seq);
17805 return *this;
17806 }
17807
17812 eProsima_user_DllExport bool operator ==(
17813 const CompleteEnumeratedType& x) const
17814 {
17815 return (m_enum_flags == x.m_enum_flags &&
17816 m_header == x.m_header &&
17817 m_literal_seq == x.m_literal_seq);
17818 }
17819
17824 eProsima_user_DllExport bool operator !=(
17825 const CompleteEnumeratedType& x) const
17826 {
17827 return !(*this == x);
17828 }
17829
17834 eProsima_user_DllExport void enum_flags(
17835 const EnumTypeFlag& _enum_flags)
17836 {
17837 m_enum_flags = _enum_flags;
17838 }
17839
17844 eProsima_user_DllExport void enum_flags(
17845 EnumTypeFlag&& _enum_flags)
17846 {
17847 m_enum_flags = std::move(_enum_flags);
17848 }
17849
17854 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
17855 {
17856 return m_enum_flags;
17857 }
17858
17863 eProsima_user_DllExport EnumTypeFlag& enum_flags()
17864 {
17865 return m_enum_flags;
17866 }
17867
17868
17873 eProsima_user_DllExport void header(
17874 const CompleteEnumeratedHeader& _header)
17875 {
17876 m_header = _header;
17877 }
17878
17883 eProsima_user_DllExport void header(
17884 CompleteEnumeratedHeader&& _header)
17885 {
17886 m_header = std::move(_header);
17887 }
17888
17893 eProsima_user_DllExport const CompleteEnumeratedHeader& header() const
17894 {
17895 return m_header;
17896 }
17897
17902 eProsima_user_DllExport CompleteEnumeratedHeader& header()
17903 {
17904 return m_header;
17905 }
17906
17907
17912 eProsima_user_DllExport void literal_seq(
17913 const CompleteEnumeratedLiteralSeq& _literal_seq)
17914 {
17915 m_literal_seq = _literal_seq;
17916 }
17917
17922 eProsima_user_DllExport void literal_seq(
17923 CompleteEnumeratedLiteralSeq&& _literal_seq)
17924 {
17925 m_literal_seq = std::move(_literal_seq);
17926 }
17927
17932 eProsima_user_DllExport const CompleteEnumeratedLiteralSeq& literal_seq() const
17933 {
17934 return m_literal_seq;
17935 }
17936
17942 {
17943 return m_literal_seq;
17944 }
17945
17946
17947
17948private:
17949
17950 EnumTypeFlag m_enum_flags{0};
17951 CompleteEnumeratedHeader m_header;
17952 CompleteEnumeratedLiteralSeq m_literal_seq;
17953
17954};
17960{
17961public:
17962
17966 eProsima_user_DllExport MinimalEnumeratedType()
17967 {
17968 }
17969
17973 eProsima_user_DllExport ~MinimalEnumeratedType()
17974 {
17975 }
17976
17981 eProsima_user_DllExport MinimalEnumeratedType(
17982 const MinimalEnumeratedType& x)
17983 {
17984 m_enum_flags = x.m_enum_flags;
17985
17986 m_header = x.m_header;
17987
17988 m_literal_seq = x.m_literal_seq;
17989
17990 }
17991
17996 eProsima_user_DllExport MinimalEnumeratedType(
17997 MinimalEnumeratedType&& x) noexcept
17998 {
17999 m_enum_flags = std::move(x.m_enum_flags);
18000 m_header = std::move(x.m_header);
18001 m_literal_seq = std::move(x.m_literal_seq);
18002 }
18003
18008 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18009 const MinimalEnumeratedType& x)
18010 {
18011
18012 m_enum_flags = x.m_enum_flags;
18013
18014 m_header = x.m_header;
18015
18016 m_literal_seq = x.m_literal_seq;
18017
18018 return *this;
18019 }
18020
18025 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18026 MinimalEnumeratedType&& x) noexcept
18027 {
18028
18029 m_enum_flags = std::move(x.m_enum_flags);
18030 m_header = std::move(x.m_header);
18031 m_literal_seq = std::move(x.m_literal_seq);
18032 return *this;
18033 }
18034
18039 eProsima_user_DllExport bool operator ==(
18040 const MinimalEnumeratedType& x) const
18041 {
18042 return (m_enum_flags == x.m_enum_flags &&
18043 m_header == x.m_header &&
18044 m_literal_seq == x.m_literal_seq);
18045 }
18046
18051 eProsima_user_DllExport bool operator !=(
18052 const MinimalEnumeratedType& x) const
18053 {
18054 return !(*this == x);
18055 }
18056
18061 eProsima_user_DllExport void enum_flags(
18062 const EnumTypeFlag& _enum_flags)
18063 {
18064 m_enum_flags = _enum_flags;
18065 }
18066
18071 eProsima_user_DllExport void enum_flags(
18072 EnumTypeFlag&& _enum_flags)
18073 {
18074 m_enum_flags = std::move(_enum_flags);
18075 }
18076
18081 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
18082 {
18083 return m_enum_flags;
18084 }
18085
18090 eProsima_user_DllExport EnumTypeFlag& enum_flags()
18091 {
18092 return m_enum_flags;
18093 }
18094
18095
18100 eProsima_user_DllExport void header(
18101 const MinimalEnumeratedHeader& _header)
18102 {
18103 m_header = _header;
18104 }
18105
18110 eProsima_user_DllExport void header(
18111 MinimalEnumeratedHeader&& _header)
18112 {
18113 m_header = std::move(_header);
18114 }
18115
18120 eProsima_user_DllExport const MinimalEnumeratedHeader& header() const
18121 {
18122 return m_header;
18123 }
18124
18129 eProsima_user_DllExport MinimalEnumeratedHeader& header()
18130 {
18131 return m_header;
18132 }
18133
18134
18139 eProsima_user_DllExport void literal_seq(
18140 const MinimalEnumeratedLiteralSeq& _literal_seq)
18141 {
18142 m_literal_seq = _literal_seq;
18143 }
18144
18149 eProsima_user_DllExport void literal_seq(
18150 MinimalEnumeratedLiteralSeq&& _literal_seq)
18151 {
18152 m_literal_seq = std::move(_literal_seq);
18153 }
18154
18159 eProsima_user_DllExport const MinimalEnumeratedLiteralSeq& literal_seq() const
18160 {
18161 return m_literal_seq;
18162 }
18163
18168 eProsima_user_DllExport MinimalEnumeratedLiteralSeq& literal_seq()
18169 {
18170 return m_literal_seq;
18171 }
18172
18173
18174
18175private:
18176
18177 EnumTypeFlag m_enum_flags{0};
18178 MinimalEnumeratedHeader m_header;
18179 MinimalEnumeratedLiteralSeq m_literal_seq;
18180
18181};
18187{
18188public:
18189
18193 eProsima_user_DllExport CommonBitflag()
18194 {
18195 }
18196
18200 eProsima_user_DllExport ~CommonBitflag()
18201 {
18202 }
18203
18208 eProsima_user_DllExport CommonBitflag(
18209 const CommonBitflag& x)
18210 {
18211 m_position = x.m_position;
18212
18213 m_flags = x.m_flags;
18214
18215 }
18216
18221 eProsima_user_DllExport CommonBitflag(
18222 CommonBitflag&& x) noexcept
18223 {
18224 m_position = x.m_position;
18225 m_flags = std::move(x.m_flags);
18226 }
18227
18232 eProsima_user_DllExport CommonBitflag& operator =(
18233 const CommonBitflag& x)
18234 {
18235
18236 m_position = x.m_position;
18237
18238 m_flags = x.m_flags;
18239
18240 return *this;
18241 }
18242
18247 eProsima_user_DllExport CommonBitflag& operator =(
18248 CommonBitflag&& x) noexcept
18249 {
18250
18251 m_position = x.m_position;
18252 m_flags = std::move(x.m_flags);
18253 return *this;
18254 }
18255
18260 eProsima_user_DllExport bool operator ==(
18261 const CommonBitflag& x) const
18262 {
18263 return (m_position == x.m_position &&
18264 m_flags == x.m_flags);
18265 }
18266
18271 eProsima_user_DllExport bool operator !=(
18272 const CommonBitflag& x) const
18273 {
18274 return !(*this == x);
18275 }
18276
18281 eProsima_user_DllExport void position(
18282 uint16_t _position)
18283 {
18284 m_position = _position;
18285 }
18286
18291 eProsima_user_DllExport uint16_t position() const
18292 {
18293 return m_position;
18294 }
18295
18300 eProsima_user_DllExport uint16_t& position()
18301 {
18302 return m_position;
18303 }
18304
18305
18310 eProsima_user_DllExport void flags(
18311 const BitflagFlag& _flags)
18312 {
18313 m_flags = _flags;
18314 }
18315
18320 eProsima_user_DllExport void flags(
18321 BitflagFlag&& _flags)
18322 {
18323 m_flags = std::move(_flags);
18324 }
18325
18330 eProsima_user_DllExport const BitflagFlag& flags() const
18331 {
18332 return m_flags;
18333 }
18334
18339 eProsima_user_DllExport BitflagFlag& flags()
18340 {
18341 return m_flags;
18342 }
18343
18344
18345
18346private:
18347
18348 uint16_t m_position{0};
18349 BitflagFlag m_flags{0};
18350
18351};
18357{
18358public:
18359
18363 eProsima_user_DllExport CompleteBitflag()
18364 {
18365 }
18366
18370 eProsima_user_DllExport ~CompleteBitflag()
18371 {
18372 }
18373
18378 eProsima_user_DllExport CompleteBitflag(
18379 const CompleteBitflag& x)
18380 {
18381 m_common = x.m_common;
18382
18383 m_detail = x.m_detail;
18384
18385 }
18386
18391 eProsima_user_DllExport CompleteBitflag(
18392 CompleteBitflag&& x) noexcept
18393 {
18394 m_common = std::move(x.m_common);
18395 m_detail = std::move(x.m_detail);
18396 }
18397
18402 eProsima_user_DllExport CompleteBitflag& operator =(
18403 const CompleteBitflag& x)
18404 {
18405
18406 m_common = x.m_common;
18407
18408 m_detail = x.m_detail;
18409
18410 return *this;
18411 }
18412
18417 eProsima_user_DllExport CompleteBitflag& operator =(
18418 CompleteBitflag&& x) noexcept
18419 {
18420
18421 m_common = std::move(x.m_common);
18422 m_detail = std::move(x.m_detail);
18423 return *this;
18424 }
18425
18430 eProsima_user_DllExport bool operator ==(
18431 const CompleteBitflag& x) const
18432 {
18433 return (m_common == x.m_common &&
18434 m_detail == x.m_detail);
18435 }
18436
18441 eProsima_user_DllExport bool operator !=(
18442 const CompleteBitflag& x) const
18443 {
18444 return !(*this == x);
18445 }
18446
18451 eProsima_user_DllExport void common(
18452 const CommonBitflag& _common)
18453 {
18454 m_common = _common;
18455 }
18456
18461 eProsima_user_DllExport void common(
18462 CommonBitflag&& _common)
18463 {
18464 m_common = std::move(_common);
18465 }
18466
18471 eProsima_user_DllExport const CommonBitflag& common() const
18472 {
18473 return m_common;
18474 }
18475
18480 eProsima_user_DllExport CommonBitflag& common()
18481 {
18482 return m_common;
18483 }
18484
18485
18490 eProsima_user_DllExport void detail(
18491 const CompleteMemberDetail& _detail)
18492 {
18493 m_detail = _detail;
18494 }
18495
18500 eProsima_user_DllExport void detail(
18501 CompleteMemberDetail&& _detail)
18502 {
18503 m_detail = std::move(_detail);
18504 }
18505
18510 eProsima_user_DllExport const CompleteMemberDetail& detail() const
18511 {
18512 return m_detail;
18513 }
18514
18519 eProsima_user_DllExport CompleteMemberDetail& detail()
18520 {
18521 return m_detail;
18522 }
18523
18524
18525
18526private:
18527
18528 CommonBitflag m_common;
18529 CompleteMemberDetail m_detail;
18530
18531};
18532typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
18533
18539{
18540public:
18541
18545 eProsima_user_DllExport MinimalBitflag()
18546 {
18547 }
18548
18552 eProsima_user_DllExport ~MinimalBitflag()
18553 {
18554 }
18555
18560 eProsima_user_DllExport MinimalBitflag(
18561 const MinimalBitflag& x)
18562 {
18563 m_common = x.m_common;
18564
18565 m_detail = x.m_detail;
18566
18567 }
18568
18573 eProsima_user_DllExport MinimalBitflag(
18574 MinimalBitflag&& x) noexcept
18575 {
18576 m_common = std::move(x.m_common);
18577 m_detail = std::move(x.m_detail);
18578 }
18579
18584 eProsima_user_DllExport MinimalBitflag& operator =(
18585 const MinimalBitflag& x)
18586 {
18587
18588 m_common = x.m_common;
18589
18590 m_detail = x.m_detail;
18591
18592 return *this;
18593 }
18594
18599 eProsima_user_DllExport MinimalBitflag& operator =(
18600 MinimalBitflag&& x) noexcept
18601 {
18602
18603 m_common = std::move(x.m_common);
18604 m_detail = std::move(x.m_detail);
18605 return *this;
18606 }
18607
18612 eProsima_user_DllExport bool operator ==(
18613 const MinimalBitflag& x) const
18614 {
18615 return (m_common == x.m_common &&
18616 m_detail == x.m_detail);
18617 }
18618
18623 eProsima_user_DllExport bool operator !=(
18624 const MinimalBitflag& x) const
18625 {
18626 return !(*this == x);
18627 }
18628
18633 eProsima_user_DllExport void common(
18634 const CommonBitflag& _common)
18635 {
18636 m_common = _common;
18637 }
18638
18643 eProsima_user_DllExport void common(
18644 CommonBitflag&& _common)
18645 {
18646 m_common = std::move(_common);
18647 }
18648
18653 eProsima_user_DllExport const CommonBitflag& common() const
18654 {
18655 return m_common;
18656 }
18657
18662 eProsima_user_DllExport CommonBitflag& common()
18663 {
18664 return m_common;
18665 }
18666
18667
18672 eProsima_user_DllExport void detail(
18673 const MinimalMemberDetail& _detail)
18674 {
18675 m_detail = _detail;
18676 }
18677
18682 eProsima_user_DllExport void detail(
18683 MinimalMemberDetail&& _detail)
18684 {
18685 m_detail = std::move(_detail);
18686 }
18687
18692 eProsima_user_DllExport const MinimalMemberDetail& detail() const
18693 {
18694 return m_detail;
18695 }
18696
18701 eProsima_user_DllExport MinimalMemberDetail& detail()
18702 {
18703 return m_detail;
18704 }
18705
18706
18707
18708private:
18709
18710 CommonBitflag m_common;
18711 MinimalMemberDetail m_detail;
18712
18713};
18714typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
18715
18721{
18722public:
18723
18727 eProsima_user_DllExport CommonBitmaskHeader()
18728 {
18729 }
18730
18734 eProsima_user_DllExport ~CommonBitmaskHeader()
18735 {
18736 }
18737
18742 eProsima_user_DllExport CommonBitmaskHeader(
18743 const CommonBitmaskHeader& x)
18744 {
18745 m_bit_bound = x.m_bit_bound;
18746
18747 }
18748
18753 eProsima_user_DllExport CommonBitmaskHeader(
18754 CommonBitmaskHeader&& x) noexcept
18755 {
18756 m_bit_bound = x.m_bit_bound;
18757 }
18758
18763 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18764 const CommonBitmaskHeader& x)
18765 {
18766
18767 m_bit_bound = x.m_bit_bound;
18768
18769 return *this;
18770 }
18771
18776 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18777 CommonBitmaskHeader&& x) noexcept
18778 {
18779
18780 m_bit_bound = x.m_bit_bound;
18781 return *this;
18782 }
18783
18788 eProsima_user_DllExport bool operator ==(
18789 const CommonBitmaskHeader& x) const
18790 {
18791 return (m_bit_bound == x.m_bit_bound);
18792 }
18793
18798 eProsima_user_DllExport bool operator !=(
18799 const CommonBitmaskHeader& x) const
18800 {
18801 return !(*this == x);
18802 }
18803
18808 eProsima_user_DllExport void bit_bound(
18809 BitBound _bit_bound)
18810 {
18811 m_bit_bound = _bit_bound;
18812 }
18813
18818 eProsima_user_DllExport BitBound bit_bound() const
18819 {
18820 return m_bit_bound;
18821 }
18822
18827 eProsima_user_DllExport BitBound& bit_bound()
18828 {
18829 return m_bit_bound;
18830 }
18831
18832
18833
18834private:
18835
18836 BitBound m_bit_bound{0};
18837
18838};
18840
18842
18848{
18849public:
18850
18854 eProsima_user_DllExport CompleteBitmaskType()
18855 {
18856 }
18857
18861 eProsima_user_DllExport ~CompleteBitmaskType()
18862 {
18863 }
18864
18869 eProsima_user_DllExport CompleteBitmaskType(
18870 const CompleteBitmaskType& x)
18871 {
18872 m_bitmask_flags = x.m_bitmask_flags;
18873
18874 m_header = x.m_header;
18875
18876 m_flag_seq = x.m_flag_seq;
18877
18878 }
18879
18884 eProsima_user_DllExport CompleteBitmaskType(
18885 CompleteBitmaskType&& x) noexcept
18886 {
18887 m_bitmask_flags = std::move(x.m_bitmask_flags);
18888 m_header = std::move(x.m_header);
18889 m_flag_seq = std::move(x.m_flag_seq);
18890 }
18891
18896 eProsima_user_DllExport CompleteBitmaskType& operator =(
18897 const CompleteBitmaskType& x)
18898 {
18899
18900 m_bitmask_flags = x.m_bitmask_flags;
18901
18902 m_header = x.m_header;
18903
18904 m_flag_seq = x.m_flag_seq;
18905
18906 return *this;
18907 }
18908
18913 eProsima_user_DllExport CompleteBitmaskType& operator =(
18914 CompleteBitmaskType&& x) noexcept
18915 {
18916
18917 m_bitmask_flags = std::move(x.m_bitmask_flags);
18918 m_header = std::move(x.m_header);
18919 m_flag_seq = std::move(x.m_flag_seq);
18920 return *this;
18921 }
18922
18927 eProsima_user_DllExport bool operator ==(
18928 const CompleteBitmaskType& x) const
18929 {
18930 return (m_bitmask_flags == x.m_bitmask_flags &&
18931 m_header == x.m_header &&
18932 m_flag_seq == x.m_flag_seq);
18933 }
18934
18939 eProsima_user_DllExport bool operator !=(
18940 const CompleteBitmaskType& x) const
18941 {
18942 return !(*this == x);
18943 }
18944
18949 eProsima_user_DllExport void bitmask_flags(
18950 const BitmaskTypeFlag& _bitmask_flags)
18951 {
18952 m_bitmask_flags = _bitmask_flags;
18953 }
18954
18959 eProsima_user_DllExport void bitmask_flags(
18960 BitmaskTypeFlag&& _bitmask_flags)
18961 {
18962 m_bitmask_flags = std::move(_bitmask_flags);
18963 }
18964
18969 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
18970 {
18971 return m_bitmask_flags;
18972 }
18973
18978 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
18979 {
18980 return m_bitmask_flags;
18981 }
18982
18983
18988 eProsima_user_DllExport void header(
18989 const CompleteBitmaskHeader& _header)
18990 {
18991 m_header = _header;
18992 }
18993
18998 eProsima_user_DllExport void header(
18999 CompleteBitmaskHeader&& _header)
19000 {
19001 m_header = std::move(_header);
19002 }
19003
19008 eProsima_user_DllExport const CompleteBitmaskHeader& header() const
19009 {
19010 return m_header;
19011 }
19012
19017 eProsima_user_DllExport CompleteBitmaskHeader& header()
19018 {
19019 return m_header;
19020 }
19021
19022
19027 eProsima_user_DllExport void flag_seq(
19028 const CompleteBitflagSeq& _flag_seq)
19029 {
19030 m_flag_seq = _flag_seq;
19031 }
19032
19037 eProsima_user_DllExport void flag_seq(
19038 CompleteBitflagSeq&& _flag_seq)
19039 {
19040 m_flag_seq = std::move(_flag_seq);
19041 }
19042
19047 eProsima_user_DllExport const CompleteBitflagSeq& flag_seq() const
19048 {
19049 return m_flag_seq;
19050 }
19051
19056 eProsima_user_DllExport CompleteBitflagSeq& flag_seq()
19057 {
19058 return m_flag_seq;
19059 }
19060
19061
19062
19063private:
19064
19065 BitmaskTypeFlag m_bitmask_flags{0};
19066 CompleteBitmaskHeader m_header;
19067 CompleteBitflagSeq m_flag_seq;
19068
19069};
19075{
19076public:
19077
19081 eProsima_user_DllExport MinimalBitmaskType()
19082 {
19083 }
19084
19088 eProsima_user_DllExport ~MinimalBitmaskType()
19089 {
19090 }
19091
19096 eProsima_user_DllExport MinimalBitmaskType(
19097 const MinimalBitmaskType& x)
19098 {
19099 m_bitmask_flags = x.m_bitmask_flags;
19100
19101 m_header = x.m_header;
19102
19103 m_flag_seq = x.m_flag_seq;
19104
19105 }
19106
19111 eProsima_user_DllExport MinimalBitmaskType(
19112 MinimalBitmaskType&& x) noexcept
19113 {
19114 m_bitmask_flags = std::move(x.m_bitmask_flags);
19115 m_header = std::move(x.m_header);
19116 m_flag_seq = std::move(x.m_flag_seq);
19117 }
19118
19123 eProsima_user_DllExport MinimalBitmaskType& operator =(
19124 const MinimalBitmaskType& x)
19125 {
19126
19127 m_bitmask_flags = x.m_bitmask_flags;
19128
19129 m_header = x.m_header;
19130
19131 m_flag_seq = x.m_flag_seq;
19132
19133 return *this;
19134 }
19135
19140 eProsima_user_DllExport MinimalBitmaskType& operator =(
19141 MinimalBitmaskType&& x) noexcept
19142 {
19143
19144 m_bitmask_flags = std::move(x.m_bitmask_flags);
19145 m_header = std::move(x.m_header);
19146 m_flag_seq = std::move(x.m_flag_seq);
19147 return *this;
19148 }
19149
19154 eProsima_user_DllExport bool operator ==(
19155 const MinimalBitmaskType& x) const
19156 {
19157 return (m_bitmask_flags == x.m_bitmask_flags &&
19158 m_header == x.m_header &&
19159 m_flag_seq == x.m_flag_seq);
19160 }
19161
19166 eProsima_user_DllExport bool operator !=(
19167 const MinimalBitmaskType& x) const
19168 {
19169 return !(*this == x);
19170 }
19171
19176 eProsima_user_DllExport void bitmask_flags(
19177 const BitmaskTypeFlag& _bitmask_flags)
19178 {
19179 m_bitmask_flags = _bitmask_flags;
19180 }
19181
19186 eProsima_user_DllExport void bitmask_flags(
19187 BitmaskTypeFlag&& _bitmask_flags)
19188 {
19189 m_bitmask_flags = std::move(_bitmask_flags);
19190 }
19191
19196 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
19197 {
19198 return m_bitmask_flags;
19199 }
19200
19205 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
19206 {
19207 return m_bitmask_flags;
19208 }
19209
19210
19215 eProsima_user_DllExport void header(
19216 const MinimalBitmaskHeader& _header)
19217 {
19218 m_header = _header;
19219 }
19220
19225 eProsima_user_DllExport void header(
19226 MinimalBitmaskHeader&& _header)
19227 {
19228 m_header = std::move(_header);
19229 }
19230
19235 eProsima_user_DllExport const MinimalBitmaskHeader& header() const
19236 {
19237 return m_header;
19238 }
19239
19244 eProsima_user_DllExport MinimalBitmaskHeader& header()
19245 {
19246 return m_header;
19247 }
19248
19249
19254 eProsima_user_DllExport void flag_seq(
19255 const MinimalBitflagSeq& _flag_seq)
19256 {
19257 m_flag_seq = _flag_seq;
19258 }
19259
19264 eProsima_user_DllExport void flag_seq(
19265 MinimalBitflagSeq&& _flag_seq)
19266 {
19267 m_flag_seq = std::move(_flag_seq);
19268 }
19269
19274 eProsima_user_DllExport const MinimalBitflagSeq& flag_seq() const
19275 {
19276 return m_flag_seq;
19277 }
19278
19283 eProsima_user_DllExport MinimalBitflagSeq& flag_seq()
19284 {
19285 return m_flag_seq;
19286 }
19287
19288
19289
19290private:
19291
19292 BitmaskTypeFlag m_bitmask_flags{0};
19293 MinimalBitmaskHeader m_header;
19294 MinimalBitflagSeq m_flag_seq;
19295
19296};
19302{
19303public:
19304
19308 eProsima_user_DllExport CommonBitfield()
19309 {
19310 }
19311
19315 eProsima_user_DllExport ~CommonBitfield()
19316 {
19317 }
19318
19323 eProsima_user_DllExport CommonBitfield(
19324 const CommonBitfield& x)
19325 {
19326 m_position = x.m_position;
19327
19328 m_flags = x.m_flags;
19329
19330 m_bitcount = x.m_bitcount;
19331
19332 m_holder_type = x.m_holder_type;
19333
19334 }
19335
19340 eProsima_user_DllExport CommonBitfield(
19341 CommonBitfield&& x) noexcept
19342 {
19343 m_position = x.m_position;
19344 m_flags = std::move(x.m_flags);
19345 m_bitcount = x.m_bitcount;
19346 m_holder_type = x.m_holder_type;
19347 }
19348
19353 eProsima_user_DllExport CommonBitfield& operator =(
19354 const CommonBitfield& x)
19355 {
19356
19357 m_position = x.m_position;
19358
19359 m_flags = x.m_flags;
19360
19361 m_bitcount = x.m_bitcount;
19362
19363 m_holder_type = x.m_holder_type;
19364
19365 return *this;
19366 }
19367
19372 eProsima_user_DllExport CommonBitfield& operator =(
19373 CommonBitfield&& x) noexcept
19374 {
19375
19376 m_position = x.m_position;
19377 m_flags = std::move(x.m_flags);
19378 m_bitcount = x.m_bitcount;
19379 m_holder_type = x.m_holder_type;
19380 return *this;
19381 }
19382
19387 eProsima_user_DllExport bool operator ==(
19388 const CommonBitfield& x) const
19389 {
19390 return (m_position == x.m_position &&
19391 m_flags == x.m_flags &&
19392 m_bitcount == x.m_bitcount &&
19393 m_holder_type == x.m_holder_type);
19394 }
19395
19400 eProsima_user_DllExport bool operator !=(
19401 const CommonBitfield& x) const
19402 {
19403 return !(*this == x);
19404 }
19405
19410 eProsima_user_DllExport void position(
19411 uint16_t _position)
19412 {
19413 m_position = _position;
19414 }
19415
19420 eProsima_user_DllExport uint16_t position() const
19421 {
19422 return m_position;
19423 }
19424
19429 eProsima_user_DllExport uint16_t& position()
19430 {
19431 return m_position;
19432 }
19433
19434
19439 eProsima_user_DllExport void flags(
19440 const BitsetMemberFlag& _flags)
19441 {
19442 m_flags = _flags;
19443 }
19444
19449 eProsima_user_DllExport void flags(
19450 BitsetMemberFlag&& _flags)
19451 {
19452 m_flags = std::move(_flags);
19453 }
19454
19459 eProsima_user_DllExport const BitsetMemberFlag& flags() const
19460 {
19461 return m_flags;
19462 }
19463
19468 eProsima_user_DllExport BitsetMemberFlag& flags()
19469 {
19470 return m_flags;
19471 }
19472
19473
19478 eProsima_user_DllExport void bitcount(
19479 uint8_t _bitcount)
19480 {
19481 m_bitcount = _bitcount;
19482 }
19483
19488 eProsima_user_DllExport uint8_t bitcount() const
19489 {
19490 return m_bitcount;
19491 }
19492
19497 eProsima_user_DllExport uint8_t& bitcount()
19498 {
19499 return m_bitcount;
19500 }
19501
19502
19507 eProsima_user_DllExport void holder_type(
19508 TypeKind _holder_type)
19509 {
19510 m_holder_type = _holder_type;
19511 }
19512
19517 eProsima_user_DllExport TypeKind holder_type() const
19518 {
19519 return m_holder_type;
19520 }
19521
19526 eProsima_user_DllExport TypeKind& holder_type()
19527 {
19528 return m_holder_type;
19529 }
19530
19531
19532
19533private:
19534
19535 uint16_t m_position{0};
19536 BitsetMemberFlag m_flags{0};
19537 uint8_t m_bitcount{0};
19538 TypeKind m_holder_type{0};
19539
19540};
19546{
19547public:
19548
19552 eProsima_user_DllExport CompleteBitfield()
19553 {
19554 }
19555
19559 eProsima_user_DllExport ~CompleteBitfield()
19560 {
19561 }
19562
19567 eProsima_user_DllExport CompleteBitfield(
19568 const CompleteBitfield& x)
19569 {
19570 m_common = x.m_common;
19571
19572 m_detail = x.m_detail;
19573
19574 }
19575
19580 eProsima_user_DllExport CompleteBitfield(
19581 CompleteBitfield&& x) noexcept
19582 {
19583 m_common = std::move(x.m_common);
19584 m_detail = std::move(x.m_detail);
19585 }
19586
19591 eProsima_user_DllExport CompleteBitfield& operator =(
19592 const CompleteBitfield& x)
19593 {
19594
19595 m_common = x.m_common;
19596
19597 m_detail = x.m_detail;
19598
19599 return *this;
19600 }
19601
19606 eProsima_user_DllExport CompleteBitfield& operator =(
19607 CompleteBitfield&& x) noexcept
19608 {
19609
19610 m_common = std::move(x.m_common);
19611 m_detail = std::move(x.m_detail);
19612 return *this;
19613 }
19614
19619 eProsima_user_DllExport bool operator ==(
19620 const CompleteBitfield& x) const
19621 {
19622 return (m_common == x.m_common &&
19623 m_detail == x.m_detail);
19624 }
19625
19630 eProsima_user_DllExport bool operator !=(
19631 const CompleteBitfield& x) const
19632 {
19633 return !(*this == x);
19634 }
19635
19640 eProsima_user_DllExport void common(
19641 const CommonBitfield& _common)
19642 {
19643 m_common = _common;
19644 }
19645
19650 eProsima_user_DllExport void common(
19651 CommonBitfield&& _common)
19652 {
19653 m_common = std::move(_common);
19654 }
19655
19660 eProsima_user_DllExport const CommonBitfield& common() const
19661 {
19662 return m_common;
19663 }
19664
19669 eProsima_user_DllExport CommonBitfield& common()
19670 {
19671 return m_common;
19672 }
19673
19674
19679 eProsima_user_DllExport void detail(
19680 const CompleteMemberDetail& _detail)
19681 {
19682 m_detail = _detail;
19683 }
19684
19689 eProsima_user_DllExport void detail(
19690 CompleteMemberDetail&& _detail)
19691 {
19692 m_detail = std::move(_detail);
19693 }
19694
19699 eProsima_user_DllExport const CompleteMemberDetail& detail() const
19700 {
19701 return m_detail;
19702 }
19703
19708 eProsima_user_DllExport CompleteMemberDetail& detail()
19709 {
19710 return m_detail;
19711 }
19712
19713
19714
19715private:
19716
19717 CommonBitfield m_common;
19718 CompleteMemberDetail m_detail;
19719
19720};
19721typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
19722
19728{
19729public:
19730
19734 eProsima_user_DllExport MinimalBitfield()
19735 {
19736 }
19737
19741 eProsima_user_DllExport ~MinimalBitfield()
19742 {
19743 }
19744
19749 eProsima_user_DllExport MinimalBitfield(
19750 const MinimalBitfield& x)
19751 {
19752 m_common = x.m_common;
19753
19754 m_name_hash = x.m_name_hash;
19755
19756 }
19757
19762 eProsima_user_DllExport MinimalBitfield(
19763 MinimalBitfield&& x) noexcept
19764 {
19765 m_common = std::move(x.m_common);
19766 m_name_hash = std::move(x.m_name_hash);
19767 }
19768
19773 eProsima_user_DllExport MinimalBitfield& operator =(
19774 const MinimalBitfield& x)
19775 {
19776
19777 m_common = x.m_common;
19778
19779 m_name_hash = x.m_name_hash;
19780
19781 return *this;
19782 }
19783
19788 eProsima_user_DllExport MinimalBitfield& operator =(
19789 MinimalBitfield&& x) noexcept
19790 {
19791
19792 m_common = std::move(x.m_common);
19793 m_name_hash = std::move(x.m_name_hash);
19794 return *this;
19795 }
19796
19801 eProsima_user_DllExport bool operator ==(
19802 const MinimalBitfield& x) const
19803 {
19804 return (m_common == x.m_common &&
19805 m_name_hash == x.m_name_hash);
19806 }
19807
19812 eProsima_user_DllExport bool operator !=(
19813 const MinimalBitfield& x) const
19814 {
19815 return !(*this == x);
19816 }
19817
19822 eProsima_user_DllExport void common(
19823 const CommonBitfield& _common)
19824 {
19825 m_common = _common;
19826 }
19827
19832 eProsima_user_DllExport void common(
19833 CommonBitfield&& _common)
19834 {
19835 m_common = std::move(_common);
19836 }
19837
19842 eProsima_user_DllExport const CommonBitfield& common() const
19843 {
19844 return m_common;
19845 }
19846
19851 eProsima_user_DllExport CommonBitfield& common()
19852 {
19853 return m_common;
19854 }
19855
19856
19861 eProsima_user_DllExport void name_hash(
19862 const NameHash& _name_hash)
19863 {
19864 m_name_hash = _name_hash;
19865 }
19866
19871 eProsima_user_DllExport void name_hash(
19872 NameHash&& _name_hash)
19873 {
19874 m_name_hash = std::move(_name_hash);
19875 }
19876
19881 eProsima_user_DllExport const NameHash& name_hash() const
19882 {
19883 return m_name_hash;
19884 }
19885
19890 eProsima_user_DllExport NameHash& name_hash()
19891 {
19892 return m_name_hash;
19893 }
19894
19895
19896
19897private:
19898
19899 CommonBitfield m_common;
19900 NameHash m_name_hash{0};
19901
19902};
19903typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
19904
19910{
19911public:
19912
19916 eProsima_user_DllExport CompleteBitsetHeader()
19917 {
19918 }
19919
19923 eProsima_user_DllExport ~CompleteBitsetHeader()
19924 {
19925 }
19926
19931 eProsima_user_DllExport CompleteBitsetHeader(
19932 const CompleteBitsetHeader& x)
19933 {
19934 m_detail = x.m_detail;
19935
19936 }
19937
19942 eProsima_user_DllExport CompleteBitsetHeader(
19943 CompleteBitsetHeader&& x) noexcept
19944 {
19945 m_detail = std::move(x.m_detail);
19946 }
19947
19952 eProsima_user_DllExport CompleteBitsetHeader& operator =(
19953 const CompleteBitsetHeader& x)
19954 {
19955
19956 m_detail = x.m_detail;
19957
19958 return *this;
19959 }
19960
19965 eProsima_user_DllExport CompleteBitsetHeader& operator =(
19966 CompleteBitsetHeader&& x) noexcept
19967 {
19968
19969 m_detail = std::move(x.m_detail);
19970 return *this;
19971 }
19972
19977 eProsima_user_DllExport bool operator ==(
19978 const CompleteBitsetHeader& x) const
19979 {
19980 return (m_detail == x.m_detail);
19981 }
19982
19987 eProsima_user_DllExport bool operator !=(
19988 const CompleteBitsetHeader& x) const
19989 {
19990 return !(*this == x);
19991 }
19992
19997 eProsima_user_DllExport void detail(
19998 const CompleteTypeDetail& _detail)
19999 {
20000 m_detail = _detail;
20001 }
20002
20007 eProsima_user_DllExport void detail(
20008 CompleteTypeDetail&& _detail)
20009 {
20010 m_detail = std::move(_detail);
20011 }
20012
20017 eProsima_user_DllExport const CompleteTypeDetail& detail() const
20018 {
20019 return m_detail;
20020 }
20021
20026 eProsima_user_DllExport CompleteTypeDetail& detail()
20027 {
20028 return m_detail;
20029 }
20030
20031
20032
20033private:
20034
20035 CompleteTypeDetail m_detail;
20036
20037};
20043{
20044public:
20045
20049 eProsima_user_DllExport MinimalBitsetHeader()
20050 {
20051 }
20052
20056 eProsima_user_DllExport ~MinimalBitsetHeader()
20057 {
20058 }
20059
20064 eProsima_user_DllExport MinimalBitsetHeader(
20065 const MinimalBitsetHeader& x)
20066 {
20067 static_cast<void>(x);
20068 }
20069
20074 eProsima_user_DllExport MinimalBitsetHeader(
20075 MinimalBitsetHeader&& x) noexcept
20076 {
20077 static_cast<void>(x);
20078 }
20079
20084 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20085 const MinimalBitsetHeader& x)
20086 {
20087
20088 static_cast<void>(x);
20089
20090 return *this;
20091 }
20092
20097 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20098 MinimalBitsetHeader&& x) noexcept
20099 {
20100
20101 static_cast<void>(x);
20102
20103 return *this;
20104 }
20105
20110 eProsima_user_DllExport bool operator ==(
20111 const MinimalBitsetHeader& x) const
20112 {
20113 static_cast<void>(x);
20114 return true;
20115 }
20116
20121 eProsima_user_DllExport bool operator !=(
20122 const MinimalBitsetHeader& x) const
20123 {
20124 return !(*this == x);
20125 }
20126
20127
20128
20129private:
20130
20131
20132};
20138{
20139public:
20140
20144 eProsima_user_DllExport CompleteBitsetType()
20145 {
20146 }
20147
20151 eProsima_user_DllExport ~CompleteBitsetType()
20152 {
20153 }
20154
20159 eProsima_user_DllExport CompleteBitsetType(
20160 const CompleteBitsetType& x)
20161 {
20162 m_bitset_flags = x.m_bitset_flags;
20163
20164 m_header = x.m_header;
20165
20166 m_field_seq = x.m_field_seq;
20167
20168 }
20169
20174 eProsima_user_DllExport CompleteBitsetType(
20175 CompleteBitsetType&& x) noexcept
20176 {
20177 m_bitset_flags = std::move(x.m_bitset_flags);
20178 m_header = std::move(x.m_header);
20179 m_field_seq = std::move(x.m_field_seq);
20180 }
20181
20186 eProsima_user_DllExport CompleteBitsetType& operator =(
20187 const CompleteBitsetType& x)
20188 {
20189
20190 m_bitset_flags = x.m_bitset_flags;
20191
20192 m_header = x.m_header;
20193
20194 m_field_seq = x.m_field_seq;
20195
20196 return *this;
20197 }
20198
20203 eProsima_user_DllExport CompleteBitsetType& operator =(
20204 CompleteBitsetType&& x) noexcept
20205 {
20206
20207 m_bitset_flags = std::move(x.m_bitset_flags);
20208 m_header = std::move(x.m_header);
20209 m_field_seq = std::move(x.m_field_seq);
20210 return *this;
20211 }
20212
20217 eProsima_user_DllExport bool operator ==(
20218 const CompleteBitsetType& x) const
20219 {
20220 return (m_bitset_flags == x.m_bitset_flags &&
20221 m_header == x.m_header &&
20222 m_field_seq == x.m_field_seq);
20223 }
20224
20229 eProsima_user_DllExport bool operator !=(
20230 const CompleteBitsetType& x) const
20231 {
20232 return !(*this == x);
20233 }
20234
20239 eProsima_user_DllExport void bitset_flags(
20240 const BitsetTypeFlag& _bitset_flags)
20241 {
20242 m_bitset_flags = _bitset_flags;
20243 }
20244
20249 eProsima_user_DllExport void bitset_flags(
20250 BitsetTypeFlag&& _bitset_flags)
20251 {
20252 m_bitset_flags = std::move(_bitset_flags);
20253 }
20254
20259 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20260 {
20261 return m_bitset_flags;
20262 }
20263
20268 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20269 {
20270 return m_bitset_flags;
20271 }
20272
20273
20278 eProsima_user_DllExport void header(
20279 const CompleteBitsetHeader& _header)
20280 {
20281 m_header = _header;
20282 }
20283
20288 eProsima_user_DllExport void header(
20289 CompleteBitsetHeader&& _header)
20290 {
20291 m_header = std::move(_header);
20292 }
20293
20298 eProsima_user_DllExport const CompleteBitsetHeader& header() const
20299 {
20300 return m_header;
20301 }
20302
20307 eProsima_user_DllExport CompleteBitsetHeader& header()
20308 {
20309 return m_header;
20310 }
20311
20312
20317 eProsima_user_DllExport void field_seq(
20318 const CompleteBitfieldSeq& _field_seq)
20319 {
20320 m_field_seq = _field_seq;
20321 }
20322
20327 eProsima_user_DllExport void field_seq(
20328 CompleteBitfieldSeq&& _field_seq)
20329 {
20330 m_field_seq = std::move(_field_seq);
20331 }
20332
20337 eProsima_user_DllExport const CompleteBitfieldSeq& field_seq() const
20338 {
20339 return m_field_seq;
20340 }
20341
20346 eProsima_user_DllExport CompleteBitfieldSeq& field_seq()
20347 {
20348 return m_field_seq;
20349 }
20350
20351
20352
20353private:
20354
20355 BitsetTypeFlag m_bitset_flags{0};
20356 CompleteBitsetHeader m_header;
20357 CompleteBitfieldSeq m_field_seq;
20358
20359};
20365{
20366public:
20367
20371 eProsima_user_DllExport MinimalBitsetType()
20372 {
20373 }
20374
20378 eProsima_user_DllExport ~MinimalBitsetType()
20379 {
20380 }
20381
20386 eProsima_user_DllExport MinimalBitsetType(
20387 const MinimalBitsetType& x)
20388 {
20389 m_bitset_flags = x.m_bitset_flags;
20390
20391 m_header = x.m_header;
20392
20393 m_field_seq = x.m_field_seq;
20394
20395 }
20396
20401 eProsima_user_DllExport MinimalBitsetType(
20402 MinimalBitsetType&& x) noexcept
20403 {
20404 m_bitset_flags = std::move(x.m_bitset_flags);
20405 m_header = std::move(x.m_header);
20406 m_field_seq = std::move(x.m_field_seq);
20407 }
20408
20413 eProsima_user_DllExport MinimalBitsetType& operator =(
20414 const MinimalBitsetType& x)
20415 {
20416
20417 m_bitset_flags = x.m_bitset_flags;
20418
20419 m_header = x.m_header;
20420
20421 m_field_seq = x.m_field_seq;
20422
20423 return *this;
20424 }
20425
20430 eProsima_user_DllExport MinimalBitsetType& operator =(
20431 MinimalBitsetType&& x) noexcept
20432 {
20433
20434 m_bitset_flags = std::move(x.m_bitset_flags);
20435 m_header = std::move(x.m_header);
20436 m_field_seq = std::move(x.m_field_seq);
20437 return *this;
20438 }
20439
20444 eProsima_user_DllExport bool operator ==(
20445 const MinimalBitsetType& x) const
20446 {
20447 return (m_bitset_flags == x.m_bitset_flags &&
20448 m_header == x.m_header &&
20449 m_field_seq == x.m_field_seq);
20450 }
20451
20456 eProsima_user_DllExport bool operator !=(
20457 const MinimalBitsetType& x) const
20458 {
20459 return !(*this == x);
20460 }
20461
20466 eProsima_user_DllExport void bitset_flags(
20467 const BitsetTypeFlag& _bitset_flags)
20468 {
20469 m_bitset_flags = _bitset_flags;
20470 }
20471
20476 eProsima_user_DllExport void bitset_flags(
20477 BitsetTypeFlag&& _bitset_flags)
20478 {
20479 m_bitset_flags = std::move(_bitset_flags);
20480 }
20481
20486 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20487 {
20488 return m_bitset_flags;
20489 }
20490
20495 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20496 {
20497 return m_bitset_flags;
20498 }
20499
20500
20505 eProsima_user_DllExport void header(
20506 const MinimalBitsetHeader& _header)
20507 {
20508 m_header = _header;
20509 }
20510
20515 eProsima_user_DllExport void header(
20516 MinimalBitsetHeader&& _header)
20517 {
20518 m_header = std::move(_header);
20519 }
20520
20525 eProsima_user_DllExport const MinimalBitsetHeader& header() const
20526 {
20527 return m_header;
20528 }
20529
20534 eProsima_user_DllExport MinimalBitsetHeader& header()
20535 {
20536 return m_header;
20537 }
20538
20539
20544 eProsima_user_DllExport void field_seq(
20545 const MinimalBitfieldSeq& _field_seq)
20546 {
20547 m_field_seq = _field_seq;
20548 }
20549
20554 eProsima_user_DllExport void field_seq(
20555 MinimalBitfieldSeq&& _field_seq)
20556 {
20557 m_field_seq = std::move(_field_seq);
20558 }
20559
20564 eProsima_user_DllExport const MinimalBitfieldSeq& field_seq() const
20565 {
20566 return m_field_seq;
20567 }
20568
20573 eProsima_user_DllExport MinimalBitfieldSeq& field_seq()
20574 {
20575 return m_field_seq;
20576 }
20577
20578
20579
20580private:
20581
20582 BitsetTypeFlag m_bitset_flags{0};
20583 MinimalBitsetHeader m_header;
20584 MinimalBitfieldSeq m_field_seq;
20585
20586};
20592{
20593public:
20594
20598 eProsima_user_DllExport CompleteExtendedType()
20599 {
20600 }
20601
20605 eProsima_user_DllExport ~CompleteExtendedType()
20606 {
20607 }
20608
20613 eProsima_user_DllExport CompleteExtendedType(
20614 const CompleteExtendedType& x)
20615 {
20616 static_cast<void>(x);
20617 }
20618
20623 eProsima_user_DllExport CompleteExtendedType(
20624 CompleteExtendedType&& x) noexcept
20625 {
20626 static_cast<void>(x);
20627 }
20628
20633 eProsima_user_DllExport CompleteExtendedType& operator =(
20634 const CompleteExtendedType& x)
20635 {
20636
20637 static_cast<void>(x);
20638
20639 return *this;
20640 }
20641
20646 eProsima_user_DllExport CompleteExtendedType& operator =(
20647 CompleteExtendedType&& x) noexcept
20648 {
20649
20650 static_cast<void>(x);
20651
20652 return *this;
20653 }
20654
20659 eProsima_user_DllExport bool operator ==(
20660 const CompleteExtendedType& x) const
20661 {
20662 static_cast<void>(x);
20663 return true;
20664 }
20665
20670 eProsima_user_DllExport bool operator !=(
20671 const CompleteExtendedType& x) const
20672 {
20673 return !(*this == x);
20674 }
20675
20676
20677
20678private:
20679
20680
20681};
20687{
20688public:
20689
20693 eProsima_user_DllExport CompleteTypeObject()
20694 {
20695 selected_member_ = 0x0000000b;
20696 member_destructor_ = [&]() {m_extended_type.~CompleteExtendedType();};
20698
20699 }
20700
20704 eProsima_user_DllExport ~CompleteTypeObject()
20705 {
20706 if (member_destructor_)
20707 {
20708 member_destructor_();
20709 }
20710 }
20711
20716 eProsima_user_DllExport CompleteTypeObject(
20717 const CompleteTypeObject& x)
20718 {
20719 m__d = x.m__d;
20720
20721 switch (x.selected_member_)
20722 {
20723 case 0x00000001:
20724 alias_type_() = x.m_alias_type;
20725 break;
20726
20727 case 0x00000002:
20728 annotation_type_() = x.m_annotation_type;
20729 break;
20730
20731 case 0x00000003:
20732 struct_type_() = x.m_struct_type;
20733 break;
20734
20735 case 0x00000004:
20736 union_type_() = x.m_union_type;
20737 break;
20738
20739 case 0x00000005:
20740 bitset_type_() = x.m_bitset_type;
20741 break;
20742
20743 case 0x00000006:
20744 sequence_type_() = x.m_sequence_type;
20745 break;
20746
20747 case 0x00000007:
20748 array_type_() = x.m_array_type;
20749 break;
20750
20751 case 0x00000008:
20752 map_type_() = x.m_map_type;
20753 break;
20754
20755 case 0x00000009:
20756 enumerated_type_() = x.m_enumerated_type;
20757 break;
20758
20759 case 0x0000000a:
20760 bitmask_type_() = x.m_bitmask_type;
20761 break;
20762
20763 case 0x0000000b:
20764 extended_type_() = x.m_extended_type;
20765 break;
20766
20767 }
20768 }
20769
20774 eProsima_user_DllExport CompleteTypeObject(
20775 CompleteTypeObject&& x) noexcept
20776 {
20777 m__d = x.m__d;
20778
20779 switch (x.selected_member_)
20780 {
20781 case 0x00000001:
20782 alias_type_() = std::move(x.m_alias_type);
20783 break;
20784
20785 case 0x00000002:
20786 annotation_type_() = std::move(x.m_annotation_type);
20787 break;
20788
20789 case 0x00000003:
20790 struct_type_() = std::move(x.m_struct_type);
20791 break;
20792
20793 case 0x00000004:
20794 union_type_() = std::move(x.m_union_type);
20795 break;
20796
20797 case 0x00000005:
20798 bitset_type_() = std::move(x.m_bitset_type);
20799 break;
20800
20801 case 0x00000006:
20802 sequence_type_() = std::move(x.m_sequence_type);
20803 break;
20804
20805 case 0x00000007:
20806 array_type_() = std::move(x.m_array_type);
20807 break;
20808
20809 case 0x00000008:
20810 map_type_() = std::move(x.m_map_type);
20811 break;
20812
20813 case 0x00000009:
20814 enumerated_type_() = std::move(x.m_enumerated_type);
20815 break;
20816
20817 case 0x0000000a:
20818 bitmask_type_() = std::move(x.m_bitmask_type);
20819 break;
20820
20821 case 0x0000000b:
20822 extended_type_() = std::move(x.m_extended_type);
20823 break;
20824
20825 }
20826 }
20827
20832 eProsima_user_DllExport CompleteTypeObject& operator =(
20833 const CompleteTypeObject& x)
20834 {
20835 m__d = x.m__d;
20836
20837 switch (x.selected_member_)
20838 {
20839 case 0x00000001:
20840 alias_type_() = x.m_alias_type;
20841 break;
20842
20843 case 0x00000002:
20844 annotation_type_() = x.m_annotation_type;
20845 break;
20846
20847 case 0x00000003:
20848 struct_type_() = x.m_struct_type;
20849 break;
20850
20851 case 0x00000004:
20852 union_type_() = x.m_union_type;
20853 break;
20854
20855 case 0x00000005:
20856 bitset_type_() = x.m_bitset_type;
20857 break;
20858
20859 case 0x00000006:
20860 sequence_type_() = x.m_sequence_type;
20861 break;
20862
20863 case 0x00000007:
20864 array_type_() = x.m_array_type;
20865 break;
20866
20867 case 0x00000008:
20868 map_type_() = x.m_map_type;
20869 break;
20870
20871 case 0x00000009:
20872 enumerated_type_() = x.m_enumerated_type;
20873 break;
20874
20875 case 0x0000000a:
20876 bitmask_type_() = x.m_bitmask_type;
20877 break;
20878
20879 case 0x0000000b:
20880 extended_type_() = x.m_extended_type;
20881 break;
20882
20883 }
20884
20885 return *this;
20886 }
20887
20892 eProsima_user_DllExport CompleteTypeObject& operator =(
20893 CompleteTypeObject&& x) noexcept
20894 {
20895 m__d = x.m__d;
20896
20897 switch (x.selected_member_)
20898 {
20899 case 0x00000001:
20900 alias_type_() = std::move(x.m_alias_type);
20901 break;
20902
20903 case 0x00000002:
20904 annotation_type_() = std::move(x.m_annotation_type);
20905 break;
20906
20907 case 0x00000003:
20908 struct_type_() = std::move(x.m_struct_type);
20909 break;
20910
20911 case 0x00000004:
20912 union_type_() = std::move(x.m_union_type);
20913 break;
20914
20915 case 0x00000005:
20916 bitset_type_() = std::move(x.m_bitset_type);
20917 break;
20918
20919 case 0x00000006:
20920 sequence_type_() = std::move(x.m_sequence_type);
20921 break;
20922
20923 case 0x00000007:
20924 array_type_() = std::move(x.m_array_type);
20925 break;
20926
20927 case 0x00000008:
20928 map_type_() = std::move(x.m_map_type);
20929 break;
20930
20931 case 0x00000009:
20932 enumerated_type_() = std::move(x.m_enumerated_type);
20933 break;
20934
20935 case 0x0000000a:
20936 bitmask_type_() = std::move(x.m_bitmask_type);
20937 break;
20938
20939 case 0x0000000b:
20940 extended_type_() = std::move(x.m_extended_type);
20941 break;
20942
20943 }
20944
20945 return *this;
20946 }
20947
20952 eProsima_user_DllExport bool operator ==(
20953 const CompleteTypeObject& x) const
20954 {
20955 bool ret_value {false};
20956
20957 if (m__d == x.m__d &&
20958 selected_member_ == x.selected_member_)
20959 {
20960 switch (selected_member_)
20961 {
20962 case 0x00000001:
20963 ret_value = (m_alias_type == x.m_alias_type);
20964 break;
20965
20966 case 0x00000002:
20967 ret_value = (m_annotation_type == x.m_annotation_type);
20968 break;
20969
20970 case 0x00000003:
20971 ret_value = (m_struct_type == x.m_struct_type);
20972 break;
20973
20974 case 0x00000004:
20975 ret_value = (m_union_type == x.m_union_type);
20976 break;
20977
20978 case 0x00000005:
20979 ret_value = (m_bitset_type == x.m_bitset_type);
20980 break;
20981
20982 case 0x00000006:
20983 ret_value = (m_sequence_type == x.m_sequence_type);
20984 break;
20985
20986 case 0x00000007:
20987 ret_value = (m_array_type == x.m_array_type);
20988 break;
20989
20990 case 0x00000008:
20991 ret_value = (m_map_type == x.m_map_type);
20992 break;
20993
20994 case 0x00000009:
20995 ret_value = (m_enumerated_type == x.m_enumerated_type);
20996 break;
20997
20998 case 0x0000000a:
20999 ret_value = (m_bitmask_type == x.m_bitmask_type);
21000 break;
21001
21002 case 0x0000000b:
21003 ret_value = (m_extended_type == x.m_extended_type);
21004 break;
21005
21006 }
21007 }
21008
21009 return ret_value;
21010 }
21011
21016 eProsima_user_DllExport bool operator !=(
21017 const CompleteTypeObject& x) const
21018 {
21019 return !(*this == x);
21020 }
21021
21027 eProsima_user_DllExport void _d(
21028 uint8_t __d)
21029 {
21030 bool valid_discriminator = false;
21031
21032 switch (__d)
21033 {
21034 case TK_ALIAS:
21035 if (0x00000001 == selected_member_)
21036 {
21037 valid_discriminator = true;
21038 }
21039 break;
21040
21041 case TK_ANNOTATION:
21042 if (0x00000002 == selected_member_)
21043 {
21044 valid_discriminator = true;
21045 }
21046 break;
21047
21048 case TK_STRUCTURE:
21049 if (0x00000003 == selected_member_)
21050 {
21051 valid_discriminator = true;
21052 }
21053 break;
21054
21055 case TK_UNION:
21056 if (0x00000004 == selected_member_)
21057 {
21058 valid_discriminator = true;
21059 }
21060 break;
21061
21062 case TK_BITSET:
21063 if (0x00000005 == selected_member_)
21064 {
21065 valid_discriminator = true;
21066 }
21067 break;
21068
21069 case TK_SEQUENCE:
21070 if (0x00000006 == selected_member_)
21071 {
21072 valid_discriminator = true;
21073 }
21074 break;
21075
21076 case TK_ARRAY:
21077 if (0x00000007 == selected_member_)
21078 {
21079 valid_discriminator = true;
21080 }
21081 break;
21082
21083 case TK_MAP:
21084 if (0x00000008 == selected_member_)
21085 {
21086 valid_discriminator = true;
21087 }
21088 break;
21089
21090 case TK_ENUM:
21091 if (0x00000009 == selected_member_)
21092 {
21093 valid_discriminator = true;
21094 }
21095 break;
21096
21097 case TK_BITMASK:
21098 if (0x0000000a == selected_member_)
21099 {
21100 valid_discriminator = true;
21101 }
21102 break;
21103
21104 default:
21105 if (0x0000000b == selected_member_)
21106 {
21107 valid_discriminator = true;
21108 }
21109 break;
21110
21111 }
21112
21113 if (!valid_discriminator)
21114 {
21115 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
21116 }
21117
21118 m__d = __d;
21119 }
21120
21125 eProsima_user_DllExport uint8_t _d() const
21126 {
21127 return m__d;
21128 }
21129
21134 eProsima_user_DllExport void alias_type(
21135 const CompleteAliasType& _alias_type)
21136 {
21137 alias_type_() = _alias_type;
21138 m__d = TK_ALIAS;
21139 }
21140
21145 eProsima_user_DllExport void alias_type(
21146 CompleteAliasType&& _alias_type)
21147 {
21148 alias_type_() = _alias_type;
21149 m__d = TK_ALIAS;
21150 }
21151
21157 eProsima_user_DllExport const CompleteAliasType& alias_type() const
21158 {
21159 if (0x00000001 != selected_member_)
21160 {
21161 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21162 }
21163
21164 return m_alias_type;
21165 }
21166
21172 eProsima_user_DllExport CompleteAliasType& alias_type()
21173 {
21174 if (0x00000001 != selected_member_)
21175 {
21176 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21177 }
21178
21179 return m_alias_type;
21180 }
21181
21182
21187 eProsima_user_DllExport void annotation_type(
21188 const CompleteAnnotationType& _annotation_type)
21189 {
21190 annotation_type_() = _annotation_type;
21191 m__d = TK_ANNOTATION;
21192 }
21193
21198 eProsima_user_DllExport void annotation_type(
21199 CompleteAnnotationType&& _annotation_type)
21200 {
21201 annotation_type_() = _annotation_type;
21202 m__d = TK_ANNOTATION;
21203 }
21204
21210 eProsima_user_DllExport const CompleteAnnotationType& annotation_type() const
21211 {
21212 if (0x00000002 != selected_member_)
21213 {
21214 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21215 }
21216
21217 return m_annotation_type;
21218 }
21219
21225 eProsima_user_DllExport CompleteAnnotationType& annotation_type()
21226 {
21227 if (0x00000002 != selected_member_)
21228 {
21229 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21230 }
21231
21232 return m_annotation_type;
21233 }
21234
21235
21240 eProsima_user_DllExport void struct_type(
21241 const CompleteStructType& _struct_type)
21242 {
21243 struct_type_() = _struct_type;
21244 m__d = TK_STRUCTURE;
21245 }
21246
21251 eProsima_user_DllExport void struct_type(
21252 CompleteStructType&& _struct_type)
21253 {
21254 struct_type_() = _struct_type;
21255 m__d = TK_STRUCTURE;
21256 }
21257
21263 eProsima_user_DllExport const CompleteStructType& struct_type() const
21264 {
21265 if (0x00000003 != selected_member_)
21266 {
21267 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21268 }
21269
21270 return m_struct_type;
21271 }
21272
21278 eProsima_user_DllExport CompleteStructType& struct_type()
21279 {
21280 if (0x00000003 != selected_member_)
21281 {
21282 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21283 }
21284
21285 return m_struct_type;
21286 }
21287
21288
21293 eProsima_user_DllExport void union_type(
21294 const CompleteUnionType& _union_type)
21295 {
21296 union_type_() = _union_type;
21297 m__d = TK_UNION;
21298 }
21299
21304 eProsima_user_DllExport void union_type(
21305 CompleteUnionType&& _union_type)
21306 {
21307 union_type_() = _union_type;
21308 m__d = TK_UNION;
21309 }
21310
21316 eProsima_user_DllExport const CompleteUnionType& union_type() const
21317 {
21318 if (0x00000004 != selected_member_)
21319 {
21320 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21321 }
21322
21323 return m_union_type;
21324 }
21325
21331 eProsima_user_DllExport CompleteUnionType& union_type()
21332 {
21333 if (0x00000004 != selected_member_)
21334 {
21335 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21336 }
21337
21338 return m_union_type;
21339 }
21340
21341
21346 eProsima_user_DllExport void bitset_type(
21347 const CompleteBitsetType& _bitset_type)
21348 {
21349 bitset_type_() = _bitset_type;
21350 m__d = TK_BITSET;
21351 }
21352
21357 eProsima_user_DllExport void bitset_type(
21358 CompleteBitsetType&& _bitset_type)
21359 {
21360 bitset_type_() = _bitset_type;
21361 m__d = TK_BITSET;
21362 }
21363
21369 eProsima_user_DllExport const CompleteBitsetType& bitset_type() const
21370 {
21371 if (0x00000005 != selected_member_)
21372 {
21373 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21374 }
21375
21376 return m_bitset_type;
21377 }
21378
21384 eProsima_user_DllExport CompleteBitsetType& bitset_type()
21385 {
21386 if (0x00000005 != selected_member_)
21387 {
21388 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21389 }
21390
21391 return m_bitset_type;
21392 }
21393
21394
21399 eProsima_user_DllExport void sequence_type(
21400 const CompleteSequenceType& _sequence_type)
21401 {
21402 sequence_type_() = _sequence_type;
21403 m__d = TK_SEQUENCE;
21404 }
21405
21410 eProsima_user_DllExport void sequence_type(
21411 CompleteSequenceType&& _sequence_type)
21412 {
21413 sequence_type_() = _sequence_type;
21414 m__d = TK_SEQUENCE;
21415 }
21416
21422 eProsima_user_DllExport const CompleteSequenceType& sequence_type() const
21423 {
21424 if (0x00000006 != selected_member_)
21425 {
21426 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21427 }
21428
21429 return m_sequence_type;
21430 }
21431
21437 eProsima_user_DllExport CompleteSequenceType& sequence_type()
21438 {
21439 if (0x00000006 != selected_member_)
21440 {
21441 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21442 }
21443
21444 return m_sequence_type;
21445 }
21446
21447
21452 eProsima_user_DllExport void array_type(
21453 const CompleteArrayType& _array_type)
21454 {
21455 array_type_() = _array_type;
21456 m__d = TK_ARRAY;
21457 }
21458
21463 eProsima_user_DllExport void array_type(
21464 CompleteArrayType&& _array_type)
21465 {
21466 array_type_() = _array_type;
21467 m__d = TK_ARRAY;
21468 }
21469
21475 eProsima_user_DllExport const CompleteArrayType& array_type() const
21476 {
21477 if (0x00000007 != selected_member_)
21478 {
21479 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21480 }
21481
21482 return m_array_type;
21483 }
21484
21490 eProsima_user_DllExport CompleteArrayType& array_type()
21491 {
21492 if (0x00000007 != selected_member_)
21493 {
21494 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21495 }
21496
21497 return m_array_type;
21498 }
21499
21500
21505 eProsima_user_DllExport void map_type(
21506 const CompleteMapType& _map_type)
21507 {
21508 map_type_() = _map_type;
21509 m__d = TK_MAP;
21510 }
21511
21516 eProsima_user_DllExport void map_type(
21517 CompleteMapType&& _map_type)
21518 {
21519 map_type_() = _map_type;
21520 m__d = TK_MAP;
21521 }
21522
21528 eProsima_user_DllExport const CompleteMapType& map_type() const
21529 {
21530 if (0x00000008 != selected_member_)
21531 {
21532 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21533 }
21534
21535 return m_map_type;
21536 }
21537
21543 eProsima_user_DllExport CompleteMapType& map_type()
21544 {
21545 if (0x00000008 != selected_member_)
21546 {
21547 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21548 }
21549
21550 return m_map_type;
21551 }
21552
21553
21558 eProsima_user_DllExport void enumerated_type(
21559 const CompleteEnumeratedType& _enumerated_type)
21560 {
21561 enumerated_type_() = _enumerated_type;
21562 m__d = TK_ENUM;
21563 }
21564
21569 eProsima_user_DllExport void enumerated_type(
21570 CompleteEnumeratedType&& _enumerated_type)
21571 {
21572 enumerated_type_() = _enumerated_type;
21573 m__d = TK_ENUM;
21574 }
21575
21581 eProsima_user_DllExport const CompleteEnumeratedType& enumerated_type() const
21582 {
21583 if (0x00000009 != selected_member_)
21584 {
21585 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21586 }
21587
21588 return m_enumerated_type;
21589 }
21590
21596 eProsima_user_DllExport CompleteEnumeratedType& enumerated_type()
21597 {
21598 if (0x00000009 != selected_member_)
21599 {
21600 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21601 }
21602
21603 return m_enumerated_type;
21604 }
21605
21606
21611 eProsima_user_DllExport void bitmask_type(
21612 const CompleteBitmaskType& _bitmask_type)
21613 {
21614 bitmask_type_() = _bitmask_type;
21615 m__d = TK_BITMASK;
21616 }
21617
21622 eProsima_user_DllExport void bitmask_type(
21623 CompleteBitmaskType&& _bitmask_type)
21624 {
21625 bitmask_type_() = _bitmask_type;
21626 m__d = TK_BITMASK;
21627 }
21628
21634 eProsima_user_DllExport const CompleteBitmaskType& bitmask_type() const
21635 {
21636 if (0x0000000a != selected_member_)
21637 {
21638 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21639 }
21640
21641 return m_bitmask_type;
21642 }
21643
21649 eProsima_user_DllExport CompleteBitmaskType& bitmask_type()
21650 {
21651 if (0x0000000a != selected_member_)
21652 {
21653 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21654 }
21655
21656 return m_bitmask_type;
21657 }
21658
21659
21664 eProsima_user_DllExport void extended_type(
21665 const CompleteExtendedType& _extended_type)
21666 {
21667 extended_type_() = _extended_type;
21668 m__d = 127;
21669 }
21670
21675 eProsima_user_DllExport void extended_type(
21676 CompleteExtendedType&& _extended_type)
21677 {
21678 extended_type_() = _extended_type;
21679 m__d = 127;
21680 }
21681
21687 eProsima_user_DllExport const CompleteExtendedType& extended_type() const
21688 {
21689 if (0x0000000b != selected_member_)
21690 {
21691 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21692 }
21693
21694 return m_extended_type;
21695 }
21696
21702 eProsima_user_DllExport CompleteExtendedType& extended_type()
21703 {
21704 if (0x0000000b != selected_member_)
21705 {
21706 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21707 }
21708
21709 return m_extended_type;
21710 }
21711
21712
21713
21714private:
21715
21716 CompleteAliasType& alias_type_()
21717 {
21718 if (0x00000001 != selected_member_)
21719 {
21720 if (member_destructor_)
21721 {
21722 member_destructor_();
21723 }
21724
21725 selected_member_ = 0x00000001;
21726 member_destructor_ = [&]() {m_alias_type.~CompleteAliasType();};
21727 new(&m_alias_type) CompleteAliasType();
21728
21729 }
21730
21731 return m_alias_type;
21732 }
21733
21734 CompleteAnnotationType& annotation_type_()
21735 {
21736 if (0x00000002 != selected_member_)
21737 {
21738 if (member_destructor_)
21739 {
21740 member_destructor_();
21741 }
21742
21743 selected_member_ = 0x00000002;
21744 member_destructor_ = [&]() {m_annotation_type.~CompleteAnnotationType();};
21745 new(&m_annotation_type) CompleteAnnotationType();
21746
21747 }
21748
21749 return m_annotation_type;
21750 }
21751
21752 CompleteStructType& struct_type_()
21753 {
21754 if (0x00000003 != selected_member_)
21755 {
21756 if (member_destructor_)
21757 {
21758 member_destructor_();
21759 }
21760
21761 selected_member_ = 0x00000003;
21762 member_destructor_ = [&]() {m_struct_type.~CompleteStructType();};
21763 new(&m_struct_type) CompleteStructType();
21764
21765 }
21766
21767 return m_struct_type;
21768 }
21769
21770 CompleteUnionType& union_type_()
21771 {
21772 if (0x00000004 != selected_member_)
21773 {
21774 if (member_destructor_)
21775 {
21776 member_destructor_();
21777 }
21778
21779 selected_member_ = 0x00000004;
21780 member_destructor_ = [&]() {m_union_type.~CompleteUnionType();};
21781 new(&m_union_type) CompleteUnionType();
21782
21783 }
21784
21785 return m_union_type;
21786 }
21787
21788 CompleteBitsetType& bitset_type_()
21789 {
21790 if (0x00000005 != selected_member_)
21791 {
21792 if (member_destructor_)
21793 {
21794 member_destructor_();
21795 }
21796
21797 selected_member_ = 0x00000005;
21798 member_destructor_ = [&]() {m_bitset_type.~CompleteBitsetType();};
21799 new(&m_bitset_type) CompleteBitsetType();
21800
21801 }
21802
21803 return m_bitset_type;
21804 }
21805
21806 CompleteSequenceType& sequence_type_()
21807 {
21808 if (0x00000006 != selected_member_)
21809 {
21810 if (member_destructor_)
21811 {
21812 member_destructor_();
21813 }
21814
21815 selected_member_ = 0x00000006;
21816 member_destructor_ = [&]() {m_sequence_type.~CompleteSequenceType();};
21817 new(&m_sequence_type) CompleteSequenceType();
21818
21819 }
21820
21821 return m_sequence_type;
21822 }
21823
21824 CompleteArrayType& array_type_()
21825 {
21826 if (0x00000007 != selected_member_)
21827 {
21828 if (member_destructor_)
21829 {
21830 member_destructor_();
21831 }
21832
21833 selected_member_ = 0x00000007;
21834 member_destructor_ = [&]() {m_array_type.~CompleteArrayType();};
21835 new(&m_array_type) CompleteArrayType();
21836
21837 }
21838
21839 return m_array_type;
21840 }
21841
21842 CompleteMapType& map_type_()
21843 {
21844 if (0x00000008 != selected_member_)
21845 {
21846 if (member_destructor_)
21847 {
21848 member_destructor_();
21849 }
21850
21851 selected_member_ = 0x00000008;
21852 member_destructor_ = [&]() {m_map_type.~CompleteMapType();};
21853 new(&m_map_type) CompleteMapType();
21854
21855 }
21856
21857 return m_map_type;
21858 }
21859
21860 CompleteEnumeratedType& enumerated_type_()
21861 {
21862 if (0x00000009 != selected_member_)
21863 {
21864 if (member_destructor_)
21865 {
21866 member_destructor_();
21867 }
21868
21869 selected_member_ = 0x00000009;
21870 member_destructor_ = [&]() {m_enumerated_type.~CompleteEnumeratedType();};
21871 new(&m_enumerated_type) CompleteEnumeratedType();
21872
21873 }
21874
21875 return m_enumerated_type;
21876 }
21877
21878 CompleteBitmaskType& bitmask_type_()
21879 {
21880 if (0x0000000a != selected_member_)
21881 {
21882 if (member_destructor_)
21883 {
21884 member_destructor_();
21885 }
21886
21887 selected_member_ = 0x0000000a;
21888 member_destructor_ = [&]() {m_bitmask_type.~CompleteBitmaskType();};
21889 new(&m_bitmask_type) CompleteBitmaskType();
21890
21891 }
21892
21893 return m_bitmask_type;
21894 }
21895
21896 CompleteExtendedType& extended_type_()
21897 {
21898 if (0x0000000b != selected_member_)
21899 {
21900 if (member_destructor_)
21901 {
21902 member_destructor_();
21903 }
21904
21905 selected_member_ = 0x0000000b;
21906 member_destructor_ = [&]() {m_extended_type.~CompleteExtendedType();};
21907 new(&m_extended_type) CompleteExtendedType();
21908
21909 }
21910
21911 return m_extended_type;
21912 }
21913
21914
21915 uint8_t m__d {TK_NONE};
21916
21917 union
21918 {
21930 };
21931
21932 uint32_t selected_member_ {0x0FFFFFFFu};
21933
21934 std::function<void()> member_destructor_;
21935};
21941{
21942public:
21943
21947 eProsima_user_DllExport MinimalExtendedType()
21948 {
21949 }
21950
21954 eProsima_user_DllExport ~MinimalExtendedType()
21955 {
21956 }
21957
21962 eProsima_user_DllExport MinimalExtendedType(
21963 const MinimalExtendedType& x)
21964 {
21965 static_cast<void>(x);
21966 }
21967
21972 eProsima_user_DllExport MinimalExtendedType(
21973 MinimalExtendedType&& x) noexcept
21974 {
21975 static_cast<void>(x);
21976 }
21977
21982 eProsima_user_DllExport MinimalExtendedType& operator =(
21983 const MinimalExtendedType& x)
21984 {
21985
21986 static_cast<void>(x);
21987
21988 return *this;
21989 }
21990
21995 eProsima_user_DllExport MinimalExtendedType& operator =(
21996 MinimalExtendedType&& x) noexcept
21997 {
21998
21999 static_cast<void>(x);
22000
22001 return *this;
22002 }
22003
22008 eProsima_user_DllExport bool operator ==(
22009 const MinimalExtendedType& x) const
22010 {
22011 static_cast<void>(x);
22012 return true;
22013 }
22014
22019 eProsima_user_DllExport bool operator !=(
22020 const MinimalExtendedType& x) const
22021 {
22022 return !(*this == x);
22023 }
22024
22025
22026
22027private:
22028
22029
22030};
22036{
22037public:
22038
22042 eProsima_user_DllExport MinimalTypeObject()
22043 {
22044 selected_member_ = 0x0000000b;
22045 member_destructor_ = [&]() {m_extended_type.~MinimalExtendedType();};
22047
22048 }
22049
22053 eProsima_user_DllExport ~MinimalTypeObject()
22054 {
22055 if (member_destructor_)
22056 {
22057 member_destructor_();
22058 }
22059 }
22060
22065 eProsima_user_DllExport MinimalTypeObject(
22066 const MinimalTypeObject& x)
22067 {
22068 m__d = x.m__d;
22069
22070 switch (x.selected_member_)
22071 {
22072 case 0x00000001:
22073 alias_type_() = x.m_alias_type;
22074 break;
22075
22076 case 0x00000002:
22077 annotation_type_() = x.m_annotation_type;
22078 break;
22079
22080 case 0x00000003:
22081 struct_type_() = x.m_struct_type;
22082 break;
22083
22084 case 0x00000004:
22085 union_type_() = x.m_union_type;
22086 break;
22087
22088 case 0x00000005:
22089 bitset_type_() = x.m_bitset_type;
22090 break;
22091
22092 case 0x00000006:
22093 sequence_type_() = x.m_sequence_type;
22094 break;
22095
22096 case 0x00000007:
22097 array_type_() = x.m_array_type;
22098 break;
22099
22100 case 0x00000008:
22101 map_type_() = x.m_map_type;
22102 break;
22103
22104 case 0x00000009:
22105 enumerated_type_() = x.m_enumerated_type;
22106 break;
22107
22108 case 0x0000000a:
22109 bitmask_type_() = x.m_bitmask_type;
22110 break;
22111
22112 case 0x0000000b:
22113 extended_type_() = x.m_extended_type;
22114 break;
22115
22116 }
22117 }
22118
22123 eProsima_user_DllExport MinimalTypeObject(
22124 MinimalTypeObject&& x) noexcept
22125 {
22126 m__d = x.m__d;
22127
22128 switch (x.selected_member_)
22129 {
22130 case 0x00000001:
22131 alias_type_() = std::move(x.m_alias_type);
22132 break;
22133
22134 case 0x00000002:
22135 annotation_type_() = std::move(x.m_annotation_type);
22136 break;
22137
22138 case 0x00000003:
22139 struct_type_() = std::move(x.m_struct_type);
22140 break;
22141
22142 case 0x00000004:
22143 union_type_() = std::move(x.m_union_type);
22144 break;
22145
22146 case 0x00000005:
22147 bitset_type_() = std::move(x.m_bitset_type);
22148 break;
22149
22150 case 0x00000006:
22151 sequence_type_() = std::move(x.m_sequence_type);
22152 break;
22153
22154 case 0x00000007:
22155 array_type_() = std::move(x.m_array_type);
22156 break;
22157
22158 case 0x00000008:
22159 map_type_() = std::move(x.m_map_type);
22160 break;
22161
22162 case 0x00000009:
22163 enumerated_type_() = std::move(x.m_enumerated_type);
22164 break;
22165
22166 case 0x0000000a:
22167 bitmask_type_() = std::move(x.m_bitmask_type);
22168 break;
22169
22170 case 0x0000000b:
22171 extended_type_() = std::move(x.m_extended_type);
22172 break;
22173
22174 }
22175 }
22176
22181 eProsima_user_DllExport MinimalTypeObject& operator =(
22182 const MinimalTypeObject& x)
22183 {
22184 m__d = x.m__d;
22185
22186 switch (x.selected_member_)
22187 {
22188 case 0x00000001:
22189 alias_type_() = x.m_alias_type;
22190 break;
22191
22192 case 0x00000002:
22193 annotation_type_() = x.m_annotation_type;
22194 break;
22195
22196 case 0x00000003:
22197 struct_type_() = x.m_struct_type;
22198 break;
22199
22200 case 0x00000004:
22201 union_type_() = x.m_union_type;
22202 break;
22203
22204 case 0x00000005:
22205 bitset_type_() = x.m_bitset_type;
22206 break;
22207
22208 case 0x00000006:
22209 sequence_type_() = x.m_sequence_type;
22210 break;
22211
22212 case 0x00000007:
22213 array_type_() = x.m_array_type;
22214 break;
22215
22216 case 0x00000008:
22217 map_type_() = x.m_map_type;
22218 break;
22219
22220 case 0x00000009:
22221 enumerated_type_() = x.m_enumerated_type;
22222 break;
22223
22224 case 0x0000000a:
22225 bitmask_type_() = x.m_bitmask_type;
22226 break;
22227
22228 case 0x0000000b:
22229 extended_type_() = x.m_extended_type;
22230 break;
22231
22232 }
22233
22234 return *this;
22235 }
22236
22241 eProsima_user_DllExport MinimalTypeObject& operator =(
22242 MinimalTypeObject&& x) noexcept
22243 {
22244 m__d = x.m__d;
22245
22246 switch (x.selected_member_)
22247 {
22248 case 0x00000001:
22249 alias_type_() = std::move(x.m_alias_type);
22250 break;
22251
22252 case 0x00000002:
22253 annotation_type_() = std::move(x.m_annotation_type);
22254 break;
22255
22256 case 0x00000003:
22257 struct_type_() = std::move(x.m_struct_type);
22258 break;
22259
22260 case 0x00000004:
22261 union_type_() = std::move(x.m_union_type);
22262 break;
22263
22264 case 0x00000005:
22265 bitset_type_() = std::move(x.m_bitset_type);
22266 break;
22267
22268 case 0x00000006:
22269 sequence_type_() = std::move(x.m_sequence_type);
22270 break;
22271
22272 case 0x00000007:
22273 array_type_() = std::move(x.m_array_type);
22274 break;
22275
22276 case 0x00000008:
22277 map_type_() = std::move(x.m_map_type);
22278 break;
22279
22280 case 0x00000009:
22281 enumerated_type_() = std::move(x.m_enumerated_type);
22282 break;
22283
22284 case 0x0000000a:
22285 bitmask_type_() = std::move(x.m_bitmask_type);
22286 break;
22287
22288 case 0x0000000b:
22289 extended_type_() = std::move(x.m_extended_type);
22290 break;
22291
22292 }
22293
22294 return *this;
22295 }
22296
22301 eProsima_user_DllExport bool operator ==(
22302 const MinimalTypeObject& x) const
22303 {
22304 bool ret_value {false};
22305
22306 if (m__d == x.m__d &&
22307 selected_member_ == x.selected_member_)
22308 {
22309 switch (selected_member_)
22310 {
22311 case 0x00000001:
22312 ret_value = (m_alias_type == x.m_alias_type);
22313 break;
22314
22315 case 0x00000002:
22316 ret_value = (m_annotation_type == x.m_annotation_type);
22317 break;
22318
22319 case 0x00000003:
22320 ret_value = (m_struct_type == x.m_struct_type);
22321 break;
22322
22323 case 0x00000004:
22324 ret_value = (m_union_type == x.m_union_type);
22325 break;
22326
22327 case 0x00000005:
22328 ret_value = (m_bitset_type == x.m_bitset_type);
22329 break;
22330
22331 case 0x00000006:
22332 ret_value = (m_sequence_type == x.m_sequence_type);
22333 break;
22334
22335 case 0x00000007:
22336 ret_value = (m_array_type == x.m_array_type);
22337 break;
22338
22339 case 0x00000008:
22340 ret_value = (m_map_type == x.m_map_type);
22341 break;
22342
22343 case 0x00000009:
22344 ret_value = (m_enumerated_type == x.m_enumerated_type);
22345 break;
22346
22347 case 0x0000000a:
22348 ret_value = (m_bitmask_type == x.m_bitmask_type);
22349 break;
22350
22351 case 0x0000000b:
22352 ret_value = (m_extended_type == x.m_extended_type);
22353 break;
22354
22355 }
22356 }
22357
22358 return ret_value;
22359 }
22360
22365 eProsima_user_DllExport bool operator !=(
22366 const MinimalTypeObject& x) const
22367 {
22368 return !(*this == x);
22369 }
22370
22376 eProsima_user_DllExport void _d(
22377 uint8_t __d)
22378 {
22379 bool valid_discriminator = false;
22380
22381 switch (__d)
22382 {
22383 case TK_ALIAS:
22384 if (0x00000001 == selected_member_)
22385 {
22386 valid_discriminator = true;
22387 }
22388 break;
22389
22390 case TK_ANNOTATION:
22391 if (0x00000002 == selected_member_)
22392 {
22393 valid_discriminator = true;
22394 }
22395 break;
22396
22397 case TK_STRUCTURE:
22398 if (0x00000003 == selected_member_)
22399 {
22400 valid_discriminator = true;
22401 }
22402 break;
22403
22404 case TK_UNION:
22405 if (0x00000004 == selected_member_)
22406 {
22407 valid_discriminator = true;
22408 }
22409 break;
22410
22411 case TK_BITSET:
22412 if (0x00000005 == selected_member_)
22413 {
22414 valid_discriminator = true;
22415 }
22416 break;
22417
22418 case TK_SEQUENCE:
22419 if (0x00000006 == selected_member_)
22420 {
22421 valid_discriminator = true;
22422 }
22423 break;
22424
22425 case TK_ARRAY:
22426 if (0x00000007 == selected_member_)
22427 {
22428 valid_discriminator = true;
22429 }
22430 break;
22431
22432 case TK_MAP:
22433 if (0x00000008 == selected_member_)
22434 {
22435 valid_discriminator = true;
22436 }
22437 break;
22438
22439 case TK_ENUM:
22440 if (0x00000009 == selected_member_)
22441 {
22442 valid_discriminator = true;
22443 }
22444 break;
22445
22446 case TK_BITMASK:
22447 if (0x0000000a == selected_member_)
22448 {
22449 valid_discriminator = true;
22450 }
22451 break;
22452
22453 default:
22454 if (0x0000000b == selected_member_)
22455 {
22456 valid_discriminator = true;
22457 }
22458 break;
22459
22460 }
22461
22462 if (!valid_discriminator)
22463 {
22464 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
22465 }
22466
22467 m__d = __d;
22468 }
22469
22474 eProsima_user_DllExport uint8_t _d() const
22475 {
22476 return m__d;
22477 }
22478
22483 eProsima_user_DllExport void alias_type(
22484 const MinimalAliasType& _alias_type)
22485 {
22486 alias_type_() = _alias_type;
22487 m__d = TK_ALIAS;
22488 }
22489
22494 eProsima_user_DllExport void alias_type(
22495 MinimalAliasType&& _alias_type)
22496 {
22497 alias_type_() = _alias_type;
22498 m__d = TK_ALIAS;
22499 }
22500
22506 eProsima_user_DllExport const MinimalAliasType& alias_type() const
22507 {
22508 if (0x00000001 != selected_member_)
22509 {
22510 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22511 }
22512
22513 return m_alias_type;
22514 }
22515
22521 eProsima_user_DllExport MinimalAliasType& alias_type()
22522 {
22523 if (0x00000001 != selected_member_)
22524 {
22525 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22526 }
22527
22528 return m_alias_type;
22529 }
22530
22531
22536 eProsima_user_DllExport void annotation_type(
22537 const MinimalAnnotationType& _annotation_type)
22538 {
22539 annotation_type_() = _annotation_type;
22540 m__d = TK_ANNOTATION;
22541 }
22542
22547 eProsima_user_DllExport void annotation_type(
22548 MinimalAnnotationType&& _annotation_type)
22549 {
22550 annotation_type_() = _annotation_type;
22551 m__d = TK_ANNOTATION;
22552 }
22553
22559 eProsima_user_DllExport const MinimalAnnotationType& annotation_type() const
22560 {
22561 if (0x00000002 != selected_member_)
22562 {
22563 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22564 }
22565
22566 return m_annotation_type;
22567 }
22568
22574 eProsima_user_DllExport MinimalAnnotationType& annotation_type()
22575 {
22576 if (0x00000002 != selected_member_)
22577 {
22578 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22579 }
22580
22581 return m_annotation_type;
22582 }
22583
22584
22589 eProsima_user_DllExport void struct_type(
22590 const MinimalStructType& _struct_type)
22591 {
22592 struct_type_() = _struct_type;
22593 m__d = TK_STRUCTURE;
22594 }
22595
22600 eProsima_user_DllExport void struct_type(
22601 MinimalStructType&& _struct_type)
22602 {
22603 struct_type_() = _struct_type;
22604 m__d = TK_STRUCTURE;
22605 }
22606
22612 eProsima_user_DllExport const MinimalStructType& struct_type() const
22613 {
22614 if (0x00000003 != selected_member_)
22615 {
22616 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22617 }
22618
22619 return m_struct_type;
22620 }
22621
22627 eProsima_user_DllExport MinimalStructType& struct_type()
22628 {
22629 if (0x00000003 != selected_member_)
22630 {
22631 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22632 }
22633
22634 return m_struct_type;
22635 }
22636
22637
22642 eProsima_user_DllExport void union_type(
22643 const MinimalUnionType& _union_type)
22644 {
22645 union_type_() = _union_type;
22646 m__d = TK_UNION;
22647 }
22648
22653 eProsima_user_DllExport void union_type(
22654 MinimalUnionType&& _union_type)
22655 {
22656 union_type_() = _union_type;
22657 m__d = TK_UNION;
22658 }
22659
22665 eProsima_user_DllExport const MinimalUnionType& union_type() const
22666 {
22667 if (0x00000004 != selected_member_)
22668 {
22669 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22670 }
22671
22672 return m_union_type;
22673 }
22674
22680 eProsima_user_DllExport MinimalUnionType& union_type()
22681 {
22682 if (0x00000004 != selected_member_)
22683 {
22684 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22685 }
22686
22687 return m_union_type;
22688 }
22689
22690
22695 eProsima_user_DllExport void bitset_type(
22696 const MinimalBitsetType& _bitset_type)
22697 {
22698 bitset_type_() = _bitset_type;
22699 m__d = TK_BITSET;
22700 }
22701
22706 eProsima_user_DllExport void bitset_type(
22707 MinimalBitsetType&& _bitset_type)
22708 {
22709 bitset_type_() = _bitset_type;
22710 m__d = TK_BITSET;
22711 }
22712
22718 eProsima_user_DllExport const MinimalBitsetType& bitset_type() const
22719 {
22720 if (0x00000005 != selected_member_)
22721 {
22722 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22723 }
22724
22725 return m_bitset_type;
22726 }
22727
22733 eProsima_user_DllExport MinimalBitsetType& bitset_type()
22734 {
22735 if (0x00000005 != selected_member_)
22736 {
22737 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22738 }
22739
22740 return m_bitset_type;
22741 }
22742
22743
22748 eProsima_user_DllExport void sequence_type(
22749 const MinimalSequenceType& _sequence_type)
22750 {
22751 sequence_type_() = _sequence_type;
22752 m__d = TK_SEQUENCE;
22753 }
22754
22759 eProsima_user_DllExport void sequence_type(
22760 MinimalSequenceType&& _sequence_type)
22761 {
22762 sequence_type_() = _sequence_type;
22763 m__d = TK_SEQUENCE;
22764 }
22765
22771 eProsima_user_DllExport const MinimalSequenceType& sequence_type() const
22772 {
22773 if (0x00000006 != selected_member_)
22774 {
22775 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22776 }
22777
22778 return m_sequence_type;
22779 }
22780
22786 eProsima_user_DllExport MinimalSequenceType& sequence_type()
22787 {
22788 if (0x00000006 != selected_member_)
22789 {
22790 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22791 }
22792
22793 return m_sequence_type;
22794 }
22795
22796
22801 eProsima_user_DllExport void array_type(
22802 const MinimalArrayType& _array_type)
22803 {
22804 array_type_() = _array_type;
22805 m__d = TK_ARRAY;
22806 }
22807
22812 eProsima_user_DllExport void array_type(
22813 MinimalArrayType&& _array_type)
22814 {
22815 array_type_() = _array_type;
22816 m__d = TK_ARRAY;
22817 }
22818
22824 eProsima_user_DllExport const MinimalArrayType& array_type() const
22825 {
22826 if (0x00000007 != selected_member_)
22827 {
22828 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22829 }
22830
22831 return m_array_type;
22832 }
22833
22839 eProsima_user_DllExport MinimalArrayType& array_type()
22840 {
22841 if (0x00000007 != selected_member_)
22842 {
22843 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22844 }
22845
22846 return m_array_type;
22847 }
22848
22849
22854 eProsima_user_DllExport void map_type(
22855 const MinimalMapType& _map_type)
22856 {
22857 map_type_() = _map_type;
22858 m__d = TK_MAP;
22859 }
22860
22865 eProsima_user_DllExport void map_type(
22866 MinimalMapType&& _map_type)
22867 {
22868 map_type_() = _map_type;
22869 m__d = TK_MAP;
22870 }
22871
22877 eProsima_user_DllExport const MinimalMapType& map_type() const
22878 {
22879 if (0x00000008 != selected_member_)
22880 {
22881 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22882 }
22883
22884 return m_map_type;
22885 }
22886
22892 eProsima_user_DllExport MinimalMapType& map_type()
22893 {
22894 if (0x00000008 != selected_member_)
22895 {
22896 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22897 }
22898
22899 return m_map_type;
22900 }
22901
22902
22907 eProsima_user_DllExport void enumerated_type(
22908 const MinimalEnumeratedType& _enumerated_type)
22909 {
22910 enumerated_type_() = _enumerated_type;
22911 m__d = TK_ENUM;
22912 }
22913
22918 eProsima_user_DllExport void enumerated_type(
22919 MinimalEnumeratedType&& _enumerated_type)
22920 {
22921 enumerated_type_() = _enumerated_type;
22922 m__d = TK_ENUM;
22923 }
22924
22930 eProsima_user_DllExport const MinimalEnumeratedType& enumerated_type() const
22931 {
22932 if (0x00000009 != selected_member_)
22933 {
22934 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22935 }
22936
22937 return m_enumerated_type;
22938 }
22939
22945 eProsima_user_DllExport MinimalEnumeratedType& enumerated_type()
22946 {
22947 if (0x00000009 != selected_member_)
22948 {
22949 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22950 }
22951
22952 return m_enumerated_type;
22953 }
22954
22955
22960 eProsima_user_DllExport void bitmask_type(
22961 const MinimalBitmaskType& _bitmask_type)
22962 {
22963 bitmask_type_() = _bitmask_type;
22964 m__d = TK_BITMASK;
22965 }
22966
22971 eProsima_user_DllExport void bitmask_type(
22972 MinimalBitmaskType&& _bitmask_type)
22973 {
22974 bitmask_type_() = _bitmask_type;
22975 m__d = TK_BITMASK;
22976 }
22977
22983 eProsima_user_DllExport const MinimalBitmaskType& bitmask_type() const
22984 {
22985 if (0x0000000a != selected_member_)
22986 {
22987 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22988 }
22989
22990 return m_bitmask_type;
22991 }
22992
22998 eProsima_user_DllExport MinimalBitmaskType& bitmask_type()
22999 {
23000 if (0x0000000a != selected_member_)
23001 {
23002 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23003 }
23004
23005 return m_bitmask_type;
23006 }
23007
23008
23013 eProsima_user_DllExport void extended_type(
23014 const MinimalExtendedType& _extended_type)
23015 {
23016 extended_type_() = _extended_type;
23017 m__d = 127;
23018 }
23019
23024 eProsima_user_DllExport void extended_type(
23025 MinimalExtendedType&& _extended_type)
23026 {
23027 extended_type_() = _extended_type;
23028 m__d = 127;
23029 }
23030
23036 eProsima_user_DllExport const MinimalExtendedType& extended_type() const
23037 {
23038 if (0x0000000b != selected_member_)
23039 {
23040 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23041 }
23042
23043 return m_extended_type;
23044 }
23045
23051 eProsima_user_DllExport MinimalExtendedType& extended_type()
23052 {
23053 if (0x0000000b != selected_member_)
23054 {
23055 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23056 }
23057
23058 return m_extended_type;
23059 }
23060
23061
23062
23063private:
23064
23065 MinimalAliasType& alias_type_()
23066 {
23067 if (0x00000001 != selected_member_)
23068 {
23069 if (member_destructor_)
23070 {
23071 member_destructor_();
23072 }
23073
23074 selected_member_ = 0x00000001;
23075 member_destructor_ = [&]() {m_alias_type.~MinimalAliasType();};
23076 new(&m_alias_type) MinimalAliasType();
23077
23078 }
23079
23080 return m_alias_type;
23081 }
23082
23083 MinimalAnnotationType& annotation_type_()
23084 {
23085 if (0x00000002 != selected_member_)
23086 {
23087 if (member_destructor_)
23088 {
23089 member_destructor_();
23090 }
23091
23092 selected_member_ = 0x00000002;
23093 member_destructor_ = [&]() {m_annotation_type.~MinimalAnnotationType();};
23094 new(&m_annotation_type) MinimalAnnotationType();
23095
23096 }
23097
23098 return m_annotation_type;
23099 }
23100
23101 MinimalStructType& struct_type_()
23102 {
23103 if (0x00000003 != selected_member_)
23104 {
23105 if (member_destructor_)
23106 {
23107 member_destructor_();
23108 }
23109
23110 selected_member_ = 0x00000003;
23111 member_destructor_ = [&]() {m_struct_type.~MinimalStructType();};
23112 new(&m_struct_type) MinimalStructType();
23113
23114 }
23115
23116 return m_struct_type;
23117 }
23118
23119 MinimalUnionType& union_type_()
23120 {
23121 if (0x00000004 != selected_member_)
23122 {
23123 if (member_destructor_)
23124 {
23125 member_destructor_();
23126 }
23127
23128 selected_member_ = 0x00000004;
23129 member_destructor_ = [&]() {m_union_type.~MinimalUnionType();};
23130 new(&m_union_type) MinimalUnionType();
23131
23132 }
23133
23134 return m_union_type;
23135 }
23136
23137 MinimalBitsetType& bitset_type_()
23138 {
23139 if (0x00000005 != selected_member_)
23140 {
23141 if (member_destructor_)
23142 {
23143 member_destructor_();
23144 }
23145
23146 selected_member_ = 0x00000005;
23147 member_destructor_ = [&]() {m_bitset_type.~MinimalBitsetType();};
23148 new(&m_bitset_type) MinimalBitsetType();
23149
23150 }
23151
23152 return m_bitset_type;
23153 }
23154
23155 MinimalSequenceType& sequence_type_()
23156 {
23157 if (0x00000006 != selected_member_)
23158 {
23159 if (member_destructor_)
23160 {
23161 member_destructor_();
23162 }
23163
23164 selected_member_ = 0x00000006;
23165 member_destructor_ = [&]() {m_sequence_type.~MinimalSequenceType();};
23166 new(&m_sequence_type) MinimalSequenceType();
23167
23168 }
23169
23170 return m_sequence_type;
23171 }
23172
23173 MinimalArrayType& array_type_()
23174 {
23175 if (0x00000007 != selected_member_)
23176 {
23177 if (member_destructor_)
23178 {
23179 member_destructor_();
23180 }
23181
23182 selected_member_ = 0x00000007;
23183 member_destructor_ = [&]() {m_array_type.~MinimalArrayType();};
23184 new(&m_array_type) MinimalArrayType();
23185
23186 }
23187
23188 return m_array_type;
23189 }
23190
23191 MinimalMapType& map_type_()
23192 {
23193 if (0x00000008 != selected_member_)
23194 {
23195 if (member_destructor_)
23196 {
23197 member_destructor_();
23198 }
23199
23200 selected_member_ = 0x00000008;
23201 member_destructor_ = [&]() {m_map_type.~MinimalMapType();};
23202 new(&m_map_type) MinimalMapType();
23203
23204 }
23205
23206 return m_map_type;
23207 }
23208
23209 MinimalEnumeratedType& enumerated_type_()
23210 {
23211 if (0x00000009 != selected_member_)
23212 {
23213 if (member_destructor_)
23214 {
23215 member_destructor_();
23216 }
23217
23218 selected_member_ = 0x00000009;
23219 member_destructor_ = [&]() {m_enumerated_type.~MinimalEnumeratedType();};
23220 new(&m_enumerated_type) MinimalEnumeratedType();
23221
23222 }
23223
23224 return m_enumerated_type;
23225 }
23226
23227 MinimalBitmaskType& bitmask_type_()
23228 {
23229 if (0x0000000a != selected_member_)
23230 {
23231 if (member_destructor_)
23232 {
23233 member_destructor_();
23234 }
23235
23236 selected_member_ = 0x0000000a;
23237 member_destructor_ = [&]() {m_bitmask_type.~MinimalBitmaskType();};
23238 new(&m_bitmask_type) MinimalBitmaskType();
23239
23240 }
23241
23242 return m_bitmask_type;
23243 }
23244
23245 MinimalExtendedType& extended_type_()
23246 {
23247 if (0x0000000b != selected_member_)
23248 {
23249 if (member_destructor_)
23250 {
23251 member_destructor_();
23252 }
23253
23254 selected_member_ = 0x0000000b;
23255 member_destructor_ = [&]() {m_extended_type.~MinimalExtendedType();};
23256 new(&m_extended_type) MinimalExtendedType();
23257
23258 }
23259
23260 return m_extended_type;
23261 }
23262
23263
23264 uint8_t m__d {TK_NONE};
23265
23266 union
23267 {
23279 };
23280
23281 uint32_t selected_member_ {0x0FFFFFFFu};
23282
23283 std::function<void()> member_destructor_;
23284};
23290{
23291public:
23292
23296 eProsima_user_DllExport TypeObject()
23297 {
23298 }
23299
23303 eProsima_user_DllExport ~TypeObject()
23304 {
23305 if (member_destructor_)
23306 {
23307 member_destructor_();
23308 }
23309 }
23310
23315 eProsima_user_DllExport TypeObject(
23316 const TypeObject& x)
23317 {
23318 m__d = x.m__d;
23319
23320 switch (x.selected_member_)
23321 {
23322 case 0x00000001:
23323 complete_() = x.m_complete;
23324 break;
23325
23326 case 0x00000002:
23327 minimal_() = x.m_minimal;
23328 break;
23329
23330 }
23331 }
23332
23337 eProsima_user_DllExport TypeObject(
23338 TypeObject&& x) noexcept
23339 {
23340 m__d = x.m__d;
23341
23342 switch (x.selected_member_)
23343 {
23344 case 0x00000001:
23345 complete_() = std::move(x.m_complete);
23346 break;
23347
23348 case 0x00000002:
23349 minimal_() = std::move(x.m_minimal);
23350 break;
23351
23352 }
23353 }
23354
23359 eProsima_user_DllExport TypeObject& operator =(
23360 const TypeObject& x)
23361 {
23362 m__d = x.m__d;
23363
23364 switch (x.selected_member_)
23365 {
23366 case 0x00000001:
23367 complete_() = x.m_complete;
23368 break;
23369
23370 case 0x00000002:
23371 minimal_() = x.m_minimal;
23372 break;
23373
23374 }
23375
23376 return *this;
23377 }
23378
23383 eProsima_user_DllExport TypeObject& operator =(
23384 TypeObject&& x) noexcept
23385 {
23386 m__d = x.m__d;
23387
23388 switch (x.selected_member_)
23389 {
23390 case 0x00000001:
23391 complete_() = std::move(x.m_complete);
23392 break;
23393
23394 case 0x00000002:
23395 minimal_() = std::move(x.m_minimal);
23396 break;
23397
23398 }
23399
23400 return *this;
23401 }
23402
23407 eProsima_user_DllExport bool operator ==(
23408 const TypeObject& x) const
23409 {
23410 bool ret_value {false};
23411
23412 if (m__d == x.m__d &&
23413 selected_member_ == x.selected_member_)
23414 {
23415 switch (selected_member_)
23416 {
23417 case 0x00000001:
23418 ret_value = (m_complete == x.m_complete);
23419 break;
23420
23421 case 0x00000002:
23422 ret_value = (m_minimal == x.m_minimal);
23423 break;
23424
23425 }
23426 }
23427
23428 return ret_value;
23429 }
23430
23435 eProsima_user_DllExport bool operator !=(
23436 const TypeObject& x) const
23437 {
23438 return !(*this == x);
23439 }
23440
23446 eProsima_user_DllExport void _d(
23447 uint8_t __d)
23448 {
23449 bool valid_discriminator = false;
23450
23451 switch (__d)
23452 {
23453 case EK_COMPLETE:
23454 if (0x00000001 == selected_member_)
23455 {
23456 valid_discriminator = true;
23457 }
23458 break;
23459
23460 case EK_MINIMAL:
23461 if (0x00000002 == selected_member_)
23462 {
23463 valid_discriminator = true;
23464 }
23465 break;
23466
23467 }
23468
23469 if (!valid_discriminator)
23470 {
23471 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
23472 }
23473
23474 m__d = __d;
23475 }
23476
23481 eProsima_user_DllExport uint8_t _d() const
23482 {
23483 return m__d;
23484 }
23485
23490 eProsima_user_DllExport void complete(
23491 const CompleteTypeObject& _complete)
23492 {
23493 complete_() = _complete;
23494 m__d = EK_COMPLETE;
23495 }
23496
23501 eProsima_user_DllExport void complete(
23502 CompleteTypeObject&& _complete)
23503 {
23504 complete_() = _complete;
23505 m__d = EK_COMPLETE;
23506 }
23507
23513 eProsima_user_DllExport const CompleteTypeObject& complete() const
23514 {
23515 if (0x00000001 != selected_member_)
23516 {
23517 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23518 }
23519
23520 return m_complete;
23521 }
23522
23528 eProsima_user_DllExport CompleteTypeObject& complete()
23529 {
23530 if (0x00000001 != selected_member_)
23531 {
23532 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23533 }
23534
23535 return m_complete;
23536 }
23537
23538
23543 eProsima_user_DllExport void minimal(
23544 const MinimalTypeObject& _minimal)
23545 {
23546 minimal_() = _minimal;
23547 m__d = EK_MINIMAL;
23548 }
23549
23554 eProsima_user_DllExport void minimal(
23555 MinimalTypeObject&& _minimal)
23556 {
23557 minimal_() = _minimal;
23558 m__d = EK_MINIMAL;
23559 }
23560
23566 eProsima_user_DllExport const MinimalTypeObject& minimal() const
23567 {
23568 if (0x00000002 != selected_member_)
23569 {
23570 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23571 }
23572
23573 return m_minimal;
23574 }
23575
23581 eProsima_user_DllExport MinimalTypeObject& minimal()
23582 {
23583 if (0x00000002 != selected_member_)
23584 {
23585 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23586 }
23587
23588 return m_minimal;
23589 }
23590
23591
23593 {
23594 if (member_destructor_)
23595 {
23596 member_destructor_();
23597 }
23598
23599 selected_member_ = 0x0FFFFFFFu;
23600 }
23601
23602
23603private:
23604
23605 CompleteTypeObject& complete_()
23606 {
23607 if (0x00000001 != selected_member_)
23608 {
23609 if (member_destructor_)
23610 {
23611 member_destructor_();
23612 }
23613
23614 selected_member_ = 0x00000001;
23615 member_destructor_ = [&]() {m_complete.~CompleteTypeObject();};
23616 new(&m_complete) CompleteTypeObject();
23617
23618 }
23619
23620 return m_complete;
23621 }
23622
23623 MinimalTypeObject& minimal_()
23624 {
23625 if (0x00000002 != selected_member_)
23626 {
23627 if (member_destructor_)
23628 {
23629 member_destructor_();
23630 }
23631
23632 selected_member_ = 0x00000002;
23633 member_destructor_ = [&]() {m_minimal.~MinimalTypeObject();};
23634 new(&m_minimal) MinimalTypeObject();
23635
23636 }
23637
23638 return m_minimal;
23639 }
23640
23641
23642 uint8_t m__d {TK_NONE};
23643
23644 union
23645 {
23648 };
23649
23650 uint32_t selected_member_ {0x0FFFFFFFu};
23651
23652 std::function<void()> member_destructor_;
23653};
23654typedef std::vector<TypeObject> TypeObjectSeq;
23655
23657
23663{
23664public:
23665
23669 eProsima_user_DllExport TypeIdentifierTypeObjectPair()
23670 {
23671 }
23672
23676 eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
23677 {
23678 }
23679
23684 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23686 {
23687 m_type_identifier = x.m_type_identifier;
23688
23689 m_type_object = x.m_type_object;
23690
23691 }
23692
23697 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23698 TypeIdentifierTypeObjectPair&& x) noexcept
23699 {
23700 m_type_identifier = std::move(x.m_type_identifier);
23701 m_type_object = std::move(x.m_type_object);
23702 }
23703
23710 {
23711
23712 m_type_identifier = x.m_type_identifier;
23713
23714 m_type_object = x.m_type_object;
23715
23716 return *this;
23717 }
23718
23724 TypeIdentifierTypeObjectPair&& x) noexcept
23725 {
23726
23727 m_type_identifier = std::move(x.m_type_identifier);
23728 m_type_object = std::move(x.m_type_object);
23729 return *this;
23730 }
23731
23736 eProsima_user_DllExport bool operator ==(
23737 const TypeIdentifierTypeObjectPair& x) const
23738 {
23739 return (m_type_identifier == x.m_type_identifier &&
23740 m_type_object == x.m_type_object);
23741 }
23742
23747 eProsima_user_DllExport bool operator !=(
23748 const TypeIdentifierTypeObjectPair& x) const
23749 {
23750 return !(*this == x);
23751 }
23752
23757 eProsima_user_DllExport void type_identifier(
23758 const TypeIdentifier& _type_identifier)
23759 {
23760 m_type_identifier = _type_identifier;
23761 }
23762
23767 eProsima_user_DllExport void type_identifier(
23768 TypeIdentifier&& _type_identifier)
23769 {
23770 m_type_identifier = std::move(_type_identifier);
23771 }
23772
23777 eProsima_user_DllExport const TypeIdentifier& type_identifier() const
23778 {
23779 return m_type_identifier;
23780 }
23781
23786 eProsima_user_DllExport TypeIdentifier& type_identifier()
23787 {
23788 return m_type_identifier;
23789 }
23790
23791
23796 eProsima_user_DllExport void type_object(
23797 const TypeObject& _type_object)
23798 {
23799 m_type_object = _type_object;
23800 }
23801
23806 eProsima_user_DllExport void type_object(
23807 TypeObject&& _type_object)
23808 {
23809 m_type_object = std::move(_type_object);
23810 }
23811
23816 eProsima_user_DllExport const TypeObject& type_object() const
23817 {
23818 return m_type_object;
23819 }
23820
23825 eProsima_user_DllExport TypeObject& type_object()
23826 {
23827 return m_type_object;
23828 }
23829
23830
23831
23832private:
23833
23834 TypeIdentifier m_type_identifier;
23835 TypeObject m_type_object;
23836
23837};
23838typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
23839
23845{
23846public:
23847
23851 eProsima_user_DllExport TypeIdentifierPair()
23852 {
23853 }
23854
23858 eProsima_user_DllExport ~TypeIdentifierPair()
23859 {
23860 }
23861
23866 eProsima_user_DllExport TypeIdentifierPair(
23867 const TypeIdentifierPair& x)
23868 {
23869 m_type_identifier1 = x.m_type_identifier1;
23870
23871 m_type_identifier2 = x.m_type_identifier2;
23872
23873 }
23874
23879 eProsima_user_DllExport TypeIdentifierPair(
23880 TypeIdentifierPair&& x) noexcept
23881 {
23882 m_type_identifier1 = std::move(x.m_type_identifier1);
23883 m_type_identifier2 = std::move(x.m_type_identifier2);
23884 }
23885
23890 eProsima_user_DllExport TypeIdentifierPair& operator =(
23891 const TypeIdentifierPair& x)
23892 {
23893
23894 m_type_identifier1 = x.m_type_identifier1;
23895
23896 m_type_identifier2 = x.m_type_identifier2;
23897
23898 return *this;
23899 }
23900
23905 eProsima_user_DllExport TypeIdentifierPair& operator =(
23906 TypeIdentifierPair&& x) noexcept
23907 {
23908
23909 m_type_identifier1 = std::move(x.m_type_identifier1);
23910 m_type_identifier2 = std::move(x.m_type_identifier2);
23911 return *this;
23912 }
23913
23918 eProsima_user_DllExport bool operator ==(
23919 const TypeIdentifierPair& x) const
23920 {
23921 return (m_type_identifier1 == x.m_type_identifier1 &&
23922 m_type_identifier2 == x.m_type_identifier2);
23923 }
23924
23929 eProsima_user_DllExport bool operator !=(
23930 const TypeIdentifierPair& x) const
23931 {
23932 return !(*this == x);
23933 }
23934
23939 eProsima_user_DllExport void type_identifier1(
23940 const TypeIdentifier& _type_identifier1)
23941 {
23942 m_type_identifier1 = _type_identifier1;
23943 }
23944
23949 eProsima_user_DllExport void type_identifier1(
23950 TypeIdentifier&& _type_identifier1)
23951 {
23952 m_type_identifier1 = std::move(_type_identifier1);
23953 }
23954
23959 eProsima_user_DllExport const TypeIdentifier& type_identifier1() const
23960 {
23961 return m_type_identifier1;
23962 }
23963
23968 eProsima_user_DllExport TypeIdentifier& type_identifier1()
23969 {
23970 return m_type_identifier1;
23971 }
23972
23973
23978 eProsima_user_DllExport void type_identifier2(
23979 const TypeIdentifier& _type_identifier2)
23980 {
23981 m_type_identifier2 = _type_identifier2;
23982 }
23983
23988 eProsima_user_DllExport void type_identifier2(
23989 TypeIdentifier&& _type_identifier2)
23990 {
23991 m_type_identifier2 = std::move(_type_identifier2);
23992 }
23993
23998 eProsima_user_DllExport const TypeIdentifier& type_identifier2() const
23999 {
24000 return m_type_identifier2;
24001 }
24002
24007 eProsima_user_DllExport TypeIdentifier& type_identifier2()
24008 {
24009 return m_type_identifier2;
24010 }
24011
24012
24013
24014private:
24015
24016 TypeIdentifier m_type_identifier1;
24017 TypeIdentifier m_type_identifier2;
24018
24019};
24020typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
24021
24027{
24028public:
24029
24033 eProsima_user_DllExport TypeIdentfierWithSize()
24034 {
24035 }
24036
24040 eProsima_user_DllExport ~TypeIdentfierWithSize()
24041 {
24042 }
24043
24048 eProsima_user_DllExport TypeIdentfierWithSize(
24049 const TypeIdentfierWithSize& x)
24050 {
24051 m_type_id = x.m_type_id;
24052
24053 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24054
24055 }
24056
24061 eProsima_user_DllExport TypeIdentfierWithSize(
24062 TypeIdentfierWithSize&& x) noexcept
24063 {
24064 m_type_id = std::move(x.m_type_id);
24065 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24066 }
24067
24072 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24073 const TypeIdentfierWithSize& x)
24074 {
24075
24076 m_type_id = x.m_type_id;
24077
24078 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24079
24080 return *this;
24081 }
24082
24087 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24088 TypeIdentfierWithSize&& x) noexcept
24089 {
24090
24091 m_type_id = std::move(x.m_type_id);
24092 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24093 return *this;
24094 }
24095
24100 eProsima_user_DllExport bool operator ==(
24101 const TypeIdentfierWithSize& x) const
24102 {
24103 return (m_type_id == x.m_type_id &&
24104 m_typeobject_serialized_size == x.m_typeobject_serialized_size);
24105 }
24106
24111 eProsima_user_DllExport bool operator !=(
24112 const TypeIdentfierWithSize& x) const
24113 {
24114 return !(*this == x);
24115 }
24116
24121 eProsima_user_DllExport void type_id(
24122 const TypeIdentifier& _type_id)
24123 {
24124 m_type_id = _type_id;
24125 }
24126
24131 eProsima_user_DllExport void type_id(
24132 TypeIdentifier&& _type_id)
24133 {
24134 m_type_id = std::move(_type_id);
24135 }
24136
24141 eProsima_user_DllExport const TypeIdentifier& type_id() const
24142 {
24143 return m_type_id;
24144 }
24145
24150 eProsima_user_DllExport TypeIdentifier& type_id()
24151 {
24152 return m_type_id;
24153 }
24154
24155
24160 eProsima_user_DllExport void typeobject_serialized_size(
24161 uint32_t _typeobject_serialized_size)
24162 {
24163 m_typeobject_serialized_size = _typeobject_serialized_size;
24164 }
24165
24170 eProsima_user_DllExport uint32_t typeobject_serialized_size() const
24171 {
24172 return m_typeobject_serialized_size;
24173 }
24174
24179 eProsima_user_DllExport uint32_t& typeobject_serialized_size()
24180 {
24181 return m_typeobject_serialized_size;
24182 }
24183
24184
24185
24186private:
24187
24188 TypeIdentifier m_type_id;
24189 uint32_t m_typeobject_serialized_size{0};
24190
24191};
24192typedef std::vector<TypeIdentfierWithSize> TypeIdentfierWithSizeSeq;
24193
24199{
24200public:
24201
24205 eProsima_user_DllExport TypeIdentifierWithDependencies()
24206 {
24207 }
24208
24212 eProsima_user_DllExport ~TypeIdentifierWithDependencies()
24213 {
24214 }
24215
24220 eProsima_user_DllExport TypeIdentifierWithDependencies(
24222 {
24223 m_typeid_with_size = x.m_typeid_with_size;
24224
24225 m_dependent_typeid_count = x.m_dependent_typeid_count;
24226
24227 m_dependent_typeids = x.m_dependent_typeids;
24228
24229 }
24230
24235 eProsima_user_DllExport TypeIdentifierWithDependencies(
24236 TypeIdentifierWithDependencies&& x) noexcept
24237 {
24238 m_typeid_with_size = std::move(x.m_typeid_with_size);
24239 m_dependent_typeid_count = x.m_dependent_typeid_count;
24240 m_dependent_typeids = std::move(x.m_dependent_typeids);
24241 }
24242
24249 {
24250
24251 m_typeid_with_size = x.m_typeid_with_size;
24252
24253 m_dependent_typeid_count = x.m_dependent_typeid_count;
24254
24255 m_dependent_typeids = x.m_dependent_typeids;
24256
24257 return *this;
24258 }
24259
24265 TypeIdentifierWithDependencies&& x) noexcept
24266 {
24267
24268 m_typeid_with_size = std::move(x.m_typeid_with_size);
24269 m_dependent_typeid_count = x.m_dependent_typeid_count;
24270 m_dependent_typeids = std::move(x.m_dependent_typeids);
24271 return *this;
24272 }
24273
24278 eProsima_user_DllExport bool operator ==(
24279 const TypeIdentifierWithDependencies& x) const
24280 {
24281 return (m_typeid_with_size == x.m_typeid_with_size &&
24282 m_dependent_typeid_count == x.m_dependent_typeid_count &&
24283 m_dependent_typeids == x.m_dependent_typeids);
24284 }
24285
24290 eProsima_user_DllExport bool operator !=(
24291 const TypeIdentifierWithDependencies& x) const
24292 {
24293 return !(*this == x);
24294 }
24295
24300 eProsima_user_DllExport void typeid_with_size(
24301 const TypeIdentfierWithSize& _typeid_with_size)
24302 {
24303 m_typeid_with_size = _typeid_with_size;
24304 }
24305
24310 eProsima_user_DllExport void typeid_with_size(
24311 TypeIdentfierWithSize&& _typeid_with_size)
24312 {
24313 m_typeid_with_size = std::move(_typeid_with_size);
24314 }
24315
24320 eProsima_user_DllExport const TypeIdentfierWithSize& typeid_with_size() const
24321 {
24322 return m_typeid_with_size;
24323 }
24324
24329 eProsima_user_DllExport TypeIdentfierWithSize& typeid_with_size()
24330 {
24331 return m_typeid_with_size;
24332 }
24333
24334
24339 eProsima_user_DllExport void dependent_typeid_count(
24340 int32_t _dependent_typeid_count)
24341 {
24342 m_dependent_typeid_count = _dependent_typeid_count;
24343 }
24344
24349 eProsima_user_DllExport int32_t dependent_typeid_count() const
24350 {
24351 return m_dependent_typeid_count;
24352 }
24353
24358 eProsima_user_DllExport int32_t& dependent_typeid_count()
24359 {
24360 return m_dependent_typeid_count;
24361 }
24362
24363
24368 eProsima_user_DllExport void dependent_typeids(
24369 const std::vector<TypeIdentfierWithSize>& _dependent_typeids)
24370 {
24371 m_dependent_typeids = _dependent_typeids;
24372 }
24373
24378 eProsima_user_DllExport void dependent_typeids(
24379 std::vector<TypeIdentfierWithSize>&& _dependent_typeids)
24380 {
24381 m_dependent_typeids = std::move(_dependent_typeids);
24382 }
24383
24388 eProsima_user_DllExport const std::vector<TypeIdentfierWithSize>& dependent_typeids() const
24389 {
24390 return m_dependent_typeids;
24391 }
24392
24397 eProsima_user_DllExport std::vector<TypeIdentfierWithSize>& dependent_typeids()
24398 {
24399 return m_dependent_typeids;
24400 }
24401
24402
24403
24404private:
24405
24406 TypeIdentfierWithSize m_typeid_with_size;
24407 int32_t m_dependent_typeid_count{0};
24408 std::vector<TypeIdentfierWithSize> m_dependent_typeids;
24409
24410};
24411typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
24412
24418{
24419public:
24420
24424 eProsima_user_DllExport TypeInformation()
24425 {
24426 }
24427
24431 eProsima_user_DllExport ~TypeInformation()
24432 {
24433 }
24434
24439 eProsima_user_DllExport TypeInformation(
24440 const TypeInformation& x)
24441 {
24442 m_minimal = x.m_minimal;
24443
24444 m_complete = x.m_complete;
24445
24446 }
24447
24452 eProsima_user_DllExport TypeInformation(
24453 TypeInformation&& x) noexcept
24454 {
24455 m_minimal = std::move(x.m_minimal);
24456 m_complete = std::move(x.m_complete);
24457 }
24458
24463 eProsima_user_DllExport TypeInformation& operator =(
24464 const TypeInformation& x)
24465 {
24466
24467 m_minimal = x.m_minimal;
24468
24469 m_complete = x.m_complete;
24470
24471 return *this;
24472 }
24473
24478 eProsima_user_DllExport TypeInformation& operator =(
24479 TypeInformation&& x) noexcept
24480 {
24481
24482 m_minimal = std::move(x.m_minimal);
24483 m_complete = std::move(x.m_complete);
24484 return *this;
24485 }
24486
24491 eProsima_user_DllExport bool operator ==(
24492 const TypeInformation& x) const
24493 {
24494 return (m_minimal == x.m_minimal &&
24495 m_complete == x.m_complete);
24496 }
24497
24502 eProsima_user_DllExport bool operator !=(
24503 const TypeInformation& x) const
24504 {
24505 return !(*this == x);
24506 }
24507
24512 eProsima_user_DllExport void minimal(
24513 const TypeIdentifierWithDependencies& _minimal)
24514 {
24515 m_minimal = _minimal;
24516 }
24517
24522 eProsima_user_DllExport void minimal(
24524 {
24525 m_minimal = std::move(_minimal);
24526 }
24527
24532 eProsima_user_DllExport const TypeIdentifierWithDependencies& minimal() const
24533 {
24534 return m_minimal;
24535 }
24536
24541 eProsima_user_DllExport TypeIdentifierWithDependencies& minimal()
24542 {
24543 return m_minimal;
24544 }
24545
24546
24551 eProsima_user_DllExport void complete(
24552 const TypeIdentifierWithDependencies& _complete)
24553 {
24554 m_complete = _complete;
24555 }
24556
24561 eProsima_user_DllExport void complete(
24563 {
24564 m_complete = std::move(_complete);
24565 }
24566
24571 eProsima_user_DllExport const TypeIdentifierWithDependencies& complete() const
24572 {
24573 return m_complete;
24574 }
24575
24580 eProsima_user_DllExport TypeIdentifierWithDependencies& complete()
24581 {
24582 return m_complete;
24583 }
24584
24585
24586
24587private:
24588
24591
24592};
24593typedef std::vector<TypeInformation> TypeInformationSeq;
24594
24595
24596} // namespace xtypes
24597
24598
24599} // namespace dds
24600
24601} // namespace fastdds
24602
24603} // namespace eprosima
24604
24605
24606#endif // _FAST_DDS_GENERATED_EPROSIMA_FASTDDS_DDS_XTYPES_DDS_XTYPES_TYPEOBJECT_HPP_
24607
24608
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:4279
eProsima_user_DllExport bool operator!=(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4768
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:5667
eProsima_user_DllExport void boolean_value(bool _boolean_value)
This function sets a value in member boolean_value.
Definition dds_xtypes_typeobject.hpp:4942
ExtendedAnnotationParameterValue m_extended_value
Definition dds_xtypes_typeobject.hpp:6137
eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > m_string8_value
Definition dds_xtypes_typeobject.hpp:6135
wchar_t m_wchar_value
Definition dds_xtypes_typeobject.hpp:6133
eProsima_user_DllExport void int8_value(int8_t _int8_value)
This function sets a value in member int8_value.
Definition dds_xtypes_typeobject.hpp:5026
eProsima_user_DllExport void float32_value(float _float32_value)
This function sets a value in member float32_value.
Definition dds_xtypes_typeobject.hpp:5362
eProsima_user_DllExport void uint8_value(uint8_t _uint8_value)
This function sets a value in member uint8_value.
Definition dds_xtypes_typeobject.hpp:5068
float m_float32_value
Definition dds_xtypes_typeobject.hpp:6129
eProsima_user_DllExport double & float64_value()
This function returns a reference to member float64_value.
Definition dds_xtypes_typeobject.hpp:5431
eProsima_user_DllExport uint64_t & uint64_value()
This function returns a reference to member uint64_value.
Definition dds_xtypes_typeobject.hpp:5347
eProsima_user_DllExport const std::wstring & string16_value() const
This function returns a constant reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5690
eProsima_user_DllExport void uint32_value(uint32_t _uint32_value)
This function sets a value in member uint32_value.
Definition dds_xtypes_typeobject.hpp:5236
eProsima_user_DllExport void extended_value(const ExtendedAnnotationParameterValue &_extended_value)
This function copies the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5720
eProsima_user_DllExport int32_t enumerated_value() const
This function returns the value of member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5584
eProsima_user_DllExport void wchar_value(wchar_t _wchar_value)
This function sets a value in member wchar_value.
Definition dds_xtypes_typeobject.hpp:5530
eProsima_user_DllExport void float128_value(long double _float128_value)
This function sets a value in member float128_value.
Definition dds_xtypes_typeobject.hpp:5446
eProsima_user_DllExport void char_value(char _char_value)
This function sets a value in member char_value.
Definition dds_xtypes_typeobject.hpp:5488
bool m_boolean_value
Definition dds_xtypes_typeobject.hpp:6119
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:5625
int32_t m_enumerated_value
Definition dds_xtypes_typeobject.hpp:6134
eProsima_user_DllExport void extended_value(ExtendedAnnotationParameterValue &&_extended_value)
This function moves the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5731
eProsima_user_DllExport float float32_value() const
This function returns the value of member float32_value.
Definition dds_xtypes_typeobject.hpp:5374
eProsima_user_DllExport char char_value() const
This function returns the value of member char_value.
Definition dds_xtypes_typeobject.hpp:5500
eProsima_user_DllExport void byte_value(uint8_t _byte_value)
This function sets a value in member byte_value.
Definition dds_xtypes_typeobject.hpp:4984
eProsima_user_DllExport void string16_value(std::wstring &&_string16_value)
This function moves the value in member string16_value.
Definition dds_xtypes_typeobject.hpp:5678
int8_t m_int8_value
Definition dds_xtypes_typeobject.hpp:6121
eProsima_user_DllExport int16_t & int16_value()
This function returns a reference to member int16_value.
Definition dds_xtypes_typeobject.hpp:5137
uint8_t m_uint8_value
Definition dds_xtypes_typeobject.hpp:6122
eProsima_user_DllExport int8_t & int8_value()
This function returns a reference to member int8_value.
Definition dds_xtypes_typeobject.hpp:5053
eProsima_user_DllExport uint8_t byte_value() const
This function returns the value of member byte_value.
Definition dds_xtypes_typeobject.hpp:4996
eProsima_user_DllExport int32_t & enumerated_value()
This function returns a reference to member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5599
uint8_t m_byte_value
Definition dds_xtypes_typeobject.hpp:6120
eProsima_user_DllExport uint16_t uint_16_value() const
This function returns the value of member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5164
eProsima_user_DllExport ExtendedAnnotationParameterValue & extended_value()
This function returns a reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5758
char m_char_value
Definition dds_xtypes_typeobject.hpp:6132
eProsima_user_DllExport uint16_t & uint_16_value()
This function returns a reference to member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5179
eProsima_user_DllExport void float64_value(double _float64_value)
This function sets a value in member float64_value.
Definition dds_xtypes_typeobject.hpp:5404
eProsima_user_DllExport bool operator==(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4672
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:5637
eProsima_user_DllExport std::wstring & string16_value()
This function returns a reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5705
eProsima_user_DllExport long double float128_value() const
This function returns the value of member float128_value.
Definition dds_xtypes_typeobject.hpp:5458
eProsima_user_DllExport int32_t int32_value() const
This function returns the value of member int32_value.
Definition dds_xtypes_typeobject.hpp:5206
eProsima_user_DllExport wchar_t & wchar_value()
This function returns a reference to member wchar_value.
Definition dds_xtypes_typeobject.hpp:5557
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:5152
eProsima_user_DllExport AnnotationParameterValue & operator=(const AnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4488
eProsima_user_DllExport uint32_t uint32_value() const
This function returns the value of member uint32_value.
Definition dds_xtypes_typeobject.hpp:5248
int64_t m_int64_value
Definition dds_xtypes_typeobject.hpp:6127
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:5652
eProsima_user_DllExport char & char_value()
This function returns a reference to member char_value.
Definition dds_xtypes_typeobject.hpp:5515
eProsima_user_DllExport const ExtendedAnnotationParameterValue & extended_value() const
This function returns a constant reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5743
eProsima_user_DllExport AnnotationParameterValue(AnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4398
eProsima_user_DllExport uint64_t uint64_value() const
This function returns the value of member uint64_value.
Definition dds_xtypes_typeobject.hpp:5332
eProsima_user_DllExport uint8_t & uint8_value()
This function returns a reference to member uint8_value.
Definition dds_xtypes_typeobject.hpp:5095
std::wstring m_string16_value
Definition dds_xtypes_typeobject.hpp:6136
int16_t m_int16_value
Definition dds_xtypes_typeobject.hpp:6123
eProsima_user_DllExport void uint64_value(uint64_t _uint64_value)
This function sets a value in member uint64_value.
Definition dds_xtypes_typeobject.hpp:5320
eProsima_user_DllExport double float64_value() const
This function returns the value of member float64_value.
Definition dds_xtypes_typeobject.hpp:5416
eProsima_user_DllExport uint8_t & byte_value()
This function returns a reference to member byte_value.
Definition dds_xtypes_typeobject.hpp:5011
eProsima_user_DllExport ~AnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4296
uint64_t m_uint64_value
Definition dds_xtypes_typeobject.hpp:6128
long double m_float128_value
Definition dds_xtypes_typeobject.hpp:6131
eProsima_user_DllExport wchar_t wchar_value() const
This function returns the value of member wchar_value.
Definition dds_xtypes_typeobject.hpp:5542
eProsima_user_DllExport float & float32_value()
This function returns a reference to member float32_value.
Definition dds_xtypes_typeobject.hpp:5389
eProsima_user_DllExport bool & boolean_value()
This function returns a reference to member boolean_value.
Definition dds_xtypes_typeobject.hpp:4969
eProsima_user_DllExport AnnotationParameterValue(const AnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4308
eProsima_user_DllExport long double & float128_value()
This function returns a reference to member float128_value.
Definition dds_xtypes_typeobject.hpp:5473
eProsima_user_DllExport void int16_value(int16_t _int16_value)
This function sets a value in member int16_value.
Definition dds_xtypes_typeobject.hpp:5110
eProsima_user_DllExport int16_t int16_value() const
This function returns the value of member int16_value.
Definition dds_xtypes_typeobject.hpp:5122
eProsima_user_DllExport void int32_value(int32_t _int32_value)
This function sets a value in member int32_value.
Definition dds_xtypes_typeobject.hpp:5194
eProsima_user_DllExport void int64_value(int64_t _int64_value)
This function sets a value in member int64_value.
Definition dds_xtypes_typeobject.hpp:5278
eProsima_user_DllExport int8_t int8_value() const
This function returns the value of member int8_value.
Definition dds_xtypes_typeobject.hpp:5038
eProsima_user_DllExport void enumerated_value(int32_t _enumerated_value)
This function sets a value in member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5572
eProsima_user_DllExport AnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4285
eProsima_user_DllExport int64_t int64_value() const
This function returns the value of member int64_value.
Definition dds_xtypes_typeobject.hpp:5290
int32_t m_int32_value
Definition dds_xtypes_typeobject.hpp:6125
eProsima_user_DllExport uint32_t & uint32_value()
This function returns a reference to member uint32_value.
Definition dds_xtypes_typeobject.hpp:5263
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:4779
uint16_t m_uint_16_value
Definition dds_xtypes_typeobject.hpp:6124
eProsima_user_DllExport int32_t & int32_value()
This function returns a reference to member int32_value.
Definition dds_xtypes_typeobject.hpp:5221
eProsima_user_DllExport uint8_t uint8_value() const
This function returns the value of member uint8_value.
Definition dds_xtypes_typeobject.hpp:5080
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:5614
eProsima_user_DllExport bool boolean_value() const
This function returns the value of member boolean_value.
Definition dds_xtypes_typeobject.hpp:4954
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:4933
uint32_t m_uint32_value
Definition dds_xtypes_typeobject.hpp:6126
eProsima_user_DllExport int64_t & int64_value()
This function returns a reference to member int64_value.
Definition dds_xtypes_typeobject.hpp:5305
double m_float64_value
Definition dds_xtypes_typeobject.hpp:6130
This class represents the structure AppliedAnnotation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6331
eProsima_user_DllExport AppliedAnnotation(AppliedAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6365
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:6474
eProsima_user_DllExport ~AppliedAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6344
eProsima_user_DllExport const TypeIdentifier & annotation_typeid() const
This function returns a constant reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6445
eProsima_user_DllExport void annotation_typeid(TypeIdentifier &&_annotation_typeid)
This function moves the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6435
eProsima_user_DllExport bool operator!=(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6415
eProsima_user_DllExport AppliedAnnotation & operator=(const AppliedAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6376
eProsima_user_DllExport AppliedAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6337
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:6464
eProsima_user_DllExport TypeIdentifier & annotation_typeid()
This function returns a reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6454
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:6484
eProsima_user_DllExport AppliedAnnotation(const AppliedAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6352
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > & param_seq()
This function returns a reference to member param_seq.
Definition dds_xtypes_typeobject.hpp:6493
eProsima_user_DllExport bool operator==(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6404
eProsima_user_DllExport void annotation_typeid(const TypeIdentifier &_annotation_typeid)
This function copies the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6425
This class represents the structure AppliedAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6149
eProsima_user_DllExport bool operator==(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6222
eProsima_user_DllExport bool operator!=(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6233
eProsima_user_DllExport AppliedAnnotationParameter & operator=(const AppliedAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6194
eProsima_user_DllExport AppliedAnnotationParameter(AppliedAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6183
eProsima_user_DllExport const AnnotationParameterValue & value() const
This function returns a constant reference to member value.
Definition dds_xtypes_typeobject.hpp:6302
eProsima_user_DllExport void paramname_hash(const NameHash &_paramname_hash)
This function copies the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6243
eProsima_user_DllExport void value(AnnotationParameterValue &&_value)
This function moves the value in member value.
Definition dds_xtypes_typeobject.hpp:6292
eProsima_user_DllExport const NameHash & paramname_hash() const
This function returns a constant reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6263
eProsima_user_DllExport AnnotationParameterValue & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:6311
eProsima_user_DllExport AppliedAnnotationParameter(const AppliedAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6170
eProsima_user_DllExport void paramname_hash(NameHash &&_paramname_hash)
This function moves the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6253
eProsima_user_DllExport void value(const AnnotationParameterValue &_value)
This function copies the value in member value.
Definition dds_xtypes_typeobject.hpp:6282
eProsima_user_DllExport ~AppliedAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6162
eProsima_user_DllExport NameHash & paramname_hash()
This function returns a reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6272
eProsima_user_DllExport AppliedAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6155
This class represents the structure AppliedBuiltinMemberAnnotations defined by the user in the IDL fi...
Definition dds_xtypes_typeobject.hpp:6740
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & min()
This function returns a reference to member min.
Definition dds_xtypes_typeobject.hpp:6916
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(const AppliedBuiltinMemberAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6761
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:6985
eProsima_user_DllExport void max(eprosima::fastcdr::optional< AnnotationParameterValue > &&_max)
This function moves the value in member max.
Definition dds_xtypes_typeobject.hpp:6936
eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6753
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:6848
eProsima_user_DllExport void min(eprosima::fastcdr::optional< AnnotationParameterValue > &&_min)
This function moves the value in member min.
Definition dds_xtypes_typeobject.hpp:6897
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:6975
eProsima_user_DllExport void max(const eprosima::fastcdr::optional< AnnotationParameterValue > &_max)
This function copies the value in member max.
Definition dds_xtypes_typeobject.hpp:6926
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & max()
This function returns a reference to member max.
Definition dds_xtypes_typeobject.hpp:6955
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & hash_id()
This function returns a reference to member hash_id.
Definition dds_xtypes_typeobject.hpp:6994
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:6868
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & max() const
This function returns a constant reference to member max.
Definition dds_xtypes_typeobject.hpp:6946
eProsima_user_DllExport void min(const eprosima::fastcdr::optional< AnnotationParameterValue > &_min)
This function copies the value in member min.
Definition dds_xtypes_typeobject.hpp:6887
eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6746
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & min() const
This function returns a constant reference to member min.
Definition dds_xtypes_typeobject.hpp:6907
eProsima_user_DllExport void unit(eprosima::fastcdr::optional< std::string > &&_unit)
This function moves the value in member unit.
Definition dds_xtypes_typeobject.hpp:6858
eProsima_user_DllExport bool operator==(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6825
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(AppliedBuiltinMemberAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6778
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:6965
eProsima_user_DllExport AppliedBuiltinMemberAnnotations & operator=(const AppliedBuiltinMemberAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6791
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & unit()
This function returns a reference to member unit.
Definition dds_xtypes_typeobject.hpp:6877
eProsima_user_DllExport bool operator!=(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6838
This class represents the structure AppliedBuiltinTypeAnnotations defined by the user in the IDL file...
Definition dds_xtypes_typeobject.hpp:7955
eProsima_user_DllExport bool operator!=(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8032
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7987
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim() const
This function returns a constant reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8062
eProsima_user_DllExport void verbatim(const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &_verbatim)
This function copies the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8042
eProsima_user_DllExport void verbatim(eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &&_verbatim)
This function moves the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8052
eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7961
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7976
eProsima_user_DllExport bool operator==(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8022
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim()
This function returns a reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8071
eProsima_user_DllExport AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7997
eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7968
This class represents the structure AppliedVerbatimAnnotation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6513
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:6634
eProsima_user_DllExport bool operator!=(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6604
eProsima_user_DllExport void text(const std::string &_text)
This function copies the value in member text.
Definition dds_xtypes_typeobject.hpp:6692
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & language()
This function returns a reference to member language.
Definition dds_xtypes_typeobject.hpp:6682
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:6653
eProsima_user_DllExport AppliedVerbatimAnnotation(AppliedVerbatimAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6549
eProsima_user_DllExport void language(eprosima::fastcdr::fixed_string< 32 > &&_language)
This function moves the value in member language.
Definition dds_xtypes_typeobject.hpp:6663
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:6614
eProsima_user_DllExport void placement(eprosima::fastcdr::fixed_string< 32 > &&_placement)
This function moves the value in member placement.
Definition dds_xtypes_typeobject.hpp:6624
eProsima_user_DllExport AppliedVerbatimAnnotation & operator=(const AppliedVerbatimAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6561
eProsima_user_DllExport AppliedVerbatimAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6519
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & placement()
This function returns a reference to member placement.
Definition dds_xtypes_typeobject.hpp:6643
eProsima_user_DllExport AppliedVerbatimAnnotation(const AppliedVerbatimAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6534
eProsima_user_DllExport ~AppliedVerbatimAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6526
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:6673
eProsima_user_DllExport std::string & text()
This function returns a reference to member text.
Definition dds_xtypes_typeobject.hpp:6721
eProsima_user_DllExport bool operator==(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6592
eProsima_user_DllExport void text(std::string &&_text)
This function moves the value in member text.
Definition dds_xtypes_typeobject.hpp:6702
eProsima_user_DllExport const std::string & text() const
This function returns a constant reference to member text.
Definition dds_xtypes_typeobject.hpp:6712
This class represents the structure CommonAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12528
eProsima_user_DllExport const AliasMemberFlag & related_flags() const
This function returns a constant reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12642
eProsima_user_DllExport CommonAliasBody(const CommonAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12549
eProsima_user_DllExport CommonAliasBody & operator=(const CommonAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12573
eProsima_user_DllExport void related_flags(const AliasMemberFlag &_related_flags)
This function copies the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12622
eProsima_user_DllExport void related_type(TypeIdentifier &&_related_type)
This function moves the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12671
eProsima_user_DllExport const TypeIdentifier & related_type() const
This function returns a constant reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12681
eProsima_user_DllExport bool operator!=(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12612
eProsima_user_DllExport ~CommonAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12541
eProsima_user_DllExport void related_type(const TypeIdentifier &_related_type)
This function copies the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12661
eProsima_user_DllExport void related_flags(AliasMemberFlag &&_related_flags)
This function moves the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12632
eProsima_user_DllExport bool operator==(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12601
eProsima_user_DllExport AliasMemberFlag & related_flags()
This function returns a reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12651
eProsima_user_DllExport TypeIdentifier & related_type()
This function returns a reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12690
eProsima_user_DllExport CommonAliasBody(CommonAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12562
eProsima_user_DllExport CommonAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12534
This class represents the structure CommonAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11208
eProsima_user_DllExport AnnotationParameterFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11331
eProsima_user_DllExport void member_flags(const AnnotationParameterFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11302
eProsima_user_DllExport bool operator!=(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11292
eProsima_user_DllExport CommonAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11214
eProsima_user_DllExport const AnnotationParameterFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11322
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:11351
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:11370
eProsima_user_DllExport void member_flags(AnnotationParameterFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11312
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:11341
eProsima_user_DllExport ~CommonAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11221
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:11361
eProsima_user_DllExport CommonAnnotationParameter(CommonAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11242
eProsima_user_DllExport CommonAnnotationParameter(const CommonAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11229
eProsima_user_DllExport bool operator==(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11281
eProsima_user_DllExport CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11253
This class represents the structure CommonArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15313
eProsima_user_DllExport LBoundSeq & bound_seq()
This function returns a reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15429
eProsima_user_DllExport const LBoundSeq & bound_seq() const
This function returns a constant reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15420
eProsima_user_DllExport bool operator!=(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15390
eProsima_user_DllExport CommonArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15319
eProsima_user_DllExport CommonArrayHeader(const CommonArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15334
eProsima_user_DllExport void bound_seq(const LBoundSeq &_bound_seq)
This function copies the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15400
eProsima_user_DllExport void bound_seq(LBoundSeq &&_bound_seq)
This function moves the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15410
eProsima_user_DllExport CommonArrayHeader & operator=(const CommonArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15355
eProsima_user_DllExport ~CommonArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15326
eProsima_user_DllExport CommonArrayHeader(CommonArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15345
eProsima_user_DllExport bool operator==(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15380
This class represents the structure CommonBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19302
eProsima_user_DllExport uint8_t & bitcount()
This function returns a reference to member bitcount.
Definition dds_xtypes_typeobject.hpp:19497
eProsima_user_DllExport const BitsetMemberFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:19459
eProsima_user_DllExport bool operator!=(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19400
eProsima_user_DllExport BitsetMemberFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:19468
eProsima_user_DllExport bool operator==(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19387
eProsima_user_DllExport void bitcount(uint8_t _bitcount)
This function sets a value in member bitcount.
Definition dds_xtypes_typeobject.hpp:19478
eProsima_user_DllExport CommonBitfield(CommonBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19340
eProsima_user_DllExport CommonBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19308
eProsima_user_DllExport uint8_t bitcount() const
This function returns the value of member bitcount.
Definition dds_xtypes_typeobject.hpp:19488
eProsima_user_DllExport void holder_type(TypeKind _holder_type)
This function sets a value in member holder_type.
Definition dds_xtypes_typeobject.hpp:19507
eProsima_user_DllExport void flags(BitsetMemberFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:19449
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:19429
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:19420
eProsima_user_DllExport ~CommonBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19315
eProsima_user_DllExport void flags(const BitsetMemberFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:19439
eProsima_user_DllExport CommonBitfield(const CommonBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19323
eProsima_user_DllExport TypeKind & holder_type()
This function returns a reference to member holder_type.
Definition dds_xtypes_typeobject.hpp:19526
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:19410
eProsima_user_DllExport TypeKind holder_type() const
This function returns the value of member holder_type.
Definition dds_xtypes_typeobject.hpp:19517
eProsima_user_DllExport CommonBitfield & operator=(const CommonBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19353
This class represents the structure CommonBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18187
eProsima_user_DllExport void flags(BitflagFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:18320
eProsima_user_DllExport CommonBitflag & operator=(const CommonBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18232
eProsima_user_DllExport CommonBitflag(CommonBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18221
eProsima_user_DllExport bool operator==(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18260
eProsima_user_DllExport const BitflagFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:18330
eProsima_user_DllExport CommonBitflag(const CommonBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18208
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:18300
eProsima_user_DllExport bool operator!=(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18271
eProsima_user_DllExport CommonBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18193
eProsima_user_DllExport void flags(const BitflagFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:18310
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:18291
eProsima_user_DllExport BitflagFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:18339
eProsima_user_DllExport ~CommonBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18200
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:18281
This class represents the structure CommonBitmaskHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18721
eProsima_user_DllExport CommonBitmaskHeader(const CommonBitmaskHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18742
eProsima_user_DllExport ~CommonBitmaskHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18734
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:18808
eProsima_user_DllExport CommonBitmaskHeader(CommonBitmaskHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18753
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:18818
eProsima_user_DllExport CommonBitmaskHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18727
eProsima_user_DllExport bool operator==(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18788
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:18827
eProsima_user_DllExport bool operator!=(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18798
eProsima_user_DllExport CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18763
This class represents the structure CommonCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13930
eProsima_user_DllExport const TypeIdentifier & type() const
This function returns a constant reference to member type.
Definition dds_xtypes_typeobject.hpp:14083
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14053
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14034
eProsima_user_DllExport CommonCollectionElement & operator=(const CommonCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13975
eProsima_user_DllExport bool operator!=(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14014
eProsima_user_DllExport CommonCollectionElement(const CommonCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13951
eProsima_user_DllExport void type(const TypeIdentifier &_type)
This function copies the value in member type.
Definition dds_xtypes_typeobject.hpp:14063
eProsima_user_DllExport TypeIdentifier & type()
This function returns a reference to member type.
Definition dds_xtypes_typeobject.hpp:14092
eProsima_user_DllExport CommonCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13936
eProsima_user_DllExport ~CommonCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13943
eProsima_user_DllExport bool operator==(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14003
eProsima_user_DllExport void type(TypeIdentifier &&_type)
This function moves the value in member type.
Definition dds_xtypes_typeobject.hpp:14073
eProsima_user_DllExport CommonCollectionElement(CommonCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13964
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14024
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14044
This class represents the structure CommonCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14423
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:14529
eProsima_user_DllExport bool operator!=(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14500
eProsima_user_DllExport CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14465
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:14510
eProsima_user_DllExport CommonCollectionHeader(CommonCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14455
eProsima_user_DllExport CommonCollectionHeader(const CommonCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14444
eProsima_user_DllExport ~CommonCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14436
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:14520
eProsima_user_DllExport CommonCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14429
eProsima_user_DllExport bool operator==(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14490
This class represents the structure CommonDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9854
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10007
eProsima_user_DllExport void member_flags(UnionDiscriminatorFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9958
eProsima_user_DllExport void member_flags(const UnionDiscriminatorFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9948
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10016
eProsima_user_DllExport bool operator==(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9927
eProsima_user_DllExport const UnionDiscriminatorFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9968
eProsima_user_DllExport ~CommonDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9867
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9997
eProsima_user_DllExport UnionDiscriminatorFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9977
eProsima_user_DllExport bool operator!=(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9938
eProsima_user_DllExport CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9899
eProsima_user_DllExport CommonDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9860
eProsima_user_DllExport CommonDiscriminatorMember(CommonDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9888
eProsima_user_DllExport CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9875
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9987
This class represents the structure CommonEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17297
eProsima_user_DllExport bool operator==(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17364
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:17384
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:17394
eProsima_user_DllExport CommonEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17303
eProsima_user_DllExport bool operator!=(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17374
eProsima_user_DllExport CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17318
eProsima_user_DllExport CommonEnumeratedHeader(CommonEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17329
eProsima_user_DllExport ~CommonEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17310
eProsima_user_DllExport CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17339
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:17403
This class represents the structure CommonEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16763
eProsima_user_DllExport void flags(EnumeratedLiteralFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:16896
eProsima_user_DllExport const EnumeratedLiteralFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:16906
eProsima_user_DllExport int32_t & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:16876
eProsima_user_DllExport void value(int32_t _value)
This function sets a value in member value.
Definition dds_xtypes_typeobject.hpp:16857
eProsima_user_DllExport CommonEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16769
eProsima_user_DllExport ~CommonEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16776
eProsima_user_DllExport void flags(const EnumeratedLiteralFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:16886
eProsima_user_DllExport EnumeratedLiteralFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:16915
eProsima_user_DllExport int32_t value() const
This function returns the value of member value.
Definition dds_xtypes_typeobject.hpp:16867
eProsima_user_DllExport bool operator==(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16836
eProsima_user_DllExport CommonEnumeratedLiteral(CommonEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16797
eProsima_user_DllExport CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16784
eProsima_user_DllExport CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16808
eProsima_user_DllExport bool operator!=(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16847
This class represents the structure CommonStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7014
eProsima_user_DllExport void member_flags(const StructMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7144
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:7193
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:7212
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:7183
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:7203
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:7134
eProsima_user_DllExport CommonStructMember & operator=(const CommonStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7062
eProsima_user_DllExport bool operator==(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7093
eProsima_user_DllExport ~CommonStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7027
eProsima_user_DllExport CommonStructMember(CommonStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7050
eProsima_user_DllExport CommonStructMember(const CommonStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7035
eProsima_user_DllExport StructMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7173
eProsima_user_DllExport CommonStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7020
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:7115
eProsima_user_DllExport const StructMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7164
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:7125
eProsima_user_DllExport bool operator!=(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7105
eProsima_user_DllExport void member_flags(StructMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7154
This class represents the structure CommonUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9226
eProsima_user_DllExport CommonUnionMember & operator=(const CommonUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9277
eProsima_user_DllExport CommonUnionMember(CommonUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9264
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9422
eProsima_user_DllExport void member_flags(const UnionMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9363
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9431
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9412
eProsima_user_DllExport bool operator==(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9311
eProsima_user_DllExport UnionMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9392
eProsima_user_DllExport const UnionMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9383
eProsima_user_DllExport void member_flags(UnionMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9373
eProsima_user_DllExport const UnionCaseLabelSeq & label_seq() const
This function returns a constant reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9461
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:9353
eProsima_user_DllExport CommonUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9232
eProsima_user_DllExport UnionCaseLabelSeq & label_seq()
This function returns a reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9470
eProsima_user_DllExport void label_seq(const UnionCaseLabelSeq &_label_seq)
This function copies the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9441
eProsima_user_DllExport ~CommonUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9239
eProsima_user_DllExport bool operator!=(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9324
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:9334
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:9344
eProsima_user_DllExport void label_seq(UnionCaseLabelSeq &&_label_seq)
This function moves the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9451
eProsima_user_DllExport CommonUnionMember(const CommonUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9247
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9402
This class represents the structure CompleteAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12708
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:12829
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:12916
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12877
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:12809
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:12858
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:12819
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:12907
eProsima_user_DllExport CompleteAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12714
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:12868
eProsima_user_DllExport CompleteAliasBody(CompleteAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12744
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:12887
eProsima_user_DllExport ~CompleteAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12721
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:12838
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:12848
eProsima_user_DllExport CompleteAliasBody & operator=(const CompleteAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12756
eProsima_user_DllExport CompleteAliasBody(const CompleteAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12729
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:12897
eProsima_user_DllExport bool operator==(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12787
eProsima_user_DllExport bool operator!=(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12799
This class represents the structure CompleteAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13068
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:13165
eProsima_user_DllExport bool operator!=(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13145
eProsima_user_DllExport CompleteAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13074
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:13184
eProsima_user_DllExport ~CompleteAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13081
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:13155
eProsima_user_DllExport CompleteAliasHeader(const CompleteAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13089
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:13175
eProsima_user_DllExport bool operator==(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13135
eProsima_user_DllExport CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13110
eProsima_user_DllExport CompleteAliasHeader(CompleteAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13100
This class represents the structure CompleteAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13296
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13417
eProsima_user_DllExport void header(const CompleteAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13436
eProsima_user_DllExport CompleteAliasType(CompleteAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13332
eProsima_user_DllExport void header(CompleteAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13446
eProsima_user_DllExport const CompleteAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13495
eProsima_user_DllExport bool operator!=(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13387
eProsima_user_DllExport bool operator==(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13375
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13397
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13407
eProsima_user_DllExport CompleteAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13302
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13426
eProsima_user_DllExport CompleteAliasType(const CompleteAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13317
eProsima_user_DllExport ~CompleteAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13309
eProsima_user_DllExport CompleteAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13504
eProsima_user_DllExport const CompleteAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13456
eProsima_user_DllExport CompleteAliasType & operator=(const CompleteAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13344
eProsima_user_DllExport void body(CompleteAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13485
eProsima_user_DllExport void body(const CompleteAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13475
eProsima_user_DllExport CompleteAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13465
This class represents the structure CompleteAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11846
eProsima_user_DllExport CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11888
eProsima_user_DllExport CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11867
eProsima_user_DllExport bool operator!=(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11923
eProsima_user_DllExport void annotation_name(QualifiedTypeName &&_annotation_name)
This function moves the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:11943
eProsima_user_DllExport const QualifiedTypeName & annotation_name() const
This function returns a constant reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:11953
eProsima_user_DllExport void annotation_name(const QualifiedTypeName &_annotation_name)
This function copies the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:11933
eProsima_user_DllExport bool operator==(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11913
eProsima_user_DllExport QualifiedTypeName & annotation_name()
This function returns a reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:11962
eProsima_user_DllExport CompleteAnnotationHeader(CompleteAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11878
eProsima_user_DllExport CompleteAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11852
eProsima_user_DllExport ~CompleteAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11859
This class represents the structure CompleteAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11388
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11509
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11489
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:11528
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:11557
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11587
eProsima_user_DllExport CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11409
eProsima_user_DllExport bool operator==(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11467
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11499
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:11548
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11518
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11596
eProsima_user_DllExport CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11436
eProsima_user_DllExport CompleteAnnotationParameter(CompleteAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11424
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11577
eProsima_user_DllExport bool operator!=(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11479
eProsima_user_DllExport ~CompleteAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11401
eProsima_user_DllExport CompleteAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11394
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11567
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:11538
This class represents the structure CompleteAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12074
eProsima_user_DllExport bool operator==(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12153
eProsima_user_DllExport ~CompleteAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12087
eProsima_user_DllExport const CompleteAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12234
eProsima_user_DllExport CompleteAnnotationType(const CompleteAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12095
eProsima_user_DllExport CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12122
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12204
eProsima_user_DllExport const CompleteAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12273
eProsima_user_DllExport CompleteAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12080
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12185
eProsima_user_DllExport void header(const CompleteAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12214
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12175
eProsima_user_DllExport void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12253
eProsima_user_DllExport CompleteAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12243
eProsima_user_DllExport void header(CompleteAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12224
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12195
eProsima_user_DllExport CompleteAnnotationType(CompleteAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12110
eProsima_user_DllExport CompleteAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12282
eProsima_user_DllExport void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12263
eProsima_user_DllExport bool operator!=(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12165
This class represents the structure CompleteArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15446
eProsima_user_DllExport bool operator==(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15519
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:15589
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:15608
eProsima_user_DllExport CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15491
eProsima_user_DllExport ~CompleteArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15459
eProsima_user_DllExport CompleteArrayHeader(CompleteArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15480
eProsima_user_DllExport CompleteArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15452
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:15579
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15550
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15569
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15560
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:15599
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15540
eProsima_user_DllExport bool operator!=(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15530
eProsima_user_DllExport CompleteArrayHeader(const CompleteArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15467
This class represents the structure CompleteArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15759
eProsima_user_DllExport CompleteArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15928
eProsima_user_DllExport CompleteArrayType & operator=(const CompleteArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15807
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15870
eProsima_user_DllExport const CompleteArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15919
eProsima_user_DllExport bool operator==(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15838
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15948
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15889
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15938
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15860
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15958
eProsima_user_DllExport CompleteArrayType(const CompleteArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15780
eProsima_user_DllExport CompleteArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15765
eProsima_user_DllExport CompleteArrayType(CompleteArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15795
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15880
eProsima_user_DllExport ~CompleteArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15772
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15967
eProsima_user_DllExport void header(const CompleteArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15899
eProsima_user_DllExport bool operator!=(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15850
eProsima_user_DllExport void header(CompleteArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15909
This class represents the structure CompleteBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19546
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19669
eProsima_user_DllExport CompleteBitfield(const CompleteBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19567
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:19679
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19660
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:19689
eProsima_user_DllExport CompleteBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19552
eProsima_user_DllExport bool operator==(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19619
eProsima_user_DllExport CompleteBitfield & operator=(const CompleteBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19591
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19640
eProsima_user_DllExport CompleteBitfield(CompleteBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19580
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:19708
eProsima_user_DllExport bool operator!=(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19630
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19650
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:19699
eProsima_user_DllExport ~CompleteBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19559
This class represents the structure CompleteBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18357
eProsima_user_DllExport CompleteBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18363
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18480
eProsima_user_DllExport ~CompleteBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18370
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18490
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18451
eProsima_user_DllExport bool operator==(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18430
eProsima_user_DllExport CompleteBitflag(CompleteBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18391
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18461
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18500
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18471
eProsima_user_DllExport bool operator!=(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18441
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18519
eProsima_user_DllExport CompleteBitflag(const CompleteBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18378
eProsima_user_DllExport CompleteBitflag & operator=(const CompleteBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18402
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18510
This class represents the structure CompleteBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18848
eProsima_user_DllExport CompleteBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19056
eProsima_user_DllExport void header(CompleteBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:18998
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18969
eProsima_user_DllExport const CompleteBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19008
eProsima_user_DllExport ~CompleteBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18861
eProsima_user_DllExport void flag_seq(const CompleteBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19027
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18949
eProsima_user_DllExport bool operator!=(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18939
eProsima_user_DllExport CompleteBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19017
eProsima_user_DllExport CompleteBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18854
eProsima_user_DllExport void flag_seq(CompleteBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19037
eProsima_user_DllExport const CompleteBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19047
eProsima_user_DllExport bool operator==(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18927
eProsima_user_DllExport void header(const CompleteBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:18988
eProsima_user_DllExport CompleteBitmaskType(CompleteBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18884
eProsima_user_DllExport CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18896
eProsima_user_DllExport CompleteBitmaskType(const CompleteBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18869
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18978
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18959
This class represents the structure CompleteBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19910
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:20007
eProsima_user_DllExport CompleteBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19916
eProsima_user_DllExport CompleteBitsetHeader(const CompleteBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19931
eProsima_user_DllExport bool operator!=(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19987
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:20026
eProsima_user_DllExport CompleteBitsetHeader(CompleteBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19942
eProsima_user_DllExport CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19952
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:19997
eProsima_user_DllExport ~CompleteBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19923
eProsima_user_DllExport bool operator==(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19977
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:20017
This class represents the structure CompleteBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20138
eProsima_user_DllExport bool operator==(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20217
eProsima_user_DllExport bool operator!=(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20229
eProsima_user_DllExport void field_seq(const CompleteBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20317
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20239
eProsima_user_DllExport CompleteBitsetType(const CompleteBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20159
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20259
eProsima_user_DllExport const CompleteBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20337
eProsima_user_DllExport void field_seq(CompleteBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20327
eProsima_user_DllExport const CompleteBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20298
eProsima_user_DllExport void header(CompleteBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20288
eProsima_user_DllExport CompleteBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20144
eProsima_user_DllExport CompleteBitsetType(CompleteBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20174
eProsima_user_DllExport ~CompleteBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20151
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20249
eProsima_user_DllExport CompleteBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20307
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20268
eProsima_user_DllExport CompleteBitsetType & operator=(const CompleteBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20186
eProsima_user_DllExport CompleteBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20346
eProsima_user_DllExport void header(const CompleteBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20278
This class represents the structure CompleteCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14110
eProsima_user_DllExport CompleteElementDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14272
eProsima_user_DllExport bool operator!=(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14194
eProsima_user_DllExport ~CompleteCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14123
eProsima_user_DllExport CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14155
eProsima_user_DllExport void detail(const CompleteElementDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14243
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14204
eProsima_user_DllExport CompleteCollectionElement(const CompleteCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14131
eProsima_user_DllExport void detail(CompleteElementDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14253
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14224
eProsima_user_DllExport const CompleteElementDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14263
eProsima_user_DllExport CompleteCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14116
eProsima_user_DllExport CompleteCollectionElement(CompleteCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14144
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14233
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14214
eProsima_user_DllExport bool operator==(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14183
This class represents the structure CompleteCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14546
eProsima_user_DllExport bool operator==(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14619
eProsima_user_DllExport CompleteCollectionHeader(const CompleteCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14567
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14669
eProsima_user_DllExport ~CompleteCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14559
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14660
eProsima_user_DllExport CompleteCollectionHeader(CompleteCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14580
eProsima_user_DllExport CompleteCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14552
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14640
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14650
eProsima_user_DllExport void detail(eprosima::fastcdr::optional< CompleteTypeDetail > &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14689
eProsima_user_DllExport const eprosima::fastcdr::optional< CompleteTypeDetail > & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14699
eProsima_user_DllExport CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14591
eProsima_user_DllExport void detail(const eprosima::fastcdr::optional< CompleteTypeDetail > &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14679
eProsima_user_DllExport bool operator!=(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14630
eProsima_user_DllExport eprosima::fastcdr::optional< CompleteTypeDetail > & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14708
This class represents the structure CompleteDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10034
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10203
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:10174
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:10242
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10164
eProsima_user_DllExport ~CompleteDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10047
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:10194
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:10233
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10155
eProsima_user_DllExport bool operator==(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10113
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:10184
eProsima_user_DllExport CompleteDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10040
eProsima_user_DllExport CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10070
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:10213
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:10223
eProsima_user_DllExport CompleteDiscriminatorMember(const CompleteDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10055
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10145
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10135
eProsima_user_DllExport CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10082
eProsima_user_DllExport bool operator!=(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10125
This class represents the structure CompleteElementDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13750
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:13912
eProsima_user_DllExport CompleteElementDetail(CompleteElementDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13784
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13873
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:13854
eProsima_user_DllExport bool operator!=(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13834
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:13903
eProsima_user_DllExport CompleteElementDetail(const CompleteElementDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13771
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:13864
eProsima_user_DllExport CompleteElementDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13756
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:13883
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:13844
eProsima_user_DllExport ~CompleteElementDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13763
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:13893
eProsima_user_DllExport CompleteElementDetail & operator=(const CompleteElementDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13795
eProsima_user_DllExport bool operator==(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13823
This class represents the structure CompleteEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17420
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17563
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17582
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17543
eProsima_user_DllExport ~CompleteEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17433
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17553
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17534
eProsima_user_DllExport CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17465
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17514
eProsima_user_DllExport CompleteEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17426
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17573
eProsima_user_DllExport bool operator==(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17493
eProsima_user_DllExport CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17454
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17504
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17524
eProsima_user_DllExport CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17441
This class represents the structure CompleteEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16933
eProsima_user_DllExport CompleteEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16939
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17047
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17066
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17017
eProsima_user_DllExport CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16978
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17076
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17056
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17095
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17027
eProsima_user_DllExport ~CompleteEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16946
eProsima_user_DllExport CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16967
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17086
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17037
eProsima_user_DllExport CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16954
eProsima_user_DllExport bool operator==(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17006
This class represents the structure CompleteEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17733
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17863
eProsima_user_DllExport const CompleteEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:17893
eProsima_user_DllExport void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17912
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17834
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17844
eProsima_user_DllExport const CompleteEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:17932
eProsima_user_DllExport CompleteEnumeratedType(CompleteEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17769
eProsima_user_DllExport ~CompleteEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17746
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17824
eProsima_user_DllExport bool operator==(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17812
eProsima_user_DllExport CompleteEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:17941
eProsima_user_DllExport CompleteEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:17902
eProsima_user_DllExport void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17922
eProsima_user_DllExport CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17781
eProsima_user_DllExport CompleteEnumeratedType(const CompleteEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17754
eProsima_user_DllExport void header(CompleteEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:17883
eProsima_user_DllExport CompleteEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17739
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17854
eProsima_user_DllExport void header(const CompleteEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:17873
This class represents the structure CompleteExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20592
eProsima_user_DllExport CompleteExtendedType & operator=(const CompleteExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20633
eProsima_user_DllExport CompleteExtendedType(const CompleteExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20613
eProsima_user_DllExport CompleteExtendedType(CompleteExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20623
eProsima_user_DllExport CompleteExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20598
eProsima_user_DllExport bool operator!=(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20670
eProsima_user_DllExport ~CompleteExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20605
eProsima_user_DllExport bool operator==(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20659
This class represents the structure CompleteMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16213
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16331
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16448
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16370
eProsima_user_DllExport void key(CompleteCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16409
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16380
eProsima_user_DllExport const CompleteCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16419
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16360
eProsima_user_DllExport CompleteMapType & operator=(const CompleteMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16264
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16350
eProsima_user_DllExport CompleteMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16219
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16389
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16438
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16321
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16458
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16341
eProsima_user_DllExport CompleteCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16428
eProsima_user_DllExport CompleteMapType(const CompleteMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16234
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16467
eProsima_user_DllExport void key(const CompleteCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16399
eProsima_user_DllExport bool operator!=(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16311
eProsima_user_DllExport ~CompleteMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16226
eProsima_user_DllExport bool operator==(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16298
eProsima_user_DllExport CompleteMapType(CompleteMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16251
This class represents the structure CompleteMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7231
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:7439
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:7332
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7400
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:7381
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:7361
eProsima_user_DllExport bool operator!=(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7322
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:7430
eProsima_user_DllExport CompleteMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7237
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:7352
eProsima_user_DllExport CompleteMemberDetail(const CompleteMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7252
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:7391
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:7410
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:7371
eProsima_user_DllExport CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7279
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:7420
eProsima_user_DllExport bool operator==(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7310
eProsima_user_DllExport ~CompleteMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7244
eProsima_user_DllExport CompleteMemberDetail(CompleteMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7267
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:7342
This class represents the structure CompleteSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14859
eProsima_user_DllExport CompleteSequenceType & operator=(const CompleteSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14907
eProsima_user_DllExport CompleteSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14865
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:14970
eProsima_user_DllExport bool operator==(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14938
eProsima_user_DllExport CompleteSequenceType(CompleteSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14895
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15048
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15009
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15019
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:14999
eProsima_user_DllExport bool operator!=(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14950
eProsima_user_DllExport ~CompleteSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14872
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:14989
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15028
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15038
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:14960
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15058
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:14980
eProsima_user_DllExport CompleteSequenceType(const CompleteSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14880
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15067
This class represents the structure CompleteStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8410
eProsima_user_DllExport ~CompleteStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8423
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8553
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8572
eProsima_user_DllExport CompleteStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8416
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8514
eProsima_user_DllExport CompleteStructHeader(CompleteStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8444
eProsima_user_DllExport bool operator!=(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8494
eProsima_user_DllExport bool operator==(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8483
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8543
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8504
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8533
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8563
eProsima_user_DllExport CompleteStructHeader(const CompleteStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8431
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8524
eProsima_user_DllExport CompleteStructHeader & operator=(const CompleteStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8455
This class represents the structure CompleteStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7591
eProsima_user_DllExport CompleteStructMember(CompleteStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7625
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7724
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7685
eProsima_user_DllExport CompleteStructMember(const CompleteStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7612
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7734
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7714
eProsima_user_DllExport ~CompleteStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7604
eProsima_user_DllExport bool operator!=(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7675
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7753
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7705
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7695
eProsima_user_DllExport CompleteStructMember & operator=(const CompleteStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7636
eProsima_user_DllExport CompleteStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7597
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7744
eProsima_user_DllExport bool operator==(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7664
This class represents the structure CompleteStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8770
eProsima_user_DllExport const CompleteStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:8930
eProsima_user_DllExport CompleteStructType(CompleteStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8806
eProsima_user_DllExport bool operator!=(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8861
eProsima_user_DllExport CompleteStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:8939
eProsima_user_DllExport ~CompleteStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8783
eProsima_user_DllExport CompleteStructType(const CompleteStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8791
eProsima_user_DllExport void header(const CompleteStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:8910
eProsima_user_DllExport CompleteStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8776
eProsima_user_DllExport CompleteStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:8978
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8881
eProsima_user_DllExport void member_seq(CompleteStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:8959
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8871
eProsima_user_DllExport CompleteStructType & operator=(const CompleteStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8818
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8891
eProsima_user_DllExport void header(CompleteStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:8920
eProsima_user_DllExport void member_seq(const CompleteStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:8949
eProsima_user_DllExport const CompleteStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:8969
eProsima_user_DllExport bool operator==(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8849
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8900
This class represents the structure CompleteTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8183
eProsima_user_DllExport CompleteTypeDetail(const CompleteTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8204
eProsima_user_DllExport const QualifiedTypeName & type_name() const
This function returns a constant reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8382
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8313
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:8284
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:8352
eProsima_user_DllExport bool operator==(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8262
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:8304
eProsima_user_DllExport CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8231
eProsima_user_DllExport QualifiedTypeName & type_name()
This function returns a reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8391
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:8343
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:8294
eProsima_user_DllExport void type_name(const QualifiedTypeName &_type_name)
This function copies the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8362
eProsima_user_DllExport CompleteTypeDetail(CompleteTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8219
eProsima_user_DllExport void type_name(QualifiedTypeName &&_type_name)
This function moves the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8372
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:8323
eProsima_user_DllExport bool operator!=(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8274
eProsima_user_DllExport ~CompleteTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8196
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:8333
eProsima_user_DllExport CompleteTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8189
This class represents the union CompleteTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20687
CompleteStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:21921
eProsima_user_DllExport const CompleteBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21634
eProsima_user_DllExport const CompleteMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21528
eProsima_user_DllExport CompleteBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21384
CompleteExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:21929
CompleteAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:21919
eProsima_user_DllExport void array_type(CompleteArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21463
eProsima_user_DllExport void bitset_type(CompleteBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21357
eProsima_user_DllExport const CompleteBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21369
eProsima_user_DllExport CompleteAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21225
eProsima_user_DllExport CompleteAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21172
eProsima_user_DllExport void map_type(const CompleteMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21505
eProsima_user_DllExport void annotation_type(CompleteAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21198
CompleteBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:21923
eProsima_user_DllExport void struct_type(const CompleteStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21240
eProsima_user_DllExport void bitmask_type(CompleteBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21622
eProsima_user_DllExport const CompleteAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21210
eProsima_user_DllExport void struct_type(CompleteStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21251
eProsima_user_DllExport void bitmask_type(const CompleteBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21611
eProsima_user_DllExport const CompleteStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21263
eProsima_user_DllExport CompleteTypeObject(const CompleteTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20716
CompleteAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:21920
eProsima_user_DllExport CompleteBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21649
eProsima_user_DllExport CompleteStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21278
eProsima_user_DllExport CompleteTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20693
eProsima_user_DllExport CompleteTypeObject(CompleteTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20774
eProsima_user_DllExport void sequence_type(const CompleteSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21399
eProsima_user_DllExport bool operator==(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20952
eProsima_user_DllExport void bitset_type(const CompleteBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21346
eProsima_user_DllExport void union_type(CompleteUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21304
eProsima_user_DllExport CompleteUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21331
eProsima_user_DllExport ~CompleteTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20704
eProsima_user_DllExport bool operator!=(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:21016
eProsima_user_DllExport CompleteTypeObject & operator=(const CompleteTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20832
eProsima_user_DllExport void alias_type(const CompleteAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21134
eProsima_user_DllExport const CompleteSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21422
eProsima_user_DllExport void union_type(const CompleteUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21293
CompleteArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:21925
eProsima_user_DllExport CompleteEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21596
eProsima_user_DllExport const CompleteEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21581
CompleteEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:21927
eProsima_user_DllExport void sequence_type(CompleteSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21410
eProsima_user_DllExport CompleteExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21702
eProsima_user_DllExport void enumerated_type(CompleteEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21569
eProsima_user_DllExport const CompleteArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21475
eProsima_user_DllExport void alias_type(CompleteAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21145
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:21027
eProsima_user_DllExport CompleteArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21490
eProsima_user_DllExport void extended_type(CompleteExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21675
CompleteBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:21928
CompleteMapType m_map_type
Definition dds_xtypes_typeobject.hpp:21926
eProsima_user_DllExport void map_type(CompleteMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21516
eProsima_user_DllExport CompleteSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21437
CompleteSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:21924
eProsima_user_DllExport const CompleteUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21316
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:21125
eProsima_user_DllExport void extended_type(const CompleteExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21664
eProsima_user_DllExport const CompleteExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21687
eProsima_user_DllExport CompleteMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21543
eProsima_user_DllExport void enumerated_type(const CompleteEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21558
eProsima_user_DllExport void annotation_type(const CompleteAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21187
CompleteUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:21922
eProsima_user_DllExport void array_type(const CompleteArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21452
eProsima_user_DllExport const CompleteAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21157
This class represents the structure CompleteUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10394
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10491
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10510
eProsima_user_DllExport ~CompleteUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10407
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10481
eProsima_user_DllExport bool operator!=(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10471
eProsima_user_DllExport CompleteUnionHeader(const CompleteUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10415
eProsima_user_DllExport CompleteUnionHeader(CompleteUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10426
eProsima_user_DllExport bool operator==(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10461
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10501
eProsima_user_DllExport CompleteUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10400
eProsima_user_DllExport CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10436
This class represents the structure CompleteUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9490
eProsima_user_DllExport CompleteUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9496
eProsima_user_DllExport CompleteUnionMember(const CompleteUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9511
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9584
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9623
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9594
eProsima_user_DllExport ~CompleteUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9503
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9613
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9633
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9604
eProsima_user_DllExport CompleteUnionMember & operator=(const CompleteUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9535
eProsima_user_DllExport bool operator!=(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9574
eProsima_user_DllExport bool operator==(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9563
eProsima_user_DllExport CompleteUnionMember(CompleteUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9524
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9652
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9643
This class represents the structure CompleteUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10660
eProsima_user_DllExport bool operator==(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10745
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10778
eProsima_user_DllExport CompleteUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10914
eProsima_user_DllExport CompleteUnionType(CompleteUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10698
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10768
eProsima_user_DllExport CompleteUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10666
eProsima_user_DllExport const CompleteUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10905
eProsima_user_DllExport ~CompleteUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10673
eProsima_user_DllExport void discriminator(CompleteDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10856
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10797
eProsima_user_DllExport CompleteUnionType & operator=(const CompleteUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10711
eProsima_user_DllExport void member_seq(CompleteUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10895
eProsima_user_DllExport bool operator!=(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10758
eProsima_user_DllExport const CompleteDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10866
eProsima_user_DllExport void discriminator(const CompleteDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10846
eProsima_user_DllExport CompleteDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10875
eProsima_user_DllExport const CompleteUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:10827
eProsima_user_DllExport void header(CompleteUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:10817
eProsima_user_DllExport void header(const CompleteUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:10807
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10788
eProsima_user_DllExport CompleteUnionType(const CompleteUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10681
eProsima_user_DllExport void member_seq(const CompleteUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10885
eProsima_user_DllExport CompleteUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:10836
This class represents the structure Dummy defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2712
eProsima_user_DllExport bool operator!=(const Dummy &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2790
eProsima_user_DllExport Dummy()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2718
eProsima_user_DllExport Dummy & operator=(const Dummy &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2753
eProsima_user_DllExport Dummy(Dummy &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2743
eProsima_user_DllExport ~Dummy()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2725
eProsima_user_DllExport Dummy(const Dummy &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2733
eProsima_user_DllExport bool operator==(const Dummy &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2779
This class represents the structure ExtendedAnnotationParameterValue defined by the user in the IDL f...
Definition dds_xtypes_typeobject.hpp:4184
eProsima_user_DllExport ExtendedAnnotationParameterValue(ExtendedAnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4215
eProsima_user_DllExport bool operator==(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4251
eProsima_user_DllExport ExtendedAnnotationParameterValue & operator=(const ExtendedAnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4225
eProsima_user_DllExport bool operator!=(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4262
eProsima_user_DllExport ExtendedAnnotationParameterValue(const ExtendedAnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4205
eProsima_user_DllExport ExtendedAnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4190
eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4197
This class represents the structure ExtendedTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2617
eProsima_user_DllExport ExtendedTypeDefn(const ExtendedTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2638
eProsima_user_DllExport bool operator!=(const ExtendedTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2695
eProsima_user_DllExport ~ExtendedTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2630
eProsima_user_DllExport ExtendedTypeDefn(ExtendedTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2648
eProsima_user_DllExport bool operator==(const ExtendedTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2684
eProsima_user_DllExport ExtendedTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2623
eProsima_user_DllExport ExtendedTypeDefn & operator=(const ExtendedTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2658
This class represents the structure MinimalAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12935
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:13042
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:13022
eProsima_user_DllExport MinimalAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12941
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:13032
eProsima_user_DllExport MinimalAliasBody(MinimalAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12967
eProsima_user_DllExport bool operator==(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13002
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:13051
eProsima_user_DllExport ~MinimalAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12948
eProsima_user_DllExport MinimalAliasBody(const MinimalAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12956
eProsima_user_DllExport MinimalAliasBody & operator=(const MinimalAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12977
eProsima_user_DllExport bool operator!=(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13012
This class represents the structure MinimalAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13201
eProsima_user_DllExport MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13242
eProsima_user_DllExport MinimalAliasHeader(const MinimalAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13222
eProsima_user_DllExport MinimalAliasHeader(MinimalAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13232
eProsima_user_DllExport ~MinimalAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13214
eProsima_user_DllExport bool operator==(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13268
eProsima_user_DllExport bool operator!=(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13279
eProsima_user_DllExport MinimalAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13207
This class represents the structure MinimalAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13523
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13644
eProsima_user_DllExport MinimalAliasType & operator=(const MinimalAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13571
eProsima_user_DllExport MinimalAliasType(const MinimalAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13544
eProsima_user_DllExport void body(const MinimalAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13702
eProsima_user_DllExport MinimalAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13529
eProsima_user_DllExport void header(const MinimalAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13663
eProsima_user_DllExport void header(MinimalAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13673
eProsima_user_DllExport MinimalAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13731
eProsima_user_DllExport bool operator==(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13602
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13624
eProsima_user_DllExport bool operator!=(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13614
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13634
eProsima_user_DllExport ~MinimalAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13536
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13653
eProsima_user_DllExport void body(MinimalAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13712
eProsima_user_DllExport const MinimalAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13722
eProsima_user_DllExport const MinimalAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13683
eProsima_user_DllExport MinimalAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13692
eProsima_user_DllExport MinimalAliasType(MinimalAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13559
This class represents the structure MinimalAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11979
eProsima_user_DllExport MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12020
eProsima_user_DllExport MinimalAnnotationHeader(MinimalAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12010
eProsima_user_DllExport MinimalAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11985
eProsima_user_DllExport bool operator!=(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12057
eProsima_user_DllExport ~MinimalAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11992
eProsima_user_DllExport MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12000
eProsima_user_DllExport bool operator==(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12046
This class represents the structure MinimalAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11617
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11738
eProsima_user_DllExport bool operator!=(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11708
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11718
eProsima_user_DllExport bool operator==(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11696
eProsima_user_DllExport MinimalAnnotationParameter(MinimalAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11653
eProsima_user_DllExport MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11665
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11816
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11757
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11728
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11747
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11825
eProsima_user_DllExport ~MinimalAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11630
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11806
eProsima_user_DllExport MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11638
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11796
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11777
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11767
eProsima_user_DllExport MinimalAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11623
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11786
This class represents the structure MinimalAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12301
eProsima_user_DllExport MinimalAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12470
eProsima_user_DllExport void header(MinimalAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12451
eProsima_user_DllExport MinimalAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12509
eProsima_user_DllExport ~MinimalAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12314
eProsima_user_DllExport MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12349
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12431
eProsima_user_DllExport MinimalAnnotationType(MinimalAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12337
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12412
eProsima_user_DllExport const MinimalAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12461
eProsima_user_DllExport bool operator==(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12380
eProsima_user_DllExport MinimalAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12307
eProsima_user_DllExport MinimalAnnotationType(const MinimalAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12322
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12402
eProsima_user_DllExport void header(const MinimalAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12441
eProsima_user_DllExport void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12490
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12422
eProsima_user_DllExport void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12480
eProsima_user_DllExport bool operator!=(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12392
eProsima_user_DllExport const MinimalAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12500
This class represents the structure MinimalArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15626
eProsima_user_DllExport MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15668
eProsima_user_DllExport ~MinimalArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15639
eProsima_user_DllExport bool operator==(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15693
eProsima_user_DllExport MinimalArrayHeader(MinimalArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15658
eProsima_user_DllExport MinimalArrayHeader(const MinimalArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15647
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15723
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15742
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15733
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15713
eProsima_user_DllExport MinimalArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15632
eProsima_user_DllExport bool operator!=(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15703
This class represents the structure MinimalArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15986
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16097
eProsima_user_DllExport void header(MinimalArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16136
eProsima_user_DllExport bool operator==(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16065
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16175
eProsima_user_DllExport void header(const MinimalArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16126
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16185
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16116
eProsima_user_DllExport const MinimalArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16146
eProsima_user_DllExport ~MinimalArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15999
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16087
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16165
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16107
eProsima_user_DllExport MinimalArrayType(MinimalArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16022
eProsima_user_DllExport bool operator!=(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16077
eProsima_user_DllExport MinimalArrayType & operator=(const MinimalArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16034
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16194
eProsima_user_DllExport MinimalArrayType(const MinimalArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16007
eProsima_user_DllExport MinimalArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15992
eProsima_user_DllExport MinimalArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16155
This class represents the structure MinimalBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19728
eProsima_user_DllExport MinimalBitfield(const MinimalBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19749
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19851
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19842
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19861
eProsima_user_DllExport bool operator!=(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19812
eProsima_user_DllExport MinimalBitfield & operator=(const MinimalBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19773
eProsima_user_DllExport MinimalBitfield(MinimalBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19762
eProsima_user_DllExport ~MinimalBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19741
eProsima_user_DllExport bool operator==(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19801
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19822
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19832
eProsima_user_DllExport MinimalBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19734
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19881
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19871
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19890
This class represents the structure MinimalBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18539
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18672
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18662
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18692
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18701
eProsima_user_DllExport MinimalBitflag(MinimalBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18573
eProsima_user_DllExport ~MinimalBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18552
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18633
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18643
eProsima_user_DllExport bool operator!=(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18623
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18653
eProsima_user_DllExport MinimalBitflag(const MinimalBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18560
eProsima_user_DllExport bool operator==(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18612
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18682
eProsima_user_DllExport MinimalBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18545
eProsima_user_DllExport MinimalBitflag & operator=(const MinimalBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18584
This class represents the structure MinimalBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19075
eProsima_user_DllExport void header(const MinimalBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:19215
eProsima_user_DllExport ~MinimalBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19088
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19196
eProsima_user_DllExport MinimalBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19244
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19176
eProsima_user_DllExport MinimalBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19081
eProsima_user_DllExport const MinimalBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19274
eProsima_user_DllExport MinimalBitmaskType(MinimalBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19111
eProsima_user_DllExport void flag_seq(MinimalBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19264
eProsima_user_DllExport bool operator==(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19154
eProsima_user_DllExport MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19123
eProsima_user_DllExport void header(MinimalBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:19225
eProsima_user_DllExport void flag_seq(const MinimalBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19254
eProsima_user_DllExport MinimalBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19283
eProsima_user_DllExport bool operator!=(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19166
eProsima_user_DllExport MinimalBitmaskType(const MinimalBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19096
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19205
eProsima_user_DllExport const MinimalBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19235
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19186
This class represents the structure MinimalBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20043
eProsima_user_DllExport MinimalBitsetHeader(MinimalBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20074
eProsima_user_DllExport MinimalBitsetHeader(const MinimalBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20064
eProsima_user_DllExport ~MinimalBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20056
eProsima_user_DllExport bool operator!=(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20121
eProsima_user_DllExport MinimalBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20049
eProsima_user_DllExport MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20084
eProsima_user_DllExport bool operator==(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20110
This class represents the structure MinimalBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20365
eProsima_user_DllExport MinimalBitsetType(MinimalBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20401
eProsima_user_DllExport ~MinimalBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20378
eProsima_user_DllExport void field_seq(const MinimalBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20544
eProsima_user_DllExport void header(const MinimalBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20505
eProsima_user_DllExport void field_seq(MinimalBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20554
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20466
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20486
eProsima_user_DllExport bool operator==(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20444
eProsima_user_DllExport MinimalBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20371
eProsima_user_DllExport MinimalBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20573
eProsima_user_DllExport const MinimalBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20564
eProsima_user_DllExport MinimalBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20534
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20476
eProsima_user_DllExport const MinimalBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20525
eProsima_user_DllExport MinimalBitsetType & operator=(const MinimalBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20413
eProsima_user_DllExport MinimalBitsetType(const MinimalBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20386
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20495
eProsima_user_DllExport bool operator!=(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20456
eProsima_user_DllExport void header(MinimalBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20515
This class represents the structure MinimalCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14290
eProsima_user_DllExport MinimalCollectionElement(MinimalCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14322
eProsima_user_DllExport MinimalCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14296
eProsima_user_DllExport bool operator!=(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14367
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14377
eProsima_user_DllExport MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14332
eProsima_user_DllExport MinimalCollectionElement(const MinimalCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14311
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14397
eProsima_user_DllExport bool operator==(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14357
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14406
eProsima_user_DllExport ~MinimalCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14303
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14387
This class represents the structure MinimalCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14726
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14842
eProsima_user_DllExport MinimalCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14732
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14833
eProsima_user_DllExport bool operator==(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14793
eProsima_user_DllExport bool operator!=(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14803
eProsima_user_DllExport ~MinimalCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14739
eProsima_user_DllExport MinimalCollectionHeader(MinimalCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14758
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14813
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14823
eProsima_user_DllExport MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14768
eProsima_user_DllExport MinimalCollectionHeader(const MinimalCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14747
This class represents the structure MinimalDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10261
eProsima_user_DllExport MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10282
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10377
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10368
eProsima_user_DllExport MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10303
eProsima_user_DllExport bool operator==(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10328
eProsima_user_DllExport ~MinimalDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10274
eProsima_user_DllExport MinimalDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10267
eProsima_user_DllExport bool operator!=(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10338
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10358
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10348
eProsima_user_DllExport MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10293
This class represents the structure MinimalEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17600
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17716
eProsima_user_DllExport MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17632
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17707
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17677
eProsima_user_DllExport ~MinimalEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17613
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17687
eProsima_user_DllExport MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17621
eProsima_user_DllExport MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17642
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17697
eProsima_user_DllExport bool operator==(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17667
eProsima_user_DllExport MinimalEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17606
This class represents the structure MinimalEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17115
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17248
eProsima_user_DllExport MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17160
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17268
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17277
eProsima_user_DllExport bool operator==(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17188
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17229
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17238
eProsima_user_DllExport ~MinimalEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17128
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17258
eProsima_user_DllExport MinimalEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17121
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17199
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17209
eProsima_user_DllExport MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17136
eProsima_user_DllExport MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17149
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17219
This class represents the structure MinimalEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17960
eProsima_user_DllExport MinimalEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:18129
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18090
eProsima_user_DllExport MinimalEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18168
eProsima_user_DllExport MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18008
eProsima_user_DllExport MinimalEnumeratedType(MinimalEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17996
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18061
eProsima_user_DllExport bool operator==(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18039
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18051
eProsima_user_DllExport void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18149
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18071
eProsima_user_DllExport void header(MinimalEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:18110
eProsima_user_DllExport void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18139
eProsima_user_DllExport ~MinimalEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17973
eProsima_user_DllExport void header(const MinimalEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:18100
eProsima_user_DllExport const MinimalEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18159
eProsima_user_DllExport MinimalEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17966
eProsima_user_DllExport const MinimalEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:18120
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18081
eProsima_user_DllExport MinimalEnumeratedType(const MinimalEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17981
This class represents the structure MinimalExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:21941
eProsima_user_DllExport MinimalExtendedType & operator=(const MinimalExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:21982
eProsima_user_DllExport bool operator==(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22008
eProsima_user_DllExport bool operator!=(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22019
eProsima_user_DllExport MinimalExtendedType(MinimalExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:21972
eProsima_user_DllExport MinimalExtendedType(const MinimalExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:21962
eProsima_user_DllExport MinimalExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:21947
eProsima_user_DllExport ~MinimalExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:21954
This class represents the structure MinimalMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16487
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16605
eProsima_user_DllExport bool operator!=(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16585
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16663
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16722
eProsima_user_DllExport void key(const MinimalCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16673
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16732
eProsima_user_DllExport MinimalCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16702
eProsima_user_DllExport ~MinimalMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16500
eProsima_user_DllExport MinimalMapType(MinimalMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16525
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16654
eProsima_user_DllExport void key(MinimalCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16683
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16624
eProsima_user_DllExport MinimalMapType(const MinimalMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16508
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16595
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16712
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16634
eProsima_user_DllExport MinimalMapType & operator=(const MinimalMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16538
eProsima_user_DllExport MinimalMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16493
eProsima_user_DllExport const MinimalCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16693
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16615
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16741
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16644
eProsima_user_DllExport bool operator==(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16572
This class represents the structure MinimalMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7458
eProsima_user_DllExport bool operator==(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7525
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7545
eProsima_user_DllExport ~MinimalMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7471
eProsima_user_DllExport MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7500
eProsima_user_DllExport bool operator!=(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7535
eProsima_user_DllExport MinimalMemberDetail(const MinimalMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7479
eProsima_user_DllExport MinimalMemberDetail(MinimalMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7490
eProsima_user_DllExport MinimalMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7464
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7565
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7555
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7574
This class represents the structure MinimalSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15086
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15197
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15255
eProsima_user_DllExport MinimalSequenceType(const MinimalSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15107
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15275
eProsima_user_DllExport bool operator!=(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15177
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15285
eProsima_user_DllExport MinimalSequenceType(MinimalSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15122
eProsima_user_DllExport MinimalSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15092
eProsima_user_DllExport bool operator==(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15165
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15246
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15216
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15187
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15265
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15226
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15207
eProsima_user_DllExport MinimalSequenceType & operator=(const MinimalSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15134
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15294
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15236
eProsima_user_DllExport ~MinimalSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15099
This class represents the structure MinimalStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8590
eProsima_user_DllExport bool operator==(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8663
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8752
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8723
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8694
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8743
eProsima_user_DllExport ~MinimalStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8603
eProsima_user_DllExport bool operator!=(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8674
eProsima_user_DllExport MinimalStructHeader & operator=(const MinimalStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8635
eProsima_user_DllExport MinimalStructHeader(const MinimalStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8611
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8684
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8713
eProsima_user_DllExport MinimalStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8596
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8704
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8733
eProsima_user_DllExport MinimalStructHeader(MinimalStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8624
This class represents the structure MinimalStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7773
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7906
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7926
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7935
eProsima_user_DllExport MinimalStructMember(MinimalStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7807
eProsima_user_DllExport MinimalStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7779
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7867
eProsima_user_DllExport MinimalStructMember & operator=(const MinimalStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7818
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7896
eProsima_user_DllExport MinimalStructMember(const MinimalStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7794
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7916
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7887
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7877
eProsima_user_DllExport ~MinimalStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7786
eProsima_user_DllExport bool operator==(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7846
eProsima_user_DllExport bool operator!=(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7857
This class represents the structure MinimalStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8997
eProsima_user_DllExport void header(const MinimalStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:9137
eProsima_user_DllExport const MinimalStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9196
eProsima_user_DllExport void header(MinimalStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:9147
eProsima_user_DllExport MinimalStructType & operator=(const MinimalStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9045
eProsima_user_DllExport MinimalStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9003
eProsima_user_DllExport MinimalStructType(const MinimalStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9018
eProsima_user_DllExport MinimalStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9205
eProsima_user_DllExport ~MinimalStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9010
eProsima_user_DllExport void member_seq(MinimalStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9186
eProsima_user_DllExport bool operator!=(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9088
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9108
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9098
eProsima_user_DllExport bool operator==(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9076
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9118
eProsima_user_DllExport const MinimalStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:9157
eProsima_user_DllExport MinimalStructType(MinimalStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9033
eProsima_user_DllExport void member_seq(const MinimalStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9176
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9127
eProsima_user_DllExport MinimalStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:9166
This class represents the structure MinimalTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8088
eProsima_user_DllExport bool operator!=(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8166
eProsima_user_DllExport MinimalTypeDetail(const MinimalTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8109
eProsima_user_DllExport MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8129
eProsima_user_DllExport MinimalTypeDetail(MinimalTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8119
eProsima_user_DllExport MinimalTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8094
eProsima_user_DllExport bool operator==(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8155
eProsima_user_DllExport ~MinimalTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8101
This class represents the union MinimalTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:22036
eProsima_user_DllExport MinimalStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22627
eProsima_user_DllExport void union_type(const MinimalUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22642
eProsima_user_DllExport const MinimalEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22930
eProsima_user_DllExport MinimalTypeObject & operator=(const MinimalTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:22181
eProsima_user_DllExport void bitmask_type(MinimalBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22971
MinimalExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:23278
eProsima_user_DllExport bool operator==(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22301
MinimalEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:23276
eProsima_user_DllExport void bitset_type(MinimalBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22706
eProsima_user_DllExport void bitmask_type(const MinimalBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22960
MinimalUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:23271
eProsima_user_DllExport void alias_type(const MinimalAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22483
MinimalAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:23268
eProsima_user_DllExport MinimalExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23051
eProsima_user_DllExport MinimalBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22733
eProsima_user_DllExport void enumerated_type(MinimalEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22918
eProsima_user_DllExport MinimalSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22786
eProsima_user_DllExport const MinimalExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23036
eProsima_user_DllExport void extended_type(MinimalExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23024
eProsima_user_DllExport void map_type(const MinimalMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22854
eProsima_user_DllExport const MinimalArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22824
eProsima_user_DllExport void array_type(MinimalArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22812
eProsima_user_DllExport MinimalAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22521
eProsima_user_DllExport const MinimalUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22665
eProsima_user_DllExport const MinimalStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22612
eProsima_user_DllExport MinimalTypeObject(const MinimalTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:22065
eProsima_user_DllExport MinimalTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:22042
eProsima_user_DllExport void sequence_type(MinimalSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22759
MinimalAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:23269
eProsima_user_DllExport MinimalEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22945
eProsima_user_DllExport void enumerated_type(const MinimalEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22907
eProsima_user_DllExport MinimalBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22998
eProsima_user_DllExport void extended_type(const MinimalExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23013
eProsima_user_DllExport const MinimalBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22983
eProsima_user_DllExport MinimalAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22574
MinimalArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:23274
eProsima_user_DllExport void sequence_type(const MinimalSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22748
eProsima_user_DllExport const MinimalAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22506
eProsima_user_DllExport void annotation_type(MinimalAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22547
eProsima_user_DllExport void annotation_type(const MinimalAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22536
eProsima_user_DllExport void union_type(MinimalUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22653
eProsima_user_DllExport const MinimalSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22771
eProsima_user_DllExport void alias_type(MinimalAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22494
eProsima_user_DllExport void struct_type(MinimalStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22600
eProsima_user_DllExport MinimalUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22680
eProsima_user_DllExport void map_type(MinimalMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22865
eProsima_user_DllExport const MinimalAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22559
eProsima_user_DllExport void struct_type(const MinimalStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22589
MinimalMapType m_map_type
Definition dds_xtypes_typeobject.hpp:23275
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:22376
eProsima_user_DllExport MinimalTypeObject(MinimalTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:22123
eProsima_user_DllExport const MinimalBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22718
eProsima_user_DllExport MinimalArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22839
MinimalBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:23277
eProsima_user_DllExport void bitset_type(const MinimalBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22695
eProsima_user_DllExport MinimalMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:22892
eProsima_user_DllExport const MinimalMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:22877
eProsima_user_DllExport ~MinimalTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:22053
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:22474
MinimalStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:23270
eProsima_user_DllExport void array_type(const MinimalArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22801
MinimalBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:23272
MinimalSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:23273
eProsima_user_DllExport bool operator!=(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22365
This class represents the structure MinimalUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10527
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10643
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10614
eProsima_user_DllExport MinimalUnionHeader(MinimalUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10559
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10634
eProsima_user_DllExport MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10569
eProsima_user_DllExport bool operator!=(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10604
eProsima_user_DllExport MinimalUnionHeader(const MinimalUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10548
eProsima_user_DllExport MinimalUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10533
eProsima_user_DllExport ~MinimalUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10540
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10624
eProsima_user_DllExport bool operator==(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10594
This class represents the structure MinimalUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9672
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9805
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9825
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9834
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9766
eProsima_user_DllExport MinimalUnionMember & operator=(const MinimalUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9717
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9776
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9795
eProsima_user_DllExport bool operator!=(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9756
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9786
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9815
eProsima_user_DllExport ~MinimalUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9685
eProsima_user_DllExport MinimalUnionMember(const MinimalUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9693
eProsima_user_DllExport bool operator==(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9745
eProsima_user_DllExport MinimalUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9678
eProsima_user_DllExport MinimalUnionMember(MinimalUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9706
This class represents the structure MinimalUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10934
eProsima_user_DllExport void discriminator(MinimalDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11130
eProsima_user_DllExport MinimalDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11149
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11052
eProsima_user_DllExport MinimalUnionType(const MinimalUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10955
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11042
eProsima_user_DllExport void header(const MinimalUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:11081
eProsima_user_DllExport MinimalUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10940
eProsima_user_DllExport const MinimalDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11140
eProsima_user_DllExport void discriminator(const MinimalDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11120
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11071
eProsima_user_DllExport MinimalUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11188
eProsima_user_DllExport ~MinimalUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10947
eProsima_user_DllExport MinimalUnionType(MinimalUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10972
eProsima_user_DllExport bool operator!=(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11032
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11062
eProsima_user_DllExport void header(MinimalUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:11091
eProsima_user_DllExport void member_seq(MinimalUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11169
eProsima_user_DllExport MinimalUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:11110
eProsima_user_DllExport void member_seq(const MinimalUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11159
eProsima_user_DllExport const MinimalUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11179
eProsima_user_DllExport MinimalUnionType & operator=(const MinimalUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10985
eProsima_user_DllExport const MinimalUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:11101
eProsima_user_DllExport bool operator==(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11019
This class represents the structure PlainArrayLElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1561
eProsima_user_DllExport LBoundSeq & array_bound_seq()
This function returns a reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1730
eProsima_user_DllExport PlainArrayLElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1567
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:1740
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:1760
eProsima_user_DllExport PlainArrayLElemDefn(const PlainArrayLElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1582
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:1750
eProsima_user_DllExport ~PlainArrayLElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1574
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1672
eProsima_user_DllExport bool operator!=(const PlainArrayLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1652
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1682
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:1721
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1662
eProsima_user_DllExport PlainArrayLElemDefn(PlainArrayLElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1597
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:1711
eProsima_user_DllExport bool operator==(const PlainArrayLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1640
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1691
eProsima_user_DllExport PlainArrayLElemDefn & operator=(const PlainArrayLElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1609
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:1701
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1769
This class represents the structure PlainArraySElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1334
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:1474
eProsima_user_DllExport ~PlainArraySElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1347
eProsima_user_DllExport PlainArraySElemDefn(PlainArraySElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1370
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:1513
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:1533
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:1523
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:1484
eProsima_user_DllExport bool operator==(const PlainArraySElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1413
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1445
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1455
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1435
eProsima_user_DllExport SBoundSeq & array_bound_seq()
This function returns a reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1503
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1464
eProsima_user_DllExport PlainArraySElemDefn & operator=(const PlainArraySElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1382
eProsima_user_DllExport PlainArraySElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1340
eProsima_user_DllExport bool operator!=(const PlainArraySElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1425
eProsima_user_DllExport PlainArraySElemDefn(const PlainArraySElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1355
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1542
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:1494
This class represents the structure PlainCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:730
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:882
eProsima_user_DllExport PlainCollectionHeader(const PlainCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:751
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:863
eProsima_user_DllExport PlainCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:736
eProsima_user_DllExport EquivalenceKind & equiv_kind()
This function returns a reference to member equiv_kind.
Definition dds_xtypes_typeobject.hpp:843
eProsima_user_DllExport ~PlainCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:743
eProsima_user_DllExport PlainCollectionHeader(PlainCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:764
eProsima_user_DllExport EquivalenceKind equiv_kind() const
This function returns the value of member equiv_kind.
Definition dds_xtypes_typeobject.hpp:834
eProsima_user_DllExport void equiv_kind(EquivalenceKind _equiv_kind)
This function sets a value in member equiv_kind.
Definition dds_xtypes_typeobject.hpp:824
eProsima_user_DllExport bool operator==(const PlainCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:803
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:853
eProsima_user_DllExport PlainCollectionHeader & operator=(const PlainCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:775
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:873
eProsima_user_DllExport bool operator!=(const PlainCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:814
This class represents the structure PlainMapLTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2099
eProsima_user_DllExport PlainMapLTypeDefn(PlainMapLTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2139
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:2272
eProsima_user_DllExport CollectionElementFlag & key_flags()
This function returns a reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2350
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:2360
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:2282
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:2302
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:2292
eProsima_user_DllExport bool operator!=(const PlainMapLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2204
eProsima_user_DllExport const CollectionElementFlag & key_flags() const
This function returns a constant reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2341
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:2253
eProsima_user_DllExport PlainMapLTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2105
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & key_identifier()
This function returns a reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2389
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:2224
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:2234
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:2214
eProsima_user_DllExport PlainMapLTypeDefn(const PlainMapLTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2120
eProsima_user_DllExport PlainMapLTypeDefn & operator=(const PlainMapLTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2153
eProsima_user_DllExport void key_flags(const CollectionElementFlag &_key_flags)
This function copies the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2321
eProsima_user_DllExport bool operator==(const PlainMapLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2190
eProsima_user_DllExport ~PlainMapLTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2112
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:2263
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:2370
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:2243
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2311
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:2380
eProsima_user_DllExport void key_flags(CollectionElementFlag &&_key_flags)
This function moves the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2331
This class represents the structure PlainMapSTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1788
eProsima_user_DllExport CollectionElementFlag & key_flags()
This function returns a reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2039
eProsima_user_DllExport PlainMapSTypeDefn(PlainMapSTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1828
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:2049
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:1971
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:1991
eProsima_user_DllExport bool operator==(const PlainMapSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1879
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:1981
eProsima_user_DllExport PlainMapSTypeDefn & operator=(const PlainMapSTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1842
eProsima_user_DllExport const CollectionElementFlag & key_flags() const
This function returns a constant reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2030
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1952
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1942
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & key_identifier()
This function returns a reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2078
eProsima_user_DllExport PlainMapSTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1794
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1913
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1923
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1903
eProsima_user_DllExport void key_flags(const CollectionElementFlag &_key_flags)
This function copies the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2010
eProsima_user_DllExport bool operator!=(const PlainMapSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1893
eProsima_user_DllExport ~PlainMapSTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1801
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:2059
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1932
eProsima_user_DllExport PlainMapSTypeDefn(const PlainMapSTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1809
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1961
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2000
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:2069
eProsima_user_DllExport void key_flags(CollectionElementFlag &&_key_flags)
This function moves the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2020
This class represents the structure PlainSequenceLElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1117
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1276
eProsima_user_DllExport PlainSequenceLElemDefn & operator=(const PlainSequenceLElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1165
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:1286
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:1306
eProsima_user_DllExport PlainSequenceLElemDefn(const PlainSequenceLElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1138
eProsima_user_DllExport ~PlainSequenceLElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1130
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:1296
eProsima_user_DllExport bool operator!=(const PlainSequenceLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1208
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1257
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1228
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1238
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1218
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1267
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1247
eProsima_user_DllExport PlainSequenceLElemDefn(PlainSequenceLElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1153
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1315
eProsima_user_DllExport bool operator==(const PlainSequenceLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1196
eProsima_user_DllExport PlainSequenceLElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1123
This class represents the structure PlainSequenceSElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:900
eProsima_user_DllExport PlainSequenceSElemDefn(const PlainSequenceSElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:921
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:1069
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:1089
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:1079
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1050
eProsima_user_DllExport PlainSequenceSElemDefn & operator=(const PlainSequenceSElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:948
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1040
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1011
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1021
eProsima_user_DllExport bool operator!=(const PlainSequenceSElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:991
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1001
eProsima_user_DllExport PlainSequenceSElemDefn(PlainSequenceSElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:936
eProsima_user_DllExport PlainSequenceSElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:906
eProsima_user_DllExport bool operator==(const PlainSequenceSElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:979
eProsima_user_DllExport ~PlainSequenceSElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:913
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1030
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1059
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1098
This class represents the structure StringLTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:607
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:713
eProsima_user_DllExport ~StringLTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:620
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:694
eProsima_user_DllExport StringLTypeDefn(StringLTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:639
eProsima_user_DllExport StringLTypeDefn & operator=(const StringLTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:649
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:704
eProsima_user_DllExport StringLTypeDefn(const StringLTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:628
eProsima_user_DllExport bool operator==(const StringLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:674
eProsima_user_DllExport bool operator!=(const StringLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:684
eProsima_user_DllExport StringLTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:613
This class represents the structure StringSTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:484
eProsima_user_DllExport StringSTypeDefn & operator=(const StringSTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:526
eProsima_user_DllExport StringSTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:490
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:581
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:571
eProsima_user_DllExport bool operator==(const StringSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:551
eProsima_user_DllExport bool operator!=(const StringSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:561
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:590
eProsima_user_DllExport StringSTypeDefn(const StringSTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:505
eProsima_user_DllExport StringSTypeDefn(StringSTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:516
eProsima_user_DllExport ~StringSTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:497
This class represents the structure StronglyConnectedComponentId defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2410
eProsima_user_DllExport TypeObjectHashId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:2540
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:2521
eProsima_user_DllExport ~StronglyConnectedComponentId()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2423
eProsima_user_DllExport int32_t scc_index() const
This function returns the value of member scc_index.
Definition dds_xtypes_typeobject.hpp:2589
eProsima_user_DllExport bool operator!=(const StronglyConnectedComponentId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2501
eProsima_user_DllExport int32_t & scc_length()
This function returns a reference to member scc_length.
Definition dds_xtypes_typeobject.hpp:2569
eProsima_user_DllExport bool operator==(const StronglyConnectedComponentId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2489
eProsima_user_DllExport StronglyConnectedComponentId(const StronglyConnectedComponentId &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2431
eProsima_user_DllExport StronglyConnectedComponentId()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2416
eProsima_user_DllExport StronglyConnectedComponentId & operator=(const StronglyConnectedComponentId &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2458
eProsima_user_DllExport StronglyConnectedComponentId(StronglyConnectedComponentId &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2446
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:2511
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:2531
eProsima_user_DllExport void scc_index(int32_t _scc_index)
This function sets a value in member scc_index.
Definition dds_xtypes_typeobject.hpp:2579
eProsima_user_DllExport int32_t scc_length() const
This function returns the value of member scc_length.
Definition dds_xtypes_typeobject.hpp:2560
eProsima_user_DllExport int32_t & scc_index()
This function returns a reference to member scc_index.
Definition dds_xtypes_typeobject.hpp:2598
eProsima_user_DllExport void scc_length(int32_t _scc_length)
This function sets a value in member scc_length.
Definition dds_xtypes_typeobject.hpp:2550
This class represents the structure TypeIdentfierWithSize defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24027
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24141
eProsima_user_DllExport bool operator==(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24100
eProsima_user_DllExport bool operator!=(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24111
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24150
eProsima_user_DllExport TypeIdentfierWithSize(TypeIdentfierWithSize &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24061
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24131
eProsima_user_DllExport uint32_t typeobject_serialized_size() const
This function returns the value of member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24170
eProsima_user_DllExport ~TypeIdentfierWithSize()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24040
eProsima_user_DllExport uint32_t & typeobject_serialized_size()
This function returns a reference to member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24179
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:24160
eProsima_user_DllExport TypeIdentfierWithSize & operator=(const TypeIdentfierWithSize &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24072
eProsima_user_DllExport TypeIdentfierWithSize(const TypeIdentfierWithSize &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24048
eProsima_user_DllExport TypeIdentfierWithSize()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24033
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24121
This class represents the union TypeIdentifier defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2807
eProsima_user_DllExport const StringLTypeDefn & string_ldefn() const
This function returns a constant reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3428
eProsima_user_DllExport TypeIdentifier(TypeIdentifier &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2898
Dummy m_no_value
Definition dds_xtypes_typeobject.hpp:4155
eProsima_user_DllExport void equivalence_hash(EquivalenceHash &&_equivalence_hash)
This function moves the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3840
eProsima_user_DllExport const EquivalenceHash & equivalence_hash() const
This function returns a constant reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3852
eProsima_user_DllExport ~TypeIdentifier()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2824
eProsima_user_DllExport PlainMapSTypeDefn & map_sdefn()
This function returns a reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3708
eProsima_user_DllExport void map_ldefn(const PlainMapLTypeDefn &_map_ldefn)
This function copies the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3723
StronglyConnectedComponentId m_sc_component_id
Definition dds_xtypes_typeobject.hpp:4164
eProsima_user_DllExport const PlainMapSTypeDefn & map_sdefn() const
This function returns a constant reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3693
eProsima_user_DllExport StringLTypeDefn & string_ldefn()
This function returns a reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3443
eProsima_user_DllExport void seq_sdefn(PlainSequenceSElemDefn &&_seq_sdefn)
This function moves the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3469
eProsima_user_DllExport void string_sdefn(StringSTypeDefn &&_string_sdefn)
This function moves the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3363
eProsima_user_DllExport void array_ldefn(PlainArrayLElemDefn &&_array_ldefn)
This function moves the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3628
eProsima_user_DllExport bool operator==(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3088
eProsima_user_DllExport const PlainMapLTypeDefn & map_ldefn() const
This function returns a constant reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3746
eProsima_user_DllExport TypeIdentifier & operator=(const TypeIdentifier &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2960
eProsima_user_DllExport void map_ldefn(PlainMapLTypeDefn &&_map_ldefn)
This function moves the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3734
eProsima_user_DllExport void string_ldefn(StringLTypeDefn &&_string_ldefn)
This function moves the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3416
eProsima_user_DllExport void string_ldefn(const StringLTypeDefn &_string_ldefn)
This function copies the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3405
PlainArrayLElemDefn m_array_ldefn
Definition dds_xtypes_typeobject.hpp:4161
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:3776
eProsima_user_DllExport TypeIdentifier(const TypeIdentifier &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2836
eProsima_user_DllExport ExtendedTypeDefn & extended_defn()
This function returns a reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3920
eProsima_user_DllExport void seq_ldefn(const PlainSequenceLElemDefn &_seq_ldefn)
This function copies the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3511
eProsima_user_DllExport void no_value(Dummy &&_no_value)
This function moves the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3310
eProsima_user_DllExport const StringSTypeDefn & string_sdefn() const
This function returns a constant reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3375
StringSTypeDefn m_string_sdefn
Definition dds_xtypes_typeobject.hpp:4156
PlainSequenceSElemDefn m_seq_sdefn
Definition dds_xtypes_typeobject.hpp:4158
eProsima_user_DllExport const PlainArrayLElemDefn & array_ldefn() const
This function returns a constant reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3640
eProsima_user_DllExport const Dummy & no_value() const
This function returns a constant reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3322
ExtendedTypeDefn m_extended_defn
Definition dds_xtypes_typeobject.hpp:4166
eProsima_user_DllExport const PlainSequenceLElemDefn & seq_ldefn() const
This function returns a constant reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3534
eProsima_user_DllExport void array_sdefn(const PlainArraySElemDefn &_array_sdefn)
This function copies the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3564
eProsima_user_DllExport TypeIdentifier()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2813
eProsima_user_DllExport bool operator!=(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3156
eProsima_user_DllExport PlainSequenceLElemDefn & seq_ldefn()
This function returns a reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3549
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:3787
eProsima_user_DllExport const ExtendedTypeDefn & extended_defn() const
This function returns a constant reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3905
eProsima_user_DllExport const PlainSequenceSElemDefn & seq_sdefn() const
This function returns a constant reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3481
eProsima_user_DllExport void map_sdefn(PlainMapSTypeDefn &&_map_sdefn)
This function moves the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3681
PlainSequenceLElemDefn m_seq_ldefn
Definition dds_xtypes_typeobject.hpp:4159
eProsima_user_DllExport void array_ldefn(const PlainArrayLElemDefn &_array_ldefn)
This function copies the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3617
eProsima_user_DllExport EquivalenceHash & equivalence_hash()
This function returns a reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3867
eProsima_user_DllExport StringSTypeDefn & string_sdefn()
This function returns a reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3390
eProsima_user_DllExport const PlainArraySElemDefn & array_sdefn() const
This function returns a constant reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3587
eProsima_user_DllExport PlainArrayLElemDefn & array_ldefn()
This function returns a reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3655
StringLTypeDefn m_string_ldefn
Definition dds_xtypes_typeobject.hpp:4157
eProsima_user_DllExport void extended_defn(ExtendedTypeDefn &&_extended_defn)
This function moves the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3893
PlainArraySElemDefn m_array_sdefn
Definition dds_xtypes_typeobject.hpp:4160
eProsima_user_DllExport void no_value(const Dummy &_no_value)
This function copies the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3299
PlainMapSTypeDefn m_map_sdefn
Definition dds_xtypes_typeobject.hpp:4162
PlainMapLTypeDefn m_map_ldefn
Definition dds_xtypes_typeobject.hpp:4163
eProsima_user_DllExport void seq_sdefn(const PlainSequenceSElemDefn &_seq_sdefn)
This function copies the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3458
eProsima_user_DllExport void string_sdefn(const StringSTypeDefn &_string_sdefn)
This function copies the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3352
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:3167
EquivalenceHash m_equivalence_hash
Definition dds_xtypes_typeobject.hpp:4165
eProsima_user_DllExport void seq_ldefn(PlainSequenceLElemDefn &&_seq_ldefn)
This function moves the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3522
eProsima_user_DllExport PlainMapLTypeDefn & map_ldefn()
This function returns a reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3761
eProsima_user_DllExport void map_sdefn(const PlainMapSTypeDefn &_map_sdefn)
This function copies the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3670
eProsima_user_DllExport void array_sdefn(PlainArraySElemDefn &&_array_sdefn)
This function moves the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3575
eProsima_user_DllExport void extended_defn(const ExtendedTypeDefn &_extended_defn)
This function copies the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3882
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:3799
eProsima_user_DllExport PlainSequenceSElemDefn & seq_sdefn()
This function returns a reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3496
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:3290
eProsima_user_DllExport StronglyConnectedComponentId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3814
eProsima_user_DllExport Dummy & no_value()
This function returns a reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3337
eProsima_user_DllExport PlainArraySElemDefn & array_sdefn()
This function returns a reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3602
eProsima_user_DllExport void equivalence_hash(const EquivalenceHash &_equivalence_hash)
This function copies the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3829
This class represents the structure TypeIdentifierPair defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23845
eProsima_user_DllExport TypeIdentifierPair(TypeIdentifierPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23879
eProsima_user_DllExport TypeIdentifierPair(const TypeIdentifierPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23866
eProsima_user_DllExport void type_identifier1(const TypeIdentifier &_type_identifier1)
This function copies the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23939
eProsima_user_DllExport TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23890
eProsima_user_DllExport void type_identifier2(TypeIdentifier &&_type_identifier2)
This function moves the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23988
eProsima_user_DllExport TypeIdentifier & type_identifier1()
This function returns a reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23968
eProsima_user_DllExport void type_identifier1(TypeIdentifier &&_type_identifier1)
This function moves the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23949
eProsima_user_DllExport const TypeIdentifier & type_identifier2() const
This function returns a constant reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23998
eProsima_user_DllExport bool operator!=(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23929
eProsima_user_DllExport void type_identifier2(const TypeIdentifier &_type_identifier2)
This function copies the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23978
eProsima_user_DllExport TypeIdentifierPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23851
eProsima_user_DllExport const TypeIdentifier & type_identifier1() const
This function returns a constant reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23959
eProsima_user_DllExport ~TypeIdentifierPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23858
eProsima_user_DllExport TypeIdentifier & type_identifier2()
This function returns a reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24007
eProsima_user_DllExport bool operator==(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23918
This class represents the structure TypeIdentifierTypeObjectPair defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23663
eProsima_user_DllExport const TypeObject & type_object() const
This function returns a constant reference to member type_object.
Definition dds_xtypes_typeobject.hpp:23816
eProsima_user_DllExport TypeIdentifierTypeObjectPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23669
eProsima_user_DllExport void type_identifier(TypeIdentifier &&_type_identifier)
This function moves the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23767
eProsima_user_DllExport void type_object(const TypeObject &_type_object)
This function copies the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23796
eProsima_user_DllExport TypeIdentifier & type_identifier()
This function returns a reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23786
eProsima_user_DllExport TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23708
eProsima_user_DllExport bool operator!=(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23747
eProsima_user_DllExport const TypeIdentifier & type_identifier() const
This function returns a constant reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23777
eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23676
eProsima_user_DllExport TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23684
eProsima_user_DllExport TypeObject & type_object()
This function returns a reference to member type_object.
Definition dds_xtypes_typeobject.hpp:23825
eProsima_user_DllExport bool operator==(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23736
eProsima_user_DllExport TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23697
eProsima_user_DllExport void type_identifier(const TypeIdentifier &_type_identifier)
This function copies the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23757
eProsima_user_DllExport void type_object(TypeObject &&_type_object)
This function moves the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23806
This class represents the structure TypeIdentifierWithDependencies defined by the user in the IDL fil...
Definition dds_xtypes_typeobject.hpp:24199
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:24339
eProsima_user_DllExport std::vector< TypeIdentfierWithSize > & dependent_typeids()
This function returns a reference to member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24397
eProsima_user_DllExport TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24220
eProsima_user_DllExport TypeIdentifierWithDependencies()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24205
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:24388
eProsima_user_DllExport TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24247
eProsima_user_DllExport int32_t dependent_typeid_count() const
This function returns the value of member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24349
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:24320
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:24368
eProsima_user_DllExport TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24235
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:24300
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:24378
eProsima_user_DllExport bool operator!=(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24290
eProsima_user_DllExport int32_t & dependent_typeid_count()
This function returns a reference to member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24358
eProsima_user_DllExport ~TypeIdentifierWithDependencies()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24212
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:24310
eProsima_user_DllExport bool operator==(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24278
eProsima_user_DllExport TypeIdentfierWithSize & typeid_with_size()
This function returns a reference to member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24329
This class represents the structure TypeInformation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24418
eProsima_user_DllExport TypeInformation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24424
eProsima_user_DllExport void minimal(TypeIdentifierWithDependencies &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24522
eProsima_user_DllExport bool operator!=(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24502
eProsima_user_DllExport const TypeIdentifierWithDependencies & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24532
eProsima_user_DllExport const TypeIdentifierWithDependencies & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:24571
eProsima_user_DllExport TypeIdentifierWithDependencies & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24541
eProsima_user_DllExport void complete(const TypeIdentifierWithDependencies &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:24551
eProsima_user_DllExport TypeInformation & operator=(const TypeInformation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24463
eProsima_user_DllExport TypeIdentifierWithDependencies & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:24580
eProsima_user_DllExport bool operator==(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24491
eProsima_user_DllExport void minimal(const TypeIdentifierWithDependencies &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24512
eProsima_user_DllExport ~TypeInformation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24431
eProsima_user_DllExport void complete(TypeIdentifierWithDependencies &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:24561
eProsima_user_DllExport TypeInformation(TypeInformation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24452
eProsima_user_DllExport TypeInformation(const TypeInformation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24439
This class represents the union TypeObjectHashId defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:147
eProsima_user_DllExport bool operator!=(const TypeObjectHashId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:272
eProsima_user_DllExport EquivalenceHash & hash()
This function returns a reference to member hash.
Definition dds_xtypes_typeobject.hpp:359
eProsima_user_DllExport const EquivalenceHash & hash() const
This function returns a constant reference to member hash.
Definition dds_xtypes_typeobject.hpp:344
eProsima_user_DllExport TypeObjectHashId(TypeObjectHashId &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:190
eProsima_user_DllExport TypeObjectHashId()
Default constructor.
Definition dds_xtypes_typeobject.hpp:153
void _default()
Definition dds_xtypes_typeobject.hpp:370
eProsima_user_DllExport void hash(const EquivalenceHash &_hash)
This function copies the value in member hash.
Definition dds_xtypes_typeobject.hpp:321
eProsima_user_DllExport ~TypeObjectHashId()
Default destructor.
Definition dds_xtypes_typeobject.hpp:160
eProsima_user_DllExport TypeObjectHashId(const TypeObjectHashId &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:172
eProsima_user_DllExport bool operator==(const TypeObjectHashId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:248
eProsima_user_DllExport void hash(EquivalenceHash &&_hash)
This function moves the value in member hash.
Definition dds_xtypes_typeobject.hpp:332
eProsima_user_DllExport TypeObjectHashId & operator=(const TypeObjectHashId &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:208
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:283
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:312
EquivalenceHash m_hash
Definition dds_xtypes_typeobject.hpp:406
This class represents the union TypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23290
eProsima_user_DllExport const MinimalTypeObject & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23566
eProsima_user_DllExport void complete(CompleteTypeObject &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:23501
eProsima_user_DllExport bool operator!=(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23435
eProsima_user_DllExport TypeObject(const TypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23315
eProsima_user_DllExport CompleteTypeObject & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:23528
eProsima_user_DllExport ~TypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23303
eProsima_user_DllExport TypeObject(TypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23337
eProsima_user_DllExport void minimal(const MinimalTypeObject &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23543
eProsima_user_DllExport MinimalTypeObject & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23581
void _default()
Definition dds_xtypes_typeobject.hpp:23592
eProsima_user_DllExport TypeObject & operator=(const TypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23359
eProsima_user_DllExport const CompleteTypeObject & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:23513
MinimalTypeObject m_minimal
Definition dds_xtypes_typeobject.hpp:23647
eProsima_user_DllExport void minimal(MinimalTypeObject &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23554
CompleteTypeObject m_complete
Definition dds_xtypes_typeobject.hpp:23646
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:23446
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:23481
eProsima_user_DllExport TypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23296
eProsima_user_DllExport void complete(const CompleteTypeObject &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:23490
eProsima_user_DllExport bool operator==(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23407
TypeFlagBits
This enumeration represents the TypeFlag bitflags defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:452
MemberFlagBits
This enumeration represents the MemberFlag bitflags defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:418
@ IS_FINAL
Definition dds_xtypes_typeobject.hpp:453
@ IS_MUTABLE
Definition dds_xtypes_typeobject.hpp:455
@ IS_NESTED
Definition dds_xtypes_typeobject.hpp:456
@ IS_APPENDABLE
Definition dds_xtypes_typeobject.hpp:454
@ IS_AUTOID_HASH
Definition dds_xtypes_typeobject.hpp:457
@ IS_MUST_UNDERSTAND
Definition dds_xtypes_typeobject.hpp:423
@ TRY_CONSTRUCT1
Definition dds_xtypes_typeobject.hpp:419
@ TRY_CONSTRUCT2
Definition dds_xtypes_typeobject.hpp:420
@ IS_KEY
Definition dds_xtypes_typeobject.hpp:424
@ IS_EXTERNAL
Definition dds_xtypes_typeobject.hpp:421
@ IS_DEFAULT
Definition dds_xtypes_typeobject.hpp:425
@ IS_OPTIONAL
Definition dds_xtypes_typeobject.hpp:422
Definition DomainParticipant.hpp:45
MemberFlag BitsetMemberFlag
Definition dds_xtypes_typeobject.hpp:444
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition dds_xtypes_typeobject.hpp:19903
uint32_t MemberId
Definition dds_xtypes_typeobject.hpp:4175
const uint8_t TK_STRING16
Definition dds_xtypes_typeobject.hpp:96
const uint8_t TI_STRONGLY_CONNECTED_COMPONENT
Definition dds_xtypes_typeobject.hpp:119
MemberFlag CollectionElementFlag
Definition dds_xtypes_typeobject.hpp:428
const uint8_t TI_PLAIN_SEQUENCE_SMALL
Definition dds_xtypes_typeobject.hpp:113
std::vector< TypeObject > TypeObjectSeq
Definition dds_xtypes_typeobject.hpp:23654
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition dds_xtypes_typeobject.hpp:24411
const uint8_t TK_CHAR8
Definition dds_xtypes_typeobject.hpp:93
const uint8_t TI_PLAIN_MAP_SMALL
Definition dds_xtypes_typeobject.hpp:117
const uint8_t TI_STRING8_LARGE
Definition dds_xtypes_typeobject.hpp:110
const uint8_t TK_BYTE
Definition dds_xtypes_typeobject.hpp:81
std::vector< CompleteUnionMember > CompleteUnionMemberSeq
Definition dds_xtypes_typeobject.hpp:9665
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition dds_xtypes_typeobject.hpp:6506
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition dds_xtypes_typeobject.hpp:24020
TypeFlag BitsetTypeFlag
Definition dds_xtypes_typeobject.hpp:474
const uint8_t TK_INT8
Definition dds_xtypes_typeobject.hpp:91
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition dds_xtypes_typeobject.hpp:17108
const uint16_t MemberFlagMinimalMask
Definition dds_xtypes_typeobject.hpp:446
const uint8_t TK_UINT16
Definition dds_xtypes_typeobject.hpp:85
TypeFlag CollectionTypeFlag
Definition dds_xtypes_typeobject.hpp:464
const uint8_t TK_UINT32
Definition dds_xtypes_typeobject.hpp:86
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition dds_xtypes_typeobject.hpp:7948
TypeFlag EnumTypeFlag
Definition dds_xtypes_typeobject.hpp:470
std::vector< LBound > LBoundSeq
Definition dds_xtypes_typeobject.hpp:134
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition dds_xtypes_typeobject.hpp:17290
uint32_t LBound
Definition dds_xtypes_typeobject.hpp:132
eprosima::fastcdr::fixed_string< TYPE_NAME_MAX_LENGTH > QualifiedTypeName
Definition dds_xtypes_typeobject.hpp:124
MemberFlag EnumeratedLiteralFlag
Definition dds_xtypes_typeobject.hpp:436
const uint8_t TK_ENUM
Definition dds_xtypes_typeobject.hpp:98
TypeFlag AliasTypeFlag
Definition dds_xtypes_typeobject.hpp:468
const uint16_t TypeFlagMinimalMask
Definition dds_xtypes_typeobject.hpp:476
const uint8_t EK_COMPLETE
Definition dds_xtypes_typeobject.hpp:75
MemberFlag UnionDiscriminatorFlag
Definition dds_xtypes_typeobject.hpp:434
uint8_t EquivalenceKind
Definition dds_xtypes_typeobject.hpp:72
TypeFlag UnionTypeFlag
Definition dds_xtypes_typeobject.hpp:462
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition dds_xtypes_typeobject.hpp:9847
const uint8_t TK_FLOAT64
Definition dds_xtypes_typeobject.hpp:89
const uint8_t TK_UINT8
Definition dds_xtypes_typeobject.hpp:92
const uint8_t TK_UINT64
Definition dds_xtypes_typeobject.hpp:87
std::vector< SBound > SBoundSeq
Definition dds_xtypes_typeobject.hpp:139
const uint8_t TK_NONE
Definition dds_xtypes_typeobject.hpp:79
const uint8_t EK_MINIMAL
Definition dds_xtypes_typeobject.hpp:74
TypeFlag StructTypeFlag
Definition dds_xtypes_typeobject.hpp:460
const uint8_t TI_PLAIN_MAP_LARGE
Definition dds_xtypes_typeobject.hpp:118
std::vector< TypeIdentfierWithSize > TypeIdentfierWithSizeSeq
Definition dds_xtypes_typeobject.hpp:24192
std::vector< AppliedAnnotationParameter > AppliedAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:6324
const uint8_t TK_UNION
Definition dds_xtypes_typeobject.hpp:102
eprosima::fastcdr::fixed_string< MEMBER_NAME_MAX_LENGTH > MemberName
Definition dds_xtypes_typeobject.hpp:121
std::vector< TypeIdentifier > TypeIdentifierSeq
Definition dds_xtypes_typeobject.hpp:4173
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:11839
const uint8_t TI_PLAIN_ARRAY_LARGE
Definition dds_xtypes_typeobject.hpp:116
const uint8_t TK_MAP
Definition dds_xtypes_typeobject.hpp:106
std::vector< MinimalBitflag > MinimalBitflagSeq
Definition dds_xtypes_typeobject.hpp:18714
std::array< uint8_t, 4 > NameHash
Definition dds_xtypes_typeobject.hpp:130
MemberFlag StructMemberFlag
Definition dds_xtypes_typeobject.hpp:430
std::array< uint8_t, 14 > EquivalenceHash
Definition dds_xtypes_typeobject.hpp:128
const uint8_t TK_FLOAT128
Definition dds_xtypes_typeobject.hpp:90
const uint8_t TK_INT32
Definition dds_xtypes_typeobject.hpp:83
std::vector< CompleteBitfield > CompleteBitfieldSeq
Definition dds_xtypes_typeobject.hpp:19721
const uint8_t TK_ARRAY
Definition dds_xtypes_typeobject.hpp:105
TypeFlag BitmaskTypeFlag
Definition dds_xtypes_typeobject.hpp:472
const uint8_t TI_PLAIN_SEQUENCE_LARGE
Definition dds_xtypes_typeobject.hpp:114
const uint32_t ANNOTATION_OCTETSEC_VALUE_MAX_LEN
Definition dds_xtypes_typeobject.hpp:4178
const uint8_t TK_CHAR16
Definition dds_xtypes_typeobject.hpp:94
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18841
std::vector< int32_t > UnionCaseLabelSeq
Definition dds_xtypes_typeobject.hpp:9219
MemberFlag UnionMemberFlag
Definition dds_xtypes_typeobject.hpp:432
TypeFlag AnnotationTypeFlag
Definition dds_xtypes_typeobject.hpp:466
const uint8_t TK_INT16
Definition dds_xtypes_typeobject.hpp:82
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition dds_xtypes_typeobject.hpp:23838
const uint8_t TK_BOOLEAN
Definition dds_xtypes_typeobject.hpp:80
const LBound INVALID_LBOUND
Definition dds_xtypes_typeobject.hpp:136
const SBound INVALID_SBOUND
Definition dds_xtypes_typeobject.hpp:141
const uint8_t TI_STRING16_SMALL
Definition dds_xtypes_typeobject.hpp:111
uint16_t BitBound
Definition dds_xtypes_typeobject.hpp:16756
MemberFlag AliasMemberFlag
Definition dds_xtypes_typeobject.hpp:440
uint8_t TypeIdentiferKind
Definition dds_xtypes_typeobject.hpp:107
const uint32_t ANNOTATION_STR_VALUE_MAX_LEN
Definition dds_xtypes_typeobject.hpp:4177
const uint8_t TK_ALIAS
Definition dds_xtypes_typeobject.hpp:97
uint8_t PrimitiveTypeId
Definition dds_xtypes_typeobject.hpp:126
const uint8_t EK_BOTH
Definition dds_xtypes_typeobject.hpp:76
std::vector< TypeInformation > TypeInformationSeq
Definition dds_xtypes_typeobject.hpp:24593
const uint8_t TI_PLAIN_ARRAY_SMALL
Definition dds_xtypes_typeobject.hpp:115
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition dds_xtypes_typeobject.hpp:18532
const uint8_t TK_BITSET
Definition dds_xtypes_typeobject.hpp:103
const uint8_t TK_STRUCTURE
Definition dds_xtypes_typeobject.hpp:101
std::vector< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:11610
MemberFlag BitflagFlag
Definition dds_xtypes_typeobject.hpp:442
const uint8_t TK_SEQUENCE
Definition dds_xtypes_typeobject.hpp:104
const uint8_t TK_FLOAT32
Definition dds_xtypes_typeobject.hpp:88
uint16_t MemberFlag
Definition dds_xtypes_typeobject.hpp:427
const uint8_t TK_ANNOTATION
Definition dds_xtypes_typeobject.hpp:100
const uint8_t TK_STRING8
Definition dds_xtypes_typeobject.hpp:95
MemberFlag AnnotationParameterFlag
Definition dds_xtypes_typeobject.hpp:438
uint16_t TypeFlag
Definition dds_xtypes_typeobject.hpp:459
const uint8_t TK_BITMASK
Definition dds_xtypes_typeobject.hpp:99
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18839
TypeObjectSeq StronglyConnectedComponent
Definition dds_xtypes_typeobject.hpp:23656
const uint8_t TI_STRING16_LARGE
Definition dds_xtypes_typeobject.hpp:112
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition dds_xtypes_typeobject.hpp:7766
const int32_t TYPE_NAME_MAX_LENGTH
Definition dds_xtypes_typeobject.hpp:123
const int32_t MEMBER_NAME_MAX_LENGTH
Definition dds_xtypes_typeobject.hpp:120
const uint8_t TK_INT64
Definition dds_xtypes_typeobject.hpp:84
uint8_t TypeKind
Definition dds_xtypes_typeobject.hpp:77
const uint8_t TI_STRING8_SMALL
Definition dds_xtypes_typeobject.hpp:109
uint8_t SBound
Definition dds_xtypes_typeobject.hpp:137
eProsima namespace.