Fast DDS  Version 3.0.0
Fast DDS
Loading...
Searching...
No Matches
dds_xtypes_typeobject.hpp
1// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
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 no_value_();
2816 }
2817
2821 eProsima_user_DllExport ~TypeIdentifier()
2822 {
2823 if (member_destructor_)
2824 {
2825 member_destructor_();
2826 }
2827 }
2828
2833 eProsima_user_DllExport TypeIdentifier(
2834 const TypeIdentifier& x)
2835 {
2836 m__d = x.m__d;
2837
2838 switch (x.selected_member_)
2839 {
2840 case 0x00000001:
2841 no_value_() = x.m_no_value;
2842 break;
2843
2844 case 0x00000002:
2845 string_sdefn_() = x.m_string_sdefn;
2846 break;
2847
2848 case 0x00000003:
2849 string_ldefn_() = x.m_string_ldefn;
2850 break;
2851
2852 case 0x00000004:
2853 seq_sdefn_() = x.m_seq_sdefn;
2854 break;
2855
2856 case 0x00000005:
2857 seq_ldefn_() = x.m_seq_ldefn;
2858 break;
2859
2860 case 0x00000006:
2861 array_sdefn_() = x.m_array_sdefn;
2862 break;
2863
2864 case 0x00000007:
2865 array_ldefn_() = x.m_array_ldefn;
2866 break;
2867
2868 case 0x00000008:
2869 map_sdefn_() = x.m_map_sdefn;
2870 break;
2871
2872 case 0x00000009:
2873 map_ldefn_() = x.m_map_ldefn;
2874 break;
2875
2876 case 0x0000000a:
2877 sc_component_id_() = x.m_sc_component_id;
2878 break;
2879
2880 case 0x0000000b:
2881 equivalence_hash_() = x.m_equivalence_hash;
2882 break;
2883
2884 case 0x0000000c:
2885 extended_defn_() = x.m_extended_defn;
2886 break;
2887
2888 }
2889 }
2890
2895 eProsima_user_DllExport TypeIdentifier(
2896 TypeIdentifier&& x) noexcept
2897 {
2898 m__d = x.m__d;
2899
2900 switch (x.selected_member_)
2901 {
2902 case 0x00000001:
2903 no_value_() = std::move(x.m_no_value);
2904 break;
2905
2906 case 0x00000002:
2907 string_sdefn_() = std::move(x.m_string_sdefn);
2908 break;
2909
2910 case 0x00000003:
2911 string_ldefn_() = std::move(x.m_string_ldefn);
2912 break;
2913
2914 case 0x00000004:
2915 seq_sdefn_() = std::move(x.m_seq_sdefn);
2916 break;
2917
2918 case 0x00000005:
2919 seq_ldefn_() = std::move(x.m_seq_ldefn);
2920 break;
2921
2922 case 0x00000006:
2923 array_sdefn_() = std::move(x.m_array_sdefn);
2924 break;
2925
2926 case 0x00000007:
2927 array_ldefn_() = std::move(x.m_array_ldefn);
2928 break;
2929
2930 case 0x00000008:
2931 map_sdefn_() = std::move(x.m_map_sdefn);
2932 break;
2933
2934 case 0x00000009:
2935 map_ldefn_() = std::move(x.m_map_ldefn);
2936 break;
2937
2938 case 0x0000000a:
2939 sc_component_id_() = std::move(x.m_sc_component_id);
2940 break;
2941
2942 case 0x0000000b:
2943 equivalence_hash_() = std::move(x.m_equivalence_hash);
2944 break;
2945
2946 case 0x0000000c:
2947 extended_defn_() = std::move(x.m_extended_defn);
2948 break;
2949
2950 }
2951 }
2952
2957 eProsima_user_DllExport TypeIdentifier& operator =(
2958 const TypeIdentifier& x)
2959 {
2960 m__d = x.m__d;
2961
2962 switch (x.selected_member_)
2963 {
2964 case 0x00000001:
2965 no_value_() = x.m_no_value;
2966 break;
2967
2968 case 0x00000002:
2969 string_sdefn_() = x.m_string_sdefn;
2970 break;
2971
2972 case 0x00000003:
2973 string_ldefn_() = x.m_string_ldefn;
2974 break;
2975
2976 case 0x00000004:
2977 seq_sdefn_() = x.m_seq_sdefn;
2978 break;
2979
2980 case 0x00000005:
2981 seq_ldefn_() = x.m_seq_ldefn;
2982 break;
2983
2984 case 0x00000006:
2985 array_sdefn_() = x.m_array_sdefn;
2986 break;
2987
2988 case 0x00000007:
2989 array_ldefn_() = x.m_array_ldefn;
2990 break;
2991
2992 case 0x00000008:
2993 map_sdefn_() = x.m_map_sdefn;
2994 break;
2995
2996 case 0x00000009:
2997 map_ldefn_() = x.m_map_ldefn;
2998 break;
2999
3000 case 0x0000000a:
3001 sc_component_id_() = x.m_sc_component_id;
3002 break;
3003
3004 case 0x0000000b:
3005 equivalence_hash_() = x.m_equivalence_hash;
3006 break;
3007
3008 case 0x0000000c:
3009 extended_defn_() = x.m_extended_defn;
3010 break;
3011
3012 }
3013
3014 return *this;
3015 }
3016
3021 eProsima_user_DllExport TypeIdentifier& operator =(
3022 TypeIdentifier&& x) noexcept
3023 {
3024 m__d = x.m__d;
3025
3026 switch (x.selected_member_)
3027 {
3028 case 0x00000001:
3029 no_value_() = std::move(x.m_no_value);
3030 break;
3031
3032 case 0x00000002:
3033 string_sdefn_() = std::move(x.m_string_sdefn);
3034 break;
3035
3036 case 0x00000003:
3037 string_ldefn_() = std::move(x.m_string_ldefn);
3038 break;
3039
3040 case 0x00000004:
3041 seq_sdefn_() = std::move(x.m_seq_sdefn);
3042 break;
3043
3044 case 0x00000005:
3045 seq_ldefn_() = std::move(x.m_seq_ldefn);
3046 break;
3047
3048 case 0x00000006:
3049 array_sdefn_() = std::move(x.m_array_sdefn);
3050 break;
3051
3052 case 0x00000007:
3053 array_ldefn_() = std::move(x.m_array_ldefn);
3054 break;
3055
3056 case 0x00000008:
3057 map_sdefn_() = std::move(x.m_map_sdefn);
3058 break;
3059
3060 case 0x00000009:
3061 map_ldefn_() = std::move(x.m_map_ldefn);
3062 break;
3063
3064 case 0x0000000a:
3065 sc_component_id_() = std::move(x.m_sc_component_id);
3066 break;
3067
3068 case 0x0000000b:
3069 equivalence_hash_() = std::move(x.m_equivalence_hash);
3070 break;
3071
3072 case 0x0000000c:
3073 extended_defn_() = std::move(x.m_extended_defn);
3074 break;
3075
3076 }
3077
3078 return *this;
3079 }
3080
3085 eProsima_user_DllExport bool operator ==(
3086 const TypeIdentifier& x) const
3087 {
3088 bool ret_value {false};
3089
3090 if (m__d == x.m__d &&
3091 selected_member_ == x.selected_member_)
3092 {
3093 switch (selected_member_)
3094 {
3095 case 0x00000001:
3096 ret_value = (m_no_value == x.m_no_value);
3097 break;
3098
3099 case 0x00000002:
3100 ret_value = (m_string_sdefn == x.m_string_sdefn);
3101 break;
3102
3103 case 0x00000003:
3104 ret_value = (m_string_ldefn == x.m_string_ldefn);
3105 break;
3106
3107 case 0x00000004:
3108 ret_value = (m_seq_sdefn == x.m_seq_sdefn);
3109 break;
3110
3111 case 0x00000005:
3112 ret_value = (m_seq_ldefn == x.m_seq_ldefn);
3113 break;
3114
3115 case 0x00000006:
3116 ret_value = (m_array_sdefn == x.m_array_sdefn);
3117 break;
3118
3119 case 0x00000007:
3120 ret_value = (m_array_ldefn == x.m_array_ldefn);
3121 break;
3122
3123 case 0x00000008:
3124 ret_value = (m_map_sdefn == x.m_map_sdefn);
3125 break;
3126
3127 case 0x00000009:
3128 ret_value = (m_map_ldefn == x.m_map_ldefn);
3129 break;
3130
3131 case 0x0000000a:
3132 ret_value = (m_sc_component_id == x.m_sc_component_id);
3133 break;
3134
3135 case 0x0000000b:
3136 ret_value = (m_equivalence_hash == x.m_equivalence_hash);
3137 break;
3138
3139 case 0x0000000c:
3140 ret_value = (m_extended_defn == x.m_extended_defn);
3141 break;
3142
3143 }
3144 }
3145
3146 return ret_value;
3147 }
3148
3153 eProsima_user_DllExport bool operator !=(
3154 const TypeIdentifier& x) const
3155 {
3156 return !(*this == x);
3157 }
3158
3164 eProsima_user_DllExport void _d(
3165 uint8_t __d)
3166 {
3167 bool valid_discriminator = false;
3168
3169 switch (__d)
3170 {
3171 case TK_NONE:
3172 case TK_BOOLEAN:
3173 case TK_BYTE:
3174 case TK_INT8:
3175 case TK_INT16:
3176 case TK_INT32:
3177 case TK_INT64:
3178 case TK_UINT8:
3179 case TK_UINT16:
3180 case TK_UINT32:
3181 case TK_UINT64:
3182 case TK_FLOAT32:
3183 case TK_FLOAT64:
3184 case TK_FLOAT128:
3185 case TK_CHAR8:
3186 case TK_CHAR16:
3187 if (0x00000001 == selected_member_)
3188 {
3189 valid_discriminator = true;
3190 }
3191 break;
3192
3193 case TI_STRING8_SMALL:
3194 case TI_STRING16_SMALL:
3195 if (0x00000002 == selected_member_)
3196 {
3197 valid_discriminator = true;
3198 }
3199 break;
3200
3201 case TI_STRING8_LARGE:
3202 case TI_STRING16_LARGE:
3203 if (0x00000003 == selected_member_)
3204 {
3205 valid_discriminator = true;
3206 }
3207 break;
3208
3210 if (0x00000004 == selected_member_)
3211 {
3212 valid_discriminator = true;
3213 }
3214 break;
3215
3217 if (0x00000005 == selected_member_)
3218 {
3219 valid_discriminator = true;
3220 }
3221 break;
3222
3224 if (0x00000006 == selected_member_)
3225 {
3226 valid_discriminator = true;
3227 }
3228 break;
3229
3231 if (0x00000007 == selected_member_)
3232 {
3233 valid_discriminator = true;
3234 }
3235 break;
3236
3237 case TI_PLAIN_MAP_SMALL:
3238 if (0x00000008 == selected_member_)
3239 {
3240 valid_discriminator = true;
3241 }
3242 break;
3243
3244 case TI_PLAIN_MAP_LARGE:
3245 if (0x00000009 == selected_member_)
3246 {
3247 valid_discriminator = true;
3248 }
3249 break;
3250
3252 if (0x0000000a == selected_member_)
3253 {
3254 valid_discriminator = true;
3255 }
3256 break;
3257
3258 case EK_COMPLETE:
3259 case EK_MINIMAL:
3260 if (0x0000000b == selected_member_)
3261 {
3262 valid_discriminator = true;
3263 }
3264 break;
3265
3266 default:
3267 if (0x0000000c == selected_member_)
3268 {
3269 valid_discriminator = true;
3270 }
3271 break;
3272
3273 }
3274
3275 if (!valid_discriminator)
3276 {
3277 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
3278 }
3279
3280 m__d = __d;
3281 }
3282
3287 eProsima_user_DllExport uint8_t _d() const
3288 {
3289 return m__d;
3290 }
3291
3296 eProsima_user_DllExport void no_value(
3297 const Dummy& _no_value)
3298 {
3299 no_value_() = _no_value;
3300 m__d = TK_NONE;
3301 }
3302
3307 eProsima_user_DllExport void no_value(
3308 Dummy&& _no_value)
3309 {
3310 no_value_() = _no_value;
3311 m__d = TK_NONE;
3312 }
3313
3319 eProsima_user_DllExport const Dummy& no_value() const
3320 {
3321 if (0x00000001 != selected_member_)
3322 {
3323 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3324 }
3325
3326 return m_no_value;
3327 }
3328
3334 eProsima_user_DllExport Dummy& no_value()
3335 {
3336 if (0x00000001 != selected_member_)
3337 {
3338 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3339 }
3340
3341 return m_no_value;
3342 }
3343
3344
3349 eProsima_user_DllExport void string_sdefn(
3350 const StringSTypeDefn& _string_sdefn)
3351 {
3352 string_sdefn_() = _string_sdefn;
3353 m__d = TI_STRING8_SMALL;
3354 }
3355
3360 eProsima_user_DllExport void string_sdefn(
3361 StringSTypeDefn&& _string_sdefn)
3362 {
3363 string_sdefn_() = _string_sdefn;
3364 m__d = TI_STRING8_SMALL;
3365 }
3366
3372 eProsima_user_DllExport const StringSTypeDefn& string_sdefn() const
3373 {
3374 if (0x00000002 != selected_member_)
3375 {
3376 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3377 }
3378
3379 return m_string_sdefn;
3380 }
3381
3387 eProsima_user_DllExport StringSTypeDefn& string_sdefn()
3388 {
3389 if (0x00000002 != selected_member_)
3390 {
3391 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3392 }
3393
3394 return m_string_sdefn;
3395 }
3396
3397
3402 eProsima_user_DllExport void string_ldefn(
3403 const StringLTypeDefn& _string_ldefn)
3404 {
3405 string_ldefn_() = _string_ldefn;
3406 m__d = TI_STRING8_LARGE;
3407 }
3408
3413 eProsima_user_DllExport void string_ldefn(
3414 StringLTypeDefn&& _string_ldefn)
3415 {
3416 string_ldefn_() = _string_ldefn;
3417 m__d = TI_STRING8_LARGE;
3418 }
3419
3425 eProsima_user_DllExport const StringLTypeDefn& string_ldefn() const
3426 {
3427 if (0x00000003 != selected_member_)
3428 {
3429 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3430 }
3431
3432 return m_string_ldefn;
3433 }
3434
3440 eProsima_user_DllExport StringLTypeDefn& string_ldefn()
3441 {
3442 if (0x00000003 != selected_member_)
3443 {
3444 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3445 }
3446
3447 return m_string_ldefn;
3448 }
3449
3450
3455 eProsima_user_DllExport void seq_sdefn(
3456 const PlainSequenceSElemDefn& _seq_sdefn)
3457 {
3458 seq_sdefn_() = _seq_sdefn;
3460 }
3461
3466 eProsima_user_DllExport void seq_sdefn(
3467 PlainSequenceSElemDefn&& _seq_sdefn)
3468 {
3469 seq_sdefn_() = _seq_sdefn;
3471 }
3472
3478 eProsima_user_DllExport const PlainSequenceSElemDefn& seq_sdefn() const
3479 {
3480 if (0x00000004 != selected_member_)
3481 {
3482 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3483 }
3484
3485 return m_seq_sdefn;
3486 }
3487
3493 eProsima_user_DllExport PlainSequenceSElemDefn& seq_sdefn()
3494 {
3495 if (0x00000004 != selected_member_)
3496 {
3497 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3498 }
3499
3500 return m_seq_sdefn;
3501 }
3502
3503
3508 eProsima_user_DllExport void seq_ldefn(
3509 const PlainSequenceLElemDefn& _seq_ldefn)
3510 {
3511 seq_ldefn_() = _seq_ldefn;
3513 }
3514
3519 eProsima_user_DllExport void seq_ldefn(
3520 PlainSequenceLElemDefn&& _seq_ldefn)
3521 {
3522 seq_ldefn_() = _seq_ldefn;
3524 }
3525
3531 eProsima_user_DllExport const PlainSequenceLElemDefn& seq_ldefn() const
3532 {
3533 if (0x00000005 != selected_member_)
3534 {
3535 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3536 }
3537
3538 return m_seq_ldefn;
3539 }
3540
3546 eProsima_user_DllExport PlainSequenceLElemDefn& seq_ldefn()
3547 {
3548 if (0x00000005 != selected_member_)
3549 {
3550 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3551 }
3552
3553 return m_seq_ldefn;
3554 }
3555
3556
3561 eProsima_user_DllExport void array_sdefn(
3562 const PlainArraySElemDefn& _array_sdefn)
3563 {
3564 array_sdefn_() = _array_sdefn;
3565 m__d = TI_PLAIN_ARRAY_SMALL;
3566 }
3567
3572 eProsima_user_DllExport void array_sdefn(
3573 PlainArraySElemDefn&& _array_sdefn)
3574 {
3575 array_sdefn_() = _array_sdefn;
3576 m__d = TI_PLAIN_ARRAY_SMALL;
3577 }
3578
3584 eProsima_user_DllExport const PlainArraySElemDefn& array_sdefn() const
3585 {
3586 if (0x00000006 != selected_member_)
3587 {
3588 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3589 }
3590
3591 return m_array_sdefn;
3592 }
3593
3599 eProsima_user_DllExport PlainArraySElemDefn& array_sdefn()
3600 {
3601 if (0x00000006 != selected_member_)
3602 {
3603 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3604 }
3605
3606 return m_array_sdefn;
3607 }
3608
3609
3614 eProsima_user_DllExport void array_ldefn(
3615 const PlainArrayLElemDefn& _array_ldefn)
3616 {
3617 array_ldefn_() = _array_ldefn;
3618 m__d = TI_PLAIN_ARRAY_LARGE;
3619 }
3620
3625 eProsima_user_DllExport void array_ldefn(
3626 PlainArrayLElemDefn&& _array_ldefn)
3627 {
3628 array_ldefn_() = _array_ldefn;
3629 m__d = TI_PLAIN_ARRAY_LARGE;
3630 }
3631
3637 eProsima_user_DllExport const PlainArrayLElemDefn& array_ldefn() const
3638 {
3639 if (0x00000007 != selected_member_)
3640 {
3641 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3642 }
3643
3644 return m_array_ldefn;
3645 }
3646
3652 eProsima_user_DllExport PlainArrayLElemDefn& array_ldefn()
3653 {
3654 if (0x00000007 != selected_member_)
3655 {
3656 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3657 }
3658
3659 return m_array_ldefn;
3660 }
3661
3662
3667 eProsima_user_DllExport void map_sdefn(
3668 const PlainMapSTypeDefn& _map_sdefn)
3669 {
3670 map_sdefn_() = _map_sdefn;
3671 m__d = TI_PLAIN_MAP_SMALL;
3672 }
3673
3678 eProsima_user_DllExport void map_sdefn(
3679 PlainMapSTypeDefn&& _map_sdefn)
3680 {
3681 map_sdefn_() = _map_sdefn;
3682 m__d = TI_PLAIN_MAP_SMALL;
3683 }
3684
3690 eProsima_user_DllExport const PlainMapSTypeDefn& map_sdefn() const
3691 {
3692 if (0x00000008 != selected_member_)
3693 {
3694 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3695 }
3696
3697 return m_map_sdefn;
3698 }
3699
3705 eProsima_user_DllExport PlainMapSTypeDefn& map_sdefn()
3706 {
3707 if (0x00000008 != selected_member_)
3708 {
3709 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3710 }
3711
3712 return m_map_sdefn;
3713 }
3714
3715
3720 eProsima_user_DllExport void map_ldefn(
3721 const PlainMapLTypeDefn& _map_ldefn)
3722 {
3723 map_ldefn_() = _map_ldefn;
3724 m__d = TI_PLAIN_MAP_LARGE;
3725 }
3726
3731 eProsima_user_DllExport void map_ldefn(
3732 PlainMapLTypeDefn&& _map_ldefn)
3733 {
3734 map_ldefn_() = _map_ldefn;
3735 m__d = TI_PLAIN_MAP_LARGE;
3736 }
3737
3743 eProsima_user_DllExport const PlainMapLTypeDefn& map_ldefn() const
3744 {
3745 if (0x00000009 != selected_member_)
3746 {
3747 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3748 }
3749
3750 return m_map_ldefn;
3751 }
3752
3758 eProsima_user_DllExport PlainMapLTypeDefn& map_ldefn()
3759 {
3760 if (0x00000009 != selected_member_)
3761 {
3762 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3763 }
3764
3765 return m_map_ldefn;
3766 }
3767
3768
3773 eProsima_user_DllExport void sc_component_id(
3774 const StronglyConnectedComponentId& _sc_component_id)
3775 {
3776 sc_component_id_() = _sc_component_id;
3778 }
3779
3784 eProsima_user_DllExport void sc_component_id(
3785 StronglyConnectedComponentId&& _sc_component_id)
3786 {
3787 sc_component_id_() = _sc_component_id;
3789 }
3790
3796 eProsima_user_DllExport const StronglyConnectedComponentId& sc_component_id() const
3797 {
3798 if (0x0000000a != selected_member_)
3799 {
3800 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3801 }
3802
3803 return m_sc_component_id;
3804 }
3805
3812 {
3813 if (0x0000000a != selected_member_)
3814 {
3815 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3816 }
3817
3818 return m_sc_component_id;
3819 }
3820
3821
3826 eProsima_user_DllExport void equivalence_hash(
3827 const EquivalenceHash& _equivalence_hash)
3828 {
3829 equivalence_hash_() = _equivalence_hash;
3830 m__d = EK_COMPLETE;
3831 }
3832
3837 eProsima_user_DllExport void equivalence_hash(
3838 EquivalenceHash&& _equivalence_hash)
3839 {
3840 equivalence_hash_() = _equivalence_hash;
3841 m__d = EK_COMPLETE;
3842 }
3843
3849 eProsima_user_DllExport const EquivalenceHash& equivalence_hash() const
3850 {
3851 if (0x0000000b != selected_member_)
3852 {
3853 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3854 }
3855
3856 return m_equivalence_hash;
3857 }
3858
3864 eProsima_user_DllExport EquivalenceHash& equivalence_hash()
3865 {
3866 if (0x0000000b != selected_member_)
3867 {
3868 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3869 }
3870
3871 return m_equivalence_hash;
3872 }
3873
3874
3879 eProsima_user_DllExport void extended_defn(
3880 const ExtendedTypeDefn& _extended_defn)
3881 {
3882 extended_defn_() = _extended_defn;
3883 m__d = 127;
3884 }
3885
3890 eProsima_user_DllExport void extended_defn(
3891 ExtendedTypeDefn&& _extended_defn)
3892 {
3893 extended_defn_() = _extended_defn;
3894 m__d = 127;
3895 }
3896
3902 eProsima_user_DllExport const ExtendedTypeDefn& extended_defn() const
3903 {
3904 if (0x0000000c != selected_member_)
3905 {
3906 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3907 }
3908
3909 return m_extended_defn;
3910 }
3911
3917 eProsima_user_DllExport ExtendedTypeDefn& extended_defn()
3918 {
3919 if (0x0000000c != selected_member_)
3920 {
3921 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3922 }
3923
3924 return m_extended_defn;
3925 }
3926
3927
3928
3929private:
3930
3931 Dummy& no_value_()
3932 {
3933 if (0x00000001 != selected_member_)
3934 {
3935 if (member_destructor_)
3936 {
3937 member_destructor_();
3938 }
3939
3940 selected_member_ = 0x00000001;
3941 member_destructor_ = [&]() {m_no_value.~Dummy();};
3942 new(&m_no_value) Dummy();
3943 ;
3944 }
3945
3946 return m_no_value;
3947 }
3948
3949 StringSTypeDefn& string_sdefn_()
3950 {
3951 if (0x00000002 != selected_member_)
3952 {
3953 if (member_destructor_)
3954 {
3955 member_destructor_();
3956 }
3957
3958 selected_member_ = 0x00000002;
3959 member_destructor_ = [&]() {m_string_sdefn.~StringSTypeDefn();};
3960 new(&m_string_sdefn) StringSTypeDefn();
3961 ;
3962 }
3963
3964 return m_string_sdefn;
3965 }
3966
3967 StringLTypeDefn& string_ldefn_()
3968 {
3969 if (0x00000003 != selected_member_)
3970 {
3971 if (member_destructor_)
3972 {
3973 member_destructor_();
3974 }
3975
3976 selected_member_ = 0x00000003;
3977 member_destructor_ = [&]() {m_string_ldefn.~StringLTypeDefn();};
3978 new(&m_string_ldefn) StringLTypeDefn();
3979 ;
3980 }
3981
3982 return m_string_ldefn;
3983 }
3984
3985 PlainSequenceSElemDefn& seq_sdefn_()
3986 {
3987 if (0x00000004 != selected_member_)
3988 {
3989 if (member_destructor_)
3990 {
3991 member_destructor_();
3992 }
3993
3994 selected_member_ = 0x00000004;
3995 member_destructor_ = [&]() {m_seq_sdefn.~PlainSequenceSElemDefn();};
3996 new(&m_seq_sdefn) PlainSequenceSElemDefn();
3997 ;
3998 }
3999
4000 return m_seq_sdefn;
4001 }
4002
4003 PlainSequenceLElemDefn& seq_ldefn_()
4004 {
4005 if (0x00000005 != selected_member_)
4006 {
4007 if (member_destructor_)
4008 {
4009 member_destructor_();
4010 }
4011
4012 selected_member_ = 0x00000005;
4013 member_destructor_ = [&]() {m_seq_ldefn.~PlainSequenceLElemDefn();};
4014 new(&m_seq_ldefn) PlainSequenceLElemDefn();
4015 ;
4016 }
4017
4018 return m_seq_ldefn;
4019 }
4020
4021 PlainArraySElemDefn& array_sdefn_()
4022 {
4023 if (0x00000006 != selected_member_)
4024 {
4025 if (member_destructor_)
4026 {
4027 member_destructor_();
4028 }
4029
4030 selected_member_ = 0x00000006;
4031 member_destructor_ = [&]() {m_array_sdefn.~PlainArraySElemDefn();};
4032 new(&m_array_sdefn) PlainArraySElemDefn();
4033 ;
4034 }
4035
4036 return m_array_sdefn;
4037 }
4038
4039 PlainArrayLElemDefn& array_ldefn_()
4040 {
4041 if (0x00000007 != selected_member_)
4042 {
4043 if (member_destructor_)
4044 {
4045 member_destructor_();
4046 }
4047
4048 selected_member_ = 0x00000007;
4049 member_destructor_ = [&]() {m_array_ldefn.~PlainArrayLElemDefn();};
4050 new(&m_array_ldefn) PlainArrayLElemDefn();
4051 ;
4052 }
4053
4054 return m_array_ldefn;
4055 }
4056
4057 PlainMapSTypeDefn& map_sdefn_()
4058 {
4059 if (0x00000008 != selected_member_)
4060 {
4061 if (member_destructor_)
4062 {
4063 member_destructor_();
4064 }
4065
4066 selected_member_ = 0x00000008;
4067 member_destructor_ = [&]() {m_map_sdefn.~PlainMapSTypeDefn();};
4068 new(&m_map_sdefn) PlainMapSTypeDefn();
4069 ;
4070 }
4071
4072 return m_map_sdefn;
4073 }
4074
4075 PlainMapLTypeDefn& map_ldefn_()
4076 {
4077 if (0x00000009 != selected_member_)
4078 {
4079 if (member_destructor_)
4080 {
4081 member_destructor_();
4082 }
4083
4084 selected_member_ = 0x00000009;
4085 member_destructor_ = [&]() {m_map_ldefn.~PlainMapLTypeDefn();};
4086 new(&m_map_ldefn) PlainMapLTypeDefn();
4087 ;
4088 }
4089
4090 return m_map_ldefn;
4091 }
4092
4093 StronglyConnectedComponentId& sc_component_id_()
4094 {
4095 if (0x0000000a != selected_member_)
4096 {
4097 if (member_destructor_)
4098 {
4099 member_destructor_();
4100 }
4101
4102 selected_member_ = 0x0000000a;
4103 member_destructor_ = [&]() {m_sc_component_id.~StronglyConnectedComponentId();};
4104 new(&m_sc_component_id) StronglyConnectedComponentId();
4105 ;
4106 }
4107
4108 return m_sc_component_id;
4109 }
4110
4111 EquivalenceHash& equivalence_hash_()
4112 {
4113 if (0x0000000b != selected_member_)
4114 {
4115 if (member_destructor_)
4116 {
4117 member_destructor_();
4118 }
4119
4120 selected_member_ = 0x0000000b;
4121 member_destructor_ = [&]() {m_equivalence_hash.~EquivalenceHash();};
4123 ;
4124 }
4125
4126 return m_equivalence_hash;
4127 }
4128
4129 ExtendedTypeDefn& extended_defn_()
4130 {
4131 if (0x0000000c != selected_member_)
4132 {
4133 if (member_destructor_)
4134 {
4135 member_destructor_();
4136 }
4137
4138 selected_member_ = 0x0000000c;
4139 member_destructor_ = [&]() {m_extended_defn.~ExtendedTypeDefn();};
4140 new(&m_extended_defn) ExtendedTypeDefn();
4141 ;
4142 }
4143
4144 return m_extended_defn;
4145 }
4146
4147
4148 uint8_t m__d {TK_NONE};
4149
4150 union
4151 {
4164 };
4165
4166 uint32_t selected_member_ {0x0FFFFFFFu};
4167
4168 std::function<void()> member_destructor_;
4169};
4170typedef std::vector<TypeIdentifier> TypeIdentifierSeq;
4171
4172typedef uint32_t MemberId;
4173
4174const uint32_t ANNOTATION_STR_VALUE_MAX_LEN = 128;
4181{
4182public:
4183
4187 eProsima_user_DllExport ExtendedAnnotationParameterValue()
4188 {
4189 }
4190
4194 eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
4195 {
4196 }
4197
4202 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4204 {
4205 static_cast<void>(x);
4206 }
4207
4212 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4214 {
4215 static_cast<void>(x);
4216 }
4217
4224 {
4225
4226 static_cast<void>(x);
4227
4228 return *this;
4229 }
4230
4237 {
4238
4239 static_cast<void>(x);
4240
4241 return *this;
4242 }
4243
4248 eProsima_user_DllExport bool operator ==(
4249 const ExtendedAnnotationParameterValue& x) const
4250 {
4251 static_cast<void>(x);
4252 return true;
4253 }
4254
4259 eProsima_user_DllExport bool operator !=(
4260 const ExtendedAnnotationParameterValue& x) const
4261 {
4262 return !(*this == x);
4263 }
4264
4265
4266
4267private:
4268
4269
4270};
4276{
4277public:
4278
4282 eProsima_user_DllExport AnnotationParameterValue()
4283 {
4284 extended_value_();
4285 }
4286
4290 eProsima_user_DllExport ~AnnotationParameterValue()
4291 {
4292 if (member_destructor_)
4293 {
4294 member_destructor_();
4295 }
4296 }
4297
4302 eProsima_user_DllExport AnnotationParameterValue(
4303 const AnnotationParameterValue& x)
4304 {
4305 m__d = x.m__d;
4306
4307 switch (x.selected_member_)
4308 {
4309 case 0x00000001:
4310 boolean_value_() = x.m_boolean_value;
4311 break;
4312
4313 case 0x00000002:
4314 byte_value_() = x.m_byte_value;
4315 break;
4316
4317 case 0x00000003:
4318 int8_value_() = x.m_int8_value;
4319 break;
4320
4321 case 0x00000004:
4322 uint8_value_() = x.m_uint8_value;
4323 break;
4324
4325 case 0x00000005:
4326 int16_value_() = x.m_int16_value;
4327 break;
4328
4329 case 0x00000006:
4330 uint_16_value_() = x.m_uint_16_value;
4331 break;
4332
4333 case 0x00000007:
4334 int32_value_() = x.m_int32_value;
4335 break;
4336
4337 case 0x00000008:
4338 uint32_value_() = x.m_uint32_value;
4339 break;
4340
4341 case 0x00000009:
4342 int64_value_() = x.m_int64_value;
4343 break;
4344
4345 case 0x0000000a:
4346 uint64_value_() = x.m_uint64_value;
4347 break;
4348
4349 case 0x0000000b:
4350 float32_value_() = x.m_float32_value;
4351 break;
4352
4353 case 0x0000000c:
4354 float64_value_() = x.m_float64_value;
4355 break;
4356
4357 case 0x0000000d:
4358 float128_value_() = x.m_float128_value;
4359 break;
4360
4361 case 0x0000000e:
4362 char_value_() = x.m_char_value;
4363 break;
4364
4365 case 0x0000000f:
4366 wchar_value_() = x.m_wchar_value;
4367 break;
4368
4369 case 0x00000010:
4370 enumerated_value_() = x.m_enumerated_value;
4371 break;
4372
4373 case 0x00000011:
4374 string8_value_() = x.m_string8_value;
4375 break;
4376
4377 case 0x00000012:
4378 string16_value_() = x.m_string16_value;
4379 break;
4380
4381 case 0x00000013:
4382 extended_value_() = x.m_extended_value;
4383 break;
4384
4385 }
4386 }
4387
4392 eProsima_user_DllExport AnnotationParameterValue(
4393 AnnotationParameterValue&& x) noexcept
4394 {
4395 m__d = x.m__d;
4396
4397 switch (x.selected_member_)
4398 {
4399 case 0x00000001:
4400 boolean_value_() = std::move(x.m_boolean_value);
4401 break;
4402
4403 case 0x00000002:
4404 byte_value_() = std::move(x.m_byte_value);
4405 break;
4406
4407 case 0x00000003:
4408 int8_value_() = std::move(x.m_int8_value);
4409 break;
4410
4411 case 0x00000004:
4412 uint8_value_() = std::move(x.m_uint8_value);
4413 break;
4414
4415 case 0x00000005:
4416 int16_value_() = std::move(x.m_int16_value);
4417 break;
4418
4419 case 0x00000006:
4420 uint_16_value_() = std::move(x.m_uint_16_value);
4421 break;
4422
4423 case 0x00000007:
4424 int32_value_() = std::move(x.m_int32_value);
4425 break;
4426
4427 case 0x00000008:
4428 uint32_value_() = std::move(x.m_uint32_value);
4429 break;
4430
4431 case 0x00000009:
4432 int64_value_() = std::move(x.m_int64_value);
4433 break;
4434
4435 case 0x0000000a:
4436 uint64_value_() = std::move(x.m_uint64_value);
4437 break;
4438
4439 case 0x0000000b:
4440 float32_value_() = std::move(x.m_float32_value);
4441 break;
4442
4443 case 0x0000000c:
4444 float64_value_() = std::move(x.m_float64_value);
4445 break;
4446
4447 case 0x0000000d:
4448 float128_value_() = std::move(x.m_float128_value);
4449 break;
4450
4451 case 0x0000000e:
4452 char_value_() = std::move(x.m_char_value);
4453 break;
4454
4455 case 0x0000000f:
4456 wchar_value_() = std::move(x.m_wchar_value);
4457 break;
4458
4459 case 0x00000010:
4460 enumerated_value_() = std::move(x.m_enumerated_value);
4461 break;
4462
4463 case 0x00000011:
4464 string8_value_() = std::move(x.m_string8_value);
4465 break;
4466
4467 case 0x00000012:
4468 string16_value_() = std::move(x.m_string16_value);
4469 break;
4470
4471 case 0x00000013:
4472 extended_value_() = std::move(x.m_extended_value);
4473 break;
4474
4475 }
4476 }
4477
4482 eProsima_user_DllExport AnnotationParameterValue& operator =(
4483 const AnnotationParameterValue& x)
4484 {
4485 m__d = x.m__d;
4486
4487 switch (x.selected_member_)
4488 {
4489 case 0x00000001:
4490 boolean_value_() = x.m_boolean_value;
4491 break;
4492
4493 case 0x00000002:
4494 byte_value_() = x.m_byte_value;
4495 break;
4496
4497 case 0x00000003:
4498 int8_value_() = x.m_int8_value;
4499 break;
4500
4501 case 0x00000004:
4502 uint8_value_() = x.m_uint8_value;
4503 break;
4504
4505 case 0x00000005:
4506 int16_value_() = x.m_int16_value;
4507 break;
4508
4509 case 0x00000006:
4510 uint_16_value_() = x.m_uint_16_value;
4511 break;
4512
4513 case 0x00000007:
4514 int32_value_() = x.m_int32_value;
4515 break;
4516
4517 case 0x00000008:
4518 uint32_value_() = x.m_uint32_value;
4519 break;
4520
4521 case 0x00000009:
4522 int64_value_() = x.m_int64_value;
4523 break;
4524
4525 case 0x0000000a:
4526 uint64_value_() = x.m_uint64_value;
4527 break;
4528
4529 case 0x0000000b:
4530 float32_value_() = x.m_float32_value;
4531 break;
4532
4533 case 0x0000000c:
4534 float64_value_() = x.m_float64_value;
4535 break;
4536
4537 case 0x0000000d:
4538 float128_value_() = x.m_float128_value;
4539 break;
4540
4541 case 0x0000000e:
4542 char_value_() = x.m_char_value;
4543 break;
4544
4545 case 0x0000000f:
4546 wchar_value_() = x.m_wchar_value;
4547 break;
4548
4549 case 0x00000010:
4550 enumerated_value_() = x.m_enumerated_value;
4551 break;
4552
4553 case 0x00000011:
4554 string8_value_() = x.m_string8_value;
4555 break;
4556
4557 case 0x00000012:
4558 string16_value_() = x.m_string16_value;
4559 break;
4560
4561 case 0x00000013:
4562 extended_value_() = x.m_extended_value;
4563 break;
4564
4565 }
4566
4567 return *this;
4568 }
4569
4574 eProsima_user_DllExport AnnotationParameterValue& operator =(
4575 AnnotationParameterValue&& x) noexcept
4576 {
4577 m__d = x.m__d;
4578
4579 switch (x.selected_member_)
4580 {
4581 case 0x00000001:
4582 boolean_value_() = std::move(x.m_boolean_value);
4583 break;
4584
4585 case 0x00000002:
4586 byte_value_() = std::move(x.m_byte_value);
4587 break;
4588
4589 case 0x00000003:
4590 int8_value_() = std::move(x.m_int8_value);
4591 break;
4592
4593 case 0x00000004:
4594 uint8_value_() = std::move(x.m_uint8_value);
4595 break;
4596
4597 case 0x00000005:
4598 int16_value_() = std::move(x.m_int16_value);
4599 break;
4600
4601 case 0x00000006:
4602 uint_16_value_() = std::move(x.m_uint_16_value);
4603 break;
4604
4605 case 0x00000007:
4606 int32_value_() = std::move(x.m_int32_value);
4607 break;
4608
4609 case 0x00000008:
4610 uint32_value_() = std::move(x.m_uint32_value);
4611 break;
4612
4613 case 0x00000009:
4614 int64_value_() = std::move(x.m_int64_value);
4615 break;
4616
4617 case 0x0000000a:
4618 uint64_value_() = std::move(x.m_uint64_value);
4619 break;
4620
4621 case 0x0000000b:
4622 float32_value_() = std::move(x.m_float32_value);
4623 break;
4624
4625 case 0x0000000c:
4626 float64_value_() = std::move(x.m_float64_value);
4627 break;
4628
4629 case 0x0000000d:
4630 float128_value_() = std::move(x.m_float128_value);
4631 break;
4632
4633 case 0x0000000e:
4634 char_value_() = std::move(x.m_char_value);
4635 break;
4636
4637 case 0x0000000f:
4638 wchar_value_() = std::move(x.m_wchar_value);
4639 break;
4640
4641 case 0x00000010:
4642 enumerated_value_() = std::move(x.m_enumerated_value);
4643 break;
4644
4645 case 0x00000011:
4646 string8_value_() = std::move(x.m_string8_value);
4647 break;
4648
4649 case 0x00000012:
4650 string16_value_() = std::move(x.m_string16_value);
4651 break;
4652
4653 case 0x00000013:
4654 extended_value_() = std::move(x.m_extended_value);
4655 break;
4656
4657 }
4658
4659 return *this;
4660 }
4661
4666 eProsima_user_DllExport bool operator ==(
4667 const AnnotationParameterValue& x) const
4668 {
4669 bool ret_value {false};
4670
4671 if (m__d == x.m__d &&
4672 selected_member_ == x.selected_member_)
4673 {
4674 switch (selected_member_)
4675 {
4676 case 0x00000001:
4677 ret_value = (m_boolean_value == x.m_boolean_value);
4678 break;
4679
4680 case 0x00000002:
4681 ret_value = (m_byte_value == x.m_byte_value);
4682 break;
4683
4684 case 0x00000003:
4685 ret_value = (m_int8_value == x.m_int8_value);
4686 break;
4687
4688 case 0x00000004:
4689 ret_value = (m_uint8_value == x.m_uint8_value);
4690 break;
4691
4692 case 0x00000005:
4693 ret_value = (m_int16_value == x.m_int16_value);
4694 break;
4695
4696 case 0x00000006:
4697 ret_value = (m_uint_16_value == x.m_uint_16_value);
4698 break;
4699
4700 case 0x00000007:
4701 ret_value = (m_int32_value == x.m_int32_value);
4702 break;
4703
4704 case 0x00000008:
4705 ret_value = (m_uint32_value == x.m_uint32_value);
4706 break;
4707
4708 case 0x00000009:
4709 ret_value = (m_int64_value == x.m_int64_value);
4710 break;
4711
4712 case 0x0000000a:
4713 ret_value = (m_uint64_value == x.m_uint64_value);
4714 break;
4715
4716 case 0x0000000b:
4717 ret_value = (m_float32_value == x.m_float32_value);
4718 break;
4719
4720 case 0x0000000c:
4721 ret_value = (m_float64_value == x.m_float64_value);
4722 break;
4723
4724 case 0x0000000d:
4725 ret_value = (m_float128_value == x.m_float128_value);
4726 break;
4727
4728 case 0x0000000e:
4729 ret_value = (m_char_value == x.m_char_value);
4730 break;
4731
4732 case 0x0000000f:
4733 ret_value = (m_wchar_value == x.m_wchar_value);
4734 break;
4735
4736 case 0x00000010:
4737 ret_value = (m_enumerated_value == x.m_enumerated_value);
4738 break;
4739
4740 case 0x00000011:
4741 ret_value = (m_string8_value == x.m_string8_value);
4742 break;
4743
4744 case 0x00000012:
4745 ret_value = (m_string16_value == x.m_string16_value);
4746 break;
4747
4748 case 0x00000013:
4749 ret_value = (m_extended_value == x.m_extended_value);
4750 break;
4751
4752 }
4753 }
4754
4755 return ret_value;
4756 }
4757
4762 eProsima_user_DllExport bool operator !=(
4763 const AnnotationParameterValue& x) const
4764 {
4765 return !(*this == x);
4766 }
4767
4773 eProsima_user_DllExport void _d(
4774 uint8_t __d)
4775 {
4776 bool valid_discriminator = false;
4777
4778 switch (__d)
4779 {
4780 case TK_BOOLEAN:
4781 if (0x00000001 == selected_member_)
4782 {
4783 valid_discriminator = true;
4784 }
4785 break;
4786
4787 case TK_BYTE:
4788 if (0x00000002 == selected_member_)
4789 {
4790 valid_discriminator = true;
4791 }
4792 break;
4793
4794 case TK_INT8:
4795 if (0x00000003 == selected_member_)
4796 {
4797 valid_discriminator = true;
4798 }
4799 break;
4800
4801 case TK_UINT8:
4802 if (0x00000004 == selected_member_)
4803 {
4804 valid_discriminator = true;
4805 }
4806 break;
4807
4808 case TK_INT16:
4809 if (0x00000005 == selected_member_)
4810 {
4811 valid_discriminator = true;
4812 }
4813 break;
4814
4815 case TK_UINT16:
4816 if (0x00000006 == selected_member_)
4817 {
4818 valid_discriminator = true;
4819 }
4820 break;
4821
4822 case TK_INT32:
4823 if (0x00000007 == selected_member_)
4824 {
4825 valid_discriminator = true;
4826 }
4827 break;
4828
4829 case TK_UINT32:
4830 if (0x00000008 == selected_member_)
4831 {
4832 valid_discriminator = true;
4833 }
4834 break;
4835
4836 case TK_INT64:
4837 if (0x00000009 == selected_member_)
4838 {
4839 valid_discriminator = true;
4840 }
4841 break;
4842
4843 case TK_UINT64:
4844 if (0x0000000a == selected_member_)
4845 {
4846 valid_discriminator = true;
4847 }
4848 break;
4849
4850 case TK_FLOAT32:
4851 if (0x0000000b == selected_member_)
4852 {
4853 valid_discriminator = true;
4854 }
4855 break;
4856
4857 case TK_FLOAT64:
4858 if (0x0000000c == selected_member_)
4859 {
4860 valid_discriminator = true;
4861 }
4862 break;
4863
4864 case TK_FLOAT128:
4865 if (0x0000000d == selected_member_)
4866 {
4867 valid_discriminator = true;
4868 }
4869 break;
4870
4871 case TK_CHAR8:
4872 if (0x0000000e == selected_member_)
4873 {
4874 valid_discriminator = true;
4875 }
4876 break;
4877
4878 case TK_CHAR16:
4879 if (0x0000000f == selected_member_)
4880 {
4881 valid_discriminator = true;
4882 }
4883 break;
4884
4885 case TK_ENUM:
4886 if (0x00000010 == selected_member_)
4887 {
4888 valid_discriminator = true;
4889 }
4890 break;
4891
4892 case TK_STRING8:
4893 if (0x00000011 == selected_member_)
4894 {
4895 valid_discriminator = true;
4896 }
4897 break;
4898
4899 case TK_STRING16:
4900 if (0x00000012 == selected_member_)
4901 {
4902 valid_discriminator = true;
4903 }
4904 break;
4905
4906 default:
4907 if (0x00000013 == selected_member_)
4908 {
4909 valid_discriminator = true;
4910 }
4911 break;
4912
4913 }
4914
4915 if (!valid_discriminator)
4916 {
4917 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
4918 }
4919
4920 m__d = __d;
4921 }
4922
4927 eProsima_user_DllExport uint8_t _d() const
4928 {
4929 return m__d;
4930 }
4931
4936 eProsima_user_DllExport void boolean_value(
4937 bool _boolean_value)
4938 {
4939 boolean_value_() = _boolean_value;
4940 m__d = TK_BOOLEAN;
4941 }
4942
4948 eProsima_user_DllExport bool boolean_value() const
4949 {
4950 if (0x00000001 != selected_member_)
4951 {
4952 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
4953 }
4954
4955 return m_boolean_value;
4956 }
4957
4963 eProsima_user_DllExport bool& boolean_value()
4964 {
4965 if (0x00000001 != selected_member_)
4966 {
4967 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
4968 }
4969
4970 return m_boolean_value;
4971 }
4972
4973
4978 eProsima_user_DllExport void byte_value(
4979 uint8_t _byte_value)
4980 {
4981 byte_value_() = _byte_value;
4982 m__d = TK_BYTE;
4983 }
4984
4990 eProsima_user_DllExport uint8_t byte_value() const
4991 {
4992 if (0x00000002 != selected_member_)
4993 {
4994 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
4995 }
4996
4997 return m_byte_value;
4998 }
4999
5005 eProsima_user_DllExport uint8_t& byte_value()
5006 {
5007 if (0x00000002 != selected_member_)
5008 {
5009 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5010 }
5011
5012 return m_byte_value;
5013 }
5014
5015
5020 eProsima_user_DllExport void int8_value(
5021 int8_t _int8_value)
5022 {
5023 int8_value_() = _int8_value;
5024 m__d = TK_INT8;
5025 }
5026
5032 eProsima_user_DllExport int8_t int8_value() const
5033 {
5034 if (0x00000003 != selected_member_)
5035 {
5036 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5037 }
5038
5039 return m_int8_value;
5040 }
5041
5047 eProsima_user_DllExport int8_t& int8_value()
5048 {
5049 if (0x00000003 != selected_member_)
5050 {
5051 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5052 }
5053
5054 return m_int8_value;
5055 }
5056
5057
5062 eProsima_user_DllExport void uint8_value(
5063 uint8_t _uint8_value)
5064 {
5065 uint8_value_() = _uint8_value;
5066 m__d = TK_UINT8;
5067 }
5068
5074 eProsima_user_DllExport uint8_t uint8_value() const
5075 {
5076 if (0x00000004 != selected_member_)
5077 {
5078 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5079 }
5080
5081 return m_uint8_value;
5082 }
5083
5089 eProsima_user_DllExport uint8_t& uint8_value()
5090 {
5091 if (0x00000004 != selected_member_)
5092 {
5093 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5094 }
5095
5096 return m_uint8_value;
5097 }
5098
5099
5104 eProsima_user_DllExport void int16_value(
5105 int16_t _int16_value)
5106 {
5107 int16_value_() = _int16_value;
5108 m__d = TK_INT16;
5109 }
5110
5116 eProsima_user_DllExport int16_t int16_value() const
5117 {
5118 if (0x00000005 != selected_member_)
5119 {
5120 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5121 }
5122
5123 return m_int16_value;
5124 }
5125
5131 eProsima_user_DllExport int16_t& int16_value()
5132 {
5133 if (0x00000005 != selected_member_)
5134 {
5135 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5136 }
5137
5138 return m_int16_value;
5139 }
5140
5141
5146 eProsima_user_DllExport void uint_16_value(
5147 uint16_t _uint_16_value)
5148 {
5149 uint_16_value_() = _uint_16_value;
5150 m__d = TK_UINT16;
5151 }
5152
5158 eProsima_user_DllExport uint16_t uint_16_value() const
5159 {
5160 if (0x00000006 != selected_member_)
5161 {
5162 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5163 }
5164
5165 return m_uint_16_value;
5166 }
5167
5173 eProsima_user_DllExport uint16_t& uint_16_value()
5174 {
5175 if (0x00000006 != selected_member_)
5176 {
5177 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5178 }
5179
5180 return m_uint_16_value;
5181 }
5182
5183
5188 eProsima_user_DllExport void int32_value(
5189 int32_t _int32_value)
5190 {
5191 int32_value_() = _int32_value;
5192 m__d = TK_INT32;
5193 }
5194
5200 eProsima_user_DllExport int32_t int32_value() const
5201 {
5202 if (0x00000007 != selected_member_)
5203 {
5204 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5205 }
5206
5207 return m_int32_value;
5208 }
5209
5215 eProsima_user_DllExport int32_t& int32_value()
5216 {
5217 if (0x00000007 != selected_member_)
5218 {
5219 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5220 }
5221
5222 return m_int32_value;
5223 }
5224
5225
5230 eProsima_user_DllExport void uint32_value(
5231 uint32_t _uint32_value)
5232 {
5233 uint32_value_() = _uint32_value;
5234 m__d = TK_UINT32;
5235 }
5236
5242 eProsima_user_DllExport uint32_t uint32_value() const
5243 {
5244 if (0x00000008 != selected_member_)
5245 {
5246 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5247 }
5248
5249 return m_uint32_value;
5250 }
5251
5257 eProsima_user_DllExport uint32_t& uint32_value()
5258 {
5259 if (0x00000008 != selected_member_)
5260 {
5261 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5262 }
5263
5264 return m_uint32_value;
5265 }
5266
5267
5272 eProsima_user_DllExport void int64_value(
5273 int64_t _int64_value)
5274 {
5275 int64_value_() = _int64_value;
5276 m__d = TK_INT64;
5277 }
5278
5284 eProsima_user_DllExport int64_t int64_value() const
5285 {
5286 if (0x00000009 != selected_member_)
5287 {
5288 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5289 }
5290
5291 return m_int64_value;
5292 }
5293
5299 eProsima_user_DllExport int64_t& int64_value()
5300 {
5301 if (0x00000009 != selected_member_)
5302 {
5303 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5304 }
5305
5306 return m_int64_value;
5307 }
5308
5309
5314 eProsima_user_DllExport void uint64_value(
5315 uint64_t _uint64_value)
5316 {
5317 uint64_value_() = _uint64_value;
5318 m__d = TK_UINT64;
5319 }
5320
5326 eProsima_user_DllExport uint64_t uint64_value() const
5327 {
5328 if (0x0000000a != selected_member_)
5329 {
5330 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5331 }
5332
5333 return m_uint64_value;
5334 }
5335
5341 eProsima_user_DllExport uint64_t& uint64_value()
5342 {
5343 if (0x0000000a != selected_member_)
5344 {
5345 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5346 }
5347
5348 return m_uint64_value;
5349 }
5350
5351
5356 eProsima_user_DllExport void float32_value(
5357 float _float32_value)
5358 {
5359 float32_value_() = _float32_value;
5360 m__d = TK_FLOAT32;
5361 }
5362
5368 eProsima_user_DllExport float float32_value() const
5369 {
5370 if (0x0000000b != selected_member_)
5371 {
5372 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5373 }
5374
5375 return m_float32_value;
5376 }
5377
5383 eProsima_user_DllExport float& float32_value()
5384 {
5385 if (0x0000000b != selected_member_)
5386 {
5387 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5388 }
5389
5390 return m_float32_value;
5391 }
5392
5393
5398 eProsima_user_DllExport void float64_value(
5399 double _float64_value)
5400 {
5401 float64_value_() = _float64_value;
5402 m__d = TK_FLOAT64;
5403 }
5404
5410 eProsima_user_DllExport double float64_value() const
5411 {
5412 if (0x0000000c != selected_member_)
5413 {
5414 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5415 }
5416
5417 return m_float64_value;
5418 }
5419
5425 eProsima_user_DllExport double& float64_value()
5426 {
5427 if (0x0000000c != selected_member_)
5428 {
5429 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5430 }
5431
5432 return m_float64_value;
5433 }
5434
5435
5440 eProsima_user_DllExport void float128_value(
5441 long double _float128_value)
5442 {
5443 float128_value_() = _float128_value;
5444 m__d = TK_FLOAT128;
5445 }
5446
5452 eProsima_user_DllExport long double float128_value() const
5453 {
5454 if (0x0000000d != selected_member_)
5455 {
5456 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5457 }
5458
5459 return m_float128_value;
5460 }
5461
5467 eProsima_user_DllExport long double& float128_value()
5468 {
5469 if (0x0000000d != selected_member_)
5470 {
5471 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5472 }
5473
5474 return m_float128_value;
5475 }
5476
5477
5482 eProsima_user_DllExport void char_value(
5483 char _char_value)
5484 {
5485 char_value_() = _char_value;
5486 m__d = TK_CHAR8;
5487 }
5488
5494 eProsima_user_DllExport char char_value() const
5495 {
5496 if (0x0000000e != selected_member_)
5497 {
5498 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5499 }
5500
5501 return m_char_value;
5502 }
5503
5509 eProsima_user_DllExport char& char_value()
5510 {
5511 if (0x0000000e != selected_member_)
5512 {
5513 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5514 }
5515
5516 return m_char_value;
5517 }
5518
5519
5524 eProsima_user_DllExport void wchar_value(
5525 wchar_t _wchar_value)
5526 {
5527 wchar_value_() = _wchar_value;
5528 m__d = TK_CHAR16;
5529 }
5530
5536 eProsima_user_DllExport wchar_t wchar_value() const
5537 {
5538 if (0x0000000f != selected_member_)
5539 {
5540 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5541 }
5542
5543 return m_wchar_value;
5544 }
5545
5551 eProsima_user_DllExport wchar_t& wchar_value()
5552 {
5553 if (0x0000000f != selected_member_)
5554 {
5555 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5556 }
5557
5558 return m_wchar_value;
5559 }
5560
5561
5566 eProsima_user_DllExport void enumerated_value(
5567 int32_t _enumerated_value)
5568 {
5569 enumerated_value_() = _enumerated_value;
5570 m__d = TK_ENUM;
5571 }
5572
5578 eProsima_user_DllExport int32_t enumerated_value() const
5579 {
5580 if (0x00000010 != selected_member_)
5581 {
5582 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5583 }
5584
5585 return m_enumerated_value;
5586 }
5587
5593 eProsima_user_DllExport int32_t& enumerated_value()
5594 {
5595 if (0x00000010 != selected_member_)
5596 {
5597 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5598 }
5599
5600 return m_enumerated_value;
5601 }
5602
5603
5608 eProsima_user_DllExport void string8_value(
5609 const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& _string8_value)
5610 {
5611 string8_value_() = _string8_value;
5612 m__d = TK_STRING8;
5613 }
5614
5619 eProsima_user_DllExport void string8_value(
5620 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>&& _string8_value)
5621 {
5622 string8_value_() = _string8_value;
5623 m__d = TK_STRING8;
5624 }
5625
5631 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value() const
5632 {
5633 if (0x00000011 != selected_member_)
5634 {
5635 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5636 }
5637
5638 return m_string8_value;
5639 }
5640
5646 eProsima_user_DllExport eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value()
5647 {
5648 if (0x00000011 != selected_member_)
5649 {
5650 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5651 }
5652
5653 return m_string8_value;
5654 }
5655
5656
5661 eProsima_user_DllExport void string16_value(
5662 const std::wstring& _string16_value)
5663 {
5664 string16_value_() = _string16_value;
5665 m__d = TK_STRING16;
5666 }
5667
5672 eProsima_user_DllExport void string16_value(
5673 std::wstring&& _string16_value)
5674 {
5675 string16_value_() = _string16_value;
5676 m__d = TK_STRING16;
5677 }
5678
5684 eProsima_user_DllExport const std::wstring& string16_value() const
5685 {
5686 if (0x00000012 != selected_member_)
5687 {
5688 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5689 }
5690
5691 return m_string16_value;
5692 }
5693
5699 eProsima_user_DllExport std::wstring& string16_value()
5700 {
5701 if (0x00000012 != selected_member_)
5702 {
5703 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5704 }
5705
5706 return m_string16_value;
5707 }
5708
5709
5714 eProsima_user_DllExport void extended_value(
5715 const ExtendedAnnotationParameterValue& _extended_value)
5716 {
5717 extended_value_() = _extended_value;
5718 m__d = 127;
5719 }
5720
5725 eProsima_user_DllExport void extended_value(
5726 ExtendedAnnotationParameterValue&& _extended_value)
5727 {
5728 extended_value_() = _extended_value;
5729 m__d = 127;
5730 }
5731
5737 eProsima_user_DllExport const ExtendedAnnotationParameterValue& extended_value() const
5738 {
5739 if (0x00000013 != selected_member_)
5740 {
5741 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5742 }
5743
5744 return m_extended_value;
5745 }
5746
5753 {
5754 if (0x00000013 != selected_member_)
5755 {
5756 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5757 }
5758
5759 return m_extended_value;
5760 }
5761
5762
5763
5764private:
5765
5766 bool& boolean_value_()
5767 {
5768 if (0x00000001 != selected_member_)
5769 {
5770 if (member_destructor_)
5771 {
5772 member_destructor_();
5773 }
5774
5775 selected_member_ = 0x00000001;
5776 member_destructor_ = nullptr;
5777 m_boolean_value = {false};
5778 ;
5779 }
5780
5781 return m_boolean_value;
5782 }
5783
5784 uint8_t& byte_value_()
5785 {
5786 if (0x00000002 != selected_member_)
5787 {
5788 if (member_destructor_)
5789 {
5790 member_destructor_();
5791 }
5792
5793 selected_member_ = 0x00000002;
5794 member_destructor_ = nullptr;
5795 m_byte_value = {0};
5796 ;
5797 }
5798
5799 return m_byte_value;
5800 }
5801
5802 int8_t& int8_value_()
5803 {
5804 if (0x00000003 != selected_member_)
5805 {
5806 if (member_destructor_)
5807 {
5808 member_destructor_();
5809 }
5810
5811 selected_member_ = 0x00000003;
5812 member_destructor_ = nullptr;
5813 m_int8_value = {0};
5814 ;
5815 }
5816
5817 return m_int8_value;
5818 }
5819
5820 uint8_t& uint8_value_()
5821 {
5822 if (0x00000004 != selected_member_)
5823 {
5824 if (member_destructor_)
5825 {
5826 member_destructor_();
5827 }
5828
5829 selected_member_ = 0x00000004;
5830 member_destructor_ = nullptr;
5831 m_uint8_value = {0};
5832 ;
5833 }
5834
5835 return m_uint8_value;
5836 }
5837
5838 int16_t& int16_value_()
5839 {
5840 if (0x00000005 != selected_member_)
5841 {
5842 if (member_destructor_)
5843 {
5844 member_destructor_();
5845 }
5846
5847 selected_member_ = 0x00000005;
5848 member_destructor_ = nullptr;
5849 m_int16_value = {0};
5850 ;
5851 }
5852
5853 return m_int16_value;
5854 }
5855
5856 uint16_t& uint_16_value_()
5857 {
5858 if (0x00000006 != selected_member_)
5859 {
5860 if (member_destructor_)
5861 {
5862 member_destructor_();
5863 }
5864
5865 selected_member_ = 0x00000006;
5866 member_destructor_ = nullptr;
5867 m_uint_16_value = {0};
5868 ;
5869 }
5870
5871 return m_uint_16_value;
5872 }
5873
5874 int32_t& int32_value_()
5875 {
5876 if (0x00000007 != selected_member_)
5877 {
5878 if (member_destructor_)
5879 {
5880 member_destructor_();
5881 }
5882
5883 selected_member_ = 0x00000007;
5884 member_destructor_ = nullptr;
5885 m_int32_value = {0};
5886 ;
5887 }
5888
5889 return m_int32_value;
5890 }
5891
5892 uint32_t& uint32_value_()
5893 {
5894 if (0x00000008 != selected_member_)
5895 {
5896 if (member_destructor_)
5897 {
5898 member_destructor_();
5899 }
5900
5901 selected_member_ = 0x00000008;
5902 member_destructor_ = nullptr;
5903 m_uint32_value = {0};
5904 ;
5905 }
5906
5907 return m_uint32_value;
5908 }
5909
5910 int64_t& int64_value_()
5911 {
5912 if (0x00000009 != selected_member_)
5913 {
5914 if (member_destructor_)
5915 {
5916 member_destructor_();
5917 }
5918
5919 selected_member_ = 0x00000009;
5920 member_destructor_ = nullptr;
5921 m_int64_value = {0};
5922 ;
5923 }
5924
5925 return m_int64_value;
5926 }
5927
5928 uint64_t& uint64_value_()
5929 {
5930 if (0x0000000a != selected_member_)
5931 {
5932 if (member_destructor_)
5933 {
5934 member_destructor_();
5935 }
5936
5937 selected_member_ = 0x0000000a;
5938 member_destructor_ = nullptr;
5939 m_uint64_value = {0};
5940 ;
5941 }
5942
5943 return m_uint64_value;
5944 }
5945
5946 float& float32_value_()
5947 {
5948 if (0x0000000b != selected_member_)
5949 {
5950 if (member_destructor_)
5951 {
5952 member_destructor_();
5953 }
5954
5955 selected_member_ = 0x0000000b;
5956 member_destructor_ = nullptr;
5957 m_float32_value = {0.0};
5958 ;
5959 }
5960
5961 return m_float32_value;
5962 }
5963
5964 double& float64_value_()
5965 {
5966 if (0x0000000c != selected_member_)
5967 {
5968 if (member_destructor_)
5969 {
5970 member_destructor_();
5971 }
5972
5973 selected_member_ = 0x0000000c;
5974 member_destructor_ = nullptr;
5975 m_float64_value = {0.0};
5976 ;
5977 }
5978
5979 return m_float64_value;
5980 }
5981
5982 long double& float128_value_()
5983 {
5984 if (0x0000000d != selected_member_)
5985 {
5986 if (member_destructor_)
5987 {
5988 member_destructor_();
5989 }
5990
5991 selected_member_ = 0x0000000d;
5992 member_destructor_ = nullptr;
5993 m_float128_value = {0.0};
5994 ;
5995 }
5996
5997 return m_float128_value;
5998 }
5999
6000 char& char_value_()
6001 {
6002 if (0x0000000e != selected_member_)
6003 {
6004 if (member_destructor_)
6005 {
6006 member_destructor_();
6007 }
6008
6009 selected_member_ = 0x0000000e;
6010 member_destructor_ = nullptr;
6011 m_char_value = {0};
6012 ;
6013 }
6014
6015 return m_char_value;
6016 }
6017
6018 wchar_t& wchar_value_()
6019 {
6020 if (0x0000000f != selected_member_)
6021 {
6022 if (member_destructor_)
6023 {
6024 member_destructor_();
6025 }
6026
6027 selected_member_ = 0x0000000f;
6028 member_destructor_ = nullptr;
6029 m_wchar_value = {0};
6030 ;
6031 }
6032
6033 return m_wchar_value;
6034 }
6035
6036 int32_t& enumerated_value_()
6037 {
6038 if (0x00000010 != selected_member_)
6039 {
6040 if (member_destructor_)
6041 {
6042 member_destructor_();
6043 }
6044
6045 selected_member_ = 0x00000010;
6046 member_destructor_ = nullptr;
6047 m_enumerated_value = {0};
6048 ;
6049 }
6050
6051 return m_enumerated_value;
6052 }
6053
6054 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value_()
6055 {
6056 if (0x00000011 != selected_member_)
6057 {
6058 if (member_destructor_)
6059 {
6060 member_destructor_();
6061 }
6062
6063 selected_member_ = 0x00000011;
6064 member_destructor_ = [&]() {m_string8_value.~fixed_string();};
6065 new(&m_string8_value) eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>();
6066 ;
6067 }
6068
6069 return m_string8_value;
6070 }
6071
6072 std::wstring& string16_value_()
6073 {
6074 if (0x00000012 != selected_member_)
6075 {
6076 if (member_destructor_)
6077 {
6078 member_destructor_();
6079 }
6080
6081 selected_member_ = 0x00000012;
6082 member_destructor_ = [&]() {m_string16_value.~basic_string();};
6083 new(&m_string16_value) std::wstring();
6084 ;
6085 }
6086
6087 return m_string16_value;
6088 }
6089
6090 ExtendedAnnotationParameterValue& extended_value_()
6091 {
6092 if (0x00000013 != selected_member_)
6093 {
6094 if (member_destructor_)
6095 {
6096 member_destructor_();
6097 }
6098
6099 selected_member_ = 0x00000013;
6100 member_destructor_ = [&]() {m_extended_value.~ExtendedAnnotationParameterValue();};
6101 new(&m_extended_value) ExtendedAnnotationParameterValue();
6102 ;
6103 }
6104
6105 return m_extended_value;
6106 }
6107
6108
6109 uint8_t m__d {127};
6110
6111 union
6112 {
6125 long double m_float128_value;
6129 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN> m_string8_value;
6130 std::wstring m_string16_value;
6132 };
6133
6134 uint32_t selected_member_ {0x0FFFFFFFu};
6135
6136 std::function<void()> member_destructor_;
6137};
6143{
6144public:
6145
6149 eProsima_user_DllExport AppliedAnnotationParameter()
6150 {
6151 }
6152
6156 eProsima_user_DllExport ~AppliedAnnotationParameter()
6157 {
6158 }
6159
6164 eProsima_user_DllExport AppliedAnnotationParameter(
6166 {
6167 m_paramname_hash = x.m_paramname_hash;
6168
6169 m_value = x.m_value;
6170
6171 }
6172
6177 eProsima_user_DllExport AppliedAnnotationParameter(
6178 AppliedAnnotationParameter&& x) noexcept
6179 {
6180 m_paramname_hash = std::move(x.m_paramname_hash);
6181 m_value = std::move(x.m_value);
6182 }
6183
6188 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6190 {
6191
6192 m_paramname_hash = x.m_paramname_hash;
6193
6194 m_value = x.m_value;
6195
6196 return *this;
6197 }
6198
6203 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6204 AppliedAnnotationParameter&& x) noexcept
6205 {
6206
6207 m_paramname_hash = std::move(x.m_paramname_hash);
6208 m_value = std::move(x.m_value);
6209 return *this;
6210 }
6211
6216 eProsima_user_DllExport bool operator ==(
6217 const AppliedAnnotationParameter& x) const
6218 {
6219 return (m_paramname_hash == x.m_paramname_hash &&
6220 m_value == x.m_value);
6221 }
6222
6227 eProsima_user_DllExport bool operator !=(
6228 const AppliedAnnotationParameter& x) const
6229 {
6230 return !(*this == x);
6231 }
6232
6237 eProsima_user_DllExport void paramname_hash(
6238 const NameHash& _paramname_hash)
6239 {
6240 m_paramname_hash = _paramname_hash;
6241 }
6242
6247 eProsima_user_DllExport void paramname_hash(
6248 NameHash&& _paramname_hash)
6249 {
6250 m_paramname_hash = std::move(_paramname_hash);
6251 }
6252
6257 eProsima_user_DllExport const NameHash& paramname_hash() const
6258 {
6259 return m_paramname_hash;
6260 }
6261
6266 eProsima_user_DllExport NameHash& paramname_hash()
6267 {
6268 return m_paramname_hash;
6269 }
6270
6271
6276 eProsima_user_DllExport void value(
6277 const AnnotationParameterValue& _value)
6278 {
6279 m_value = _value;
6280 }
6281
6286 eProsima_user_DllExport void value(
6287 AnnotationParameterValue&& _value)
6288 {
6289 m_value = std::move(_value);
6290 }
6291
6296 eProsima_user_DllExport const AnnotationParameterValue& value() const
6297 {
6298 return m_value;
6299 }
6300
6305 eProsima_user_DllExport AnnotationParameterValue& value()
6306 {
6307 return m_value;
6308 }
6309
6310
6311
6312private:
6313
6314 NameHash m_paramname_hash{0};
6315 AnnotationParameterValue m_value;
6316
6317};
6318typedef std::vector<AppliedAnnotationParameter> AppliedAnnotationParameterSeq;
6319
6325{
6326public:
6327
6331 eProsima_user_DllExport AppliedAnnotation()
6332 {
6333 }
6334
6338 eProsima_user_DllExport ~AppliedAnnotation()
6339 {
6340 }
6341
6346 eProsima_user_DllExport AppliedAnnotation(
6347 const AppliedAnnotation& x)
6348 {
6349 m_annotation_typeid = x.m_annotation_typeid;
6350
6351 m_param_seq = x.m_param_seq;
6352
6353 }
6354
6359 eProsima_user_DllExport AppliedAnnotation(
6360 AppliedAnnotation&& x) noexcept
6361 {
6362 m_annotation_typeid = std::move(x.m_annotation_typeid);
6363 m_param_seq = std::move(x.m_param_seq);
6364 }
6365
6370 eProsima_user_DllExport AppliedAnnotation& operator =(
6371 const AppliedAnnotation& x)
6372 {
6373
6374 m_annotation_typeid = x.m_annotation_typeid;
6375
6376 m_param_seq = x.m_param_seq;
6377
6378 return *this;
6379 }
6380
6385 eProsima_user_DllExport AppliedAnnotation& operator =(
6386 AppliedAnnotation&& x) noexcept
6387 {
6388
6389 m_annotation_typeid = std::move(x.m_annotation_typeid);
6390 m_param_seq = std::move(x.m_param_seq);
6391 return *this;
6392 }
6393
6398 eProsima_user_DllExport bool operator ==(
6399 const AppliedAnnotation& x) const
6400 {
6401 return (m_annotation_typeid == x.m_annotation_typeid &&
6402 m_param_seq == x.m_param_seq);
6403 }
6404
6409 eProsima_user_DllExport bool operator !=(
6410 const AppliedAnnotation& x) const
6411 {
6412 return !(*this == x);
6413 }
6414
6419 eProsima_user_DllExport void annotation_typeid(
6420 const TypeIdentifier& _annotation_typeid)
6421 {
6422 m_annotation_typeid = _annotation_typeid;
6423 }
6424
6429 eProsima_user_DllExport void annotation_typeid(
6430 TypeIdentifier&& _annotation_typeid)
6431 {
6432 m_annotation_typeid = std::move(_annotation_typeid);
6433 }
6434
6439 eProsima_user_DllExport const TypeIdentifier& annotation_typeid() const
6440 {
6441 return m_annotation_typeid;
6442 }
6443
6448 eProsima_user_DllExport TypeIdentifier& annotation_typeid()
6449 {
6450 return m_annotation_typeid;
6451 }
6452
6453
6458 eProsima_user_DllExport void param_seq(
6459 const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& _param_seq)
6460 {
6461 m_param_seq = _param_seq;
6462 }
6463
6468 eProsima_user_DllExport void param_seq(
6469 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>&& _param_seq)
6470 {
6471 m_param_seq = std::move(_param_seq);
6472 }
6473
6478 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq() const
6479 {
6480 return m_param_seq;
6481 }
6482
6487 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq()
6488 {
6489 return m_param_seq;
6490 }
6491
6492
6493
6494private:
6495
6496 TypeIdentifier m_annotation_typeid;
6497 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq> m_param_seq;
6498
6499};
6500typedef std::vector<AppliedAnnotation> AppliedAnnotationSeq;
6501
6507{
6508public:
6509
6513 eProsima_user_DllExport AppliedVerbatimAnnotation()
6514 {
6515 }
6516
6520 eProsima_user_DllExport ~AppliedVerbatimAnnotation()
6521 {
6522 }
6523
6528 eProsima_user_DllExport AppliedVerbatimAnnotation(
6530 {
6531 m_placement = x.m_placement;
6532
6533 m_language = x.m_language;
6534
6535 m_text = x.m_text;
6536
6537 }
6538
6543 eProsima_user_DllExport AppliedVerbatimAnnotation(
6544 AppliedVerbatimAnnotation&& x) noexcept
6545 {
6546 m_placement = std::move(x.m_placement);
6547 m_language = std::move(x.m_language);
6548 m_text = std::move(x.m_text);
6549 }
6550
6555 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6557 {
6558
6559 m_placement = x.m_placement;
6560
6561 m_language = x.m_language;
6562
6563 m_text = x.m_text;
6564
6565 return *this;
6566 }
6567
6572 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6573 AppliedVerbatimAnnotation&& x) noexcept
6574 {
6575
6576 m_placement = std::move(x.m_placement);
6577 m_language = std::move(x.m_language);
6578 m_text = std::move(x.m_text);
6579 return *this;
6580 }
6581
6586 eProsima_user_DllExport bool operator ==(
6587 const AppliedVerbatimAnnotation& x) const
6588 {
6589 return (m_placement == x.m_placement &&
6590 m_language == x.m_language &&
6591 m_text == x.m_text);
6592 }
6593
6598 eProsima_user_DllExport bool operator !=(
6599 const AppliedVerbatimAnnotation& x) const
6600 {
6601 return !(*this == x);
6602 }
6603
6608 eProsima_user_DllExport void placement(
6609 const eprosima::fastcdr::fixed_string<32>& _placement)
6610 {
6611 m_placement = _placement;
6612 }
6613
6618 eProsima_user_DllExport void placement(
6619 eprosima::fastcdr::fixed_string<32>&& _placement)
6620 {
6621 m_placement = std::move(_placement);
6622 }
6623
6628 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& placement() const
6629 {
6630 return m_placement;
6631 }
6632
6637 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& placement()
6638 {
6639 return m_placement;
6640 }
6641
6642
6647 eProsima_user_DllExport void language(
6648 const eprosima::fastcdr::fixed_string<32>& _language)
6649 {
6650 m_language = _language;
6651 }
6652
6657 eProsima_user_DllExport void language(
6658 eprosima::fastcdr::fixed_string<32>&& _language)
6659 {
6660 m_language = std::move(_language);
6661 }
6662
6667 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& language() const
6668 {
6669 return m_language;
6670 }
6671
6676 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& language()
6677 {
6678 return m_language;
6679 }
6680
6681
6686 eProsima_user_DllExport void text(
6687 const std::string& _text)
6688 {
6689 m_text = _text;
6690 }
6691
6696 eProsima_user_DllExport void text(
6697 std::string&& _text)
6698 {
6699 m_text = std::move(_text);
6700 }
6701
6706 eProsima_user_DllExport const std::string& text() const
6707 {
6708 return m_text;
6709 }
6710
6715 eProsima_user_DllExport std::string& text()
6716 {
6717 return m_text;
6718 }
6719
6720
6721
6722private:
6723
6724 eprosima::fastcdr::fixed_string<32> m_placement;
6725 eprosima::fastcdr::fixed_string<32> m_language;
6726 std::string m_text;
6727
6728};
6734{
6735public:
6736
6740 eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
6741 {
6742 }
6743
6747 eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
6748 {
6749 }
6750
6755 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6757 {
6758 m_unit = x.m_unit;
6759
6760 m_min = x.m_min;
6761
6762 m_max = x.m_max;
6763
6764 m_hash_id = x.m_hash_id;
6765
6766 }
6767
6772 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6774 {
6775 m_unit = std::move(x.m_unit);
6776 m_min = std::move(x.m_min);
6777 m_max = std::move(x.m_max);
6778 m_hash_id = std::move(x.m_hash_id);
6779 }
6780
6787 {
6788
6789 m_unit = x.m_unit;
6790
6791 m_min = x.m_min;
6792
6793 m_max = x.m_max;
6794
6795 m_hash_id = x.m_hash_id;
6796
6797 return *this;
6798 }
6799
6806 {
6807
6808 m_unit = std::move(x.m_unit);
6809 m_min = std::move(x.m_min);
6810 m_max = std::move(x.m_max);
6811 m_hash_id = std::move(x.m_hash_id);
6812 return *this;
6813 }
6814
6819 eProsima_user_DllExport bool operator ==(
6820 const AppliedBuiltinMemberAnnotations& x) const
6821 {
6822 return (m_unit == x.m_unit &&
6823 m_min == x.m_min &&
6824 m_max == x.m_max &&
6825 m_hash_id == x.m_hash_id);
6826 }
6827
6832 eProsima_user_DllExport bool operator !=(
6833 const AppliedBuiltinMemberAnnotations& x) const
6834 {
6835 return !(*this == x);
6836 }
6837
6842 eProsima_user_DllExport void unit(
6843 const eprosima::fastcdr::optional<std::string>& _unit)
6844 {
6845 m_unit = _unit;
6846 }
6847
6852 eProsima_user_DllExport void unit(
6853 eprosima::fastcdr::optional<std::string>&& _unit)
6854 {
6855 m_unit = std::move(_unit);
6856 }
6857
6862 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& unit() const
6863 {
6864 return m_unit;
6865 }
6866
6871 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& unit()
6872 {
6873 return m_unit;
6874 }
6875
6876
6881 eProsima_user_DllExport void min(
6882 const eprosima::fastcdr::optional<AnnotationParameterValue>& _min)
6883 {
6884 m_min = _min;
6885 }
6886
6891 eProsima_user_DllExport void min(
6892 eprosima::fastcdr::optional<AnnotationParameterValue>&& _min)
6893 {
6894 m_min = std::move(_min);
6895 }
6896
6901 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& min() const
6902 {
6903 return m_min;
6904 }
6905
6910 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& min()
6911 {
6912 return m_min;
6913 }
6914
6915
6920 eProsima_user_DllExport void max(
6921 const eprosima::fastcdr::optional<AnnotationParameterValue>& _max)
6922 {
6923 m_max = _max;
6924 }
6925
6930 eProsima_user_DllExport void max(
6931 eprosima::fastcdr::optional<AnnotationParameterValue>&& _max)
6932 {
6933 m_max = std::move(_max);
6934 }
6935
6940 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& max() const
6941 {
6942 return m_max;
6943 }
6944
6949 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& max()
6950 {
6951 return m_max;
6952 }
6953
6954
6959 eProsima_user_DllExport void hash_id(
6960 const eprosima::fastcdr::optional<std::string>& _hash_id)
6961 {
6962 m_hash_id = _hash_id;
6963 }
6964
6969 eProsima_user_DllExport void hash_id(
6970 eprosima::fastcdr::optional<std::string>&& _hash_id)
6971 {
6972 m_hash_id = std::move(_hash_id);
6973 }
6974
6979 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& hash_id() const
6980 {
6981 return m_hash_id;
6982 }
6983
6988 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& hash_id()
6989 {
6990 return m_hash_id;
6991 }
6992
6993
6994
6995private:
6996
6997 eprosima::fastcdr::optional<std::string> m_unit;
6998 eprosima::fastcdr::optional<AnnotationParameterValue> m_min;
6999 eprosima::fastcdr::optional<AnnotationParameterValue> m_max;
7000 eprosima::fastcdr::optional<std::string> m_hash_id;
7001
7002};
7008{
7009public:
7010
7014 eProsima_user_DllExport CommonStructMember()
7015 {
7016 }
7017
7021 eProsima_user_DllExport ~CommonStructMember()
7022 {
7023 }
7024
7029 eProsima_user_DllExport CommonStructMember(
7030 const CommonStructMember& x)
7031 {
7032 m_member_id = x.m_member_id;
7033
7034 m_member_flags = x.m_member_flags;
7035
7036 m_member_type_id = x.m_member_type_id;
7037
7038 }
7039
7044 eProsima_user_DllExport CommonStructMember(
7045 CommonStructMember&& x) noexcept
7046 {
7047 m_member_id = x.m_member_id;
7048 m_member_flags = std::move(x.m_member_flags);
7049 m_member_type_id = std::move(x.m_member_type_id);
7050 }
7051
7056 eProsima_user_DllExport CommonStructMember& operator =(
7057 const CommonStructMember& x)
7058 {
7059
7060 m_member_id = x.m_member_id;
7061
7062 m_member_flags = x.m_member_flags;
7063
7064 m_member_type_id = x.m_member_type_id;
7065
7066 return *this;
7067 }
7068
7073 eProsima_user_DllExport CommonStructMember& operator =(
7074 CommonStructMember&& x) noexcept
7075 {
7076
7077 m_member_id = x.m_member_id;
7078 m_member_flags = std::move(x.m_member_flags);
7079 m_member_type_id = std::move(x.m_member_type_id);
7080 return *this;
7081 }
7082
7087 eProsima_user_DllExport bool operator ==(
7088 const CommonStructMember& x) const
7089 {
7090 return (m_member_id == x.m_member_id &&
7091 m_member_flags == x.m_member_flags &&
7092 m_member_type_id == x.m_member_type_id);
7093 }
7094
7099 eProsima_user_DllExport bool operator !=(
7100 const CommonStructMember& x) const
7101 {
7102 return !(*this == x);
7103 }
7104
7109 eProsima_user_DllExport void member_id(
7110 MemberId _member_id)
7111 {
7112 m_member_id = _member_id;
7113 }
7114
7119 eProsima_user_DllExport MemberId member_id() const
7120 {
7121 return m_member_id;
7122 }
7123
7128 eProsima_user_DllExport MemberId& member_id()
7129 {
7130 return m_member_id;
7131 }
7132
7133
7138 eProsima_user_DllExport void member_flags(
7139 const StructMemberFlag& _member_flags)
7140 {
7141 m_member_flags = _member_flags;
7142 }
7143
7148 eProsima_user_DllExport void member_flags(
7149 StructMemberFlag&& _member_flags)
7150 {
7151 m_member_flags = std::move(_member_flags);
7152 }
7153
7158 eProsima_user_DllExport const StructMemberFlag& member_flags() const
7159 {
7160 return m_member_flags;
7161 }
7162
7167 eProsima_user_DllExport StructMemberFlag& member_flags()
7168 {
7169 return m_member_flags;
7170 }
7171
7172
7177 eProsima_user_DllExport void member_type_id(
7178 const TypeIdentifier& _member_type_id)
7179 {
7180 m_member_type_id = _member_type_id;
7181 }
7182
7187 eProsima_user_DllExport void member_type_id(
7188 TypeIdentifier&& _member_type_id)
7189 {
7190 m_member_type_id = std::move(_member_type_id);
7191 }
7192
7197 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
7198 {
7199 return m_member_type_id;
7200 }
7201
7206 eProsima_user_DllExport TypeIdentifier& member_type_id()
7207 {
7208 return m_member_type_id;
7209 }
7210
7211
7212
7213private:
7214
7215 MemberId m_member_id{0};
7216 StructMemberFlag m_member_flags{0};
7217 TypeIdentifier m_member_type_id;
7218
7219};
7225{
7226public:
7227
7231 eProsima_user_DllExport CompleteMemberDetail()
7232 {
7233 }
7234
7238 eProsima_user_DllExport ~CompleteMemberDetail()
7239 {
7240 }
7241
7246 eProsima_user_DllExport CompleteMemberDetail(
7247 const CompleteMemberDetail& x)
7248 {
7249 m_name = x.m_name;
7250
7251 m_ann_builtin = x.m_ann_builtin;
7252
7253 m_ann_custom = x.m_ann_custom;
7254
7255 }
7256
7261 eProsima_user_DllExport CompleteMemberDetail(
7262 CompleteMemberDetail&& x) noexcept
7263 {
7264 m_name = std::move(x.m_name);
7265 m_ann_builtin = std::move(x.m_ann_builtin);
7266 m_ann_custom = std::move(x.m_ann_custom);
7267 }
7268
7273 eProsima_user_DllExport CompleteMemberDetail& operator =(
7274 const CompleteMemberDetail& x)
7275 {
7276
7277 m_name = x.m_name;
7278
7279 m_ann_builtin = x.m_ann_builtin;
7280
7281 m_ann_custom = x.m_ann_custom;
7282
7283 return *this;
7284 }
7285
7290 eProsima_user_DllExport CompleteMemberDetail& operator =(
7291 CompleteMemberDetail&& x) noexcept
7292 {
7293
7294 m_name = std::move(x.m_name);
7295 m_ann_builtin = std::move(x.m_ann_builtin);
7296 m_ann_custom = std::move(x.m_ann_custom);
7297 return *this;
7298 }
7299
7304 eProsima_user_DllExport bool operator ==(
7305 const CompleteMemberDetail& x) const
7306 {
7307 return (m_name == x.m_name &&
7308 m_ann_builtin == x.m_ann_builtin &&
7309 m_ann_custom == x.m_ann_custom);
7310 }
7311
7316 eProsima_user_DllExport bool operator !=(
7317 const CompleteMemberDetail& x) const
7318 {
7319 return !(*this == x);
7320 }
7321
7326 eProsima_user_DllExport void name(
7327 const MemberName& _name)
7328 {
7329 m_name = _name;
7330 }
7331
7336 eProsima_user_DllExport void name(
7337 MemberName&& _name)
7338 {
7339 m_name = std::move(_name);
7340 }
7341
7346 eProsima_user_DllExport const MemberName& name() const
7347 {
7348 return m_name;
7349 }
7350
7355 eProsima_user_DllExport MemberName& name()
7356 {
7357 return m_name;
7358 }
7359
7360
7365 eProsima_user_DllExport void ann_builtin(
7366 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
7367 {
7368 m_ann_builtin = _ann_builtin;
7369 }
7370
7375 eProsima_user_DllExport void ann_builtin(
7376 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
7377 {
7378 m_ann_builtin = std::move(_ann_builtin);
7379 }
7380
7385 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
7386 {
7387 return m_ann_builtin;
7388 }
7389
7394 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
7395 {
7396 return m_ann_builtin;
7397 }
7398
7399
7404 eProsima_user_DllExport void ann_custom(
7405 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
7406 {
7407 m_ann_custom = _ann_custom;
7408 }
7409
7414 eProsima_user_DllExport void ann_custom(
7415 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
7416 {
7417 m_ann_custom = std::move(_ann_custom);
7418 }
7419
7424 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
7425 {
7426 return m_ann_custom;
7427 }
7428
7433 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
7434 {
7435 return m_ann_custom;
7436 }
7437
7438
7439
7440private:
7441
7442 MemberName m_name;
7443 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
7444 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
7445
7446};
7452{
7453public:
7454
7458 eProsima_user_DllExport MinimalMemberDetail()
7459 {
7460 }
7461
7465 eProsima_user_DllExport ~MinimalMemberDetail()
7466 {
7467 }
7468
7473 eProsima_user_DllExport MinimalMemberDetail(
7474 const MinimalMemberDetail& x)
7475 {
7476 m_name_hash = x.m_name_hash;
7477
7478 }
7479
7484 eProsima_user_DllExport MinimalMemberDetail(
7485 MinimalMemberDetail&& x) noexcept
7486 {
7487 m_name_hash = std::move(x.m_name_hash);
7488 }
7489
7494 eProsima_user_DllExport MinimalMemberDetail& operator =(
7495 const MinimalMemberDetail& x)
7496 {
7497
7498 m_name_hash = x.m_name_hash;
7499
7500 return *this;
7501 }
7502
7507 eProsima_user_DllExport MinimalMemberDetail& operator =(
7508 MinimalMemberDetail&& x) noexcept
7509 {
7510
7511 m_name_hash = std::move(x.m_name_hash);
7512 return *this;
7513 }
7514
7519 eProsima_user_DllExport bool operator ==(
7520 const MinimalMemberDetail& x) const
7521 {
7522 return (m_name_hash == x.m_name_hash);
7523 }
7524
7529 eProsima_user_DllExport bool operator !=(
7530 const MinimalMemberDetail& x) const
7531 {
7532 return !(*this == x);
7533 }
7534
7539 eProsima_user_DllExport void name_hash(
7540 const NameHash& _name_hash)
7541 {
7542 m_name_hash = _name_hash;
7543 }
7544
7549 eProsima_user_DllExport void name_hash(
7550 NameHash&& _name_hash)
7551 {
7552 m_name_hash = std::move(_name_hash);
7553 }
7554
7559 eProsima_user_DllExport const NameHash& name_hash() const
7560 {
7561 return m_name_hash;
7562 }
7563
7568 eProsima_user_DllExport NameHash& name_hash()
7569 {
7570 return m_name_hash;
7571 }
7572
7573
7574
7575private:
7576
7577 NameHash m_name_hash{0};
7578
7579};
7585{
7586public:
7587
7591 eProsima_user_DllExport CompleteStructMember()
7592 {
7593 }
7594
7598 eProsima_user_DllExport ~CompleteStructMember()
7599 {
7600 }
7601
7606 eProsima_user_DllExport CompleteStructMember(
7607 const CompleteStructMember& x)
7608 {
7609 m_common = x.m_common;
7610
7611 m_detail = x.m_detail;
7612
7613 }
7614
7619 eProsima_user_DllExport CompleteStructMember(
7620 CompleteStructMember&& x) noexcept
7621 {
7622 m_common = std::move(x.m_common);
7623 m_detail = std::move(x.m_detail);
7624 }
7625
7630 eProsima_user_DllExport CompleteStructMember& operator =(
7631 const CompleteStructMember& x)
7632 {
7633
7634 m_common = x.m_common;
7635
7636 m_detail = x.m_detail;
7637
7638 return *this;
7639 }
7640
7645 eProsima_user_DllExport CompleteStructMember& operator =(
7646 CompleteStructMember&& x) noexcept
7647 {
7648
7649 m_common = std::move(x.m_common);
7650 m_detail = std::move(x.m_detail);
7651 return *this;
7652 }
7653
7658 eProsima_user_DllExport bool operator ==(
7659 const CompleteStructMember& x) const
7660 {
7661 return (m_common == x.m_common &&
7662 m_detail == x.m_detail);
7663 }
7664
7669 eProsima_user_DllExport bool operator !=(
7670 const CompleteStructMember& x) const
7671 {
7672 return !(*this == x);
7673 }
7674
7679 eProsima_user_DllExport void common(
7680 const CommonStructMember& _common)
7681 {
7682 m_common = _common;
7683 }
7684
7689 eProsima_user_DllExport void common(
7690 CommonStructMember&& _common)
7691 {
7692 m_common = std::move(_common);
7693 }
7694
7699 eProsima_user_DllExport const CommonStructMember& common() const
7700 {
7701 return m_common;
7702 }
7703
7708 eProsima_user_DllExport CommonStructMember& common()
7709 {
7710 return m_common;
7711 }
7712
7713
7718 eProsima_user_DllExport void detail(
7719 const CompleteMemberDetail& _detail)
7720 {
7721 m_detail = _detail;
7722 }
7723
7728 eProsima_user_DllExport void detail(
7729 CompleteMemberDetail&& _detail)
7730 {
7731 m_detail = std::move(_detail);
7732 }
7733
7738 eProsima_user_DllExport const CompleteMemberDetail& detail() const
7739 {
7740 return m_detail;
7741 }
7742
7747 eProsima_user_DllExport CompleteMemberDetail& detail()
7748 {
7749 return m_detail;
7750 }
7751
7752
7753
7754private:
7755
7756 CommonStructMember m_common;
7757 CompleteMemberDetail m_detail;
7758
7759};
7760typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
7761
7767{
7768public:
7769
7773 eProsima_user_DllExport MinimalStructMember()
7774 {
7775 }
7776
7780 eProsima_user_DllExport ~MinimalStructMember()
7781 {
7782 }
7783
7788 eProsima_user_DllExport MinimalStructMember(
7789 const MinimalStructMember& x)
7790 {
7791 m_common = x.m_common;
7792
7793 m_detail = x.m_detail;
7794
7795 }
7796
7801 eProsima_user_DllExport MinimalStructMember(
7802 MinimalStructMember&& x) noexcept
7803 {
7804 m_common = std::move(x.m_common);
7805 m_detail = std::move(x.m_detail);
7806 }
7807
7812 eProsima_user_DllExport MinimalStructMember& operator =(
7813 const MinimalStructMember& x)
7814 {
7815
7816 m_common = x.m_common;
7817
7818 m_detail = x.m_detail;
7819
7820 return *this;
7821 }
7822
7827 eProsima_user_DllExport MinimalStructMember& operator =(
7828 MinimalStructMember&& x) noexcept
7829 {
7830
7831 m_common = std::move(x.m_common);
7832 m_detail = std::move(x.m_detail);
7833 return *this;
7834 }
7835
7840 eProsima_user_DllExport bool operator ==(
7841 const MinimalStructMember& x) const
7842 {
7843 return (m_common == x.m_common &&
7844 m_detail == x.m_detail);
7845 }
7846
7851 eProsima_user_DllExport bool operator !=(
7852 const MinimalStructMember& x) const
7853 {
7854 return !(*this == x);
7855 }
7856
7861 eProsima_user_DllExport void common(
7862 const CommonStructMember& _common)
7863 {
7864 m_common = _common;
7865 }
7866
7871 eProsima_user_DllExport void common(
7872 CommonStructMember&& _common)
7873 {
7874 m_common = std::move(_common);
7875 }
7876
7881 eProsima_user_DllExport const CommonStructMember& common() const
7882 {
7883 return m_common;
7884 }
7885
7890 eProsima_user_DllExport CommonStructMember& common()
7891 {
7892 return m_common;
7893 }
7894
7895
7900 eProsima_user_DllExport void detail(
7901 const MinimalMemberDetail& _detail)
7902 {
7903 m_detail = _detail;
7904 }
7905
7910 eProsima_user_DllExport void detail(
7911 MinimalMemberDetail&& _detail)
7912 {
7913 m_detail = std::move(_detail);
7914 }
7915
7920 eProsima_user_DllExport const MinimalMemberDetail& detail() const
7921 {
7922 return m_detail;
7923 }
7924
7929 eProsima_user_DllExport MinimalMemberDetail& detail()
7930 {
7931 return m_detail;
7932 }
7933
7934
7935
7936private:
7937
7938 CommonStructMember m_common;
7939 MinimalMemberDetail m_detail;
7940
7941};
7942typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
7943
7949{
7950public:
7951
7955 eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
7956 {
7957 }
7958
7962 eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
7963 {
7964 }
7965
7970 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
7972 {
7973 m_verbatim = x.m_verbatim;
7974
7975 }
7976
7981 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
7982 AppliedBuiltinTypeAnnotations&& x) noexcept
7983 {
7984 m_verbatim = std::move(x.m_verbatim);
7985 }
7986
7993 {
7994
7995 m_verbatim = x.m_verbatim;
7996
7997 return *this;
7998 }
7999
8005 AppliedBuiltinTypeAnnotations&& x) noexcept
8006 {
8007
8008 m_verbatim = std::move(x.m_verbatim);
8009 return *this;
8010 }
8011
8016 eProsima_user_DllExport bool operator ==(
8017 const AppliedBuiltinTypeAnnotations& x) const
8018 {
8019 return (m_verbatim == x.m_verbatim);
8020 }
8021
8026 eProsima_user_DllExport bool operator !=(
8027 const AppliedBuiltinTypeAnnotations& x) const
8028 {
8029 return !(*this == x);
8030 }
8031
8036 eProsima_user_DllExport void verbatim(
8037 const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& _verbatim)
8038 {
8039 m_verbatim = _verbatim;
8040 }
8041
8046 eProsima_user_DllExport void verbatim(
8047 eprosima::fastcdr::optional<AppliedVerbatimAnnotation>&& _verbatim)
8048 {
8049 m_verbatim = std::move(_verbatim);
8050 }
8051
8056 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim() const
8057 {
8058 return m_verbatim;
8059 }
8060
8065 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim()
8066 {
8067 return m_verbatim;
8068 }
8069
8070
8071
8072private:
8073
8074 eprosima::fastcdr::optional<AppliedVerbatimAnnotation> m_verbatim;
8075
8076};
8082{
8083public:
8084
8088 eProsima_user_DllExport MinimalTypeDetail()
8089 {
8090 }
8091
8095 eProsima_user_DllExport ~MinimalTypeDetail()
8096 {
8097 }
8098
8103 eProsima_user_DllExport MinimalTypeDetail(
8104 const MinimalTypeDetail& x)
8105 {
8106 static_cast<void>(x);
8107 }
8108
8113 eProsima_user_DllExport MinimalTypeDetail(
8114 MinimalTypeDetail&& x) noexcept
8115 {
8116 static_cast<void>(x);
8117 }
8118
8123 eProsima_user_DllExport MinimalTypeDetail& operator =(
8124 const MinimalTypeDetail& x)
8125 {
8126
8127 static_cast<void>(x);
8128
8129 return *this;
8130 }
8131
8136 eProsima_user_DllExport MinimalTypeDetail& operator =(
8137 MinimalTypeDetail&& x) noexcept
8138 {
8139
8140 static_cast<void>(x);
8141
8142 return *this;
8143 }
8144
8149 eProsima_user_DllExport bool operator ==(
8150 const MinimalTypeDetail& x) const
8151 {
8152 static_cast<void>(x);
8153 return true;
8154 }
8155
8160 eProsima_user_DllExport bool operator !=(
8161 const MinimalTypeDetail& x) const
8162 {
8163 return !(*this == x);
8164 }
8165
8166
8167
8168private:
8169
8170
8171};
8177{
8178public:
8179
8183 eProsima_user_DllExport CompleteTypeDetail()
8184 {
8185 }
8186
8190 eProsima_user_DllExport ~CompleteTypeDetail()
8191 {
8192 }
8193
8198 eProsima_user_DllExport CompleteTypeDetail(
8199 const CompleteTypeDetail& x)
8200 {
8201 m_ann_builtin = x.m_ann_builtin;
8202
8203 m_ann_custom = x.m_ann_custom;
8204
8205 m_type_name = x.m_type_name;
8206
8207 }
8208
8213 eProsima_user_DllExport CompleteTypeDetail(
8214 CompleteTypeDetail&& x) noexcept
8215 {
8216 m_ann_builtin = std::move(x.m_ann_builtin);
8217 m_ann_custom = std::move(x.m_ann_custom);
8218 m_type_name = std::move(x.m_type_name);
8219 }
8220
8225 eProsima_user_DllExport CompleteTypeDetail& operator =(
8226 const CompleteTypeDetail& x)
8227 {
8228
8229 m_ann_builtin = x.m_ann_builtin;
8230
8231 m_ann_custom = x.m_ann_custom;
8232
8233 m_type_name = x.m_type_name;
8234
8235 return *this;
8236 }
8237
8242 eProsima_user_DllExport CompleteTypeDetail& operator =(
8243 CompleteTypeDetail&& x) noexcept
8244 {
8245
8246 m_ann_builtin = std::move(x.m_ann_builtin);
8247 m_ann_custom = std::move(x.m_ann_custom);
8248 m_type_name = std::move(x.m_type_name);
8249 return *this;
8250 }
8251
8256 eProsima_user_DllExport bool operator ==(
8257 const CompleteTypeDetail& x) const
8258 {
8259 return (m_ann_builtin == x.m_ann_builtin &&
8260 m_ann_custom == x.m_ann_custom &&
8261 m_type_name == x.m_type_name);
8262 }
8263
8268 eProsima_user_DllExport bool operator !=(
8269 const CompleteTypeDetail& x) const
8270 {
8271 return !(*this == x);
8272 }
8273
8278 eProsima_user_DllExport void ann_builtin(
8279 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
8280 {
8281 m_ann_builtin = _ann_builtin;
8282 }
8283
8288 eProsima_user_DllExport void ann_builtin(
8289 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
8290 {
8291 m_ann_builtin = std::move(_ann_builtin);
8292 }
8293
8298 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
8299 {
8300 return m_ann_builtin;
8301 }
8302
8307 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
8308 {
8309 return m_ann_builtin;
8310 }
8311
8312
8317 eProsima_user_DllExport void ann_custom(
8318 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
8319 {
8320 m_ann_custom = _ann_custom;
8321 }
8322
8327 eProsima_user_DllExport void ann_custom(
8328 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
8329 {
8330 m_ann_custom = std::move(_ann_custom);
8331 }
8332
8337 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
8338 {
8339 return m_ann_custom;
8340 }
8341
8346 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
8347 {
8348 return m_ann_custom;
8349 }
8350
8351
8356 eProsima_user_DllExport void type_name(
8357 const QualifiedTypeName& _type_name)
8358 {
8359 m_type_name = _type_name;
8360 }
8361
8366 eProsima_user_DllExport void type_name(
8367 QualifiedTypeName&& _type_name)
8368 {
8369 m_type_name = std::move(_type_name);
8370 }
8371
8376 eProsima_user_DllExport const QualifiedTypeName& type_name() const
8377 {
8378 return m_type_name;
8379 }
8380
8385 eProsima_user_DllExport QualifiedTypeName& type_name()
8386 {
8387 return m_type_name;
8388 }
8389
8390
8391
8392private:
8393
8394 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
8395 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
8396 QualifiedTypeName m_type_name;
8397
8398};
8404{
8405public:
8406
8410 eProsima_user_DllExport CompleteStructHeader()
8411 {
8412 }
8413
8417 eProsima_user_DllExport ~CompleteStructHeader()
8418 {
8419 }
8420
8425 eProsima_user_DllExport CompleteStructHeader(
8426 const CompleteStructHeader& x)
8427 {
8428 m_base_type = x.m_base_type;
8429
8430 m_detail = x.m_detail;
8431
8432 }
8433
8438 eProsima_user_DllExport CompleteStructHeader(
8439 CompleteStructHeader&& x) noexcept
8440 {
8441 m_base_type = std::move(x.m_base_type);
8442 m_detail = std::move(x.m_detail);
8443 }
8444
8449 eProsima_user_DllExport CompleteStructHeader& operator =(
8450 const CompleteStructHeader& x)
8451 {
8452
8453 m_base_type = x.m_base_type;
8454
8455 m_detail = x.m_detail;
8456
8457 return *this;
8458 }
8459
8464 eProsima_user_DllExport CompleteStructHeader& operator =(
8465 CompleteStructHeader&& x) noexcept
8466 {
8467
8468 m_base_type = std::move(x.m_base_type);
8469 m_detail = std::move(x.m_detail);
8470 return *this;
8471 }
8472
8477 eProsima_user_DllExport bool operator ==(
8478 const CompleteStructHeader& x) const
8479 {
8480 return (m_base_type == x.m_base_type &&
8481 m_detail == x.m_detail);
8482 }
8483
8488 eProsima_user_DllExport bool operator !=(
8489 const CompleteStructHeader& x) const
8490 {
8491 return !(*this == x);
8492 }
8493
8498 eProsima_user_DllExport void base_type(
8499 const TypeIdentifier& _base_type)
8500 {
8501 m_base_type = _base_type;
8502 }
8503
8508 eProsima_user_DllExport void base_type(
8509 TypeIdentifier&& _base_type)
8510 {
8511 m_base_type = std::move(_base_type);
8512 }
8513
8518 eProsima_user_DllExport const TypeIdentifier& base_type() const
8519 {
8520 return m_base_type;
8521 }
8522
8527 eProsima_user_DllExport TypeIdentifier& base_type()
8528 {
8529 return m_base_type;
8530 }
8531
8532
8537 eProsima_user_DllExport void detail(
8538 const CompleteTypeDetail& _detail)
8539 {
8540 m_detail = _detail;
8541 }
8542
8547 eProsima_user_DllExport void detail(
8548 CompleteTypeDetail&& _detail)
8549 {
8550 m_detail = std::move(_detail);
8551 }
8552
8557 eProsima_user_DllExport const CompleteTypeDetail& detail() const
8558 {
8559 return m_detail;
8560 }
8561
8566 eProsima_user_DllExport CompleteTypeDetail& detail()
8567 {
8568 return m_detail;
8569 }
8570
8571
8572
8573private:
8574
8575 TypeIdentifier m_base_type;
8576 CompleteTypeDetail m_detail;
8577
8578};
8584{
8585public:
8586
8590 eProsima_user_DllExport MinimalStructHeader()
8591 {
8592 }
8593
8597 eProsima_user_DllExport ~MinimalStructHeader()
8598 {
8599 }
8600
8605 eProsima_user_DllExport MinimalStructHeader(
8606 const MinimalStructHeader& x)
8607 {
8608 m_base_type = x.m_base_type;
8609
8610 m_detail = x.m_detail;
8611
8612 }
8613
8618 eProsima_user_DllExport MinimalStructHeader(
8619 MinimalStructHeader&& x) noexcept
8620 {
8621 m_base_type = std::move(x.m_base_type);
8622 m_detail = std::move(x.m_detail);
8623 }
8624
8629 eProsima_user_DllExport MinimalStructHeader& operator =(
8630 const MinimalStructHeader& x)
8631 {
8632
8633 m_base_type = x.m_base_type;
8634
8635 m_detail = x.m_detail;
8636
8637 return *this;
8638 }
8639
8644 eProsima_user_DllExport MinimalStructHeader& operator =(
8645 MinimalStructHeader&& x) noexcept
8646 {
8647
8648 m_base_type = std::move(x.m_base_type);
8649 m_detail = std::move(x.m_detail);
8650 return *this;
8651 }
8652
8657 eProsima_user_DllExport bool operator ==(
8658 const MinimalStructHeader& x) const
8659 {
8660 return (m_base_type == x.m_base_type &&
8661 m_detail == x.m_detail);
8662 }
8663
8668 eProsima_user_DllExport bool operator !=(
8669 const MinimalStructHeader& x) const
8670 {
8671 return !(*this == x);
8672 }
8673
8678 eProsima_user_DllExport void base_type(
8679 const TypeIdentifier& _base_type)
8680 {
8681 m_base_type = _base_type;
8682 }
8683
8688 eProsima_user_DllExport void base_type(
8689 TypeIdentifier&& _base_type)
8690 {
8691 m_base_type = std::move(_base_type);
8692 }
8693
8698 eProsima_user_DllExport const TypeIdentifier& base_type() const
8699 {
8700 return m_base_type;
8701 }
8702
8707 eProsima_user_DllExport TypeIdentifier& base_type()
8708 {
8709 return m_base_type;
8710 }
8711
8712
8717 eProsima_user_DllExport void detail(
8718 const MinimalTypeDetail& _detail)
8719 {
8720 m_detail = _detail;
8721 }
8722
8727 eProsima_user_DllExport void detail(
8728 MinimalTypeDetail&& _detail)
8729 {
8730 m_detail = std::move(_detail);
8731 }
8732
8737 eProsima_user_DllExport const MinimalTypeDetail& detail() const
8738 {
8739 return m_detail;
8740 }
8741
8746 eProsima_user_DllExport MinimalTypeDetail& detail()
8747 {
8748 return m_detail;
8749 }
8750
8751
8752
8753private:
8754
8755 TypeIdentifier m_base_type;
8756 MinimalTypeDetail m_detail;
8757
8758};
8764{
8765public:
8766
8770 eProsima_user_DllExport CompleteStructType()
8771 {
8772 }
8773
8777 eProsima_user_DllExport ~CompleteStructType()
8778 {
8779 }
8780
8785 eProsima_user_DllExport CompleteStructType(
8786 const CompleteStructType& x)
8787 {
8788 m_struct_flags = x.m_struct_flags;
8789
8790 m_header = x.m_header;
8791
8792 m_member_seq = x.m_member_seq;
8793
8794 }
8795
8800 eProsima_user_DllExport CompleteStructType(
8801 CompleteStructType&& x) noexcept
8802 {
8803 m_struct_flags = std::move(x.m_struct_flags);
8804 m_header = std::move(x.m_header);
8805 m_member_seq = std::move(x.m_member_seq);
8806 }
8807
8812 eProsima_user_DllExport CompleteStructType& operator =(
8813 const CompleteStructType& x)
8814 {
8815
8816 m_struct_flags = x.m_struct_flags;
8817
8818 m_header = x.m_header;
8819
8820 m_member_seq = x.m_member_seq;
8821
8822 return *this;
8823 }
8824
8829 eProsima_user_DllExport CompleteStructType& operator =(
8830 CompleteStructType&& x) noexcept
8831 {
8832
8833 m_struct_flags = std::move(x.m_struct_flags);
8834 m_header = std::move(x.m_header);
8835 m_member_seq = std::move(x.m_member_seq);
8836 return *this;
8837 }
8838
8843 eProsima_user_DllExport bool operator ==(
8844 const CompleteStructType& x) const
8845 {
8846 return (m_struct_flags == x.m_struct_flags &&
8847 m_header == x.m_header &&
8848 m_member_seq == x.m_member_seq);
8849 }
8850
8855 eProsima_user_DllExport bool operator !=(
8856 const CompleteStructType& x) const
8857 {
8858 return !(*this == x);
8859 }
8860
8865 eProsima_user_DllExport void struct_flags(
8866 const StructTypeFlag& _struct_flags)
8867 {
8868 m_struct_flags = _struct_flags;
8869 }
8870
8875 eProsima_user_DllExport void struct_flags(
8876 StructTypeFlag&& _struct_flags)
8877 {
8878 m_struct_flags = std::move(_struct_flags);
8879 }
8880
8885 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
8886 {
8887 return m_struct_flags;
8888 }
8889
8894 eProsima_user_DllExport StructTypeFlag& struct_flags()
8895 {
8896 return m_struct_flags;
8897 }
8898
8899
8904 eProsima_user_DllExport void header(
8905 const CompleteStructHeader& _header)
8906 {
8907 m_header = _header;
8908 }
8909
8914 eProsima_user_DllExport void header(
8915 CompleteStructHeader&& _header)
8916 {
8917 m_header = std::move(_header);
8918 }
8919
8924 eProsima_user_DllExport const CompleteStructHeader& header() const
8925 {
8926 return m_header;
8927 }
8928
8933 eProsima_user_DllExport CompleteStructHeader& header()
8934 {
8935 return m_header;
8936 }
8937
8938
8943 eProsima_user_DllExport void member_seq(
8944 const CompleteStructMemberSeq& _member_seq)
8945 {
8946 m_member_seq = _member_seq;
8947 }
8948
8953 eProsima_user_DllExport void member_seq(
8954 CompleteStructMemberSeq&& _member_seq)
8955 {
8956 m_member_seq = std::move(_member_seq);
8957 }
8958
8963 eProsima_user_DllExport const CompleteStructMemberSeq& member_seq() const
8964 {
8965 return m_member_seq;
8966 }
8967
8972 eProsima_user_DllExport CompleteStructMemberSeq& member_seq()
8973 {
8974 return m_member_seq;
8975 }
8976
8977
8978
8979private:
8980
8981 StructTypeFlag m_struct_flags{0};
8982 CompleteStructHeader m_header;
8983 CompleteStructMemberSeq m_member_seq;
8984
8985};
8991{
8992public:
8993
8997 eProsima_user_DllExport MinimalStructType()
8998 {
8999 }
9000
9004 eProsima_user_DllExport ~MinimalStructType()
9005 {
9006 }
9007
9012 eProsima_user_DllExport MinimalStructType(
9013 const MinimalStructType& x)
9014 {
9015 m_struct_flags = x.m_struct_flags;
9016
9017 m_header = x.m_header;
9018
9019 m_member_seq = x.m_member_seq;
9020
9021 }
9022
9027 eProsima_user_DllExport MinimalStructType(
9028 MinimalStructType&& x) noexcept
9029 {
9030 m_struct_flags = std::move(x.m_struct_flags);
9031 m_header = std::move(x.m_header);
9032 m_member_seq = std::move(x.m_member_seq);
9033 }
9034
9039 eProsima_user_DllExport MinimalStructType& operator =(
9040 const MinimalStructType& x)
9041 {
9042
9043 m_struct_flags = x.m_struct_flags;
9044
9045 m_header = x.m_header;
9046
9047 m_member_seq = x.m_member_seq;
9048
9049 return *this;
9050 }
9051
9056 eProsima_user_DllExport MinimalStructType& operator =(
9057 MinimalStructType&& x) noexcept
9058 {
9059
9060 m_struct_flags = std::move(x.m_struct_flags);
9061 m_header = std::move(x.m_header);
9062 m_member_seq = std::move(x.m_member_seq);
9063 return *this;
9064 }
9065
9070 eProsima_user_DllExport bool operator ==(
9071 const MinimalStructType& x) const
9072 {
9073 return (m_struct_flags == x.m_struct_flags &&
9074 m_header == x.m_header &&
9075 m_member_seq == x.m_member_seq);
9076 }
9077
9082 eProsima_user_DllExport bool operator !=(
9083 const MinimalStructType& x) const
9084 {
9085 return !(*this == x);
9086 }
9087
9092 eProsima_user_DllExport void struct_flags(
9093 const StructTypeFlag& _struct_flags)
9094 {
9095 m_struct_flags = _struct_flags;
9096 }
9097
9102 eProsima_user_DllExport void struct_flags(
9103 StructTypeFlag&& _struct_flags)
9104 {
9105 m_struct_flags = std::move(_struct_flags);
9106 }
9107
9112 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
9113 {
9114 return m_struct_flags;
9115 }
9116
9121 eProsima_user_DllExport StructTypeFlag& struct_flags()
9122 {
9123 return m_struct_flags;
9124 }
9125
9126
9131 eProsima_user_DllExport void header(
9132 const MinimalStructHeader& _header)
9133 {
9134 m_header = _header;
9135 }
9136
9141 eProsima_user_DllExport void header(
9142 MinimalStructHeader&& _header)
9143 {
9144 m_header = std::move(_header);
9145 }
9146
9151 eProsima_user_DllExport const MinimalStructHeader& header() const
9152 {
9153 return m_header;
9154 }
9155
9160 eProsima_user_DllExport MinimalStructHeader& header()
9161 {
9162 return m_header;
9163 }
9164
9165
9170 eProsima_user_DllExport void member_seq(
9171 const MinimalStructMemberSeq& _member_seq)
9172 {
9173 m_member_seq = _member_seq;
9174 }
9175
9180 eProsima_user_DllExport void member_seq(
9181 MinimalStructMemberSeq&& _member_seq)
9182 {
9183 m_member_seq = std::move(_member_seq);
9184 }
9185
9190 eProsima_user_DllExport const MinimalStructMemberSeq& member_seq() const
9191 {
9192 return m_member_seq;
9193 }
9194
9199 eProsima_user_DllExport MinimalStructMemberSeq& member_seq()
9200 {
9201 return m_member_seq;
9202 }
9203
9204
9205
9206private:
9207
9208 StructTypeFlag m_struct_flags{0};
9209 MinimalStructHeader m_header;
9210 MinimalStructMemberSeq m_member_seq;
9211
9212};
9213typedef std::vector<int32_t> UnionCaseLabelSeq;
9214
9220{
9221public:
9222
9226 eProsima_user_DllExport CommonUnionMember()
9227 {
9228 }
9229
9233 eProsima_user_DllExport ~CommonUnionMember()
9234 {
9235 }
9236
9241 eProsima_user_DllExport CommonUnionMember(
9242 const CommonUnionMember& x)
9243 {
9244 m_member_id = x.m_member_id;
9245
9246 m_member_flags = x.m_member_flags;
9247
9248 m_type_id = x.m_type_id;
9249
9250 m_label_seq = x.m_label_seq;
9251
9252 }
9253
9258 eProsima_user_DllExport CommonUnionMember(
9259 CommonUnionMember&& x) noexcept
9260 {
9261 m_member_id = x.m_member_id;
9262 m_member_flags = std::move(x.m_member_flags);
9263 m_type_id = std::move(x.m_type_id);
9264 m_label_seq = std::move(x.m_label_seq);
9265 }
9266
9271 eProsima_user_DllExport CommonUnionMember& operator =(
9272 const CommonUnionMember& x)
9273 {
9274
9275 m_member_id = x.m_member_id;
9276
9277 m_member_flags = x.m_member_flags;
9278
9279 m_type_id = x.m_type_id;
9280
9281 m_label_seq = x.m_label_seq;
9282
9283 return *this;
9284 }
9285
9290 eProsima_user_DllExport CommonUnionMember& operator =(
9291 CommonUnionMember&& x) noexcept
9292 {
9293
9294 m_member_id = x.m_member_id;
9295 m_member_flags = std::move(x.m_member_flags);
9296 m_type_id = std::move(x.m_type_id);
9297 m_label_seq = std::move(x.m_label_seq);
9298 return *this;
9299 }
9300
9305 eProsima_user_DllExport bool operator ==(
9306 const CommonUnionMember& x) const
9307 {
9308 return (m_member_id == x.m_member_id &&
9309 m_member_flags == x.m_member_flags &&
9310 m_type_id == x.m_type_id &&
9311 m_label_seq == x.m_label_seq);
9312 }
9313
9318 eProsima_user_DllExport bool operator !=(
9319 const CommonUnionMember& x) const
9320 {
9321 return !(*this == x);
9322 }
9323
9328 eProsima_user_DllExport void member_id(
9329 MemberId _member_id)
9330 {
9331 m_member_id = _member_id;
9332 }
9333
9338 eProsima_user_DllExport MemberId member_id() const
9339 {
9340 return m_member_id;
9341 }
9342
9347 eProsima_user_DllExport MemberId& member_id()
9348 {
9349 return m_member_id;
9350 }
9351
9352
9357 eProsima_user_DllExport void member_flags(
9358 const UnionMemberFlag& _member_flags)
9359 {
9360 m_member_flags = _member_flags;
9361 }
9362
9367 eProsima_user_DllExport void member_flags(
9368 UnionMemberFlag&& _member_flags)
9369 {
9370 m_member_flags = std::move(_member_flags);
9371 }
9372
9377 eProsima_user_DllExport const UnionMemberFlag& member_flags() const
9378 {
9379 return m_member_flags;
9380 }
9381
9386 eProsima_user_DllExport UnionMemberFlag& member_flags()
9387 {
9388 return m_member_flags;
9389 }
9390
9391
9396 eProsima_user_DllExport void type_id(
9397 const TypeIdentifier& _type_id)
9398 {
9399 m_type_id = _type_id;
9400 }
9401
9406 eProsima_user_DllExport void type_id(
9407 TypeIdentifier&& _type_id)
9408 {
9409 m_type_id = std::move(_type_id);
9410 }
9411
9416 eProsima_user_DllExport const TypeIdentifier& type_id() const
9417 {
9418 return m_type_id;
9419 }
9420
9425 eProsima_user_DllExport TypeIdentifier& type_id()
9426 {
9427 return m_type_id;
9428 }
9429
9430
9435 eProsima_user_DllExport void label_seq(
9436 const UnionCaseLabelSeq& _label_seq)
9437 {
9438 m_label_seq = _label_seq;
9439 }
9440
9445 eProsima_user_DllExport void label_seq(
9446 UnionCaseLabelSeq&& _label_seq)
9447 {
9448 m_label_seq = std::move(_label_seq);
9449 }
9450
9455 eProsima_user_DllExport const UnionCaseLabelSeq& label_seq() const
9456 {
9457 return m_label_seq;
9458 }
9459
9464 eProsima_user_DllExport UnionCaseLabelSeq& label_seq()
9465 {
9466 return m_label_seq;
9467 }
9468
9469
9470
9471private:
9472
9473 MemberId m_member_id{0};
9474 UnionMemberFlag m_member_flags{0};
9475 TypeIdentifier m_type_id;
9476 UnionCaseLabelSeq m_label_seq;
9477
9478};
9484{
9485public:
9486
9490 eProsima_user_DllExport CompleteUnionMember()
9491 {
9492 }
9493
9497 eProsima_user_DllExport ~CompleteUnionMember()
9498 {
9499 }
9500
9505 eProsima_user_DllExport CompleteUnionMember(
9506 const CompleteUnionMember& x)
9507 {
9508 m_common = x.m_common;
9509
9510 m_detail = x.m_detail;
9511
9512 }
9513
9518 eProsima_user_DllExport CompleteUnionMember(
9519 CompleteUnionMember&& x) noexcept
9520 {
9521 m_common = std::move(x.m_common);
9522 m_detail = std::move(x.m_detail);
9523 }
9524
9529 eProsima_user_DllExport CompleteUnionMember& operator =(
9530 const CompleteUnionMember& x)
9531 {
9532
9533 m_common = x.m_common;
9534
9535 m_detail = x.m_detail;
9536
9537 return *this;
9538 }
9539
9544 eProsima_user_DllExport CompleteUnionMember& operator =(
9545 CompleteUnionMember&& x) noexcept
9546 {
9547
9548 m_common = std::move(x.m_common);
9549 m_detail = std::move(x.m_detail);
9550 return *this;
9551 }
9552
9557 eProsima_user_DllExport bool operator ==(
9558 const CompleteUnionMember& x) const
9559 {
9560 return (m_common == x.m_common &&
9561 m_detail == x.m_detail);
9562 }
9563
9568 eProsima_user_DllExport bool operator !=(
9569 const CompleteUnionMember& x) const
9570 {
9571 return !(*this == x);
9572 }
9573
9578 eProsima_user_DllExport void common(
9579 const CommonUnionMember& _common)
9580 {
9581 m_common = _common;
9582 }
9583
9588 eProsima_user_DllExport void common(
9589 CommonUnionMember&& _common)
9590 {
9591 m_common = std::move(_common);
9592 }
9593
9598 eProsima_user_DllExport const CommonUnionMember& common() const
9599 {
9600 return m_common;
9601 }
9602
9607 eProsima_user_DllExport CommonUnionMember& common()
9608 {
9609 return m_common;
9610 }
9611
9612
9617 eProsima_user_DllExport void detail(
9618 const CompleteMemberDetail& _detail)
9619 {
9620 m_detail = _detail;
9621 }
9622
9627 eProsima_user_DllExport void detail(
9628 CompleteMemberDetail&& _detail)
9629 {
9630 m_detail = std::move(_detail);
9631 }
9632
9637 eProsima_user_DllExport const CompleteMemberDetail& detail() const
9638 {
9639 return m_detail;
9640 }
9641
9646 eProsima_user_DllExport CompleteMemberDetail& detail()
9647 {
9648 return m_detail;
9649 }
9650
9651
9652
9653private:
9654
9655 CommonUnionMember m_common;
9656 CompleteMemberDetail m_detail;
9657
9658};
9659typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
9660
9666{
9667public:
9668
9672 eProsima_user_DllExport MinimalUnionMember()
9673 {
9674 }
9675
9679 eProsima_user_DllExport ~MinimalUnionMember()
9680 {
9681 }
9682
9687 eProsima_user_DllExport MinimalUnionMember(
9688 const MinimalUnionMember& x)
9689 {
9690 m_common = x.m_common;
9691
9692 m_detail = x.m_detail;
9693
9694 }
9695
9700 eProsima_user_DllExport MinimalUnionMember(
9701 MinimalUnionMember&& x) noexcept
9702 {
9703 m_common = std::move(x.m_common);
9704 m_detail = std::move(x.m_detail);
9705 }
9706
9711 eProsima_user_DllExport MinimalUnionMember& operator =(
9712 const MinimalUnionMember& x)
9713 {
9714
9715 m_common = x.m_common;
9716
9717 m_detail = x.m_detail;
9718
9719 return *this;
9720 }
9721
9726 eProsima_user_DllExport MinimalUnionMember& operator =(
9727 MinimalUnionMember&& x) noexcept
9728 {
9729
9730 m_common = std::move(x.m_common);
9731 m_detail = std::move(x.m_detail);
9732 return *this;
9733 }
9734
9739 eProsima_user_DllExport bool operator ==(
9740 const MinimalUnionMember& x) const
9741 {
9742 return (m_common == x.m_common &&
9743 m_detail == x.m_detail);
9744 }
9745
9750 eProsima_user_DllExport bool operator !=(
9751 const MinimalUnionMember& x) const
9752 {
9753 return !(*this == x);
9754 }
9755
9760 eProsima_user_DllExport void common(
9761 const CommonUnionMember& _common)
9762 {
9763 m_common = _common;
9764 }
9765
9770 eProsima_user_DllExport void common(
9771 CommonUnionMember&& _common)
9772 {
9773 m_common = std::move(_common);
9774 }
9775
9780 eProsima_user_DllExport const CommonUnionMember& common() const
9781 {
9782 return m_common;
9783 }
9784
9789 eProsima_user_DllExport CommonUnionMember& common()
9790 {
9791 return m_common;
9792 }
9793
9794
9799 eProsima_user_DllExport void detail(
9800 const MinimalMemberDetail& _detail)
9801 {
9802 m_detail = _detail;
9803 }
9804
9809 eProsima_user_DllExport void detail(
9810 MinimalMemberDetail&& _detail)
9811 {
9812 m_detail = std::move(_detail);
9813 }
9814
9819 eProsima_user_DllExport const MinimalMemberDetail& detail() const
9820 {
9821 return m_detail;
9822 }
9823
9828 eProsima_user_DllExport MinimalMemberDetail& detail()
9829 {
9830 return m_detail;
9831 }
9832
9833
9834
9835private:
9836
9837 CommonUnionMember m_common;
9838 MinimalMemberDetail m_detail;
9839
9840};
9841typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
9842
9848{
9849public:
9850
9854 eProsima_user_DllExport CommonDiscriminatorMember()
9855 {
9856 }
9857
9861 eProsima_user_DllExport ~CommonDiscriminatorMember()
9862 {
9863 }
9864
9869 eProsima_user_DllExport CommonDiscriminatorMember(
9871 {
9872 m_member_flags = x.m_member_flags;
9873
9874 m_type_id = x.m_type_id;
9875
9876 }
9877
9882 eProsima_user_DllExport CommonDiscriminatorMember(
9883 CommonDiscriminatorMember&& x) noexcept
9884 {
9885 m_member_flags = std::move(x.m_member_flags);
9886 m_type_id = std::move(x.m_type_id);
9887 }
9888
9893 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9895 {
9896
9897 m_member_flags = x.m_member_flags;
9898
9899 m_type_id = x.m_type_id;
9900
9901 return *this;
9902 }
9903
9908 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9909 CommonDiscriminatorMember&& x) noexcept
9910 {
9911
9912 m_member_flags = std::move(x.m_member_flags);
9913 m_type_id = std::move(x.m_type_id);
9914 return *this;
9915 }
9916
9921 eProsima_user_DllExport bool operator ==(
9922 const CommonDiscriminatorMember& x) const
9923 {
9924 return (m_member_flags == x.m_member_flags &&
9925 m_type_id == x.m_type_id);
9926 }
9927
9932 eProsima_user_DllExport bool operator !=(
9933 const CommonDiscriminatorMember& x) const
9934 {
9935 return !(*this == x);
9936 }
9937
9942 eProsima_user_DllExport void member_flags(
9943 const UnionDiscriminatorFlag& _member_flags)
9944 {
9945 m_member_flags = _member_flags;
9946 }
9947
9952 eProsima_user_DllExport void member_flags(
9953 UnionDiscriminatorFlag&& _member_flags)
9954 {
9955 m_member_flags = std::move(_member_flags);
9956 }
9957
9962 eProsima_user_DllExport const UnionDiscriminatorFlag& member_flags() const
9963 {
9964 return m_member_flags;
9965 }
9966
9971 eProsima_user_DllExport UnionDiscriminatorFlag& member_flags()
9972 {
9973 return m_member_flags;
9974 }
9975
9976
9981 eProsima_user_DllExport void type_id(
9982 const TypeIdentifier& _type_id)
9983 {
9984 m_type_id = _type_id;
9985 }
9986
9991 eProsima_user_DllExport void type_id(
9992 TypeIdentifier&& _type_id)
9993 {
9994 m_type_id = std::move(_type_id);
9995 }
9996
10001 eProsima_user_DllExport const TypeIdentifier& type_id() const
10002 {
10003 return m_type_id;
10004 }
10005
10010 eProsima_user_DllExport TypeIdentifier& type_id()
10011 {
10012 return m_type_id;
10013 }
10014
10015
10016
10017private:
10018
10019 UnionDiscriminatorFlag m_member_flags{0};
10020 TypeIdentifier m_type_id;
10021
10022};
10028{
10029public:
10030
10034 eProsima_user_DllExport CompleteDiscriminatorMember()
10035 {
10036 }
10037
10041 eProsima_user_DllExport ~CompleteDiscriminatorMember()
10042 {
10043 }
10044
10049 eProsima_user_DllExport CompleteDiscriminatorMember(
10051 {
10052 m_common = x.m_common;
10053
10054 m_ann_builtin = x.m_ann_builtin;
10055
10056 m_ann_custom = x.m_ann_custom;
10057
10058 }
10059
10064 eProsima_user_DllExport CompleteDiscriminatorMember(
10065 CompleteDiscriminatorMember&& x) noexcept
10066 {
10067 m_common = std::move(x.m_common);
10068 m_ann_builtin = std::move(x.m_ann_builtin);
10069 m_ann_custom = std::move(x.m_ann_custom);
10070 }
10071
10076 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10078 {
10079
10080 m_common = x.m_common;
10081
10082 m_ann_builtin = x.m_ann_builtin;
10083
10084 m_ann_custom = x.m_ann_custom;
10085
10086 return *this;
10087 }
10088
10093 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10094 CompleteDiscriminatorMember&& x) noexcept
10095 {
10096
10097 m_common = std::move(x.m_common);
10098 m_ann_builtin = std::move(x.m_ann_builtin);
10099 m_ann_custom = std::move(x.m_ann_custom);
10100 return *this;
10101 }
10102
10107 eProsima_user_DllExport bool operator ==(
10108 const CompleteDiscriminatorMember& x) const
10109 {
10110 return (m_common == x.m_common &&
10111 m_ann_builtin == x.m_ann_builtin &&
10112 m_ann_custom == x.m_ann_custom);
10113 }
10114
10119 eProsima_user_DllExport bool operator !=(
10120 const CompleteDiscriminatorMember& x) const
10121 {
10122 return !(*this == x);
10123 }
10124
10129 eProsima_user_DllExport void common(
10130 const CommonDiscriminatorMember& _common)
10131 {
10132 m_common = _common;
10133 }
10134
10139 eProsima_user_DllExport void common(
10140 CommonDiscriminatorMember&& _common)
10141 {
10142 m_common = std::move(_common);
10143 }
10144
10149 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10150 {
10151 return m_common;
10152 }
10153
10158 eProsima_user_DllExport CommonDiscriminatorMember& common()
10159 {
10160 return m_common;
10161 }
10162
10163
10168 eProsima_user_DllExport void ann_builtin(
10169 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
10170 {
10171 m_ann_builtin = _ann_builtin;
10172 }
10173
10178 eProsima_user_DllExport void ann_builtin(
10179 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
10180 {
10181 m_ann_builtin = std::move(_ann_builtin);
10182 }
10183
10188 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
10189 {
10190 return m_ann_builtin;
10191 }
10192
10197 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
10198 {
10199 return m_ann_builtin;
10200 }
10201
10202
10207 eProsima_user_DllExport void ann_custom(
10208 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
10209 {
10210 m_ann_custom = _ann_custom;
10211 }
10212
10217 eProsima_user_DllExport void ann_custom(
10218 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
10219 {
10220 m_ann_custom = std::move(_ann_custom);
10221 }
10222
10227 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
10228 {
10229 return m_ann_custom;
10230 }
10231
10236 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
10237 {
10238 return m_ann_custom;
10239 }
10240
10241
10242
10243private:
10244
10246 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
10247 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
10248
10249};
10255{
10256public:
10257
10261 eProsima_user_DllExport MinimalDiscriminatorMember()
10262 {
10263 }
10264
10268 eProsima_user_DllExport ~MinimalDiscriminatorMember()
10269 {
10270 }
10271
10276 eProsima_user_DllExport MinimalDiscriminatorMember(
10278 {
10279 m_common = x.m_common;
10280
10281 }
10282
10287 eProsima_user_DllExport MinimalDiscriminatorMember(
10288 MinimalDiscriminatorMember&& x) noexcept
10289 {
10290 m_common = std::move(x.m_common);
10291 }
10292
10297 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10299 {
10300
10301 m_common = x.m_common;
10302
10303 return *this;
10304 }
10305
10310 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10311 MinimalDiscriminatorMember&& x) noexcept
10312 {
10313
10314 m_common = std::move(x.m_common);
10315 return *this;
10316 }
10317
10322 eProsima_user_DllExport bool operator ==(
10323 const MinimalDiscriminatorMember& x) const
10324 {
10325 return (m_common == x.m_common);
10326 }
10327
10332 eProsima_user_DllExport bool operator !=(
10333 const MinimalDiscriminatorMember& x) const
10334 {
10335 return !(*this == x);
10336 }
10337
10342 eProsima_user_DllExport void common(
10343 const CommonDiscriminatorMember& _common)
10344 {
10345 m_common = _common;
10346 }
10347
10352 eProsima_user_DllExport void common(
10353 CommonDiscriminatorMember&& _common)
10354 {
10355 m_common = std::move(_common);
10356 }
10357
10362 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10363 {
10364 return m_common;
10365 }
10366
10371 eProsima_user_DllExport CommonDiscriminatorMember& common()
10372 {
10373 return m_common;
10374 }
10375
10376
10377
10378private:
10379
10381
10382};
10388{
10389public:
10390
10394 eProsima_user_DllExport CompleteUnionHeader()
10395 {
10396 }
10397
10401 eProsima_user_DllExport ~CompleteUnionHeader()
10402 {
10403 }
10404
10409 eProsima_user_DllExport CompleteUnionHeader(
10410 const CompleteUnionHeader& x)
10411 {
10412 m_detail = x.m_detail;
10413
10414 }
10415
10420 eProsima_user_DllExport CompleteUnionHeader(
10421 CompleteUnionHeader&& x) noexcept
10422 {
10423 m_detail = std::move(x.m_detail);
10424 }
10425
10430 eProsima_user_DllExport CompleteUnionHeader& operator =(
10431 const CompleteUnionHeader& x)
10432 {
10433
10434 m_detail = x.m_detail;
10435
10436 return *this;
10437 }
10438
10443 eProsima_user_DllExport CompleteUnionHeader& operator =(
10444 CompleteUnionHeader&& x) noexcept
10445 {
10446
10447 m_detail = std::move(x.m_detail);
10448 return *this;
10449 }
10450
10455 eProsima_user_DllExport bool operator ==(
10456 const CompleteUnionHeader& x) const
10457 {
10458 return (m_detail == x.m_detail);
10459 }
10460
10465 eProsima_user_DllExport bool operator !=(
10466 const CompleteUnionHeader& x) const
10467 {
10468 return !(*this == x);
10469 }
10470
10475 eProsima_user_DllExport void detail(
10476 const CompleteTypeDetail& _detail)
10477 {
10478 m_detail = _detail;
10479 }
10480
10485 eProsima_user_DllExport void detail(
10486 CompleteTypeDetail&& _detail)
10487 {
10488 m_detail = std::move(_detail);
10489 }
10490
10495 eProsima_user_DllExport const CompleteTypeDetail& detail() const
10496 {
10497 return m_detail;
10498 }
10499
10504 eProsima_user_DllExport CompleteTypeDetail& detail()
10505 {
10506 return m_detail;
10507 }
10508
10509
10510
10511private:
10512
10513 CompleteTypeDetail m_detail;
10514
10515};
10521{
10522public:
10523
10527 eProsima_user_DllExport MinimalUnionHeader()
10528 {
10529 }
10530
10534 eProsima_user_DllExport ~MinimalUnionHeader()
10535 {
10536 }
10537
10542 eProsima_user_DllExport MinimalUnionHeader(
10543 const MinimalUnionHeader& x)
10544 {
10545 m_detail = x.m_detail;
10546
10547 }
10548
10553 eProsima_user_DllExport MinimalUnionHeader(
10554 MinimalUnionHeader&& x) noexcept
10555 {
10556 m_detail = std::move(x.m_detail);
10557 }
10558
10563 eProsima_user_DllExport MinimalUnionHeader& operator =(
10564 const MinimalUnionHeader& x)
10565 {
10566
10567 m_detail = x.m_detail;
10568
10569 return *this;
10570 }
10571
10576 eProsima_user_DllExport MinimalUnionHeader& operator =(
10577 MinimalUnionHeader&& x) noexcept
10578 {
10579
10580 m_detail = std::move(x.m_detail);
10581 return *this;
10582 }
10583
10588 eProsima_user_DllExport bool operator ==(
10589 const MinimalUnionHeader& x) const
10590 {
10591 return (m_detail == x.m_detail);
10592 }
10593
10598 eProsima_user_DllExport bool operator !=(
10599 const MinimalUnionHeader& x) const
10600 {
10601 return !(*this == x);
10602 }
10603
10608 eProsima_user_DllExport void detail(
10609 const MinimalTypeDetail& _detail)
10610 {
10611 m_detail = _detail;
10612 }
10613
10618 eProsima_user_DllExport void detail(
10619 MinimalTypeDetail&& _detail)
10620 {
10621 m_detail = std::move(_detail);
10622 }
10623
10628 eProsima_user_DllExport const MinimalTypeDetail& detail() const
10629 {
10630 return m_detail;
10631 }
10632
10637 eProsima_user_DllExport MinimalTypeDetail& detail()
10638 {
10639 return m_detail;
10640 }
10641
10642
10643
10644private:
10645
10646 MinimalTypeDetail m_detail;
10647
10648};
10654{
10655public:
10656
10660 eProsima_user_DllExport CompleteUnionType()
10661 {
10662 }
10663
10667 eProsima_user_DllExport ~CompleteUnionType()
10668 {
10669 }
10670
10675 eProsima_user_DllExport CompleteUnionType(
10676 const CompleteUnionType& x)
10677 {
10678 m_union_flags = x.m_union_flags;
10679
10680 m_header = x.m_header;
10681
10682 m_discriminator = x.m_discriminator;
10683
10684 m_member_seq = x.m_member_seq;
10685
10686 }
10687
10692 eProsima_user_DllExport CompleteUnionType(
10693 CompleteUnionType&& x) noexcept
10694 {
10695 m_union_flags = std::move(x.m_union_flags);
10696 m_header = std::move(x.m_header);
10697 m_discriminator = std::move(x.m_discriminator);
10698 m_member_seq = std::move(x.m_member_seq);
10699 }
10700
10705 eProsima_user_DllExport CompleteUnionType& operator =(
10706 const CompleteUnionType& x)
10707 {
10708
10709 m_union_flags = x.m_union_flags;
10710
10711 m_header = x.m_header;
10712
10713 m_discriminator = x.m_discriminator;
10714
10715 m_member_seq = x.m_member_seq;
10716
10717 return *this;
10718 }
10719
10724 eProsima_user_DllExport CompleteUnionType& operator =(
10725 CompleteUnionType&& x) noexcept
10726 {
10727
10728 m_union_flags = std::move(x.m_union_flags);
10729 m_header = std::move(x.m_header);
10730 m_discriminator = std::move(x.m_discriminator);
10731 m_member_seq = std::move(x.m_member_seq);
10732 return *this;
10733 }
10734
10739 eProsima_user_DllExport bool operator ==(
10740 const CompleteUnionType& x) const
10741 {
10742 return (m_union_flags == x.m_union_flags &&
10743 m_header == x.m_header &&
10744 m_discriminator == x.m_discriminator &&
10745 m_member_seq == x.m_member_seq);
10746 }
10747
10752 eProsima_user_DllExport bool operator !=(
10753 const CompleteUnionType& x) const
10754 {
10755 return !(*this == x);
10756 }
10757
10762 eProsima_user_DllExport void union_flags(
10763 const UnionTypeFlag& _union_flags)
10764 {
10765 m_union_flags = _union_flags;
10766 }
10767
10772 eProsima_user_DllExport void union_flags(
10773 UnionTypeFlag&& _union_flags)
10774 {
10775 m_union_flags = std::move(_union_flags);
10776 }
10777
10782 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
10783 {
10784 return m_union_flags;
10785 }
10786
10791 eProsima_user_DllExport UnionTypeFlag& union_flags()
10792 {
10793 return m_union_flags;
10794 }
10795
10796
10801 eProsima_user_DllExport void header(
10802 const CompleteUnionHeader& _header)
10803 {
10804 m_header = _header;
10805 }
10806
10811 eProsima_user_DllExport void header(
10812 CompleteUnionHeader&& _header)
10813 {
10814 m_header = std::move(_header);
10815 }
10816
10821 eProsima_user_DllExport const CompleteUnionHeader& header() const
10822 {
10823 return m_header;
10824 }
10825
10830 eProsima_user_DllExport CompleteUnionHeader& header()
10831 {
10832 return m_header;
10833 }
10834
10835
10840 eProsima_user_DllExport void discriminator(
10841 const CompleteDiscriminatorMember& _discriminator)
10842 {
10843 m_discriminator = _discriminator;
10844 }
10845
10850 eProsima_user_DllExport void discriminator(
10851 CompleteDiscriminatorMember&& _discriminator)
10852 {
10853 m_discriminator = std::move(_discriminator);
10854 }
10855
10860 eProsima_user_DllExport const CompleteDiscriminatorMember& discriminator() const
10861 {
10862 return m_discriminator;
10863 }
10864
10870 {
10871 return m_discriminator;
10872 }
10873
10874
10879 eProsima_user_DllExport void member_seq(
10880 const CompleteUnionMemberSeq& _member_seq)
10881 {
10882 m_member_seq = _member_seq;
10883 }
10884
10889 eProsima_user_DllExport void member_seq(
10890 CompleteUnionMemberSeq&& _member_seq)
10891 {
10892 m_member_seq = std::move(_member_seq);
10893 }
10894
10899 eProsima_user_DllExport const CompleteUnionMemberSeq& member_seq() const
10900 {
10901 return m_member_seq;
10902 }
10903
10908 eProsima_user_DllExport CompleteUnionMemberSeq& member_seq()
10909 {
10910 return m_member_seq;
10911 }
10912
10913
10914
10915private:
10916
10917 UnionTypeFlag m_union_flags{0};
10918 CompleteUnionHeader m_header;
10919 CompleteDiscriminatorMember m_discriminator;
10920 CompleteUnionMemberSeq m_member_seq;
10921
10922};
10928{
10929public:
10930
10934 eProsima_user_DllExport MinimalUnionType()
10935 {
10936 }
10937
10941 eProsima_user_DllExport ~MinimalUnionType()
10942 {
10943 }
10944
10949 eProsima_user_DllExport MinimalUnionType(
10950 const MinimalUnionType& x)
10951 {
10952 m_union_flags = x.m_union_flags;
10953
10954 m_header = x.m_header;
10955
10956 m_discriminator = x.m_discriminator;
10957
10958 m_member_seq = x.m_member_seq;
10959
10960 }
10961
10966 eProsima_user_DllExport MinimalUnionType(
10967 MinimalUnionType&& x) noexcept
10968 {
10969 m_union_flags = std::move(x.m_union_flags);
10970 m_header = std::move(x.m_header);
10971 m_discriminator = std::move(x.m_discriminator);
10972 m_member_seq = std::move(x.m_member_seq);
10973 }
10974
10979 eProsima_user_DllExport MinimalUnionType& operator =(
10980 const MinimalUnionType& x)
10981 {
10982
10983 m_union_flags = x.m_union_flags;
10984
10985 m_header = x.m_header;
10986
10987 m_discriminator = x.m_discriminator;
10988
10989 m_member_seq = x.m_member_seq;
10990
10991 return *this;
10992 }
10993
10998 eProsima_user_DllExport MinimalUnionType& operator =(
10999 MinimalUnionType&& x) noexcept
11000 {
11001
11002 m_union_flags = std::move(x.m_union_flags);
11003 m_header = std::move(x.m_header);
11004 m_discriminator = std::move(x.m_discriminator);
11005 m_member_seq = std::move(x.m_member_seq);
11006 return *this;
11007 }
11008
11013 eProsima_user_DllExport bool operator ==(
11014 const MinimalUnionType& x) const
11015 {
11016 return (m_union_flags == x.m_union_flags &&
11017 m_header == x.m_header &&
11018 m_discriminator == x.m_discriminator &&
11019 m_member_seq == x.m_member_seq);
11020 }
11021
11026 eProsima_user_DllExport bool operator !=(
11027 const MinimalUnionType& x) const
11028 {
11029 return !(*this == x);
11030 }
11031
11036 eProsima_user_DllExport void union_flags(
11037 const UnionTypeFlag& _union_flags)
11038 {
11039 m_union_flags = _union_flags;
11040 }
11041
11046 eProsima_user_DllExport void union_flags(
11047 UnionTypeFlag&& _union_flags)
11048 {
11049 m_union_flags = std::move(_union_flags);
11050 }
11051
11056 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
11057 {
11058 return m_union_flags;
11059 }
11060
11065 eProsima_user_DllExport UnionTypeFlag& union_flags()
11066 {
11067 return m_union_flags;
11068 }
11069
11070
11075 eProsima_user_DllExport void header(
11076 const MinimalUnionHeader& _header)
11077 {
11078 m_header = _header;
11079 }
11080
11085 eProsima_user_DllExport void header(
11086 MinimalUnionHeader&& _header)
11087 {
11088 m_header = std::move(_header);
11089 }
11090
11095 eProsima_user_DllExport const MinimalUnionHeader& header() const
11096 {
11097 return m_header;
11098 }
11099
11104 eProsima_user_DllExport MinimalUnionHeader& header()
11105 {
11106 return m_header;
11107 }
11108
11109
11114 eProsima_user_DllExport void discriminator(
11115 const MinimalDiscriminatorMember& _discriminator)
11116 {
11117 m_discriminator = _discriminator;
11118 }
11119
11124 eProsima_user_DllExport void discriminator(
11125 MinimalDiscriminatorMember&& _discriminator)
11126 {
11127 m_discriminator = std::move(_discriminator);
11128 }
11129
11134 eProsima_user_DllExport const MinimalDiscriminatorMember& discriminator() const
11135 {
11136 return m_discriminator;
11137 }
11138
11144 {
11145 return m_discriminator;
11146 }
11147
11148
11153 eProsima_user_DllExport void member_seq(
11154 const MinimalUnionMemberSeq& _member_seq)
11155 {
11156 m_member_seq = _member_seq;
11157 }
11158
11163 eProsima_user_DllExport void member_seq(
11164 MinimalUnionMemberSeq&& _member_seq)
11165 {
11166 m_member_seq = std::move(_member_seq);
11167 }
11168
11173 eProsima_user_DllExport const MinimalUnionMemberSeq& member_seq() const
11174 {
11175 return m_member_seq;
11176 }
11177
11182 eProsima_user_DllExport MinimalUnionMemberSeq& member_seq()
11183 {
11184 return m_member_seq;
11185 }
11186
11187
11188
11189private:
11190
11191 UnionTypeFlag m_union_flags{0};
11192 MinimalUnionHeader m_header;
11193 MinimalDiscriminatorMember m_discriminator;
11194 MinimalUnionMemberSeq m_member_seq;
11195
11196};
11202{
11203public:
11204
11208 eProsima_user_DllExport CommonAnnotationParameter()
11209 {
11210 }
11211
11215 eProsima_user_DllExport ~CommonAnnotationParameter()
11216 {
11217 }
11218
11223 eProsima_user_DllExport CommonAnnotationParameter(
11225 {
11226 m_member_flags = x.m_member_flags;
11227
11228 m_member_type_id = x.m_member_type_id;
11229
11230 }
11231
11236 eProsima_user_DllExport CommonAnnotationParameter(
11237 CommonAnnotationParameter&& x) noexcept
11238 {
11239 m_member_flags = std::move(x.m_member_flags);
11240 m_member_type_id = std::move(x.m_member_type_id);
11241 }
11242
11247 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11249 {
11250
11251 m_member_flags = x.m_member_flags;
11252
11253 m_member_type_id = x.m_member_type_id;
11254
11255 return *this;
11256 }
11257
11262 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11263 CommonAnnotationParameter&& x) noexcept
11264 {
11265
11266 m_member_flags = std::move(x.m_member_flags);
11267 m_member_type_id = std::move(x.m_member_type_id);
11268 return *this;
11269 }
11270
11275 eProsima_user_DllExport bool operator ==(
11276 const CommonAnnotationParameter& x) const
11277 {
11278 return (m_member_flags == x.m_member_flags &&
11279 m_member_type_id == x.m_member_type_id);
11280 }
11281
11286 eProsima_user_DllExport bool operator !=(
11287 const CommonAnnotationParameter& x) const
11288 {
11289 return !(*this == x);
11290 }
11291
11296 eProsima_user_DllExport void member_flags(
11297 const AnnotationParameterFlag& _member_flags)
11298 {
11299 m_member_flags = _member_flags;
11300 }
11301
11306 eProsima_user_DllExport void member_flags(
11307 AnnotationParameterFlag&& _member_flags)
11308 {
11309 m_member_flags = std::move(_member_flags);
11310 }
11311
11316 eProsima_user_DllExport const AnnotationParameterFlag& member_flags() const
11317 {
11318 return m_member_flags;
11319 }
11320
11325 eProsima_user_DllExport AnnotationParameterFlag& member_flags()
11326 {
11327 return m_member_flags;
11328 }
11329
11330
11335 eProsima_user_DllExport void member_type_id(
11336 const TypeIdentifier& _member_type_id)
11337 {
11338 m_member_type_id = _member_type_id;
11339 }
11340
11345 eProsima_user_DllExport void member_type_id(
11346 TypeIdentifier&& _member_type_id)
11347 {
11348 m_member_type_id = std::move(_member_type_id);
11349 }
11350
11355 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
11356 {
11357 return m_member_type_id;
11358 }
11359
11364 eProsima_user_DllExport TypeIdentifier& member_type_id()
11365 {
11366 return m_member_type_id;
11367 }
11368
11369
11370
11371private:
11372
11373 AnnotationParameterFlag m_member_flags{0};
11374 TypeIdentifier m_member_type_id;
11375
11376};
11382{
11383public:
11384
11388 eProsima_user_DllExport CompleteAnnotationParameter()
11389 {
11390 }
11391
11395 eProsima_user_DllExport ~CompleteAnnotationParameter()
11396 {
11397 }
11398
11403 eProsima_user_DllExport CompleteAnnotationParameter(
11405 {
11406 m_common = x.m_common;
11407
11408 m_name = x.m_name;
11409
11410 m_default_value = x.m_default_value;
11411
11412 }
11413
11418 eProsima_user_DllExport CompleteAnnotationParameter(
11419 CompleteAnnotationParameter&& x) noexcept
11420 {
11421 m_common = std::move(x.m_common);
11422 m_name = std::move(x.m_name);
11423 m_default_value = std::move(x.m_default_value);
11424 }
11425
11430 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11432 {
11433
11434 m_common = x.m_common;
11435
11436 m_name = x.m_name;
11437
11438 m_default_value = x.m_default_value;
11439
11440 return *this;
11441 }
11442
11447 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11448 CompleteAnnotationParameter&& x) noexcept
11449 {
11450
11451 m_common = std::move(x.m_common);
11452 m_name = std::move(x.m_name);
11453 m_default_value = std::move(x.m_default_value);
11454 return *this;
11455 }
11456
11461 eProsima_user_DllExport bool operator ==(
11462 const CompleteAnnotationParameter& x) const
11463 {
11464 return (m_common == x.m_common &&
11465 m_name == x.m_name &&
11466 m_default_value == x.m_default_value);
11467 }
11468
11473 eProsima_user_DllExport bool operator !=(
11474 const CompleteAnnotationParameter& x) const
11475 {
11476 return !(*this == x);
11477 }
11478
11483 eProsima_user_DllExport void common(
11484 const CommonAnnotationParameter& _common)
11485 {
11486 m_common = _common;
11487 }
11488
11493 eProsima_user_DllExport void common(
11494 CommonAnnotationParameter&& _common)
11495 {
11496 m_common = std::move(_common);
11497 }
11498
11503 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11504 {
11505 return m_common;
11506 }
11507
11512 eProsima_user_DllExport CommonAnnotationParameter& common()
11513 {
11514 return m_common;
11515 }
11516
11517
11522 eProsima_user_DllExport void name(
11523 const MemberName& _name)
11524 {
11525 m_name = _name;
11526 }
11527
11532 eProsima_user_DllExport void name(
11533 MemberName&& _name)
11534 {
11535 m_name = std::move(_name);
11536 }
11537
11542 eProsima_user_DllExport const MemberName& name() const
11543 {
11544 return m_name;
11545 }
11546
11551 eProsima_user_DllExport MemberName& name()
11552 {
11553 return m_name;
11554 }
11555
11556
11561 eProsima_user_DllExport void default_value(
11562 const AnnotationParameterValue& _default_value)
11563 {
11564 m_default_value = _default_value;
11565 }
11566
11571 eProsima_user_DllExport void default_value(
11572 AnnotationParameterValue&& _default_value)
11573 {
11574 m_default_value = std::move(_default_value);
11575 }
11576
11581 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11582 {
11583 return m_default_value;
11584 }
11585
11590 eProsima_user_DllExport AnnotationParameterValue& default_value()
11591 {
11592 return m_default_value;
11593 }
11594
11595
11596
11597private:
11598
11600 MemberName m_name;
11601 AnnotationParameterValue m_default_value;
11602
11603};
11604typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
11605
11611{
11612public:
11613
11617 eProsima_user_DllExport MinimalAnnotationParameter()
11618 {
11619 }
11620
11624 eProsima_user_DllExport ~MinimalAnnotationParameter()
11625 {
11626 }
11627
11632 eProsima_user_DllExport MinimalAnnotationParameter(
11634 {
11635 m_common = x.m_common;
11636
11637 m_name_hash = x.m_name_hash;
11638
11639 m_default_value = x.m_default_value;
11640
11641 }
11642
11647 eProsima_user_DllExport MinimalAnnotationParameter(
11648 MinimalAnnotationParameter&& x) noexcept
11649 {
11650 m_common = std::move(x.m_common);
11651 m_name_hash = std::move(x.m_name_hash);
11652 m_default_value = std::move(x.m_default_value);
11653 }
11654
11659 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11661 {
11662
11663 m_common = x.m_common;
11664
11665 m_name_hash = x.m_name_hash;
11666
11667 m_default_value = x.m_default_value;
11668
11669 return *this;
11670 }
11671
11676 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11677 MinimalAnnotationParameter&& x) noexcept
11678 {
11679
11680 m_common = std::move(x.m_common);
11681 m_name_hash = std::move(x.m_name_hash);
11682 m_default_value = std::move(x.m_default_value);
11683 return *this;
11684 }
11685
11690 eProsima_user_DllExport bool operator ==(
11691 const MinimalAnnotationParameter& x) const
11692 {
11693 return (m_common == x.m_common &&
11694 m_name_hash == x.m_name_hash &&
11695 m_default_value == x.m_default_value);
11696 }
11697
11702 eProsima_user_DllExport bool operator !=(
11703 const MinimalAnnotationParameter& x) const
11704 {
11705 return !(*this == x);
11706 }
11707
11712 eProsima_user_DllExport void common(
11713 const CommonAnnotationParameter& _common)
11714 {
11715 m_common = _common;
11716 }
11717
11722 eProsima_user_DllExport void common(
11723 CommonAnnotationParameter&& _common)
11724 {
11725 m_common = std::move(_common);
11726 }
11727
11732 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11733 {
11734 return m_common;
11735 }
11736
11741 eProsima_user_DllExport CommonAnnotationParameter& common()
11742 {
11743 return m_common;
11744 }
11745
11746
11751 eProsima_user_DllExport void name_hash(
11752 const NameHash& _name_hash)
11753 {
11754 m_name_hash = _name_hash;
11755 }
11756
11761 eProsima_user_DllExport void name_hash(
11762 NameHash&& _name_hash)
11763 {
11764 m_name_hash = std::move(_name_hash);
11765 }
11766
11771 eProsima_user_DllExport const NameHash& name_hash() const
11772 {
11773 return m_name_hash;
11774 }
11775
11780 eProsima_user_DllExport NameHash& name_hash()
11781 {
11782 return m_name_hash;
11783 }
11784
11785
11790 eProsima_user_DllExport void default_value(
11791 const AnnotationParameterValue& _default_value)
11792 {
11793 m_default_value = _default_value;
11794 }
11795
11800 eProsima_user_DllExport void default_value(
11801 AnnotationParameterValue&& _default_value)
11802 {
11803 m_default_value = std::move(_default_value);
11804 }
11805
11810 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11811 {
11812 return m_default_value;
11813 }
11814
11819 eProsima_user_DllExport AnnotationParameterValue& default_value()
11820 {
11821 return m_default_value;
11822 }
11823
11824
11825
11826private:
11827
11829 NameHash m_name_hash{0};
11830 AnnotationParameterValue m_default_value;
11831
11832};
11833typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
11834
11840{
11841public:
11842
11846 eProsima_user_DllExport CompleteAnnotationHeader()
11847 {
11848 }
11849
11853 eProsima_user_DllExport ~CompleteAnnotationHeader()
11854 {
11855 }
11856
11861 eProsima_user_DllExport CompleteAnnotationHeader(
11862 const CompleteAnnotationHeader& x)
11863 {
11864 m_annotation_name = x.m_annotation_name;
11865
11866 }
11867
11872 eProsima_user_DllExport CompleteAnnotationHeader(
11873 CompleteAnnotationHeader&& x) noexcept
11874 {
11875 m_annotation_name = std::move(x.m_annotation_name);
11876 }
11877
11882 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11883 const CompleteAnnotationHeader& x)
11884 {
11885
11886 m_annotation_name = x.m_annotation_name;
11887
11888 return *this;
11889 }
11890
11895 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11896 CompleteAnnotationHeader&& x) noexcept
11897 {
11898
11899 m_annotation_name = std::move(x.m_annotation_name);
11900 return *this;
11901 }
11902
11907 eProsima_user_DllExport bool operator ==(
11908 const CompleteAnnotationHeader& x) const
11909 {
11910 return (m_annotation_name == x.m_annotation_name);
11911 }
11912
11917 eProsima_user_DllExport bool operator !=(
11918 const CompleteAnnotationHeader& x) const
11919 {
11920 return !(*this == x);
11921 }
11922
11927 eProsima_user_DllExport void annotation_name(
11928 const QualifiedTypeName& _annotation_name)
11929 {
11930 m_annotation_name = _annotation_name;
11931 }
11932
11937 eProsima_user_DllExport void annotation_name(
11938 QualifiedTypeName&& _annotation_name)
11939 {
11940 m_annotation_name = std::move(_annotation_name);
11941 }
11942
11947 eProsima_user_DllExport const QualifiedTypeName& annotation_name() const
11948 {
11949 return m_annotation_name;
11950 }
11951
11956 eProsima_user_DllExport QualifiedTypeName& annotation_name()
11957 {
11958 return m_annotation_name;
11959 }
11960
11961
11962
11963private:
11964
11965 QualifiedTypeName m_annotation_name;
11966
11967};
11973{
11974public:
11975
11979 eProsima_user_DllExport MinimalAnnotationHeader()
11980 {
11981 }
11982
11986 eProsima_user_DllExport ~MinimalAnnotationHeader()
11987 {
11988 }
11989
11994 eProsima_user_DllExport MinimalAnnotationHeader(
11995 const MinimalAnnotationHeader& x)
11996 {
11997 static_cast<void>(x);
11998 }
11999
12004 eProsima_user_DllExport MinimalAnnotationHeader(
12005 MinimalAnnotationHeader&& x) noexcept
12006 {
12007 static_cast<void>(x);
12008 }
12009
12014 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12015 const MinimalAnnotationHeader& x)
12016 {
12017
12018 static_cast<void>(x);
12019
12020 return *this;
12021 }
12022
12027 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12028 MinimalAnnotationHeader&& x) noexcept
12029 {
12030
12031 static_cast<void>(x);
12032
12033 return *this;
12034 }
12035
12040 eProsima_user_DllExport bool operator ==(
12041 const MinimalAnnotationHeader& x) const
12042 {
12043 static_cast<void>(x);
12044 return true;
12045 }
12046
12051 eProsima_user_DllExport bool operator !=(
12052 const MinimalAnnotationHeader& x) const
12053 {
12054 return !(*this == x);
12055 }
12056
12057
12058
12059private:
12060
12061
12062};
12068{
12069public:
12070
12074 eProsima_user_DllExport CompleteAnnotationType()
12075 {
12076 }
12077
12081 eProsima_user_DllExport ~CompleteAnnotationType()
12082 {
12083 }
12084
12089 eProsima_user_DllExport CompleteAnnotationType(
12090 const CompleteAnnotationType& x)
12091 {
12092 m_annotation_flag = x.m_annotation_flag;
12093
12094 m_header = x.m_header;
12095
12096 m_member_seq = x.m_member_seq;
12097
12098 }
12099
12104 eProsima_user_DllExport CompleteAnnotationType(
12105 CompleteAnnotationType&& x) noexcept
12106 {
12107 m_annotation_flag = std::move(x.m_annotation_flag);
12108 m_header = std::move(x.m_header);
12109 m_member_seq = std::move(x.m_member_seq);
12110 }
12111
12116 eProsima_user_DllExport CompleteAnnotationType& operator =(
12117 const CompleteAnnotationType& x)
12118 {
12119
12120 m_annotation_flag = x.m_annotation_flag;
12121
12122 m_header = x.m_header;
12123
12124 m_member_seq = x.m_member_seq;
12125
12126 return *this;
12127 }
12128
12133 eProsima_user_DllExport CompleteAnnotationType& operator =(
12134 CompleteAnnotationType&& x) noexcept
12135 {
12136
12137 m_annotation_flag = std::move(x.m_annotation_flag);
12138 m_header = std::move(x.m_header);
12139 m_member_seq = std::move(x.m_member_seq);
12140 return *this;
12141 }
12142
12147 eProsima_user_DllExport bool operator ==(
12148 const CompleteAnnotationType& x) const
12149 {
12150 return (m_annotation_flag == x.m_annotation_flag &&
12151 m_header == x.m_header &&
12152 m_member_seq == x.m_member_seq);
12153 }
12154
12159 eProsima_user_DllExport bool operator !=(
12160 const CompleteAnnotationType& x) const
12161 {
12162 return !(*this == x);
12163 }
12164
12169 eProsima_user_DllExport void annotation_flag(
12170 const AnnotationTypeFlag& _annotation_flag)
12171 {
12172 m_annotation_flag = _annotation_flag;
12173 }
12174
12179 eProsima_user_DllExport void annotation_flag(
12180 AnnotationTypeFlag&& _annotation_flag)
12181 {
12182 m_annotation_flag = std::move(_annotation_flag);
12183 }
12184
12189 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12190 {
12191 return m_annotation_flag;
12192 }
12193
12198 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12199 {
12200 return m_annotation_flag;
12201 }
12202
12203
12208 eProsima_user_DllExport void header(
12209 const CompleteAnnotationHeader& _header)
12210 {
12211 m_header = _header;
12212 }
12213
12218 eProsima_user_DllExport void header(
12219 CompleteAnnotationHeader&& _header)
12220 {
12221 m_header = std::move(_header);
12222 }
12223
12228 eProsima_user_DllExport const CompleteAnnotationHeader& header() const
12229 {
12230 return m_header;
12231 }
12232
12237 eProsima_user_DllExport CompleteAnnotationHeader& header()
12238 {
12239 return m_header;
12240 }
12241
12242
12247 eProsima_user_DllExport void member_seq(
12248 const CompleteAnnotationParameterSeq& _member_seq)
12249 {
12250 m_member_seq = _member_seq;
12251 }
12252
12257 eProsima_user_DllExport void member_seq(
12258 CompleteAnnotationParameterSeq&& _member_seq)
12259 {
12260 m_member_seq = std::move(_member_seq);
12261 }
12262
12267 eProsima_user_DllExport const CompleteAnnotationParameterSeq& member_seq() const
12268 {
12269 return m_member_seq;
12270 }
12271
12277 {
12278 return m_member_seq;
12279 }
12280
12281
12282
12283private:
12284
12285 AnnotationTypeFlag m_annotation_flag{0};
12286 CompleteAnnotationHeader m_header;
12287 CompleteAnnotationParameterSeq m_member_seq;
12288
12289};
12295{
12296public:
12297
12301 eProsima_user_DllExport MinimalAnnotationType()
12302 {
12303 }
12304
12308 eProsima_user_DllExport ~MinimalAnnotationType()
12309 {
12310 }
12311
12316 eProsima_user_DllExport MinimalAnnotationType(
12317 const MinimalAnnotationType& x)
12318 {
12319 m_annotation_flag = x.m_annotation_flag;
12320
12321 m_header = x.m_header;
12322
12323 m_member_seq = x.m_member_seq;
12324
12325 }
12326
12331 eProsima_user_DllExport MinimalAnnotationType(
12332 MinimalAnnotationType&& x) noexcept
12333 {
12334 m_annotation_flag = std::move(x.m_annotation_flag);
12335 m_header = std::move(x.m_header);
12336 m_member_seq = std::move(x.m_member_seq);
12337 }
12338
12343 eProsima_user_DllExport MinimalAnnotationType& operator =(
12344 const MinimalAnnotationType& x)
12345 {
12346
12347 m_annotation_flag = x.m_annotation_flag;
12348
12349 m_header = x.m_header;
12350
12351 m_member_seq = x.m_member_seq;
12352
12353 return *this;
12354 }
12355
12360 eProsima_user_DllExport MinimalAnnotationType& operator =(
12361 MinimalAnnotationType&& x) noexcept
12362 {
12363
12364 m_annotation_flag = std::move(x.m_annotation_flag);
12365 m_header = std::move(x.m_header);
12366 m_member_seq = std::move(x.m_member_seq);
12367 return *this;
12368 }
12369
12374 eProsima_user_DllExport bool operator ==(
12375 const MinimalAnnotationType& x) const
12376 {
12377 return (m_annotation_flag == x.m_annotation_flag &&
12378 m_header == x.m_header &&
12379 m_member_seq == x.m_member_seq);
12380 }
12381
12386 eProsima_user_DllExport bool operator !=(
12387 const MinimalAnnotationType& x) const
12388 {
12389 return !(*this == x);
12390 }
12391
12396 eProsima_user_DllExport void annotation_flag(
12397 const AnnotationTypeFlag& _annotation_flag)
12398 {
12399 m_annotation_flag = _annotation_flag;
12400 }
12401
12406 eProsima_user_DllExport void annotation_flag(
12407 AnnotationTypeFlag&& _annotation_flag)
12408 {
12409 m_annotation_flag = std::move(_annotation_flag);
12410 }
12411
12416 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12417 {
12418 return m_annotation_flag;
12419 }
12420
12425 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12426 {
12427 return m_annotation_flag;
12428 }
12429
12430
12435 eProsima_user_DllExport void header(
12436 const MinimalAnnotationHeader& _header)
12437 {
12438 m_header = _header;
12439 }
12440
12445 eProsima_user_DllExport void header(
12446 MinimalAnnotationHeader&& _header)
12447 {
12448 m_header = std::move(_header);
12449 }
12450
12455 eProsima_user_DllExport const MinimalAnnotationHeader& header() const
12456 {
12457 return m_header;
12458 }
12459
12464 eProsima_user_DllExport MinimalAnnotationHeader& header()
12465 {
12466 return m_header;
12467 }
12468
12469
12474 eProsima_user_DllExport void member_seq(
12475 const MinimalAnnotationParameterSeq& _member_seq)
12476 {
12477 m_member_seq = _member_seq;
12478 }
12479
12484 eProsima_user_DllExport void member_seq(
12485 MinimalAnnotationParameterSeq&& _member_seq)
12486 {
12487 m_member_seq = std::move(_member_seq);
12488 }
12489
12494 eProsima_user_DllExport const MinimalAnnotationParameterSeq& member_seq() const
12495 {
12496 return m_member_seq;
12497 }
12498
12504 {
12505 return m_member_seq;
12506 }
12507
12508
12509
12510private:
12511
12512 AnnotationTypeFlag m_annotation_flag{0};
12513 MinimalAnnotationHeader m_header;
12514 MinimalAnnotationParameterSeq m_member_seq;
12515
12516};
12522{
12523public:
12524
12528 eProsima_user_DllExport CommonAliasBody()
12529 {
12530 }
12531
12535 eProsima_user_DllExport ~CommonAliasBody()
12536 {
12537 }
12538
12543 eProsima_user_DllExport CommonAliasBody(
12544 const CommonAliasBody& x)
12545 {
12546 m_related_flags = x.m_related_flags;
12547
12548 m_related_type = x.m_related_type;
12549
12550 }
12551
12556 eProsima_user_DllExport CommonAliasBody(
12557 CommonAliasBody&& x) noexcept
12558 {
12559 m_related_flags = std::move(x.m_related_flags);
12560 m_related_type = std::move(x.m_related_type);
12561 }
12562
12567 eProsima_user_DllExport CommonAliasBody& operator =(
12568 const CommonAliasBody& x)
12569 {
12570
12571 m_related_flags = x.m_related_flags;
12572
12573 m_related_type = x.m_related_type;
12574
12575 return *this;
12576 }
12577
12582 eProsima_user_DllExport CommonAliasBody& operator =(
12583 CommonAliasBody&& x) noexcept
12584 {
12585
12586 m_related_flags = std::move(x.m_related_flags);
12587 m_related_type = std::move(x.m_related_type);
12588 return *this;
12589 }
12590
12595 eProsima_user_DllExport bool operator ==(
12596 const CommonAliasBody& x) const
12597 {
12598 return (m_related_flags == x.m_related_flags &&
12599 m_related_type == x.m_related_type);
12600 }
12601
12606 eProsima_user_DllExport bool operator !=(
12607 const CommonAliasBody& x) const
12608 {
12609 return !(*this == x);
12610 }
12611
12616 eProsima_user_DllExport void related_flags(
12617 const AliasMemberFlag& _related_flags)
12618 {
12619 m_related_flags = _related_flags;
12620 }
12621
12626 eProsima_user_DllExport void related_flags(
12627 AliasMemberFlag&& _related_flags)
12628 {
12629 m_related_flags = std::move(_related_flags);
12630 }
12631
12636 eProsima_user_DllExport const AliasMemberFlag& related_flags() const
12637 {
12638 return m_related_flags;
12639 }
12640
12645 eProsima_user_DllExport AliasMemberFlag& related_flags()
12646 {
12647 return m_related_flags;
12648 }
12649
12650
12655 eProsima_user_DllExport void related_type(
12656 const TypeIdentifier& _related_type)
12657 {
12658 m_related_type = _related_type;
12659 }
12660
12665 eProsima_user_DllExport void related_type(
12666 TypeIdentifier&& _related_type)
12667 {
12668 m_related_type = std::move(_related_type);
12669 }
12670
12675 eProsima_user_DllExport const TypeIdentifier& related_type() const
12676 {
12677 return m_related_type;
12678 }
12679
12684 eProsima_user_DllExport TypeIdentifier& related_type()
12685 {
12686 return m_related_type;
12687 }
12688
12689
12690
12691private:
12692
12693 AliasMemberFlag m_related_flags{0};
12694 TypeIdentifier m_related_type;
12695
12696};
12702{
12703public:
12704
12708 eProsima_user_DllExport CompleteAliasBody()
12709 {
12710 }
12711
12715 eProsima_user_DllExport ~CompleteAliasBody()
12716 {
12717 }
12718
12723 eProsima_user_DllExport CompleteAliasBody(
12724 const CompleteAliasBody& x)
12725 {
12726 m_common = x.m_common;
12727
12728 m_ann_builtin = x.m_ann_builtin;
12729
12730 m_ann_custom = x.m_ann_custom;
12731
12732 }
12733
12738 eProsima_user_DllExport CompleteAliasBody(
12739 CompleteAliasBody&& x) noexcept
12740 {
12741 m_common = std::move(x.m_common);
12742 m_ann_builtin = std::move(x.m_ann_builtin);
12743 m_ann_custom = std::move(x.m_ann_custom);
12744 }
12745
12750 eProsima_user_DllExport CompleteAliasBody& operator =(
12751 const CompleteAliasBody& x)
12752 {
12753
12754 m_common = x.m_common;
12755
12756 m_ann_builtin = x.m_ann_builtin;
12757
12758 m_ann_custom = x.m_ann_custom;
12759
12760 return *this;
12761 }
12762
12767 eProsima_user_DllExport CompleteAliasBody& operator =(
12768 CompleteAliasBody&& x) noexcept
12769 {
12770
12771 m_common = std::move(x.m_common);
12772 m_ann_builtin = std::move(x.m_ann_builtin);
12773 m_ann_custom = std::move(x.m_ann_custom);
12774 return *this;
12775 }
12776
12781 eProsima_user_DllExport bool operator ==(
12782 const CompleteAliasBody& x) const
12783 {
12784 return (m_common == x.m_common &&
12785 m_ann_builtin == x.m_ann_builtin &&
12786 m_ann_custom == x.m_ann_custom);
12787 }
12788
12793 eProsima_user_DllExport bool operator !=(
12794 const CompleteAliasBody& x) const
12795 {
12796 return !(*this == x);
12797 }
12798
12803 eProsima_user_DllExport void common(
12804 const CommonAliasBody& _common)
12805 {
12806 m_common = _common;
12807 }
12808
12813 eProsima_user_DllExport void common(
12814 CommonAliasBody&& _common)
12815 {
12816 m_common = std::move(_common);
12817 }
12818
12823 eProsima_user_DllExport const CommonAliasBody& common() const
12824 {
12825 return m_common;
12826 }
12827
12832 eProsima_user_DllExport CommonAliasBody& common()
12833 {
12834 return m_common;
12835 }
12836
12837
12842 eProsima_user_DllExport void ann_builtin(
12843 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
12844 {
12845 m_ann_builtin = _ann_builtin;
12846 }
12847
12852 eProsima_user_DllExport void ann_builtin(
12853 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
12854 {
12855 m_ann_builtin = std::move(_ann_builtin);
12856 }
12857
12862 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
12863 {
12864 return m_ann_builtin;
12865 }
12866
12871 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
12872 {
12873 return m_ann_builtin;
12874 }
12875
12876
12881 eProsima_user_DllExport void ann_custom(
12882 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
12883 {
12884 m_ann_custom = _ann_custom;
12885 }
12886
12891 eProsima_user_DllExport void ann_custom(
12892 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
12893 {
12894 m_ann_custom = std::move(_ann_custom);
12895 }
12896
12901 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
12902 {
12903 return m_ann_custom;
12904 }
12905
12910 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
12911 {
12912 return m_ann_custom;
12913 }
12914
12915
12916
12917private:
12918
12919 CommonAliasBody m_common;
12920 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
12921 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
12922
12923};
12929{
12930public:
12931
12935 eProsima_user_DllExport MinimalAliasBody()
12936 {
12937 }
12938
12942 eProsima_user_DllExport ~MinimalAliasBody()
12943 {
12944 }
12945
12950 eProsima_user_DllExport MinimalAliasBody(
12951 const MinimalAliasBody& x)
12952 {
12953 m_common = x.m_common;
12954
12955 }
12956
12961 eProsima_user_DllExport MinimalAliasBody(
12962 MinimalAliasBody&& x) noexcept
12963 {
12964 m_common = std::move(x.m_common);
12965 }
12966
12971 eProsima_user_DllExport MinimalAliasBody& operator =(
12972 const MinimalAliasBody& x)
12973 {
12974
12975 m_common = x.m_common;
12976
12977 return *this;
12978 }
12979
12984 eProsima_user_DllExport MinimalAliasBody& operator =(
12985 MinimalAliasBody&& x) noexcept
12986 {
12987
12988 m_common = std::move(x.m_common);
12989 return *this;
12990 }
12991
12996 eProsima_user_DllExport bool operator ==(
12997 const MinimalAliasBody& x) const
12998 {
12999 return (m_common == x.m_common);
13000 }
13001
13006 eProsima_user_DllExport bool operator !=(
13007 const MinimalAliasBody& x) const
13008 {
13009 return !(*this == x);
13010 }
13011
13016 eProsima_user_DllExport void common(
13017 const CommonAliasBody& _common)
13018 {
13019 m_common = _common;
13020 }
13021
13026 eProsima_user_DllExport void common(
13027 CommonAliasBody&& _common)
13028 {
13029 m_common = std::move(_common);
13030 }
13031
13036 eProsima_user_DllExport const CommonAliasBody& common() const
13037 {
13038 return m_common;
13039 }
13040
13045 eProsima_user_DllExport CommonAliasBody& common()
13046 {
13047 return m_common;
13048 }
13049
13050
13051
13052private:
13053
13054 CommonAliasBody m_common;
13055
13056};
13062{
13063public:
13064
13068 eProsima_user_DllExport CompleteAliasHeader()
13069 {
13070 }
13071
13075 eProsima_user_DllExport ~CompleteAliasHeader()
13076 {
13077 }
13078
13083 eProsima_user_DllExport CompleteAliasHeader(
13084 const CompleteAliasHeader& x)
13085 {
13086 m_detail = x.m_detail;
13087
13088 }
13089
13094 eProsima_user_DllExport CompleteAliasHeader(
13095 CompleteAliasHeader&& x) noexcept
13096 {
13097 m_detail = std::move(x.m_detail);
13098 }
13099
13104 eProsima_user_DllExport CompleteAliasHeader& operator =(
13105 const CompleteAliasHeader& x)
13106 {
13107
13108 m_detail = x.m_detail;
13109
13110 return *this;
13111 }
13112
13117 eProsima_user_DllExport CompleteAliasHeader& operator =(
13118 CompleteAliasHeader&& x) noexcept
13119 {
13120
13121 m_detail = std::move(x.m_detail);
13122 return *this;
13123 }
13124
13129 eProsima_user_DllExport bool operator ==(
13130 const CompleteAliasHeader& x) const
13131 {
13132 return (m_detail == x.m_detail);
13133 }
13134
13139 eProsima_user_DllExport bool operator !=(
13140 const CompleteAliasHeader& x) const
13141 {
13142 return !(*this == x);
13143 }
13144
13149 eProsima_user_DllExport void detail(
13150 const CompleteTypeDetail& _detail)
13151 {
13152 m_detail = _detail;
13153 }
13154
13159 eProsima_user_DllExport void detail(
13160 CompleteTypeDetail&& _detail)
13161 {
13162 m_detail = std::move(_detail);
13163 }
13164
13169 eProsima_user_DllExport const CompleteTypeDetail& detail() const
13170 {
13171 return m_detail;
13172 }
13173
13178 eProsima_user_DllExport CompleteTypeDetail& detail()
13179 {
13180 return m_detail;
13181 }
13182
13183
13184
13185private:
13186
13187 CompleteTypeDetail m_detail;
13188
13189};
13195{
13196public:
13197
13201 eProsima_user_DllExport MinimalAliasHeader()
13202 {
13203 }
13204
13208 eProsima_user_DllExport ~MinimalAliasHeader()
13209 {
13210 }
13211
13216 eProsima_user_DllExport MinimalAliasHeader(
13217 const MinimalAliasHeader& x)
13218 {
13219 static_cast<void>(x);
13220 }
13221
13226 eProsima_user_DllExport MinimalAliasHeader(
13227 MinimalAliasHeader&& x) noexcept
13228 {
13229 static_cast<void>(x);
13230 }
13231
13236 eProsima_user_DllExport MinimalAliasHeader& operator =(
13237 const MinimalAliasHeader& x)
13238 {
13239
13240 static_cast<void>(x);
13241
13242 return *this;
13243 }
13244
13249 eProsima_user_DllExport MinimalAliasHeader& operator =(
13250 MinimalAliasHeader&& x) noexcept
13251 {
13252
13253 static_cast<void>(x);
13254
13255 return *this;
13256 }
13257
13262 eProsima_user_DllExport bool operator ==(
13263 const MinimalAliasHeader& x) const
13264 {
13265 static_cast<void>(x);
13266 return true;
13267 }
13268
13273 eProsima_user_DllExport bool operator !=(
13274 const MinimalAliasHeader& x) const
13275 {
13276 return !(*this == x);
13277 }
13278
13279
13280
13281private:
13282
13283
13284};
13290{
13291public:
13292
13296 eProsima_user_DllExport CompleteAliasType()
13297 {
13298 }
13299
13303 eProsima_user_DllExport ~CompleteAliasType()
13304 {
13305 }
13306
13311 eProsima_user_DllExport CompleteAliasType(
13312 const CompleteAliasType& x)
13313 {
13314 m_alias_flags = x.m_alias_flags;
13315
13316 m_header = x.m_header;
13317
13318 m_body = x.m_body;
13319
13320 }
13321
13326 eProsima_user_DllExport CompleteAliasType(
13327 CompleteAliasType&& x) noexcept
13328 {
13329 m_alias_flags = std::move(x.m_alias_flags);
13330 m_header = std::move(x.m_header);
13331 m_body = std::move(x.m_body);
13332 }
13333
13338 eProsima_user_DllExport CompleteAliasType& operator =(
13339 const CompleteAliasType& x)
13340 {
13341
13342 m_alias_flags = x.m_alias_flags;
13343
13344 m_header = x.m_header;
13345
13346 m_body = x.m_body;
13347
13348 return *this;
13349 }
13350
13355 eProsima_user_DllExport CompleteAliasType& operator =(
13356 CompleteAliasType&& x) noexcept
13357 {
13358
13359 m_alias_flags = std::move(x.m_alias_flags);
13360 m_header = std::move(x.m_header);
13361 m_body = std::move(x.m_body);
13362 return *this;
13363 }
13364
13369 eProsima_user_DllExport bool operator ==(
13370 const CompleteAliasType& x) const
13371 {
13372 return (m_alias_flags == x.m_alias_flags &&
13373 m_header == x.m_header &&
13374 m_body == x.m_body);
13375 }
13376
13381 eProsima_user_DllExport bool operator !=(
13382 const CompleteAliasType& x) const
13383 {
13384 return !(*this == x);
13385 }
13386
13391 eProsima_user_DllExport void alias_flags(
13392 const AliasTypeFlag& _alias_flags)
13393 {
13394 m_alias_flags = _alias_flags;
13395 }
13396
13401 eProsima_user_DllExport void alias_flags(
13402 AliasTypeFlag&& _alias_flags)
13403 {
13404 m_alias_flags = std::move(_alias_flags);
13405 }
13406
13411 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13412 {
13413 return m_alias_flags;
13414 }
13415
13420 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13421 {
13422 return m_alias_flags;
13423 }
13424
13425
13430 eProsima_user_DllExport void header(
13431 const CompleteAliasHeader& _header)
13432 {
13433 m_header = _header;
13434 }
13435
13440 eProsima_user_DllExport void header(
13441 CompleteAliasHeader&& _header)
13442 {
13443 m_header = std::move(_header);
13444 }
13445
13450 eProsima_user_DllExport const CompleteAliasHeader& header() const
13451 {
13452 return m_header;
13453 }
13454
13459 eProsima_user_DllExport CompleteAliasHeader& header()
13460 {
13461 return m_header;
13462 }
13463
13464
13469 eProsima_user_DllExport void body(
13470 const CompleteAliasBody& _body)
13471 {
13472 m_body = _body;
13473 }
13474
13479 eProsima_user_DllExport void body(
13480 CompleteAliasBody&& _body)
13481 {
13482 m_body = std::move(_body);
13483 }
13484
13489 eProsima_user_DllExport const CompleteAliasBody& body() const
13490 {
13491 return m_body;
13492 }
13493
13498 eProsima_user_DllExport CompleteAliasBody& body()
13499 {
13500 return m_body;
13501 }
13502
13503
13504
13505private:
13506
13507 AliasTypeFlag m_alias_flags{0};
13508 CompleteAliasHeader m_header;
13509 CompleteAliasBody m_body;
13510
13511};
13517{
13518public:
13519
13523 eProsima_user_DllExport MinimalAliasType()
13524 {
13525 }
13526
13530 eProsima_user_DllExport ~MinimalAliasType()
13531 {
13532 }
13533
13538 eProsima_user_DllExport MinimalAliasType(
13539 const MinimalAliasType& x)
13540 {
13541 m_alias_flags = x.m_alias_flags;
13542
13543 m_header = x.m_header;
13544
13545 m_body = x.m_body;
13546
13547 }
13548
13553 eProsima_user_DllExport MinimalAliasType(
13554 MinimalAliasType&& x) noexcept
13555 {
13556 m_alias_flags = std::move(x.m_alias_flags);
13557 m_header = std::move(x.m_header);
13558 m_body = std::move(x.m_body);
13559 }
13560
13565 eProsima_user_DllExport MinimalAliasType& operator =(
13566 const MinimalAliasType& x)
13567 {
13568
13569 m_alias_flags = x.m_alias_flags;
13570
13571 m_header = x.m_header;
13572
13573 m_body = x.m_body;
13574
13575 return *this;
13576 }
13577
13582 eProsima_user_DllExport MinimalAliasType& operator =(
13583 MinimalAliasType&& x) noexcept
13584 {
13585
13586 m_alias_flags = std::move(x.m_alias_flags);
13587 m_header = std::move(x.m_header);
13588 m_body = std::move(x.m_body);
13589 return *this;
13590 }
13591
13596 eProsima_user_DllExport bool operator ==(
13597 const MinimalAliasType& x) const
13598 {
13599 return (m_alias_flags == x.m_alias_flags &&
13600 m_header == x.m_header &&
13601 m_body == x.m_body);
13602 }
13603
13608 eProsima_user_DllExport bool operator !=(
13609 const MinimalAliasType& x) const
13610 {
13611 return !(*this == x);
13612 }
13613
13618 eProsima_user_DllExport void alias_flags(
13619 const AliasTypeFlag& _alias_flags)
13620 {
13621 m_alias_flags = _alias_flags;
13622 }
13623
13628 eProsima_user_DllExport void alias_flags(
13629 AliasTypeFlag&& _alias_flags)
13630 {
13631 m_alias_flags = std::move(_alias_flags);
13632 }
13633
13638 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13639 {
13640 return m_alias_flags;
13641 }
13642
13647 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13648 {
13649 return m_alias_flags;
13650 }
13651
13652
13657 eProsima_user_DllExport void header(
13658 const MinimalAliasHeader& _header)
13659 {
13660 m_header = _header;
13661 }
13662
13667 eProsima_user_DllExport void header(
13668 MinimalAliasHeader&& _header)
13669 {
13670 m_header = std::move(_header);
13671 }
13672
13677 eProsima_user_DllExport const MinimalAliasHeader& header() const
13678 {
13679 return m_header;
13680 }
13681
13686 eProsima_user_DllExport MinimalAliasHeader& header()
13687 {
13688 return m_header;
13689 }
13690
13691
13696 eProsima_user_DllExport void body(
13697 const MinimalAliasBody& _body)
13698 {
13699 m_body = _body;
13700 }
13701
13706 eProsima_user_DllExport void body(
13707 MinimalAliasBody&& _body)
13708 {
13709 m_body = std::move(_body);
13710 }
13711
13716 eProsima_user_DllExport const MinimalAliasBody& body() const
13717 {
13718 return m_body;
13719 }
13720
13725 eProsima_user_DllExport MinimalAliasBody& body()
13726 {
13727 return m_body;
13728 }
13729
13730
13731
13732private:
13733
13734 AliasTypeFlag m_alias_flags{0};
13735 MinimalAliasHeader m_header;
13736 MinimalAliasBody m_body;
13737
13738};
13744{
13745public:
13746
13750 eProsima_user_DllExport CompleteElementDetail()
13751 {
13752 }
13753
13757 eProsima_user_DllExport ~CompleteElementDetail()
13758 {
13759 }
13760
13765 eProsima_user_DllExport CompleteElementDetail(
13766 const CompleteElementDetail& x)
13767 {
13768 m_ann_builtin = x.m_ann_builtin;
13769
13770 m_ann_custom = x.m_ann_custom;
13771
13772 }
13773
13778 eProsima_user_DllExport CompleteElementDetail(
13779 CompleteElementDetail&& x) noexcept
13780 {
13781 m_ann_builtin = std::move(x.m_ann_builtin);
13782 m_ann_custom = std::move(x.m_ann_custom);
13783 }
13784
13789 eProsima_user_DllExport CompleteElementDetail& operator =(
13790 const CompleteElementDetail& x)
13791 {
13792
13793 m_ann_builtin = x.m_ann_builtin;
13794
13795 m_ann_custom = x.m_ann_custom;
13796
13797 return *this;
13798 }
13799
13804 eProsima_user_DllExport CompleteElementDetail& operator =(
13805 CompleteElementDetail&& x) noexcept
13806 {
13807
13808 m_ann_builtin = std::move(x.m_ann_builtin);
13809 m_ann_custom = std::move(x.m_ann_custom);
13810 return *this;
13811 }
13812
13817 eProsima_user_DllExport bool operator ==(
13818 const CompleteElementDetail& x) const
13819 {
13820 return (m_ann_builtin == x.m_ann_builtin &&
13821 m_ann_custom == x.m_ann_custom);
13822 }
13823
13828 eProsima_user_DllExport bool operator !=(
13829 const CompleteElementDetail& x) const
13830 {
13831 return !(*this == x);
13832 }
13833
13838 eProsima_user_DllExport void ann_builtin(
13839 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
13840 {
13841 m_ann_builtin = _ann_builtin;
13842 }
13843
13848 eProsima_user_DllExport void ann_builtin(
13849 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
13850 {
13851 m_ann_builtin = std::move(_ann_builtin);
13852 }
13853
13858 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
13859 {
13860 return m_ann_builtin;
13861 }
13862
13867 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
13868 {
13869 return m_ann_builtin;
13870 }
13871
13872
13877 eProsima_user_DllExport void ann_custom(
13878 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
13879 {
13880 m_ann_custom = _ann_custom;
13881 }
13882
13887 eProsima_user_DllExport void ann_custom(
13888 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
13889 {
13890 m_ann_custom = std::move(_ann_custom);
13891 }
13892
13897 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
13898 {
13899 return m_ann_custom;
13900 }
13901
13906 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
13907 {
13908 return m_ann_custom;
13909 }
13910
13911
13912
13913private:
13914
13915 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
13916 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
13917
13918};
13924{
13925public:
13926
13930 eProsima_user_DllExport CommonCollectionElement()
13931 {
13932 }
13933
13937 eProsima_user_DllExport ~CommonCollectionElement()
13938 {
13939 }
13940
13945 eProsima_user_DllExport CommonCollectionElement(
13946 const CommonCollectionElement& x)
13947 {
13948 m_element_flags = x.m_element_flags;
13949
13950 m_type = x.m_type;
13951
13952 }
13953
13958 eProsima_user_DllExport CommonCollectionElement(
13959 CommonCollectionElement&& x) noexcept
13960 {
13961 m_element_flags = std::move(x.m_element_flags);
13962 m_type = std::move(x.m_type);
13963 }
13964
13969 eProsima_user_DllExport CommonCollectionElement& operator =(
13970 const CommonCollectionElement& x)
13971 {
13972
13973 m_element_flags = x.m_element_flags;
13974
13975 m_type = x.m_type;
13976
13977 return *this;
13978 }
13979
13984 eProsima_user_DllExport CommonCollectionElement& operator =(
13985 CommonCollectionElement&& x) noexcept
13986 {
13987
13988 m_element_flags = std::move(x.m_element_flags);
13989 m_type = std::move(x.m_type);
13990 return *this;
13991 }
13992
13997 eProsima_user_DllExport bool operator ==(
13998 const CommonCollectionElement& x) const
13999 {
14000 return (m_element_flags == x.m_element_flags &&
14001 m_type == x.m_type);
14002 }
14003
14008 eProsima_user_DllExport bool operator !=(
14009 const CommonCollectionElement& x) const
14010 {
14011 return !(*this == x);
14012 }
14013
14018 eProsima_user_DllExport void element_flags(
14019 const CollectionElementFlag& _element_flags)
14020 {
14021 m_element_flags = _element_flags;
14022 }
14023
14028 eProsima_user_DllExport void element_flags(
14029 CollectionElementFlag&& _element_flags)
14030 {
14031 m_element_flags = std::move(_element_flags);
14032 }
14033
14038 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
14039 {
14040 return m_element_flags;
14041 }
14042
14047 eProsima_user_DllExport CollectionElementFlag& element_flags()
14048 {
14049 return m_element_flags;
14050 }
14051
14052
14057 eProsima_user_DllExport void type(
14058 const TypeIdentifier& _type)
14059 {
14060 m_type = _type;
14061 }
14062
14067 eProsima_user_DllExport void type(
14068 TypeIdentifier&& _type)
14069 {
14070 m_type = std::move(_type);
14071 }
14072
14077 eProsima_user_DllExport const TypeIdentifier& type() const
14078 {
14079 return m_type;
14080 }
14081
14086 eProsima_user_DllExport TypeIdentifier& type()
14087 {
14088 return m_type;
14089 }
14090
14091
14092
14093private:
14094
14095 CollectionElementFlag m_element_flags{0};
14096 TypeIdentifier m_type;
14097
14098};
14104{
14105public:
14106
14110 eProsima_user_DllExport CompleteCollectionElement()
14111 {
14112 }
14113
14117 eProsima_user_DllExport ~CompleteCollectionElement()
14118 {
14119 }
14120
14125 eProsima_user_DllExport CompleteCollectionElement(
14127 {
14128 m_common = x.m_common;
14129
14130 m_detail = x.m_detail;
14131
14132 }
14133
14138 eProsima_user_DllExport CompleteCollectionElement(
14139 CompleteCollectionElement&& x) noexcept
14140 {
14141 m_common = std::move(x.m_common);
14142 m_detail = std::move(x.m_detail);
14143 }
14144
14149 eProsima_user_DllExport CompleteCollectionElement& operator =(
14151 {
14152
14153 m_common = x.m_common;
14154
14155 m_detail = x.m_detail;
14156
14157 return *this;
14158 }
14159
14164 eProsima_user_DllExport CompleteCollectionElement& operator =(
14165 CompleteCollectionElement&& x) noexcept
14166 {
14167
14168 m_common = std::move(x.m_common);
14169 m_detail = std::move(x.m_detail);
14170 return *this;
14171 }
14172
14177 eProsima_user_DllExport bool operator ==(
14178 const CompleteCollectionElement& x) const
14179 {
14180 return (m_common == x.m_common &&
14181 m_detail == x.m_detail);
14182 }
14183
14188 eProsima_user_DllExport bool operator !=(
14189 const CompleteCollectionElement& x) const
14190 {
14191 return !(*this == x);
14192 }
14193
14198 eProsima_user_DllExport void common(
14199 const CommonCollectionElement& _common)
14200 {
14201 m_common = _common;
14202 }
14203
14208 eProsima_user_DllExport void common(
14209 CommonCollectionElement&& _common)
14210 {
14211 m_common = std::move(_common);
14212 }
14213
14218 eProsima_user_DllExport const CommonCollectionElement& common() const
14219 {
14220 return m_common;
14221 }
14222
14227 eProsima_user_DllExport CommonCollectionElement& common()
14228 {
14229 return m_common;
14230 }
14231
14232
14237 eProsima_user_DllExport void detail(
14238 const CompleteElementDetail& _detail)
14239 {
14240 m_detail = _detail;
14241 }
14242
14247 eProsima_user_DllExport void detail(
14248 CompleteElementDetail&& _detail)
14249 {
14250 m_detail = std::move(_detail);
14251 }
14252
14257 eProsima_user_DllExport const CompleteElementDetail& detail() const
14258 {
14259 return m_detail;
14260 }
14261
14266 eProsima_user_DllExport CompleteElementDetail& detail()
14267 {
14268 return m_detail;
14269 }
14270
14271
14272
14273private:
14274
14275 CommonCollectionElement m_common;
14276 CompleteElementDetail m_detail;
14277
14278};
14284{
14285public:
14286
14290 eProsima_user_DllExport MinimalCollectionElement()
14291 {
14292 }
14293
14297 eProsima_user_DllExport ~MinimalCollectionElement()
14298 {
14299 }
14300
14305 eProsima_user_DllExport MinimalCollectionElement(
14306 const MinimalCollectionElement& x)
14307 {
14308 m_common = x.m_common;
14309
14310 }
14311
14316 eProsima_user_DllExport MinimalCollectionElement(
14317 MinimalCollectionElement&& x) noexcept
14318 {
14319 m_common = std::move(x.m_common);
14320 }
14321
14326 eProsima_user_DllExport MinimalCollectionElement& operator =(
14327 const MinimalCollectionElement& x)
14328 {
14329
14330 m_common = x.m_common;
14331
14332 return *this;
14333 }
14334
14339 eProsima_user_DllExport MinimalCollectionElement& operator =(
14340 MinimalCollectionElement&& x) noexcept
14341 {
14342
14343 m_common = std::move(x.m_common);
14344 return *this;
14345 }
14346
14351 eProsima_user_DllExport bool operator ==(
14352 const MinimalCollectionElement& x) const
14353 {
14354 return (m_common == x.m_common);
14355 }
14356
14361 eProsima_user_DllExport bool operator !=(
14362 const MinimalCollectionElement& x) const
14363 {
14364 return !(*this == x);
14365 }
14366
14371 eProsima_user_DllExport void common(
14372 const CommonCollectionElement& _common)
14373 {
14374 m_common = _common;
14375 }
14376
14381 eProsima_user_DllExport void common(
14382 CommonCollectionElement&& _common)
14383 {
14384 m_common = std::move(_common);
14385 }
14386
14391 eProsima_user_DllExport const CommonCollectionElement& common() const
14392 {
14393 return m_common;
14394 }
14395
14400 eProsima_user_DllExport CommonCollectionElement& common()
14401 {
14402 return m_common;
14403 }
14404
14405
14406
14407private:
14408
14409 CommonCollectionElement m_common;
14410
14411};
14417{
14418public:
14419
14423 eProsima_user_DllExport CommonCollectionHeader()
14424 {
14425 }
14426
14430 eProsima_user_DllExport ~CommonCollectionHeader()
14431 {
14432 }
14433
14438 eProsima_user_DllExport CommonCollectionHeader(
14439 const CommonCollectionHeader& x)
14440 {
14441 m_bound = x.m_bound;
14442
14443 }
14444
14449 eProsima_user_DllExport CommonCollectionHeader(
14450 CommonCollectionHeader&& x) noexcept
14451 {
14452 m_bound = x.m_bound;
14453 }
14454
14459 eProsima_user_DllExport CommonCollectionHeader& operator =(
14460 const CommonCollectionHeader& x)
14461 {
14462
14463 m_bound = x.m_bound;
14464
14465 return *this;
14466 }
14467
14472 eProsima_user_DllExport CommonCollectionHeader& operator =(
14473 CommonCollectionHeader&& x) noexcept
14474 {
14475
14476 m_bound = x.m_bound;
14477 return *this;
14478 }
14479
14484 eProsima_user_DllExport bool operator ==(
14485 const CommonCollectionHeader& x) const
14486 {
14487 return (m_bound == x.m_bound);
14488 }
14489
14494 eProsima_user_DllExport bool operator !=(
14495 const CommonCollectionHeader& x) const
14496 {
14497 return !(*this == x);
14498 }
14499
14504 eProsima_user_DllExport void bound(
14505 LBound _bound)
14506 {
14507 m_bound = _bound;
14508 }
14509
14514 eProsima_user_DllExport LBound bound() const
14515 {
14516 return m_bound;
14517 }
14518
14523 eProsima_user_DllExport LBound& bound()
14524 {
14525 return m_bound;
14526 }
14527
14528
14529
14530private:
14531
14532 LBound m_bound{0};
14533
14534};
14540{
14541public:
14542
14546 eProsima_user_DllExport CompleteCollectionHeader()
14547 {
14548 }
14549
14553 eProsima_user_DllExport ~CompleteCollectionHeader()
14554 {
14555 }
14556
14561 eProsima_user_DllExport CompleteCollectionHeader(
14562 const CompleteCollectionHeader& x)
14563 {
14564 m_common = x.m_common;
14565
14566 m_detail = x.m_detail;
14567
14568 }
14569
14574 eProsima_user_DllExport CompleteCollectionHeader(
14575 CompleteCollectionHeader&& x) noexcept
14576 {
14577 m_common = std::move(x.m_common);
14578 m_detail = std::move(x.m_detail);
14579 }
14580
14585 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14586 const CompleteCollectionHeader& x)
14587 {
14588
14589 m_common = x.m_common;
14590
14591 m_detail = x.m_detail;
14592
14593 return *this;
14594 }
14595
14600 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14601 CompleteCollectionHeader&& x) noexcept
14602 {
14603
14604 m_common = std::move(x.m_common);
14605 m_detail = std::move(x.m_detail);
14606 return *this;
14607 }
14608
14613 eProsima_user_DllExport bool operator ==(
14614 const CompleteCollectionHeader& x) const
14615 {
14616 return (m_common == x.m_common &&
14617 m_detail == x.m_detail);
14618 }
14619
14624 eProsima_user_DllExport bool operator !=(
14625 const CompleteCollectionHeader& x) const
14626 {
14627 return !(*this == x);
14628 }
14629
14634 eProsima_user_DllExport void common(
14635 const CommonCollectionHeader& _common)
14636 {
14637 m_common = _common;
14638 }
14639
14644 eProsima_user_DllExport void common(
14645 CommonCollectionHeader&& _common)
14646 {
14647 m_common = std::move(_common);
14648 }
14649
14654 eProsima_user_DllExport const CommonCollectionHeader& common() const
14655 {
14656 return m_common;
14657 }
14658
14663 eProsima_user_DllExport CommonCollectionHeader& common()
14664 {
14665 return m_common;
14666 }
14667
14668
14673 eProsima_user_DllExport void detail(
14674 const eprosima::fastcdr::optional<CompleteTypeDetail>& _detail)
14675 {
14676 m_detail = _detail;
14677 }
14678
14683 eProsima_user_DllExport void detail(
14684 eprosima::fastcdr::optional<CompleteTypeDetail>&& _detail)
14685 {
14686 m_detail = std::move(_detail);
14687 }
14688
14693 eProsima_user_DllExport const eprosima::fastcdr::optional<CompleteTypeDetail>& detail() const
14694 {
14695 return m_detail;
14696 }
14697
14702 eProsima_user_DllExport eprosima::fastcdr::optional<CompleteTypeDetail>& detail()
14703 {
14704 return m_detail;
14705 }
14706
14707
14708
14709private:
14710
14711 CommonCollectionHeader m_common;
14712 eprosima::fastcdr::optional<CompleteTypeDetail> m_detail;
14713
14714};
14720{
14721public:
14722
14726 eProsima_user_DllExport MinimalCollectionHeader()
14727 {
14728 }
14729
14733 eProsima_user_DllExport ~MinimalCollectionHeader()
14734 {
14735 }
14736
14741 eProsima_user_DllExport MinimalCollectionHeader(
14742 const MinimalCollectionHeader& x)
14743 {
14744 m_common = x.m_common;
14745
14746 }
14747
14752 eProsima_user_DllExport MinimalCollectionHeader(
14753 MinimalCollectionHeader&& x) noexcept
14754 {
14755 m_common = std::move(x.m_common);
14756 }
14757
14762 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14763 const MinimalCollectionHeader& x)
14764 {
14765
14766 m_common = x.m_common;
14767
14768 return *this;
14769 }
14770
14775 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14776 MinimalCollectionHeader&& x) noexcept
14777 {
14778
14779 m_common = std::move(x.m_common);
14780 return *this;
14781 }
14782
14787 eProsima_user_DllExport bool operator ==(
14788 const MinimalCollectionHeader& x) const
14789 {
14790 return (m_common == x.m_common);
14791 }
14792
14797 eProsima_user_DllExport bool operator !=(
14798 const MinimalCollectionHeader& x) const
14799 {
14800 return !(*this == x);
14801 }
14802
14807 eProsima_user_DllExport void common(
14808 const CommonCollectionHeader& _common)
14809 {
14810 m_common = _common;
14811 }
14812
14817 eProsima_user_DllExport void common(
14818 CommonCollectionHeader&& _common)
14819 {
14820 m_common = std::move(_common);
14821 }
14822
14827 eProsima_user_DllExport const CommonCollectionHeader& common() const
14828 {
14829 return m_common;
14830 }
14831
14836 eProsima_user_DllExport CommonCollectionHeader& common()
14837 {
14838 return m_common;
14839 }
14840
14841
14842
14843private:
14844
14845 CommonCollectionHeader m_common;
14846
14847};
14853{
14854public:
14855
14859 eProsima_user_DllExport CompleteSequenceType()
14860 {
14861 }
14862
14866 eProsima_user_DllExport ~CompleteSequenceType()
14867 {
14868 }
14869
14874 eProsima_user_DllExport CompleteSequenceType(
14875 const CompleteSequenceType& x)
14876 {
14877 m_collection_flag = x.m_collection_flag;
14878
14879 m_header = x.m_header;
14880
14881 m_element = x.m_element;
14882
14883 }
14884
14889 eProsima_user_DllExport CompleteSequenceType(
14890 CompleteSequenceType&& x) noexcept
14891 {
14892 m_collection_flag = std::move(x.m_collection_flag);
14893 m_header = std::move(x.m_header);
14894 m_element = std::move(x.m_element);
14895 }
14896
14901 eProsima_user_DllExport CompleteSequenceType& operator =(
14902 const CompleteSequenceType& x)
14903 {
14904
14905 m_collection_flag = x.m_collection_flag;
14906
14907 m_header = x.m_header;
14908
14909 m_element = x.m_element;
14910
14911 return *this;
14912 }
14913
14918 eProsima_user_DllExport CompleteSequenceType& operator =(
14919 CompleteSequenceType&& x) noexcept
14920 {
14921
14922 m_collection_flag = std::move(x.m_collection_flag);
14923 m_header = std::move(x.m_header);
14924 m_element = std::move(x.m_element);
14925 return *this;
14926 }
14927
14932 eProsima_user_DllExport bool operator ==(
14933 const CompleteSequenceType& x) const
14934 {
14935 return (m_collection_flag == x.m_collection_flag &&
14936 m_header == x.m_header &&
14937 m_element == x.m_element);
14938 }
14939
14944 eProsima_user_DllExport bool operator !=(
14945 const CompleteSequenceType& x) const
14946 {
14947 return !(*this == x);
14948 }
14949
14954 eProsima_user_DllExport void collection_flag(
14955 const CollectionTypeFlag& _collection_flag)
14956 {
14957 m_collection_flag = _collection_flag;
14958 }
14959
14964 eProsima_user_DllExport void collection_flag(
14965 CollectionTypeFlag&& _collection_flag)
14966 {
14967 m_collection_flag = std::move(_collection_flag);
14968 }
14969
14974 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
14975 {
14976 return m_collection_flag;
14977 }
14978
14983 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
14984 {
14985 return m_collection_flag;
14986 }
14987
14988
14993 eProsima_user_DllExport void header(
14994 const CompleteCollectionHeader& _header)
14995 {
14996 m_header = _header;
14997 }
14998
15003 eProsima_user_DllExport void header(
15004 CompleteCollectionHeader&& _header)
15005 {
15006 m_header = std::move(_header);
15007 }
15008
15013 eProsima_user_DllExport const CompleteCollectionHeader& header() const
15014 {
15015 return m_header;
15016 }
15017
15022 eProsima_user_DllExport CompleteCollectionHeader& header()
15023 {
15024 return m_header;
15025 }
15026
15027
15032 eProsima_user_DllExport void element(
15033 const CompleteCollectionElement& _element)
15034 {
15035 m_element = _element;
15036 }
15037
15042 eProsima_user_DllExport void element(
15043 CompleteCollectionElement&& _element)
15044 {
15045 m_element = std::move(_element);
15046 }
15047
15052 eProsima_user_DllExport const CompleteCollectionElement& element() const
15053 {
15054 return m_element;
15055 }
15056
15061 eProsima_user_DllExport CompleteCollectionElement& element()
15062 {
15063 return m_element;
15064 }
15065
15066
15067
15068private:
15069
15070 CollectionTypeFlag m_collection_flag{0};
15071 CompleteCollectionHeader m_header;
15072 CompleteCollectionElement m_element;
15073
15074};
15080{
15081public:
15082
15086 eProsima_user_DllExport MinimalSequenceType()
15087 {
15088 }
15089
15093 eProsima_user_DllExport ~MinimalSequenceType()
15094 {
15095 }
15096
15101 eProsima_user_DllExport MinimalSequenceType(
15102 const MinimalSequenceType& x)
15103 {
15104 m_collection_flag = x.m_collection_flag;
15105
15106 m_header = x.m_header;
15107
15108 m_element = x.m_element;
15109
15110 }
15111
15116 eProsima_user_DllExport MinimalSequenceType(
15117 MinimalSequenceType&& x) noexcept
15118 {
15119 m_collection_flag = std::move(x.m_collection_flag);
15120 m_header = std::move(x.m_header);
15121 m_element = std::move(x.m_element);
15122 }
15123
15128 eProsima_user_DllExport MinimalSequenceType& operator =(
15129 const MinimalSequenceType& x)
15130 {
15131
15132 m_collection_flag = x.m_collection_flag;
15133
15134 m_header = x.m_header;
15135
15136 m_element = x.m_element;
15137
15138 return *this;
15139 }
15140
15145 eProsima_user_DllExport MinimalSequenceType& operator =(
15146 MinimalSequenceType&& x) noexcept
15147 {
15148
15149 m_collection_flag = std::move(x.m_collection_flag);
15150 m_header = std::move(x.m_header);
15151 m_element = std::move(x.m_element);
15152 return *this;
15153 }
15154
15159 eProsima_user_DllExport bool operator ==(
15160 const MinimalSequenceType& x) const
15161 {
15162 return (m_collection_flag == x.m_collection_flag &&
15163 m_header == x.m_header &&
15164 m_element == x.m_element);
15165 }
15166
15171 eProsima_user_DllExport bool operator !=(
15172 const MinimalSequenceType& x) const
15173 {
15174 return !(*this == x);
15175 }
15176
15181 eProsima_user_DllExport void collection_flag(
15182 const CollectionTypeFlag& _collection_flag)
15183 {
15184 m_collection_flag = _collection_flag;
15185 }
15186
15191 eProsima_user_DllExport void collection_flag(
15192 CollectionTypeFlag&& _collection_flag)
15193 {
15194 m_collection_flag = std::move(_collection_flag);
15195 }
15196
15201 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15202 {
15203 return m_collection_flag;
15204 }
15205
15210 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15211 {
15212 return m_collection_flag;
15213 }
15214
15215
15220 eProsima_user_DllExport void header(
15221 const MinimalCollectionHeader& _header)
15222 {
15223 m_header = _header;
15224 }
15225
15230 eProsima_user_DllExport void header(
15231 MinimalCollectionHeader&& _header)
15232 {
15233 m_header = std::move(_header);
15234 }
15235
15240 eProsima_user_DllExport const MinimalCollectionHeader& header() const
15241 {
15242 return m_header;
15243 }
15244
15249 eProsima_user_DllExport MinimalCollectionHeader& header()
15250 {
15251 return m_header;
15252 }
15253
15254
15259 eProsima_user_DllExport void element(
15260 const MinimalCollectionElement& _element)
15261 {
15262 m_element = _element;
15263 }
15264
15269 eProsima_user_DllExport void element(
15270 MinimalCollectionElement&& _element)
15271 {
15272 m_element = std::move(_element);
15273 }
15274
15279 eProsima_user_DllExport const MinimalCollectionElement& element() const
15280 {
15281 return m_element;
15282 }
15283
15288 eProsima_user_DllExport MinimalCollectionElement& element()
15289 {
15290 return m_element;
15291 }
15292
15293
15294
15295private:
15296
15297 CollectionTypeFlag m_collection_flag{0};
15298 MinimalCollectionHeader m_header;
15299 MinimalCollectionElement m_element;
15300
15301};
15307{
15308public:
15309
15313 eProsima_user_DllExport CommonArrayHeader()
15314 {
15315 }
15316
15320 eProsima_user_DllExport ~CommonArrayHeader()
15321 {
15322 }
15323
15328 eProsima_user_DllExport CommonArrayHeader(
15329 const CommonArrayHeader& x)
15330 {
15331 m_bound_seq = x.m_bound_seq;
15332
15333 }
15334
15339 eProsima_user_DllExport CommonArrayHeader(
15340 CommonArrayHeader&& x) noexcept
15341 {
15342 m_bound_seq = std::move(x.m_bound_seq);
15343 }
15344
15349 eProsima_user_DllExport CommonArrayHeader& operator =(
15350 const CommonArrayHeader& x)
15351 {
15352
15353 m_bound_seq = x.m_bound_seq;
15354
15355 return *this;
15356 }
15357
15362 eProsima_user_DllExport CommonArrayHeader& operator =(
15363 CommonArrayHeader&& x) noexcept
15364 {
15365
15366 m_bound_seq = std::move(x.m_bound_seq);
15367 return *this;
15368 }
15369
15374 eProsima_user_DllExport bool operator ==(
15375 const CommonArrayHeader& x) const
15376 {
15377 return (m_bound_seq == x.m_bound_seq);
15378 }
15379
15384 eProsima_user_DllExport bool operator !=(
15385 const CommonArrayHeader& x) const
15386 {
15387 return !(*this == x);
15388 }
15389
15394 eProsima_user_DllExport void bound_seq(
15395 const LBoundSeq& _bound_seq)
15396 {
15397 m_bound_seq = _bound_seq;
15398 }
15399
15404 eProsima_user_DllExport void bound_seq(
15405 LBoundSeq&& _bound_seq)
15406 {
15407 m_bound_seq = std::move(_bound_seq);
15408 }
15409
15414 eProsima_user_DllExport const LBoundSeq& bound_seq() const
15415 {
15416 return m_bound_seq;
15417 }
15418
15423 eProsima_user_DllExport LBoundSeq& bound_seq()
15424 {
15425 return m_bound_seq;
15426 }
15427
15428
15429
15430private:
15431
15432 LBoundSeq m_bound_seq;
15433
15434};
15440{
15441public:
15442
15446 eProsima_user_DllExport CompleteArrayHeader()
15447 {
15448 }
15449
15453 eProsima_user_DllExport ~CompleteArrayHeader()
15454 {
15455 }
15456
15461 eProsima_user_DllExport CompleteArrayHeader(
15462 const CompleteArrayHeader& x)
15463 {
15464 m_common = x.m_common;
15465
15466 m_detail = x.m_detail;
15467
15468 }
15469
15474 eProsima_user_DllExport CompleteArrayHeader(
15475 CompleteArrayHeader&& x) noexcept
15476 {
15477 m_common = std::move(x.m_common);
15478 m_detail = std::move(x.m_detail);
15479 }
15480
15485 eProsima_user_DllExport CompleteArrayHeader& operator =(
15486 const CompleteArrayHeader& x)
15487 {
15488
15489 m_common = x.m_common;
15490
15491 m_detail = x.m_detail;
15492
15493 return *this;
15494 }
15495
15500 eProsima_user_DllExport CompleteArrayHeader& operator =(
15501 CompleteArrayHeader&& x) noexcept
15502 {
15503
15504 m_common = std::move(x.m_common);
15505 m_detail = std::move(x.m_detail);
15506 return *this;
15507 }
15508
15513 eProsima_user_DllExport bool operator ==(
15514 const CompleteArrayHeader& x) const
15515 {
15516 return (m_common == x.m_common &&
15517 m_detail == x.m_detail);
15518 }
15519
15524 eProsima_user_DllExport bool operator !=(
15525 const CompleteArrayHeader& x) const
15526 {
15527 return !(*this == x);
15528 }
15529
15534 eProsima_user_DllExport void common(
15535 const CommonArrayHeader& _common)
15536 {
15537 m_common = _common;
15538 }
15539
15544 eProsima_user_DllExport void common(
15545 CommonArrayHeader&& _common)
15546 {
15547 m_common = std::move(_common);
15548 }
15549
15554 eProsima_user_DllExport const CommonArrayHeader& common() const
15555 {
15556 return m_common;
15557 }
15558
15563 eProsima_user_DllExport CommonArrayHeader& common()
15564 {
15565 return m_common;
15566 }
15567
15568
15573 eProsima_user_DllExport void detail(
15574 const CompleteTypeDetail& _detail)
15575 {
15576 m_detail = _detail;
15577 }
15578
15583 eProsima_user_DllExport void detail(
15584 CompleteTypeDetail&& _detail)
15585 {
15586 m_detail = std::move(_detail);
15587 }
15588
15593 eProsima_user_DllExport const CompleteTypeDetail& detail() const
15594 {
15595 return m_detail;
15596 }
15597
15602 eProsima_user_DllExport CompleteTypeDetail& detail()
15603 {
15604 return m_detail;
15605 }
15606
15607
15608
15609private:
15610
15611 CommonArrayHeader m_common;
15612 CompleteTypeDetail m_detail;
15613
15614};
15620{
15621public:
15622
15626 eProsima_user_DllExport MinimalArrayHeader()
15627 {
15628 }
15629
15633 eProsima_user_DllExport ~MinimalArrayHeader()
15634 {
15635 }
15636
15641 eProsima_user_DllExport MinimalArrayHeader(
15642 const MinimalArrayHeader& x)
15643 {
15644 m_common = x.m_common;
15645
15646 }
15647
15652 eProsima_user_DllExport MinimalArrayHeader(
15653 MinimalArrayHeader&& x) noexcept
15654 {
15655 m_common = std::move(x.m_common);
15656 }
15657
15662 eProsima_user_DllExport MinimalArrayHeader& operator =(
15663 const MinimalArrayHeader& x)
15664 {
15665
15666 m_common = x.m_common;
15667
15668 return *this;
15669 }
15670
15675 eProsima_user_DllExport MinimalArrayHeader& operator =(
15676 MinimalArrayHeader&& x) noexcept
15677 {
15678
15679 m_common = std::move(x.m_common);
15680 return *this;
15681 }
15682
15687 eProsima_user_DllExport bool operator ==(
15688 const MinimalArrayHeader& x) const
15689 {
15690 return (m_common == x.m_common);
15691 }
15692
15697 eProsima_user_DllExport bool operator !=(
15698 const MinimalArrayHeader& x) const
15699 {
15700 return !(*this == x);
15701 }
15702
15707 eProsima_user_DllExport void common(
15708 const CommonArrayHeader& _common)
15709 {
15710 m_common = _common;
15711 }
15712
15717 eProsima_user_DllExport void common(
15718 CommonArrayHeader&& _common)
15719 {
15720 m_common = std::move(_common);
15721 }
15722
15727 eProsima_user_DllExport const CommonArrayHeader& common() const
15728 {
15729 return m_common;
15730 }
15731
15736 eProsima_user_DllExport CommonArrayHeader& common()
15737 {
15738 return m_common;
15739 }
15740
15741
15742
15743private:
15744
15745 CommonArrayHeader m_common;
15746
15747};
15753{
15754public:
15755
15759 eProsima_user_DllExport CompleteArrayType()
15760 {
15761 }
15762
15766 eProsima_user_DllExport ~CompleteArrayType()
15767 {
15768 }
15769
15774 eProsima_user_DllExport CompleteArrayType(
15775 const CompleteArrayType& x)
15776 {
15777 m_collection_flag = x.m_collection_flag;
15778
15779 m_header = x.m_header;
15780
15781 m_element = x.m_element;
15782
15783 }
15784
15789 eProsima_user_DllExport CompleteArrayType(
15790 CompleteArrayType&& x) noexcept
15791 {
15792 m_collection_flag = std::move(x.m_collection_flag);
15793 m_header = std::move(x.m_header);
15794 m_element = std::move(x.m_element);
15795 }
15796
15801 eProsima_user_DllExport CompleteArrayType& operator =(
15802 const CompleteArrayType& x)
15803 {
15804
15805 m_collection_flag = x.m_collection_flag;
15806
15807 m_header = x.m_header;
15808
15809 m_element = x.m_element;
15810
15811 return *this;
15812 }
15813
15818 eProsima_user_DllExport CompleteArrayType& operator =(
15819 CompleteArrayType&& x) noexcept
15820 {
15821
15822 m_collection_flag = std::move(x.m_collection_flag);
15823 m_header = std::move(x.m_header);
15824 m_element = std::move(x.m_element);
15825 return *this;
15826 }
15827
15832 eProsima_user_DllExport bool operator ==(
15833 const CompleteArrayType& x) const
15834 {
15835 return (m_collection_flag == x.m_collection_flag &&
15836 m_header == x.m_header &&
15837 m_element == x.m_element);
15838 }
15839
15844 eProsima_user_DllExport bool operator !=(
15845 const CompleteArrayType& x) const
15846 {
15847 return !(*this == x);
15848 }
15849
15854 eProsima_user_DllExport void collection_flag(
15855 const CollectionTypeFlag& _collection_flag)
15856 {
15857 m_collection_flag = _collection_flag;
15858 }
15859
15864 eProsima_user_DllExport void collection_flag(
15865 CollectionTypeFlag&& _collection_flag)
15866 {
15867 m_collection_flag = std::move(_collection_flag);
15868 }
15869
15874 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15875 {
15876 return m_collection_flag;
15877 }
15878
15883 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15884 {
15885 return m_collection_flag;
15886 }
15887
15888
15893 eProsima_user_DllExport void header(
15894 const CompleteArrayHeader& _header)
15895 {
15896 m_header = _header;
15897 }
15898
15903 eProsima_user_DllExport void header(
15904 CompleteArrayHeader&& _header)
15905 {
15906 m_header = std::move(_header);
15907 }
15908
15913 eProsima_user_DllExport const CompleteArrayHeader& header() const
15914 {
15915 return m_header;
15916 }
15917
15922 eProsima_user_DllExport CompleteArrayHeader& header()
15923 {
15924 return m_header;
15925 }
15926
15927
15932 eProsima_user_DllExport void element(
15933 const CompleteCollectionElement& _element)
15934 {
15935 m_element = _element;
15936 }
15937
15942 eProsima_user_DllExport void element(
15943 CompleteCollectionElement&& _element)
15944 {
15945 m_element = std::move(_element);
15946 }
15947
15952 eProsima_user_DllExport const CompleteCollectionElement& element() const
15953 {
15954 return m_element;
15955 }
15956
15961 eProsima_user_DllExport CompleteCollectionElement& element()
15962 {
15963 return m_element;
15964 }
15965
15966
15967
15968private:
15969
15970 CollectionTypeFlag m_collection_flag{0};
15971 CompleteArrayHeader m_header;
15972 CompleteCollectionElement m_element;
15973
15974};
15980{
15981public:
15982
15986 eProsima_user_DllExport MinimalArrayType()
15987 {
15988 }
15989
15993 eProsima_user_DllExport ~MinimalArrayType()
15994 {
15995 }
15996
16001 eProsima_user_DllExport MinimalArrayType(
16002 const MinimalArrayType& x)
16003 {
16004 m_collection_flag = x.m_collection_flag;
16005
16006 m_header = x.m_header;
16007
16008 m_element = x.m_element;
16009
16010 }
16011
16016 eProsima_user_DllExport MinimalArrayType(
16017 MinimalArrayType&& x) noexcept
16018 {
16019 m_collection_flag = std::move(x.m_collection_flag);
16020 m_header = std::move(x.m_header);
16021 m_element = std::move(x.m_element);
16022 }
16023
16028 eProsima_user_DllExport MinimalArrayType& operator =(
16029 const MinimalArrayType& x)
16030 {
16031
16032 m_collection_flag = x.m_collection_flag;
16033
16034 m_header = x.m_header;
16035
16036 m_element = x.m_element;
16037
16038 return *this;
16039 }
16040
16045 eProsima_user_DllExport MinimalArrayType& operator =(
16046 MinimalArrayType&& x) noexcept
16047 {
16048
16049 m_collection_flag = std::move(x.m_collection_flag);
16050 m_header = std::move(x.m_header);
16051 m_element = std::move(x.m_element);
16052 return *this;
16053 }
16054
16059 eProsima_user_DllExport bool operator ==(
16060 const MinimalArrayType& x) const
16061 {
16062 return (m_collection_flag == x.m_collection_flag &&
16063 m_header == x.m_header &&
16064 m_element == x.m_element);
16065 }
16066
16071 eProsima_user_DllExport bool operator !=(
16072 const MinimalArrayType& x) const
16073 {
16074 return !(*this == x);
16075 }
16076
16081 eProsima_user_DllExport void collection_flag(
16082 const CollectionTypeFlag& _collection_flag)
16083 {
16084 m_collection_flag = _collection_flag;
16085 }
16086
16091 eProsima_user_DllExport void collection_flag(
16092 CollectionTypeFlag&& _collection_flag)
16093 {
16094 m_collection_flag = std::move(_collection_flag);
16095 }
16096
16101 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16102 {
16103 return m_collection_flag;
16104 }
16105
16110 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16111 {
16112 return m_collection_flag;
16113 }
16114
16115
16120 eProsima_user_DllExport void header(
16121 const MinimalArrayHeader& _header)
16122 {
16123 m_header = _header;
16124 }
16125
16130 eProsima_user_DllExport void header(
16131 MinimalArrayHeader&& _header)
16132 {
16133 m_header = std::move(_header);
16134 }
16135
16140 eProsima_user_DllExport const MinimalArrayHeader& header() const
16141 {
16142 return m_header;
16143 }
16144
16149 eProsima_user_DllExport MinimalArrayHeader& header()
16150 {
16151 return m_header;
16152 }
16153
16154
16159 eProsima_user_DllExport void element(
16160 const MinimalCollectionElement& _element)
16161 {
16162 m_element = _element;
16163 }
16164
16169 eProsima_user_DllExport void element(
16170 MinimalCollectionElement&& _element)
16171 {
16172 m_element = std::move(_element);
16173 }
16174
16179 eProsima_user_DllExport const MinimalCollectionElement& element() const
16180 {
16181 return m_element;
16182 }
16183
16188 eProsima_user_DllExport MinimalCollectionElement& element()
16189 {
16190 return m_element;
16191 }
16192
16193
16194
16195private:
16196
16197 CollectionTypeFlag m_collection_flag{0};
16198 MinimalArrayHeader m_header;
16199 MinimalCollectionElement m_element;
16200
16201};
16207{
16208public:
16209
16213 eProsima_user_DllExport CompleteMapType()
16214 {
16215 }
16216
16220 eProsima_user_DllExport ~CompleteMapType()
16221 {
16222 }
16223
16228 eProsima_user_DllExport CompleteMapType(
16229 const CompleteMapType& x)
16230 {
16231 m_collection_flag = x.m_collection_flag;
16232
16233 m_header = x.m_header;
16234
16235 m_key = x.m_key;
16236
16237 m_element = x.m_element;
16238
16239 }
16240
16245 eProsima_user_DllExport CompleteMapType(
16246 CompleteMapType&& x) noexcept
16247 {
16248 m_collection_flag = std::move(x.m_collection_flag);
16249 m_header = std::move(x.m_header);
16250 m_key = std::move(x.m_key);
16251 m_element = std::move(x.m_element);
16252 }
16253
16258 eProsima_user_DllExport CompleteMapType& operator =(
16259 const CompleteMapType& x)
16260 {
16261
16262 m_collection_flag = x.m_collection_flag;
16263
16264 m_header = x.m_header;
16265
16266 m_key = x.m_key;
16267
16268 m_element = x.m_element;
16269
16270 return *this;
16271 }
16272
16277 eProsima_user_DllExport CompleteMapType& operator =(
16278 CompleteMapType&& x) noexcept
16279 {
16280
16281 m_collection_flag = std::move(x.m_collection_flag);
16282 m_header = std::move(x.m_header);
16283 m_key = std::move(x.m_key);
16284 m_element = std::move(x.m_element);
16285 return *this;
16286 }
16287
16292 eProsima_user_DllExport bool operator ==(
16293 const CompleteMapType& x) const
16294 {
16295 return (m_collection_flag == x.m_collection_flag &&
16296 m_header == x.m_header &&
16297 m_key == x.m_key &&
16298 m_element == x.m_element);
16299 }
16300
16305 eProsima_user_DllExport bool operator !=(
16306 const CompleteMapType& x) const
16307 {
16308 return !(*this == x);
16309 }
16310
16315 eProsima_user_DllExport void collection_flag(
16316 const CollectionTypeFlag& _collection_flag)
16317 {
16318 m_collection_flag = _collection_flag;
16319 }
16320
16325 eProsima_user_DllExport void collection_flag(
16326 CollectionTypeFlag&& _collection_flag)
16327 {
16328 m_collection_flag = std::move(_collection_flag);
16329 }
16330
16335 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16336 {
16337 return m_collection_flag;
16338 }
16339
16344 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16345 {
16346 return m_collection_flag;
16347 }
16348
16349
16354 eProsima_user_DllExport void header(
16355 const CompleteCollectionHeader& _header)
16356 {
16357 m_header = _header;
16358 }
16359
16364 eProsima_user_DllExport void header(
16365 CompleteCollectionHeader&& _header)
16366 {
16367 m_header = std::move(_header);
16368 }
16369
16374 eProsima_user_DllExport const CompleteCollectionHeader& header() const
16375 {
16376 return m_header;
16377 }
16378
16383 eProsima_user_DllExport CompleteCollectionHeader& header()
16384 {
16385 return m_header;
16386 }
16387
16388
16393 eProsima_user_DllExport void key(
16394 const CompleteCollectionElement& _key)
16395 {
16396 m_key = _key;
16397 }
16398
16403 eProsima_user_DllExport void key(
16405 {
16406 m_key = std::move(_key);
16407 }
16408
16413 eProsima_user_DllExport const CompleteCollectionElement& key() const
16414 {
16415 return m_key;
16416 }
16417
16422 eProsima_user_DllExport CompleteCollectionElement& key()
16423 {
16424 return m_key;
16425 }
16426
16427
16432 eProsima_user_DllExport void element(
16433 const CompleteCollectionElement& _element)
16434 {
16435 m_element = _element;
16436 }
16437
16442 eProsima_user_DllExport void element(
16443 CompleteCollectionElement&& _element)
16444 {
16445 m_element = std::move(_element);
16446 }
16447
16452 eProsima_user_DllExport const CompleteCollectionElement& element() const
16453 {
16454 return m_element;
16455 }
16456
16461 eProsima_user_DllExport CompleteCollectionElement& element()
16462 {
16463 return m_element;
16464 }
16465
16466
16467
16468private:
16469
16470 CollectionTypeFlag m_collection_flag{0};
16471 CompleteCollectionHeader m_header;
16472 CompleteCollectionElement m_key;
16473 CompleteCollectionElement m_element;
16474
16475};
16481{
16482public:
16483
16487 eProsima_user_DllExport MinimalMapType()
16488 {
16489 }
16490
16494 eProsima_user_DllExport ~MinimalMapType()
16495 {
16496 }
16497
16502 eProsima_user_DllExport MinimalMapType(
16503 const MinimalMapType& x)
16504 {
16505 m_collection_flag = x.m_collection_flag;
16506
16507 m_header = x.m_header;
16508
16509 m_key = x.m_key;
16510
16511 m_element = x.m_element;
16512
16513 }
16514
16519 eProsima_user_DllExport MinimalMapType(
16520 MinimalMapType&& x) noexcept
16521 {
16522 m_collection_flag = std::move(x.m_collection_flag);
16523 m_header = std::move(x.m_header);
16524 m_key = std::move(x.m_key);
16525 m_element = std::move(x.m_element);
16526 }
16527
16532 eProsima_user_DllExport MinimalMapType& operator =(
16533 const MinimalMapType& x)
16534 {
16535
16536 m_collection_flag = x.m_collection_flag;
16537
16538 m_header = x.m_header;
16539
16540 m_key = x.m_key;
16541
16542 m_element = x.m_element;
16543
16544 return *this;
16545 }
16546
16551 eProsima_user_DllExport MinimalMapType& operator =(
16552 MinimalMapType&& x) noexcept
16553 {
16554
16555 m_collection_flag = std::move(x.m_collection_flag);
16556 m_header = std::move(x.m_header);
16557 m_key = std::move(x.m_key);
16558 m_element = std::move(x.m_element);
16559 return *this;
16560 }
16561
16566 eProsima_user_DllExport bool operator ==(
16567 const MinimalMapType& x) const
16568 {
16569 return (m_collection_flag == x.m_collection_flag &&
16570 m_header == x.m_header &&
16571 m_key == x.m_key &&
16572 m_element == x.m_element);
16573 }
16574
16579 eProsima_user_DllExport bool operator !=(
16580 const MinimalMapType& x) const
16581 {
16582 return !(*this == x);
16583 }
16584
16589 eProsima_user_DllExport void collection_flag(
16590 const CollectionTypeFlag& _collection_flag)
16591 {
16592 m_collection_flag = _collection_flag;
16593 }
16594
16599 eProsima_user_DllExport void collection_flag(
16600 CollectionTypeFlag&& _collection_flag)
16601 {
16602 m_collection_flag = std::move(_collection_flag);
16603 }
16604
16609 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16610 {
16611 return m_collection_flag;
16612 }
16613
16618 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16619 {
16620 return m_collection_flag;
16621 }
16622
16623
16628 eProsima_user_DllExport void header(
16629 const MinimalCollectionHeader& _header)
16630 {
16631 m_header = _header;
16632 }
16633
16638 eProsima_user_DllExport void header(
16639 MinimalCollectionHeader&& _header)
16640 {
16641 m_header = std::move(_header);
16642 }
16643
16648 eProsima_user_DllExport const MinimalCollectionHeader& header() const
16649 {
16650 return m_header;
16651 }
16652
16657 eProsima_user_DllExport MinimalCollectionHeader& header()
16658 {
16659 return m_header;
16660 }
16661
16662
16667 eProsima_user_DllExport void key(
16668 const MinimalCollectionElement& _key)
16669 {
16670 m_key = _key;
16671 }
16672
16677 eProsima_user_DllExport void key(
16679 {
16680 m_key = std::move(_key);
16681 }
16682
16687 eProsima_user_DllExport const MinimalCollectionElement& key() const
16688 {
16689 return m_key;
16690 }
16691
16696 eProsima_user_DllExport MinimalCollectionElement& key()
16697 {
16698 return m_key;
16699 }
16700
16701
16706 eProsima_user_DllExport void element(
16707 const MinimalCollectionElement& _element)
16708 {
16709 m_element = _element;
16710 }
16711
16716 eProsima_user_DllExport void element(
16717 MinimalCollectionElement&& _element)
16718 {
16719 m_element = std::move(_element);
16720 }
16721
16726 eProsima_user_DllExport const MinimalCollectionElement& element() const
16727 {
16728 return m_element;
16729 }
16730
16735 eProsima_user_DllExport MinimalCollectionElement& element()
16736 {
16737 return m_element;
16738 }
16739
16740
16741
16742private:
16743
16744 CollectionTypeFlag m_collection_flag{0};
16745 MinimalCollectionHeader m_header;
16746 MinimalCollectionElement m_key;
16747 MinimalCollectionElement m_element;
16748
16749};
16750typedef uint16_t BitBound;
16751
16757{
16758public:
16759
16763 eProsima_user_DllExport CommonEnumeratedLiteral()
16764 {
16765 }
16766
16770 eProsima_user_DllExport ~CommonEnumeratedLiteral()
16771 {
16772 }
16773
16778 eProsima_user_DllExport CommonEnumeratedLiteral(
16779 const CommonEnumeratedLiteral& x)
16780 {
16781 m_value = x.m_value;
16782
16783 m_flags = x.m_flags;
16784
16785 }
16786
16791 eProsima_user_DllExport CommonEnumeratedLiteral(
16792 CommonEnumeratedLiteral&& x) noexcept
16793 {
16794 m_value = x.m_value;
16795 m_flags = std::move(x.m_flags);
16796 }
16797
16802 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16803 const CommonEnumeratedLiteral& x)
16804 {
16805
16806 m_value = x.m_value;
16807
16808 m_flags = x.m_flags;
16809
16810 return *this;
16811 }
16812
16817 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16818 CommonEnumeratedLiteral&& x) noexcept
16819 {
16820
16821 m_value = x.m_value;
16822 m_flags = std::move(x.m_flags);
16823 return *this;
16824 }
16825
16830 eProsima_user_DllExport bool operator ==(
16831 const CommonEnumeratedLiteral& x) const
16832 {
16833 return (m_value == x.m_value &&
16834 m_flags == x.m_flags);
16835 }
16836
16841 eProsima_user_DllExport bool operator !=(
16842 const CommonEnumeratedLiteral& x) const
16843 {
16844 return !(*this == x);
16845 }
16846
16851 eProsima_user_DllExport void value(
16852 int32_t _value)
16853 {
16854 m_value = _value;
16855 }
16856
16861 eProsima_user_DllExport int32_t value() const
16862 {
16863 return m_value;
16864 }
16865
16870 eProsima_user_DllExport int32_t& value()
16871 {
16872 return m_value;
16873 }
16874
16875
16880 eProsima_user_DllExport void flags(
16881 const EnumeratedLiteralFlag& _flags)
16882 {
16883 m_flags = _flags;
16884 }
16885
16890 eProsima_user_DllExport void flags(
16891 EnumeratedLiteralFlag&& _flags)
16892 {
16893 m_flags = std::move(_flags);
16894 }
16895
16900 eProsima_user_DllExport const EnumeratedLiteralFlag& flags() const
16901 {
16902 return m_flags;
16903 }
16904
16909 eProsima_user_DllExport EnumeratedLiteralFlag& flags()
16910 {
16911 return m_flags;
16912 }
16913
16914
16915
16916private:
16917
16918 int32_t m_value{0};
16919 EnumeratedLiteralFlag m_flags{0};
16920
16921};
16927{
16928public:
16929
16933 eProsima_user_DllExport CompleteEnumeratedLiteral()
16934 {
16935 }
16936
16940 eProsima_user_DllExport ~CompleteEnumeratedLiteral()
16941 {
16942 }
16943
16948 eProsima_user_DllExport CompleteEnumeratedLiteral(
16950 {
16951 m_common = x.m_common;
16952
16953 m_detail = x.m_detail;
16954
16955 }
16956
16961 eProsima_user_DllExport CompleteEnumeratedLiteral(
16962 CompleteEnumeratedLiteral&& x) noexcept
16963 {
16964 m_common = std::move(x.m_common);
16965 m_detail = std::move(x.m_detail);
16966 }
16967
16972 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
16974 {
16975
16976 m_common = x.m_common;
16977
16978 m_detail = x.m_detail;
16979
16980 return *this;
16981 }
16982
16987 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
16988 CompleteEnumeratedLiteral&& x) noexcept
16989 {
16990
16991 m_common = std::move(x.m_common);
16992 m_detail = std::move(x.m_detail);
16993 return *this;
16994 }
16995
17000 eProsima_user_DllExport bool operator ==(
17001 const CompleteEnumeratedLiteral& x) const
17002 {
17003 return (m_common == x.m_common &&
17004 m_detail == x.m_detail);
17005 }
17006
17011 eProsima_user_DllExport bool operator !=(
17012 const CompleteEnumeratedLiteral& x) const
17013 {
17014 return !(*this == x);
17015 }
17016
17021 eProsima_user_DllExport void common(
17022 const CommonEnumeratedLiteral& _common)
17023 {
17024 m_common = _common;
17025 }
17026
17031 eProsima_user_DllExport void common(
17032 CommonEnumeratedLiteral&& _common)
17033 {
17034 m_common = std::move(_common);
17035 }
17036
17041 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17042 {
17043 return m_common;
17044 }
17045
17050 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17051 {
17052 return m_common;
17053 }
17054
17055
17060 eProsima_user_DllExport void detail(
17061 const CompleteMemberDetail& _detail)
17062 {
17063 m_detail = _detail;
17064 }
17065
17070 eProsima_user_DllExport void detail(
17071 CompleteMemberDetail&& _detail)
17072 {
17073 m_detail = std::move(_detail);
17074 }
17075
17080 eProsima_user_DllExport const CompleteMemberDetail& detail() const
17081 {
17082 return m_detail;
17083 }
17084
17089 eProsima_user_DllExport CompleteMemberDetail& detail()
17090 {
17091 return m_detail;
17092 }
17093
17094
17095
17096private:
17097
17098 CommonEnumeratedLiteral m_common;
17099 CompleteMemberDetail m_detail;
17100
17101};
17102typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
17103
17109{
17110public:
17111
17115 eProsima_user_DllExport MinimalEnumeratedLiteral()
17116 {
17117 }
17118
17122 eProsima_user_DllExport ~MinimalEnumeratedLiteral()
17123 {
17124 }
17125
17130 eProsima_user_DllExport MinimalEnumeratedLiteral(
17131 const MinimalEnumeratedLiteral& x)
17132 {
17133 m_common = x.m_common;
17134
17135 m_detail = x.m_detail;
17136
17137 }
17138
17143 eProsima_user_DllExport MinimalEnumeratedLiteral(
17144 MinimalEnumeratedLiteral&& x) noexcept
17145 {
17146 m_common = std::move(x.m_common);
17147 m_detail = std::move(x.m_detail);
17148 }
17149
17154 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17155 const MinimalEnumeratedLiteral& x)
17156 {
17157
17158 m_common = x.m_common;
17159
17160 m_detail = x.m_detail;
17161
17162 return *this;
17163 }
17164
17169 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17170 MinimalEnumeratedLiteral&& x) noexcept
17171 {
17172
17173 m_common = std::move(x.m_common);
17174 m_detail = std::move(x.m_detail);
17175 return *this;
17176 }
17177
17182 eProsima_user_DllExport bool operator ==(
17183 const MinimalEnumeratedLiteral& x) const
17184 {
17185 return (m_common == x.m_common &&
17186 m_detail == x.m_detail);
17187 }
17188
17193 eProsima_user_DllExport bool operator !=(
17194 const MinimalEnumeratedLiteral& x) const
17195 {
17196 return !(*this == x);
17197 }
17198
17203 eProsima_user_DllExport void common(
17204 const CommonEnumeratedLiteral& _common)
17205 {
17206 m_common = _common;
17207 }
17208
17213 eProsima_user_DllExport void common(
17214 CommonEnumeratedLiteral&& _common)
17215 {
17216 m_common = std::move(_common);
17217 }
17218
17223 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17224 {
17225 return m_common;
17226 }
17227
17232 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17233 {
17234 return m_common;
17235 }
17236
17237
17242 eProsima_user_DllExport void detail(
17243 const MinimalMemberDetail& _detail)
17244 {
17245 m_detail = _detail;
17246 }
17247
17252 eProsima_user_DllExport void detail(
17253 MinimalMemberDetail&& _detail)
17254 {
17255 m_detail = std::move(_detail);
17256 }
17257
17262 eProsima_user_DllExport const MinimalMemberDetail& detail() const
17263 {
17264 return m_detail;
17265 }
17266
17271 eProsima_user_DllExport MinimalMemberDetail& detail()
17272 {
17273 return m_detail;
17274 }
17275
17276
17277
17278private:
17279
17280 CommonEnumeratedLiteral m_common;
17281 MinimalMemberDetail m_detail;
17282
17283};
17284typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
17285
17291{
17292public:
17293
17297 eProsima_user_DllExport CommonEnumeratedHeader()
17298 {
17299 }
17300
17304 eProsima_user_DllExport ~CommonEnumeratedHeader()
17305 {
17306 }
17307
17312 eProsima_user_DllExport CommonEnumeratedHeader(
17313 const CommonEnumeratedHeader& x)
17314 {
17315 m_bit_bound = x.m_bit_bound;
17316
17317 }
17318
17323 eProsima_user_DllExport CommonEnumeratedHeader(
17324 CommonEnumeratedHeader&& x) noexcept
17325 {
17326 m_bit_bound = x.m_bit_bound;
17327 }
17328
17333 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17334 const CommonEnumeratedHeader& x)
17335 {
17336
17337 m_bit_bound = x.m_bit_bound;
17338
17339 return *this;
17340 }
17341
17346 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17347 CommonEnumeratedHeader&& x) noexcept
17348 {
17349
17350 m_bit_bound = x.m_bit_bound;
17351 return *this;
17352 }
17353
17358 eProsima_user_DllExport bool operator ==(
17359 const CommonEnumeratedHeader& x) const
17360 {
17361 return (m_bit_bound == x.m_bit_bound);
17362 }
17363
17368 eProsima_user_DllExport bool operator !=(
17369 const CommonEnumeratedHeader& x) const
17370 {
17371 return !(*this == x);
17372 }
17373
17378 eProsima_user_DllExport void bit_bound(
17379 BitBound _bit_bound)
17380 {
17381 m_bit_bound = _bit_bound;
17382 }
17383
17388 eProsima_user_DllExport BitBound bit_bound() const
17389 {
17390 return m_bit_bound;
17391 }
17392
17397 eProsima_user_DllExport BitBound& bit_bound()
17398 {
17399 return m_bit_bound;
17400 }
17401
17402
17403
17404private:
17405
17406 BitBound m_bit_bound{0};
17407
17408};
17414{
17415public:
17416
17420 eProsima_user_DllExport CompleteEnumeratedHeader()
17421 {
17422 }
17423
17427 eProsima_user_DllExport ~CompleteEnumeratedHeader()
17428 {
17429 }
17430
17435 eProsima_user_DllExport CompleteEnumeratedHeader(
17436 const CompleteEnumeratedHeader& x)
17437 {
17438 m_common = x.m_common;
17439
17440 m_detail = x.m_detail;
17441
17442 }
17443
17448 eProsima_user_DllExport CompleteEnumeratedHeader(
17449 CompleteEnumeratedHeader&& x) noexcept
17450 {
17451 m_common = std::move(x.m_common);
17452 m_detail = std::move(x.m_detail);
17453 }
17454
17459 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17460 const CompleteEnumeratedHeader& x)
17461 {
17462
17463 m_common = x.m_common;
17464
17465 m_detail = x.m_detail;
17466
17467 return *this;
17468 }
17469
17474 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17475 CompleteEnumeratedHeader&& x) noexcept
17476 {
17477
17478 m_common = std::move(x.m_common);
17479 m_detail = std::move(x.m_detail);
17480 return *this;
17481 }
17482
17487 eProsima_user_DllExport bool operator ==(
17488 const CompleteEnumeratedHeader& x) const
17489 {
17490 return (m_common == x.m_common &&
17491 m_detail == x.m_detail);
17492 }
17493
17498 eProsima_user_DllExport bool operator !=(
17499 const CompleteEnumeratedHeader& x) const
17500 {
17501 return !(*this == x);
17502 }
17503
17508 eProsima_user_DllExport void common(
17509 const CommonEnumeratedHeader& _common)
17510 {
17511 m_common = _common;
17512 }
17513
17518 eProsima_user_DllExport void common(
17519 CommonEnumeratedHeader&& _common)
17520 {
17521 m_common = std::move(_common);
17522 }
17523
17528 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17529 {
17530 return m_common;
17531 }
17532
17537 eProsima_user_DllExport CommonEnumeratedHeader& common()
17538 {
17539 return m_common;
17540 }
17541
17542
17547 eProsima_user_DllExport void detail(
17548 const CompleteTypeDetail& _detail)
17549 {
17550 m_detail = _detail;
17551 }
17552
17557 eProsima_user_DllExport void detail(
17558 CompleteTypeDetail&& _detail)
17559 {
17560 m_detail = std::move(_detail);
17561 }
17562
17567 eProsima_user_DllExport const CompleteTypeDetail& detail() const
17568 {
17569 return m_detail;
17570 }
17571
17576 eProsima_user_DllExport CompleteTypeDetail& detail()
17577 {
17578 return m_detail;
17579 }
17580
17581
17582
17583private:
17584
17585 CommonEnumeratedHeader m_common;
17586 CompleteTypeDetail m_detail;
17587
17588};
17594{
17595public:
17596
17600 eProsima_user_DllExport MinimalEnumeratedHeader()
17601 {
17602 }
17603
17607 eProsima_user_DllExport ~MinimalEnumeratedHeader()
17608 {
17609 }
17610
17615 eProsima_user_DllExport MinimalEnumeratedHeader(
17616 const MinimalEnumeratedHeader& x)
17617 {
17618 m_common = x.m_common;
17619
17620 }
17621
17626 eProsima_user_DllExport MinimalEnumeratedHeader(
17627 MinimalEnumeratedHeader&& x) noexcept
17628 {
17629 m_common = std::move(x.m_common);
17630 }
17631
17636 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17637 const MinimalEnumeratedHeader& x)
17638 {
17639
17640 m_common = x.m_common;
17641
17642 return *this;
17643 }
17644
17649 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17650 MinimalEnumeratedHeader&& x) noexcept
17651 {
17652
17653 m_common = std::move(x.m_common);
17654 return *this;
17655 }
17656
17661 eProsima_user_DllExport bool operator ==(
17662 const MinimalEnumeratedHeader& x) const
17663 {
17664 return (m_common == x.m_common);
17665 }
17666
17671 eProsima_user_DllExport bool operator !=(
17672 const MinimalEnumeratedHeader& x) const
17673 {
17674 return !(*this == x);
17675 }
17676
17681 eProsima_user_DllExport void common(
17682 const CommonEnumeratedHeader& _common)
17683 {
17684 m_common = _common;
17685 }
17686
17691 eProsima_user_DllExport void common(
17692 CommonEnumeratedHeader&& _common)
17693 {
17694 m_common = std::move(_common);
17695 }
17696
17701 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17702 {
17703 return m_common;
17704 }
17705
17710 eProsima_user_DllExport CommonEnumeratedHeader& common()
17711 {
17712 return m_common;
17713 }
17714
17715
17716
17717private:
17718
17719 CommonEnumeratedHeader m_common;
17720
17721};
17727{
17728public:
17729
17733 eProsima_user_DllExport CompleteEnumeratedType()
17734 {
17735 }
17736
17740 eProsima_user_DllExport ~CompleteEnumeratedType()
17741 {
17742 }
17743
17748 eProsima_user_DllExport CompleteEnumeratedType(
17749 const CompleteEnumeratedType& x)
17750 {
17751 m_enum_flags = x.m_enum_flags;
17752
17753 m_header = x.m_header;
17754
17755 m_literal_seq = x.m_literal_seq;
17756
17757 }
17758
17763 eProsima_user_DllExport CompleteEnumeratedType(
17764 CompleteEnumeratedType&& x) noexcept
17765 {
17766 m_enum_flags = std::move(x.m_enum_flags);
17767 m_header = std::move(x.m_header);
17768 m_literal_seq = std::move(x.m_literal_seq);
17769 }
17770
17775 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17776 const CompleteEnumeratedType& x)
17777 {
17778
17779 m_enum_flags = x.m_enum_flags;
17780
17781 m_header = x.m_header;
17782
17783 m_literal_seq = x.m_literal_seq;
17784
17785 return *this;
17786 }
17787
17792 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17793 CompleteEnumeratedType&& x) noexcept
17794 {
17795
17796 m_enum_flags = std::move(x.m_enum_flags);
17797 m_header = std::move(x.m_header);
17798 m_literal_seq = std::move(x.m_literal_seq);
17799 return *this;
17800 }
17801
17806 eProsima_user_DllExport bool operator ==(
17807 const CompleteEnumeratedType& x) const
17808 {
17809 return (m_enum_flags == x.m_enum_flags &&
17810 m_header == x.m_header &&
17811 m_literal_seq == x.m_literal_seq);
17812 }
17813
17818 eProsima_user_DllExport bool operator !=(
17819 const CompleteEnumeratedType& x) const
17820 {
17821 return !(*this == x);
17822 }
17823
17828 eProsima_user_DllExport void enum_flags(
17829 const EnumTypeFlag& _enum_flags)
17830 {
17831 m_enum_flags = _enum_flags;
17832 }
17833
17838 eProsima_user_DllExport void enum_flags(
17839 EnumTypeFlag&& _enum_flags)
17840 {
17841 m_enum_flags = std::move(_enum_flags);
17842 }
17843
17848 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
17849 {
17850 return m_enum_flags;
17851 }
17852
17857 eProsima_user_DllExport EnumTypeFlag& enum_flags()
17858 {
17859 return m_enum_flags;
17860 }
17861
17862
17867 eProsima_user_DllExport void header(
17868 const CompleteEnumeratedHeader& _header)
17869 {
17870 m_header = _header;
17871 }
17872
17877 eProsima_user_DllExport void header(
17878 CompleteEnumeratedHeader&& _header)
17879 {
17880 m_header = std::move(_header);
17881 }
17882
17887 eProsima_user_DllExport const CompleteEnumeratedHeader& header() const
17888 {
17889 return m_header;
17890 }
17891
17896 eProsima_user_DllExport CompleteEnumeratedHeader& header()
17897 {
17898 return m_header;
17899 }
17900
17901
17906 eProsima_user_DllExport void literal_seq(
17907 const CompleteEnumeratedLiteralSeq& _literal_seq)
17908 {
17909 m_literal_seq = _literal_seq;
17910 }
17911
17916 eProsima_user_DllExport void literal_seq(
17917 CompleteEnumeratedLiteralSeq&& _literal_seq)
17918 {
17919 m_literal_seq = std::move(_literal_seq);
17920 }
17921
17926 eProsima_user_DllExport const CompleteEnumeratedLiteralSeq& literal_seq() const
17927 {
17928 return m_literal_seq;
17929 }
17930
17936 {
17937 return m_literal_seq;
17938 }
17939
17940
17941
17942private:
17943
17944 EnumTypeFlag m_enum_flags{0};
17945 CompleteEnumeratedHeader m_header;
17946 CompleteEnumeratedLiteralSeq m_literal_seq;
17947
17948};
17954{
17955public:
17956
17960 eProsima_user_DllExport MinimalEnumeratedType()
17961 {
17962 }
17963
17967 eProsima_user_DllExport ~MinimalEnumeratedType()
17968 {
17969 }
17970
17975 eProsima_user_DllExport MinimalEnumeratedType(
17976 const MinimalEnumeratedType& x)
17977 {
17978 m_enum_flags = x.m_enum_flags;
17979
17980 m_header = x.m_header;
17981
17982 m_literal_seq = x.m_literal_seq;
17983
17984 }
17985
17990 eProsima_user_DllExport MinimalEnumeratedType(
17991 MinimalEnumeratedType&& x) noexcept
17992 {
17993 m_enum_flags = std::move(x.m_enum_flags);
17994 m_header = std::move(x.m_header);
17995 m_literal_seq = std::move(x.m_literal_seq);
17996 }
17997
18002 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18003 const MinimalEnumeratedType& x)
18004 {
18005
18006 m_enum_flags = x.m_enum_flags;
18007
18008 m_header = x.m_header;
18009
18010 m_literal_seq = x.m_literal_seq;
18011
18012 return *this;
18013 }
18014
18019 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18020 MinimalEnumeratedType&& x) noexcept
18021 {
18022
18023 m_enum_flags = std::move(x.m_enum_flags);
18024 m_header = std::move(x.m_header);
18025 m_literal_seq = std::move(x.m_literal_seq);
18026 return *this;
18027 }
18028
18033 eProsima_user_DllExport bool operator ==(
18034 const MinimalEnumeratedType& x) const
18035 {
18036 return (m_enum_flags == x.m_enum_flags &&
18037 m_header == x.m_header &&
18038 m_literal_seq == x.m_literal_seq);
18039 }
18040
18045 eProsima_user_DllExport bool operator !=(
18046 const MinimalEnumeratedType& x) const
18047 {
18048 return !(*this == x);
18049 }
18050
18055 eProsima_user_DllExport void enum_flags(
18056 const EnumTypeFlag& _enum_flags)
18057 {
18058 m_enum_flags = _enum_flags;
18059 }
18060
18065 eProsima_user_DllExport void enum_flags(
18066 EnumTypeFlag&& _enum_flags)
18067 {
18068 m_enum_flags = std::move(_enum_flags);
18069 }
18070
18075 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
18076 {
18077 return m_enum_flags;
18078 }
18079
18084 eProsima_user_DllExport EnumTypeFlag& enum_flags()
18085 {
18086 return m_enum_flags;
18087 }
18088
18089
18094 eProsima_user_DllExport void header(
18095 const MinimalEnumeratedHeader& _header)
18096 {
18097 m_header = _header;
18098 }
18099
18104 eProsima_user_DllExport void header(
18105 MinimalEnumeratedHeader&& _header)
18106 {
18107 m_header = std::move(_header);
18108 }
18109
18114 eProsima_user_DllExport const MinimalEnumeratedHeader& header() const
18115 {
18116 return m_header;
18117 }
18118
18123 eProsima_user_DllExport MinimalEnumeratedHeader& header()
18124 {
18125 return m_header;
18126 }
18127
18128
18133 eProsima_user_DllExport void literal_seq(
18134 const MinimalEnumeratedLiteralSeq& _literal_seq)
18135 {
18136 m_literal_seq = _literal_seq;
18137 }
18138
18143 eProsima_user_DllExport void literal_seq(
18144 MinimalEnumeratedLiteralSeq&& _literal_seq)
18145 {
18146 m_literal_seq = std::move(_literal_seq);
18147 }
18148
18153 eProsima_user_DllExport const MinimalEnumeratedLiteralSeq& literal_seq() const
18154 {
18155 return m_literal_seq;
18156 }
18157
18162 eProsima_user_DllExport MinimalEnumeratedLiteralSeq& literal_seq()
18163 {
18164 return m_literal_seq;
18165 }
18166
18167
18168
18169private:
18170
18171 EnumTypeFlag m_enum_flags{0};
18172 MinimalEnumeratedHeader m_header;
18173 MinimalEnumeratedLiteralSeq m_literal_seq;
18174
18175};
18181{
18182public:
18183
18187 eProsima_user_DllExport CommonBitflag()
18188 {
18189 }
18190
18194 eProsima_user_DllExport ~CommonBitflag()
18195 {
18196 }
18197
18202 eProsima_user_DllExport CommonBitflag(
18203 const CommonBitflag& x)
18204 {
18205 m_position = x.m_position;
18206
18207 m_flags = x.m_flags;
18208
18209 }
18210
18215 eProsima_user_DllExport CommonBitflag(
18216 CommonBitflag&& x) noexcept
18217 {
18218 m_position = x.m_position;
18219 m_flags = std::move(x.m_flags);
18220 }
18221
18226 eProsima_user_DllExport CommonBitflag& operator =(
18227 const CommonBitflag& x)
18228 {
18229
18230 m_position = x.m_position;
18231
18232 m_flags = x.m_flags;
18233
18234 return *this;
18235 }
18236
18241 eProsima_user_DllExport CommonBitflag& operator =(
18242 CommonBitflag&& x) noexcept
18243 {
18244
18245 m_position = x.m_position;
18246 m_flags = std::move(x.m_flags);
18247 return *this;
18248 }
18249
18254 eProsima_user_DllExport bool operator ==(
18255 const CommonBitflag& x) const
18256 {
18257 return (m_position == x.m_position &&
18258 m_flags == x.m_flags);
18259 }
18260
18265 eProsima_user_DllExport bool operator !=(
18266 const CommonBitflag& x) const
18267 {
18268 return !(*this == x);
18269 }
18270
18275 eProsima_user_DllExport void position(
18276 uint16_t _position)
18277 {
18278 m_position = _position;
18279 }
18280
18285 eProsima_user_DllExport uint16_t position() const
18286 {
18287 return m_position;
18288 }
18289
18294 eProsima_user_DllExport uint16_t& position()
18295 {
18296 return m_position;
18297 }
18298
18299
18304 eProsima_user_DllExport void flags(
18305 const BitflagFlag& _flags)
18306 {
18307 m_flags = _flags;
18308 }
18309
18314 eProsima_user_DllExport void flags(
18315 BitflagFlag&& _flags)
18316 {
18317 m_flags = std::move(_flags);
18318 }
18319
18324 eProsima_user_DllExport const BitflagFlag& flags() const
18325 {
18326 return m_flags;
18327 }
18328
18333 eProsima_user_DllExport BitflagFlag& flags()
18334 {
18335 return m_flags;
18336 }
18337
18338
18339
18340private:
18341
18342 uint16_t m_position{0};
18343 BitflagFlag m_flags{0};
18344
18345};
18351{
18352public:
18353
18357 eProsima_user_DllExport CompleteBitflag()
18358 {
18359 }
18360
18364 eProsima_user_DllExport ~CompleteBitflag()
18365 {
18366 }
18367
18372 eProsima_user_DllExport CompleteBitflag(
18373 const CompleteBitflag& x)
18374 {
18375 m_common = x.m_common;
18376
18377 m_detail = x.m_detail;
18378
18379 }
18380
18385 eProsima_user_DllExport CompleteBitflag(
18386 CompleteBitflag&& x) noexcept
18387 {
18388 m_common = std::move(x.m_common);
18389 m_detail = std::move(x.m_detail);
18390 }
18391
18396 eProsima_user_DllExport CompleteBitflag& operator =(
18397 const CompleteBitflag& x)
18398 {
18399
18400 m_common = x.m_common;
18401
18402 m_detail = x.m_detail;
18403
18404 return *this;
18405 }
18406
18411 eProsima_user_DllExport CompleteBitflag& operator =(
18412 CompleteBitflag&& x) noexcept
18413 {
18414
18415 m_common = std::move(x.m_common);
18416 m_detail = std::move(x.m_detail);
18417 return *this;
18418 }
18419
18424 eProsima_user_DllExport bool operator ==(
18425 const CompleteBitflag& x) const
18426 {
18427 return (m_common == x.m_common &&
18428 m_detail == x.m_detail);
18429 }
18430
18435 eProsima_user_DllExport bool operator !=(
18436 const CompleteBitflag& x) const
18437 {
18438 return !(*this == x);
18439 }
18440
18445 eProsima_user_DllExport void common(
18446 const CommonBitflag& _common)
18447 {
18448 m_common = _common;
18449 }
18450
18455 eProsima_user_DllExport void common(
18456 CommonBitflag&& _common)
18457 {
18458 m_common = std::move(_common);
18459 }
18460
18465 eProsima_user_DllExport const CommonBitflag& common() const
18466 {
18467 return m_common;
18468 }
18469
18474 eProsima_user_DllExport CommonBitflag& common()
18475 {
18476 return m_common;
18477 }
18478
18479
18484 eProsima_user_DllExport void detail(
18485 const CompleteMemberDetail& _detail)
18486 {
18487 m_detail = _detail;
18488 }
18489
18494 eProsima_user_DllExport void detail(
18495 CompleteMemberDetail&& _detail)
18496 {
18497 m_detail = std::move(_detail);
18498 }
18499
18504 eProsima_user_DllExport const CompleteMemberDetail& detail() const
18505 {
18506 return m_detail;
18507 }
18508
18513 eProsima_user_DllExport CompleteMemberDetail& detail()
18514 {
18515 return m_detail;
18516 }
18517
18518
18519
18520private:
18521
18522 CommonBitflag m_common;
18523 CompleteMemberDetail m_detail;
18524
18525};
18526typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
18527
18533{
18534public:
18535
18539 eProsima_user_DllExport MinimalBitflag()
18540 {
18541 }
18542
18546 eProsima_user_DllExport ~MinimalBitflag()
18547 {
18548 }
18549
18554 eProsima_user_DllExport MinimalBitflag(
18555 const MinimalBitflag& x)
18556 {
18557 m_common = x.m_common;
18558
18559 m_detail = x.m_detail;
18560
18561 }
18562
18567 eProsima_user_DllExport MinimalBitflag(
18568 MinimalBitflag&& x) noexcept
18569 {
18570 m_common = std::move(x.m_common);
18571 m_detail = std::move(x.m_detail);
18572 }
18573
18578 eProsima_user_DllExport MinimalBitflag& operator =(
18579 const MinimalBitflag& x)
18580 {
18581
18582 m_common = x.m_common;
18583
18584 m_detail = x.m_detail;
18585
18586 return *this;
18587 }
18588
18593 eProsima_user_DllExport MinimalBitflag& operator =(
18594 MinimalBitflag&& x) noexcept
18595 {
18596
18597 m_common = std::move(x.m_common);
18598 m_detail = std::move(x.m_detail);
18599 return *this;
18600 }
18601
18606 eProsima_user_DllExport bool operator ==(
18607 const MinimalBitflag& x) const
18608 {
18609 return (m_common == x.m_common &&
18610 m_detail == x.m_detail);
18611 }
18612
18617 eProsima_user_DllExport bool operator !=(
18618 const MinimalBitflag& x) const
18619 {
18620 return !(*this == x);
18621 }
18622
18627 eProsima_user_DllExport void common(
18628 const CommonBitflag& _common)
18629 {
18630 m_common = _common;
18631 }
18632
18637 eProsima_user_DllExport void common(
18638 CommonBitflag&& _common)
18639 {
18640 m_common = std::move(_common);
18641 }
18642
18647 eProsima_user_DllExport const CommonBitflag& common() const
18648 {
18649 return m_common;
18650 }
18651
18656 eProsima_user_DllExport CommonBitflag& common()
18657 {
18658 return m_common;
18659 }
18660
18661
18666 eProsima_user_DllExport void detail(
18667 const MinimalMemberDetail& _detail)
18668 {
18669 m_detail = _detail;
18670 }
18671
18676 eProsima_user_DllExport void detail(
18677 MinimalMemberDetail&& _detail)
18678 {
18679 m_detail = std::move(_detail);
18680 }
18681
18686 eProsima_user_DllExport const MinimalMemberDetail& detail() const
18687 {
18688 return m_detail;
18689 }
18690
18695 eProsima_user_DllExport MinimalMemberDetail& detail()
18696 {
18697 return m_detail;
18698 }
18699
18700
18701
18702private:
18703
18704 CommonBitflag m_common;
18705 MinimalMemberDetail m_detail;
18706
18707};
18708typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
18709
18715{
18716public:
18717
18721 eProsima_user_DllExport CommonBitmaskHeader()
18722 {
18723 }
18724
18728 eProsima_user_DllExport ~CommonBitmaskHeader()
18729 {
18730 }
18731
18736 eProsima_user_DllExport CommonBitmaskHeader(
18737 const CommonBitmaskHeader& x)
18738 {
18739 m_bit_bound = x.m_bit_bound;
18740
18741 }
18742
18747 eProsima_user_DllExport CommonBitmaskHeader(
18748 CommonBitmaskHeader&& x) noexcept
18749 {
18750 m_bit_bound = x.m_bit_bound;
18751 }
18752
18757 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18758 const CommonBitmaskHeader& x)
18759 {
18760
18761 m_bit_bound = x.m_bit_bound;
18762
18763 return *this;
18764 }
18765
18770 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18771 CommonBitmaskHeader&& x) noexcept
18772 {
18773
18774 m_bit_bound = x.m_bit_bound;
18775 return *this;
18776 }
18777
18782 eProsima_user_DllExport bool operator ==(
18783 const CommonBitmaskHeader& x) const
18784 {
18785 return (m_bit_bound == x.m_bit_bound);
18786 }
18787
18792 eProsima_user_DllExport bool operator !=(
18793 const CommonBitmaskHeader& x) const
18794 {
18795 return !(*this == x);
18796 }
18797
18802 eProsima_user_DllExport void bit_bound(
18803 BitBound _bit_bound)
18804 {
18805 m_bit_bound = _bit_bound;
18806 }
18807
18812 eProsima_user_DllExport BitBound bit_bound() const
18813 {
18814 return m_bit_bound;
18815 }
18816
18821 eProsima_user_DllExport BitBound& bit_bound()
18822 {
18823 return m_bit_bound;
18824 }
18825
18826
18827
18828private:
18829
18830 BitBound m_bit_bound{0};
18831
18832};
18834
18836
18842{
18843public:
18844
18848 eProsima_user_DllExport CompleteBitmaskType()
18849 {
18850 }
18851
18855 eProsima_user_DllExport ~CompleteBitmaskType()
18856 {
18857 }
18858
18863 eProsima_user_DllExport CompleteBitmaskType(
18864 const CompleteBitmaskType& x)
18865 {
18866 m_bitmask_flags = x.m_bitmask_flags;
18867
18868 m_header = x.m_header;
18869
18870 m_flag_seq = x.m_flag_seq;
18871
18872 }
18873
18878 eProsima_user_DllExport CompleteBitmaskType(
18879 CompleteBitmaskType&& x) noexcept
18880 {
18881 m_bitmask_flags = std::move(x.m_bitmask_flags);
18882 m_header = std::move(x.m_header);
18883 m_flag_seq = std::move(x.m_flag_seq);
18884 }
18885
18890 eProsima_user_DllExport CompleteBitmaskType& operator =(
18891 const CompleteBitmaskType& x)
18892 {
18893
18894 m_bitmask_flags = x.m_bitmask_flags;
18895
18896 m_header = x.m_header;
18897
18898 m_flag_seq = x.m_flag_seq;
18899
18900 return *this;
18901 }
18902
18907 eProsima_user_DllExport CompleteBitmaskType& operator =(
18908 CompleteBitmaskType&& x) noexcept
18909 {
18910
18911 m_bitmask_flags = std::move(x.m_bitmask_flags);
18912 m_header = std::move(x.m_header);
18913 m_flag_seq = std::move(x.m_flag_seq);
18914 return *this;
18915 }
18916
18921 eProsima_user_DllExport bool operator ==(
18922 const CompleteBitmaskType& x) const
18923 {
18924 return (m_bitmask_flags == x.m_bitmask_flags &&
18925 m_header == x.m_header &&
18926 m_flag_seq == x.m_flag_seq);
18927 }
18928
18933 eProsima_user_DllExport bool operator !=(
18934 const CompleteBitmaskType& x) const
18935 {
18936 return !(*this == x);
18937 }
18938
18943 eProsima_user_DllExport void bitmask_flags(
18944 const BitmaskTypeFlag& _bitmask_flags)
18945 {
18946 m_bitmask_flags = _bitmask_flags;
18947 }
18948
18953 eProsima_user_DllExport void bitmask_flags(
18954 BitmaskTypeFlag&& _bitmask_flags)
18955 {
18956 m_bitmask_flags = std::move(_bitmask_flags);
18957 }
18958
18963 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
18964 {
18965 return m_bitmask_flags;
18966 }
18967
18972 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
18973 {
18974 return m_bitmask_flags;
18975 }
18976
18977
18982 eProsima_user_DllExport void header(
18983 const CompleteBitmaskHeader& _header)
18984 {
18985 m_header = _header;
18986 }
18987
18992 eProsima_user_DllExport void header(
18993 CompleteBitmaskHeader&& _header)
18994 {
18995 m_header = std::move(_header);
18996 }
18997
19002 eProsima_user_DllExport const CompleteBitmaskHeader& header() const
19003 {
19004 return m_header;
19005 }
19006
19011 eProsima_user_DllExport CompleteBitmaskHeader& header()
19012 {
19013 return m_header;
19014 }
19015
19016
19021 eProsima_user_DllExport void flag_seq(
19022 const CompleteBitflagSeq& _flag_seq)
19023 {
19024 m_flag_seq = _flag_seq;
19025 }
19026
19031 eProsima_user_DllExport void flag_seq(
19032 CompleteBitflagSeq&& _flag_seq)
19033 {
19034 m_flag_seq = std::move(_flag_seq);
19035 }
19036
19041 eProsima_user_DllExport const CompleteBitflagSeq& flag_seq() const
19042 {
19043 return m_flag_seq;
19044 }
19045
19050 eProsima_user_DllExport CompleteBitflagSeq& flag_seq()
19051 {
19052 return m_flag_seq;
19053 }
19054
19055
19056
19057private:
19058
19059 BitmaskTypeFlag m_bitmask_flags{0};
19060 CompleteBitmaskHeader m_header;
19061 CompleteBitflagSeq m_flag_seq;
19062
19063};
19069{
19070public:
19071
19075 eProsima_user_DllExport MinimalBitmaskType()
19076 {
19077 }
19078
19082 eProsima_user_DllExport ~MinimalBitmaskType()
19083 {
19084 }
19085
19090 eProsima_user_DllExport MinimalBitmaskType(
19091 const MinimalBitmaskType& x)
19092 {
19093 m_bitmask_flags = x.m_bitmask_flags;
19094
19095 m_header = x.m_header;
19096
19097 m_flag_seq = x.m_flag_seq;
19098
19099 }
19100
19105 eProsima_user_DllExport MinimalBitmaskType(
19106 MinimalBitmaskType&& x) noexcept
19107 {
19108 m_bitmask_flags = std::move(x.m_bitmask_flags);
19109 m_header = std::move(x.m_header);
19110 m_flag_seq = std::move(x.m_flag_seq);
19111 }
19112
19117 eProsima_user_DllExport MinimalBitmaskType& operator =(
19118 const MinimalBitmaskType& x)
19119 {
19120
19121 m_bitmask_flags = x.m_bitmask_flags;
19122
19123 m_header = x.m_header;
19124
19125 m_flag_seq = x.m_flag_seq;
19126
19127 return *this;
19128 }
19129
19134 eProsima_user_DllExport MinimalBitmaskType& operator =(
19135 MinimalBitmaskType&& x) noexcept
19136 {
19137
19138 m_bitmask_flags = std::move(x.m_bitmask_flags);
19139 m_header = std::move(x.m_header);
19140 m_flag_seq = std::move(x.m_flag_seq);
19141 return *this;
19142 }
19143
19148 eProsima_user_DllExport bool operator ==(
19149 const MinimalBitmaskType& x) const
19150 {
19151 return (m_bitmask_flags == x.m_bitmask_flags &&
19152 m_header == x.m_header &&
19153 m_flag_seq == x.m_flag_seq);
19154 }
19155
19160 eProsima_user_DllExport bool operator !=(
19161 const MinimalBitmaskType& x) const
19162 {
19163 return !(*this == x);
19164 }
19165
19170 eProsima_user_DllExport void bitmask_flags(
19171 const BitmaskTypeFlag& _bitmask_flags)
19172 {
19173 m_bitmask_flags = _bitmask_flags;
19174 }
19175
19180 eProsima_user_DllExport void bitmask_flags(
19181 BitmaskTypeFlag&& _bitmask_flags)
19182 {
19183 m_bitmask_flags = std::move(_bitmask_flags);
19184 }
19185
19190 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
19191 {
19192 return m_bitmask_flags;
19193 }
19194
19199 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
19200 {
19201 return m_bitmask_flags;
19202 }
19203
19204
19209 eProsima_user_DllExport void header(
19210 const MinimalBitmaskHeader& _header)
19211 {
19212 m_header = _header;
19213 }
19214
19219 eProsima_user_DllExport void header(
19220 MinimalBitmaskHeader&& _header)
19221 {
19222 m_header = std::move(_header);
19223 }
19224
19229 eProsima_user_DllExport const MinimalBitmaskHeader& header() const
19230 {
19231 return m_header;
19232 }
19233
19238 eProsima_user_DllExport MinimalBitmaskHeader& header()
19239 {
19240 return m_header;
19241 }
19242
19243
19248 eProsima_user_DllExport void flag_seq(
19249 const MinimalBitflagSeq& _flag_seq)
19250 {
19251 m_flag_seq = _flag_seq;
19252 }
19253
19258 eProsima_user_DllExport void flag_seq(
19259 MinimalBitflagSeq&& _flag_seq)
19260 {
19261 m_flag_seq = std::move(_flag_seq);
19262 }
19263
19268 eProsima_user_DllExport const MinimalBitflagSeq& flag_seq() const
19269 {
19270 return m_flag_seq;
19271 }
19272
19277 eProsima_user_DllExport MinimalBitflagSeq& flag_seq()
19278 {
19279 return m_flag_seq;
19280 }
19281
19282
19283
19284private:
19285
19286 BitmaskTypeFlag m_bitmask_flags{0};
19287 MinimalBitmaskHeader m_header;
19288 MinimalBitflagSeq m_flag_seq;
19289
19290};
19296{
19297public:
19298
19302 eProsima_user_DllExport CommonBitfield()
19303 {
19304 }
19305
19309 eProsima_user_DllExport ~CommonBitfield()
19310 {
19311 }
19312
19317 eProsima_user_DllExport CommonBitfield(
19318 const CommonBitfield& x)
19319 {
19320 m_position = x.m_position;
19321
19322 m_flags = x.m_flags;
19323
19324 m_bitcount = x.m_bitcount;
19325
19326 m_holder_type = x.m_holder_type;
19327
19328 }
19329
19334 eProsima_user_DllExport CommonBitfield(
19335 CommonBitfield&& x) noexcept
19336 {
19337 m_position = x.m_position;
19338 m_flags = std::move(x.m_flags);
19339 m_bitcount = x.m_bitcount;
19340 m_holder_type = x.m_holder_type;
19341 }
19342
19347 eProsima_user_DllExport CommonBitfield& operator =(
19348 const CommonBitfield& x)
19349 {
19350
19351 m_position = x.m_position;
19352
19353 m_flags = x.m_flags;
19354
19355 m_bitcount = x.m_bitcount;
19356
19357 m_holder_type = x.m_holder_type;
19358
19359 return *this;
19360 }
19361
19366 eProsima_user_DllExport CommonBitfield& operator =(
19367 CommonBitfield&& x) noexcept
19368 {
19369
19370 m_position = x.m_position;
19371 m_flags = std::move(x.m_flags);
19372 m_bitcount = x.m_bitcount;
19373 m_holder_type = x.m_holder_type;
19374 return *this;
19375 }
19376
19381 eProsima_user_DllExport bool operator ==(
19382 const CommonBitfield& x) const
19383 {
19384 return (m_position == x.m_position &&
19385 m_flags == x.m_flags &&
19386 m_bitcount == x.m_bitcount &&
19387 m_holder_type == x.m_holder_type);
19388 }
19389
19394 eProsima_user_DllExport bool operator !=(
19395 const CommonBitfield& x) const
19396 {
19397 return !(*this == x);
19398 }
19399
19404 eProsima_user_DllExport void position(
19405 uint16_t _position)
19406 {
19407 m_position = _position;
19408 }
19409
19414 eProsima_user_DllExport uint16_t position() const
19415 {
19416 return m_position;
19417 }
19418
19423 eProsima_user_DllExport uint16_t& position()
19424 {
19425 return m_position;
19426 }
19427
19428
19433 eProsima_user_DllExport void flags(
19434 const BitsetMemberFlag& _flags)
19435 {
19436 m_flags = _flags;
19437 }
19438
19443 eProsima_user_DllExport void flags(
19444 BitsetMemberFlag&& _flags)
19445 {
19446 m_flags = std::move(_flags);
19447 }
19448
19453 eProsima_user_DllExport const BitsetMemberFlag& flags() const
19454 {
19455 return m_flags;
19456 }
19457
19462 eProsima_user_DllExport BitsetMemberFlag& flags()
19463 {
19464 return m_flags;
19465 }
19466
19467
19472 eProsima_user_DllExport void bitcount(
19473 uint8_t _bitcount)
19474 {
19475 m_bitcount = _bitcount;
19476 }
19477
19482 eProsima_user_DllExport uint8_t bitcount() const
19483 {
19484 return m_bitcount;
19485 }
19486
19491 eProsima_user_DllExport uint8_t& bitcount()
19492 {
19493 return m_bitcount;
19494 }
19495
19496
19501 eProsima_user_DllExport void holder_type(
19502 TypeKind _holder_type)
19503 {
19504 m_holder_type = _holder_type;
19505 }
19506
19511 eProsima_user_DllExport TypeKind holder_type() const
19512 {
19513 return m_holder_type;
19514 }
19515
19520 eProsima_user_DllExport TypeKind& holder_type()
19521 {
19522 return m_holder_type;
19523 }
19524
19525
19526
19527private:
19528
19529 uint16_t m_position{0};
19530 BitsetMemberFlag m_flags{0};
19531 uint8_t m_bitcount{0};
19532 TypeKind m_holder_type{0};
19533
19534};
19540{
19541public:
19542
19546 eProsima_user_DllExport CompleteBitfield()
19547 {
19548 }
19549
19553 eProsima_user_DllExport ~CompleteBitfield()
19554 {
19555 }
19556
19561 eProsima_user_DllExport CompleteBitfield(
19562 const CompleteBitfield& x)
19563 {
19564 m_common = x.m_common;
19565
19566 m_detail = x.m_detail;
19567
19568 }
19569
19574 eProsima_user_DllExport CompleteBitfield(
19575 CompleteBitfield&& x) noexcept
19576 {
19577 m_common = std::move(x.m_common);
19578 m_detail = std::move(x.m_detail);
19579 }
19580
19585 eProsima_user_DllExport CompleteBitfield& operator =(
19586 const CompleteBitfield& x)
19587 {
19588
19589 m_common = x.m_common;
19590
19591 m_detail = x.m_detail;
19592
19593 return *this;
19594 }
19595
19600 eProsima_user_DllExport CompleteBitfield& operator =(
19601 CompleteBitfield&& x) noexcept
19602 {
19603
19604 m_common = std::move(x.m_common);
19605 m_detail = std::move(x.m_detail);
19606 return *this;
19607 }
19608
19613 eProsima_user_DllExport bool operator ==(
19614 const CompleteBitfield& x) const
19615 {
19616 return (m_common == x.m_common &&
19617 m_detail == x.m_detail);
19618 }
19619
19624 eProsima_user_DllExport bool operator !=(
19625 const CompleteBitfield& x) const
19626 {
19627 return !(*this == x);
19628 }
19629
19634 eProsima_user_DllExport void common(
19635 const CommonBitfield& _common)
19636 {
19637 m_common = _common;
19638 }
19639
19644 eProsima_user_DllExport void common(
19645 CommonBitfield&& _common)
19646 {
19647 m_common = std::move(_common);
19648 }
19649
19654 eProsima_user_DllExport const CommonBitfield& common() const
19655 {
19656 return m_common;
19657 }
19658
19663 eProsima_user_DllExport CommonBitfield& common()
19664 {
19665 return m_common;
19666 }
19667
19668
19673 eProsima_user_DllExport void detail(
19674 const CompleteMemberDetail& _detail)
19675 {
19676 m_detail = _detail;
19677 }
19678
19683 eProsima_user_DllExport void detail(
19684 CompleteMemberDetail&& _detail)
19685 {
19686 m_detail = std::move(_detail);
19687 }
19688
19693 eProsima_user_DllExport const CompleteMemberDetail& detail() const
19694 {
19695 return m_detail;
19696 }
19697
19702 eProsima_user_DllExport CompleteMemberDetail& detail()
19703 {
19704 return m_detail;
19705 }
19706
19707
19708
19709private:
19710
19711 CommonBitfield m_common;
19712 CompleteMemberDetail m_detail;
19713
19714};
19715typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
19716
19722{
19723public:
19724
19728 eProsima_user_DllExport MinimalBitfield()
19729 {
19730 }
19731
19735 eProsima_user_DllExport ~MinimalBitfield()
19736 {
19737 }
19738
19743 eProsima_user_DllExport MinimalBitfield(
19744 const MinimalBitfield& x)
19745 {
19746 m_common = x.m_common;
19747
19748 m_name_hash = x.m_name_hash;
19749
19750 }
19751
19756 eProsima_user_DllExport MinimalBitfield(
19757 MinimalBitfield&& x) noexcept
19758 {
19759 m_common = std::move(x.m_common);
19760 m_name_hash = std::move(x.m_name_hash);
19761 }
19762
19767 eProsima_user_DllExport MinimalBitfield& operator =(
19768 const MinimalBitfield& x)
19769 {
19770
19771 m_common = x.m_common;
19772
19773 m_name_hash = x.m_name_hash;
19774
19775 return *this;
19776 }
19777
19782 eProsima_user_DllExport MinimalBitfield& operator =(
19783 MinimalBitfield&& x) noexcept
19784 {
19785
19786 m_common = std::move(x.m_common);
19787 m_name_hash = std::move(x.m_name_hash);
19788 return *this;
19789 }
19790
19795 eProsima_user_DllExport bool operator ==(
19796 const MinimalBitfield& x) const
19797 {
19798 return (m_common == x.m_common &&
19799 m_name_hash == x.m_name_hash);
19800 }
19801
19806 eProsima_user_DllExport bool operator !=(
19807 const MinimalBitfield& x) const
19808 {
19809 return !(*this == x);
19810 }
19811
19816 eProsima_user_DllExport void common(
19817 const CommonBitfield& _common)
19818 {
19819 m_common = _common;
19820 }
19821
19826 eProsima_user_DllExport void common(
19827 CommonBitfield&& _common)
19828 {
19829 m_common = std::move(_common);
19830 }
19831
19836 eProsima_user_DllExport const CommonBitfield& common() const
19837 {
19838 return m_common;
19839 }
19840
19845 eProsima_user_DllExport CommonBitfield& common()
19846 {
19847 return m_common;
19848 }
19849
19850
19855 eProsima_user_DllExport void name_hash(
19856 const NameHash& _name_hash)
19857 {
19858 m_name_hash = _name_hash;
19859 }
19860
19865 eProsima_user_DllExport void name_hash(
19866 NameHash&& _name_hash)
19867 {
19868 m_name_hash = std::move(_name_hash);
19869 }
19870
19875 eProsima_user_DllExport const NameHash& name_hash() const
19876 {
19877 return m_name_hash;
19878 }
19879
19884 eProsima_user_DllExport NameHash& name_hash()
19885 {
19886 return m_name_hash;
19887 }
19888
19889
19890
19891private:
19892
19893 CommonBitfield m_common;
19894 NameHash m_name_hash{0};
19895
19896};
19897typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
19898
19904{
19905public:
19906
19910 eProsima_user_DllExport CompleteBitsetHeader()
19911 {
19912 }
19913
19917 eProsima_user_DllExport ~CompleteBitsetHeader()
19918 {
19919 }
19920
19925 eProsima_user_DllExport CompleteBitsetHeader(
19926 const CompleteBitsetHeader& x)
19927 {
19928 m_detail = x.m_detail;
19929
19930 }
19931
19936 eProsima_user_DllExport CompleteBitsetHeader(
19937 CompleteBitsetHeader&& x) noexcept
19938 {
19939 m_detail = std::move(x.m_detail);
19940 }
19941
19946 eProsima_user_DllExport CompleteBitsetHeader& operator =(
19947 const CompleteBitsetHeader& x)
19948 {
19949
19950 m_detail = x.m_detail;
19951
19952 return *this;
19953 }
19954
19959 eProsima_user_DllExport CompleteBitsetHeader& operator =(
19960 CompleteBitsetHeader&& x) noexcept
19961 {
19962
19963 m_detail = std::move(x.m_detail);
19964 return *this;
19965 }
19966
19971 eProsima_user_DllExport bool operator ==(
19972 const CompleteBitsetHeader& x) const
19973 {
19974 return (m_detail == x.m_detail);
19975 }
19976
19981 eProsima_user_DllExport bool operator !=(
19982 const CompleteBitsetHeader& x) const
19983 {
19984 return !(*this == x);
19985 }
19986
19991 eProsima_user_DllExport void detail(
19992 const CompleteTypeDetail& _detail)
19993 {
19994 m_detail = _detail;
19995 }
19996
20001 eProsima_user_DllExport void detail(
20002 CompleteTypeDetail&& _detail)
20003 {
20004 m_detail = std::move(_detail);
20005 }
20006
20011 eProsima_user_DllExport const CompleteTypeDetail& detail() const
20012 {
20013 return m_detail;
20014 }
20015
20020 eProsima_user_DllExport CompleteTypeDetail& detail()
20021 {
20022 return m_detail;
20023 }
20024
20025
20026
20027private:
20028
20029 CompleteTypeDetail m_detail;
20030
20031};
20037{
20038public:
20039
20043 eProsima_user_DllExport MinimalBitsetHeader()
20044 {
20045 }
20046
20050 eProsima_user_DllExport ~MinimalBitsetHeader()
20051 {
20052 }
20053
20058 eProsima_user_DllExport MinimalBitsetHeader(
20059 const MinimalBitsetHeader& x)
20060 {
20061 static_cast<void>(x);
20062 }
20063
20068 eProsima_user_DllExport MinimalBitsetHeader(
20069 MinimalBitsetHeader&& x) noexcept
20070 {
20071 static_cast<void>(x);
20072 }
20073
20078 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20079 const MinimalBitsetHeader& x)
20080 {
20081
20082 static_cast<void>(x);
20083
20084 return *this;
20085 }
20086
20091 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20092 MinimalBitsetHeader&& x) noexcept
20093 {
20094
20095 static_cast<void>(x);
20096
20097 return *this;
20098 }
20099
20104 eProsima_user_DllExport bool operator ==(
20105 const MinimalBitsetHeader& x) const
20106 {
20107 static_cast<void>(x);
20108 return true;
20109 }
20110
20115 eProsima_user_DllExport bool operator !=(
20116 const MinimalBitsetHeader& x) const
20117 {
20118 return !(*this == x);
20119 }
20120
20121
20122
20123private:
20124
20125
20126};
20132{
20133public:
20134
20138 eProsima_user_DllExport CompleteBitsetType()
20139 {
20140 }
20141
20145 eProsima_user_DllExport ~CompleteBitsetType()
20146 {
20147 }
20148
20153 eProsima_user_DllExport CompleteBitsetType(
20154 const CompleteBitsetType& x)
20155 {
20156 m_bitset_flags = x.m_bitset_flags;
20157
20158 m_header = x.m_header;
20159
20160 m_field_seq = x.m_field_seq;
20161
20162 }
20163
20168 eProsima_user_DllExport CompleteBitsetType(
20169 CompleteBitsetType&& x) noexcept
20170 {
20171 m_bitset_flags = std::move(x.m_bitset_flags);
20172 m_header = std::move(x.m_header);
20173 m_field_seq = std::move(x.m_field_seq);
20174 }
20175
20180 eProsima_user_DllExport CompleteBitsetType& operator =(
20181 const CompleteBitsetType& x)
20182 {
20183
20184 m_bitset_flags = x.m_bitset_flags;
20185
20186 m_header = x.m_header;
20187
20188 m_field_seq = x.m_field_seq;
20189
20190 return *this;
20191 }
20192
20197 eProsima_user_DllExport CompleteBitsetType& operator =(
20198 CompleteBitsetType&& x) noexcept
20199 {
20200
20201 m_bitset_flags = std::move(x.m_bitset_flags);
20202 m_header = std::move(x.m_header);
20203 m_field_seq = std::move(x.m_field_seq);
20204 return *this;
20205 }
20206
20211 eProsima_user_DllExport bool operator ==(
20212 const CompleteBitsetType& x) const
20213 {
20214 return (m_bitset_flags == x.m_bitset_flags &&
20215 m_header == x.m_header &&
20216 m_field_seq == x.m_field_seq);
20217 }
20218
20223 eProsima_user_DllExport bool operator !=(
20224 const CompleteBitsetType& x) const
20225 {
20226 return !(*this == x);
20227 }
20228
20233 eProsima_user_DllExport void bitset_flags(
20234 const BitsetTypeFlag& _bitset_flags)
20235 {
20236 m_bitset_flags = _bitset_flags;
20237 }
20238
20243 eProsima_user_DllExport void bitset_flags(
20244 BitsetTypeFlag&& _bitset_flags)
20245 {
20246 m_bitset_flags = std::move(_bitset_flags);
20247 }
20248
20253 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20254 {
20255 return m_bitset_flags;
20256 }
20257
20262 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20263 {
20264 return m_bitset_flags;
20265 }
20266
20267
20272 eProsima_user_DllExport void header(
20273 const CompleteBitsetHeader& _header)
20274 {
20275 m_header = _header;
20276 }
20277
20282 eProsima_user_DllExport void header(
20283 CompleteBitsetHeader&& _header)
20284 {
20285 m_header = std::move(_header);
20286 }
20287
20292 eProsima_user_DllExport const CompleteBitsetHeader& header() const
20293 {
20294 return m_header;
20295 }
20296
20301 eProsima_user_DllExport CompleteBitsetHeader& header()
20302 {
20303 return m_header;
20304 }
20305
20306
20311 eProsima_user_DllExport void field_seq(
20312 const CompleteBitfieldSeq& _field_seq)
20313 {
20314 m_field_seq = _field_seq;
20315 }
20316
20321 eProsima_user_DllExport void field_seq(
20322 CompleteBitfieldSeq&& _field_seq)
20323 {
20324 m_field_seq = std::move(_field_seq);
20325 }
20326
20331 eProsima_user_DllExport const CompleteBitfieldSeq& field_seq() const
20332 {
20333 return m_field_seq;
20334 }
20335
20340 eProsima_user_DllExport CompleteBitfieldSeq& field_seq()
20341 {
20342 return m_field_seq;
20343 }
20344
20345
20346
20347private:
20348
20349 BitsetTypeFlag m_bitset_flags{0};
20350 CompleteBitsetHeader m_header;
20351 CompleteBitfieldSeq m_field_seq;
20352
20353};
20359{
20360public:
20361
20365 eProsima_user_DllExport MinimalBitsetType()
20366 {
20367 }
20368
20372 eProsima_user_DllExport ~MinimalBitsetType()
20373 {
20374 }
20375
20380 eProsima_user_DllExport MinimalBitsetType(
20381 const MinimalBitsetType& x)
20382 {
20383 m_bitset_flags = x.m_bitset_flags;
20384
20385 m_header = x.m_header;
20386
20387 m_field_seq = x.m_field_seq;
20388
20389 }
20390
20395 eProsima_user_DllExport MinimalBitsetType(
20396 MinimalBitsetType&& x) noexcept
20397 {
20398 m_bitset_flags = std::move(x.m_bitset_flags);
20399 m_header = std::move(x.m_header);
20400 m_field_seq = std::move(x.m_field_seq);
20401 }
20402
20407 eProsima_user_DllExport MinimalBitsetType& operator =(
20408 const MinimalBitsetType& x)
20409 {
20410
20411 m_bitset_flags = x.m_bitset_flags;
20412
20413 m_header = x.m_header;
20414
20415 m_field_seq = x.m_field_seq;
20416
20417 return *this;
20418 }
20419
20424 eProsima_user_DllExport MinimalBitsetType& operator =(
20425 MinimalBitsetType&& x) noexcept
20426 {
20427
20428 m_bitset_flags = std::move(x.m_bitset_flags);
20429 m_header = std::move(x.m_header);
20430 m_field_seq = std::move(x.m_field_seq);
20431 return *this;
20432 }
20433
20438 eProsima_user_DllExport bool operator ==(
20439 const MinimalBitsetType& x) const
20440 {
20441 return (m_bitset_flags == x.m_bitset_flags &&
20442 m_header == x.m_header &&
20443 m_field_seq == x.m_field_seq);
20444 }
20445
20450 eProsima_user_DllExport bool operator !=(
20451 const MinimalBitsetType& x) const
20452 {
20453 return !(*this == x);
20454 }
20455
20460 eProsima_user_DllExport void bitset_flags(
20461 const BitsetTypeFlag& _bitset_flags)
20462 {
20463 m_bitset_flags = _bitset_flags;
20464 }
20465
20470 eProsima_user_DllExport void bitset_flags(
20471 BitsetTypeFlag&& _bitset_flags)
20472 {
20473 m_bitset_flags = std::move(_bitset_flags);
20474 }
20475
20480 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20481 {
20482 return m_bitset_flags;
20483 }
20484
20489 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20490 {
20491 return m_bitset_flags;
20492 }
20493
20494
20499 eProsima_user_DllExport void header(
20500 const MinimalBitsetHeader& _header)
20501 {
20502 m_header = _header;
20503 }
20504
20509 eProsima_user_DllExport void header(
20510 MinimalBitsetHeader&& _header)
20511 {
20512 m_header = std::move(_header);
20513 }
20514
20519 eProsima_user_DllExport const MinimalBitsetHeader& header() const
20520 {
20521 return m_header;
20522 }
20523
20528 eProsima_user_DllExport MinimalBitsetHeader& header()
20529 {
20530 return m_header;
20531 }
20532
20533
20538 eProsima_user_DllExport void field_seq(
20539 const MinimalBitfieldSeq& _field_seq)
20540 {
20541 m_field_seq = _field_seq;
20542 }
20543
20548 eProsima_user_DllExport void field_seq(
20549 MinimalBitfieldSeq&& _field_seq)
20550 {
20551 m_field_seq = std::move(_field_seq);
20552 }
20553
20558 eProsima_user_DllExport const MinimalBitfieldSeq& field_seq() const
20559 {
20560 return m_field_seq;
20561 }
20562
20567 eProsima_user_DllExport MinimalBitfieldSeq& field_seq()
20568 {
20569 return m_field_seq;
20570 }
20571
20572
20573
20574private:
20575
20576 BitsetTypeFlag m_bitset_flags{0};
20577 MinimalBitsetHeader m_header;
20578 MinimalBitfieldSeq m_field_seq;
20579
20580};
20586{
20587public:
20588
20592 eProsima_user_DllExport CompleteExtendedType()
20593 {
20594 }
20595
20599 eProsima_user_DllExport ~CompleteExtendedType()
20600 {
20601 }
20602
20607 eProsima_user_DllExport CompleteExtendedType(
20608 const CompleteExtendedType& x)
20609 {
20610 static_cast<void>(x);
20611 }
20612
20617 eProsima_user_DllExport CompleteExtendedType(
20618 CompleteExtendedType&& x) noexcept
20619 {
20620 static_cast<void>(x);
20621 }
20622
20627 eProsima_user_DllExport CompleteExtendedType& operator =(
20628 const CompleteExtendedType& x)
20629 {
20630
20631 static_cast<void>(x);
20632
20633 return *this;
20634 }
20635
20640 eProsima_user_DllExport CompleteExtendedType& operator =(
20641 CompleteExtendedType&& x) noexcept
20642 {
20643
20644 static_cast<void>(x);
20645
20646 return *this;
20647 }
20648
20653 eProsima_user_DllExport bool operator ==(
20654 const CompleteExtendedType& x) const
20655 {
20656 static_cast<void>(x);
20657 return true;
20658 }
20659
20664 eProsima_user_DllExport bool operator !=(
20665 const CompleteExtendedType& x) const
20666 {
20667 return !(*this == x);
20668 }
20669
20670
20671
20672private:
20673
20674
20675};
20681{
20682public:
20683
20687 eProsima_user_DllExport CompleteTypeObject()
20688 {
20689 extended_type_();
20690 }
20691
20695 eProsima_user_DllExport ~CompleteTypeObject()
20696 {
20697 if (member_destructor_)
20698 {
20699 member_destructor_();
20700 }
20701 }
20702
20707 eProsima_user_DllExport CompleteTypeObject(
20708 const CompleteTypeObject& x)
20709 {
20710 m__d = x.m__d;
20711
20712 switch (x.selected_member_)
20713 {
20714 case 0x00000001:
20715 alias_type_() = x.m_alias_type;
20716 break;
20717
20718 case 0x00000002:
20719 annotation_type_() = x.m_annotation_type;
20720 break;
20721
20722 case 0x00000003:
20723 struct_type_() = x.m_struct_type;
20724 break;
20725
20726 case 0x00000004:
20727 union_type_() = x.m_union_type;
20728 break;
20729
20730 case 0x00000005:
20731 bitset_type_() = x.m_bitset_type;
20732 break;
20733
20734 case 0x00000006:
20735 sequence_type_() = x.m_sequence_type;
20736 break;
20737
20738 case 0x00000007:
20739 array_type_() = x.m_array_type;
20740 break;
20741
20742 case 0x00000008:
20743 map_type_() = x.m_map_type;
20744 break;
20745
20746 case 0x00000009:
20747 enumerated_type_() = x.m_enumerated_type;
20748 break;
20749
20750 case 0x0000000a:
20751 bitmask_type_() = x.m_bitmask_type;
20752 break;
20753
20754 case 0x0000000b:
20755 extended_type_() = x.m_extended_type;
20756 break;
20757
20758 }
20759 }
20760
20765 eProsima_user_DllExport CompleteTypeObject(
20766 CompleteTypeObject&& x) noexcept
20767 {
20768 m__d = x.m__d;
20769
20770 switch (x.selected_member_)
20771 {
20772 case 0x00000001:
20773 alias_type_() = std::move(x.m_alias_type);
20774 break;
20775
20776 case 0x00000002:
20777 annotation_type_() = std::move(x.m_annotation_type);
20778 break;
20779
20780 case 0x00000003:
20781 struct_type_() = std::move(x.m_struct_type);
20782 break;
20783
20784 case 0x00000004:
20785 union_type_() = std::move(x.m_union_type);
20786 break;
20787
20788 case 0x00000005:
20789 bitset_type_() = std::move(x.m_bitset_type);
20790 break;
20791
20792 case 0x00000006:
20793 sequence_type_() = std::move(x.m_sequence_type);
20794 break;
20795
20796 case 0x00000007:
20797 array_type_() = std::move(x.m_array_type);
20798 break;
20799
20800 case 0x00000008:
20801 map_type_() = std::move(x.m_map_type);
20802 break;
20803
20804 case 0x00000009:
20805 enumerated_type_() = std::move(x.m_enumerated_type);
20806 break;
20807
20808 case 0x0000000a:
20809 bitmask_type_() = std::move(x.m_bitmask_type);
20810 break;
20811
20812 case 0x0000000b:
20813 extended_type_() = std::move(x.m_extended_type);
20814 break;
20815
20816 }
20817 }
20818
20823 eProsima_user_DllExport CompleteTypeObject& operator =(
20824 const CompleteTypeObject& x)
20825 {
20826 m__d = x.m__d;
20827
20828 switch (x.selected_member_)
20829 {
20830 case 0x00000001:
20831 alias_type_() = x.m_alias_type;
20832 break;
20833
20834 case 0x00000002:
20835 annotation_type_() = x.m_annotation_type;
20836 break;
20837
20838 case 0x00000003:
20839 struct_type_() = x.m_struct_type;
20840 break;
20841
20842 case 0x00000004:
20843 union_type_() = x.m_union_type;
20844 break;
20845
20846 case 0x00000005:
20847 bitset_type_() = x.m_bitset_type;
20848 break;
20849
20850 case 0x00000006:
20851 sequence_type_() = x.m_sequence_type;
20852 break;
20853
20854 case 0x00000007:
20855 array_type_() = x.m_array_type;
20856 break;
20857
20858 case 0x00000008:
20859 map_type_() = x.m_map_type;
20860 break;
20861
20862 case 0x00000009:
20863 enumerated_type_() = x.m_enumerated_type;
20864 break;
20865
20866 case 0x0000000a:
20867 bitmask_type_() = x.m_bitmask_type;
20868 break;
20869
20870 case 0x0000000b:
20871 extended_type_() = x.m_extended_type;
20872 break;
20873
20874 }
20875
20876 return *this;
20877 }
20878
20883 eProsima_user_DllExport CompleteTypeObject& operator =(
20884 CompleteTypeObject&& x) noexcept
20885 {
20886 m__d = x.m__d;
20887
20888 switch (x.selected_member_)
20889 {
20890 case 0x00000001:
20891 alias_type_() = std::move(x.m_alias_type);
20892 break;
20893
20894 case 0x00000002:
20895 annotation_type_() = std::move(x.m_annotation_type);
20896 break;
20897
20898 case 0x00000003:
20899 struct_type_() = std::move(x.m_struct_type);
20900 break;
20901
20902 case 0x00000004:
20903 union_type_() = std::move(x.m_union_type);
20904 break;
20905
20906 case 0x00000005:
20907 bitset_type_() = std::move(x.m_bitset_type);
20908 break;
20909
20910 case 0x00000006:
20911 sequence_type_() = std::move(x.m_sequence_type);
20912 break;
20913
20914 case 0x00000007:
20915 array_type_() = std::move(x.m_array_type);
20916 break;
20917
20918 case 0x00000008:
20919 map_type_() = std::move(x.m_map_type);
20920 break;
20921
20922 case 0x00000009:
20923 enumerated_type_() = std::move(x.m_enumerated_type);
20924 break;
20925
20926 case 0x0000000a:
20927 bitmask_type_() = std::move(x.m_bitmask_type);
20928 break;
20929
20930 case 0x0000000b:
20931 extended_type_() = std::move(x.m_extended_type);
20932 break;
20933
20934 }
20935
20936 return *this;
20937 }
20938
20943 eProsima_user_DllExport bool operator ==(
20944 const CompleteTypeObject& x) const
20945 {
20946 bool ret_value {false};
20947
20948 if (m__d == x.m__d &&
20949 selected_member_ == x.selected_member_)
20950 {
20951 switch (selected_member_)
20952 {
20953 case 0x00000001:
20954 ret_value = (m_alias_type == x.m_alias_type);
20955 break;
20956
20957 case 0x00000002:
20958 ret_value = (m_annotation_type == x.m_annotation_type);
20959 break;
20960
20961 case 0x00000003:
20962 ret_value = (m_struct_type == x.m_struct_type);
20963 break;
20964
20965 case 0x00000004:
20966 ret_value = (m_union_type == x.m_union_type);
20967 break;
20968
20969 case 0x00000005:
20970 ret_value = (m_bitset_type == x.m_bitset_type);
20971 break;
20972
20973 case 0x00000006:
20974 ret_value = (m_sequence_type == x.m_sequence_type);
20975 break;
20976
20977 case 0x00000007:
20978 ret_value = (m_array_type == x.m_array_type);
20979 break;
20980
20981 case 0x00000008:
20982 ret_value = (m_map_type == x.m_map_type);
20983 break;
20984
20985 case 0x00000009:
20986 ret_value = (m_enumerated_type == x.m_enumerated_type);
20987 break;
20988
20989 case 0x0000000a:
20990 ret_value = (m_bitmask_type == x.m_bitmask_type);
20991 break;
20992
20993 case 0x0000000b:
20994 ret_value = (m_extended_type == x.m_extended_type);
20995 break;
20996
20997 }
20998 }
20999
21000 return ret_value;
21001 }
21002
21007 eProsima_user_DllExport bool operator !=(
21008 const CompleteTypeObject& x) const
21009 {
21010 return !(*this == x);
21011 }
21012
21018 eProsima_user_DllExport void _d(
21019 uint8_t __d)
21020 {
21021 bool valid_discriminator = false;
21022
21023 switch (__d)
21024 {
21025 case TK_ALIAS:
21026 if (0x00000001 == selected_member_)
21027 {
21028 valid_discriminator = true;
21029 }
21030 break;
21031
21032 case TK_ANNOTATION:
21033 if (0x00000002 == selected_member_)
21034 {
21035 valid_discriminator = true;
21036 }
21037 break;
21038
21039 case TK_STRUCTURE:
21040 if (0x00000003 == selected_member_)
21041 {
21042 valid_discriminator = true;
21043 }
21044 break;
21045
21046 case TK_UNION:
21047 if (0x00000004 == selected_member_)
21048 {
21049 valid_discriminator = true;
21050 }
21051 break;
21052
21053 case TK_BITSET:
21054 if (0x00000005 == selected_member_)
21055 {
21056 valid_discriminator = true;
21057 }
21058 break;
21059
21060 case TK_SEQUENCE:
21061 if (0x00000006 == selected_member_)
21062 {
21063 valid_discriminator = true;
21064 }
21065 break;
21066
21067 case TK_ARRAY:
21068 if (0x00000007 == selected_member_)
21069 {
21070 valid_discriminator = true;
21071 }
21072 break;
21073
21074 case TK_MAP:
21075 if (0x00000008 == selected_member_)
21076 {
21077 valid_discriminator = true;
21078 }
21079 break;
21080
21081 case TK_ENUM:
21082 if (0x00000009 == selected_member_)
21083 {
21084 valid_discriminator = true;
21085 }
21086 break;
21087
21088 case TK_BITMASK:
21089 if (0x0000000a == selected_member_)
21090 {
21091 valid_discriminator = true;
21092 }
21093 break;
21094
21095 default:
21096 if (0x0000000b == selected_member_)
21097 {
21098 valid_discriminator = true;
21099 }
21100 break;
21101
21102 }
21103
21104 if (!valid_discriminator)
21105 {
21106 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
21107 }
21108
21109 m__d = __d;
21110 }
21111
21116 eProsima_user_DllExport uint8_t _d() const
21117 {
21118 return m__d;
21119 }
21120
21125 eProsima_user_DllExport void alias_type(
21126 const CompleteAliasType& _alias_type)
21127 {
21128 alias_type_() = _alias_type;
21129 m__d = TK_ALIAS;
21130 }
21131
21136 eProsima_user_DllExport void alias_type(
21137 CompleteAliasType&& _alias_type)
21138 {
21139 alias_type_() = _alias_type;
21140 m__d = TK_ALIAS;
21141 }
21142
21148 eProsima_user_DllExport const CompleteAliasType& alias_type() const
21149 {
21150 if (0x00000001 != selected_member_)
21151 {
21152 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21153 }
21154
21155 return m_alias_type;
21156 }
21157
21163 eProsima_user_DllExport CompleteAliasType& alias_type()
21164 {
21165 if (0x00000001 != selected_member_)
21166 {
21167 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21168 }
21169
21170 return m_alias_type;
21171 }
21172
21173
21178 eProsima_user_DllExport void annotation_type(
21179 const CompleteAnnotationType& _annotation_type)
21180 {
21181 annotation_type_() = _annotation_type;
21182 m__d = TK_ANNOTATION;
21183 }
21184
21189 eProsima_user_DllExport void annotation_type(
21190 CompleteAnnotationType&& _annotation_type)
21191 {
21192 annotation_type_() = _annotation_type;
21193 m__d = TK_ANNOTATION;
21194 }
21195
21201 eProsima_user_DllExport const CompleteAnnotationType& annotation_type() const
21202 {
21203 if (0x00000002 != selected_member_)
21204 {
21205 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21206 }
21207
21208 return m_annotation_type;
21209 }
21210
21216 eProsima_user_DllExport CompleteAnnotationType& annotation_type()
21217 {
21218 if (0x00000002 != selected_member_)
21219 {
21220 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21221 }
21222
21223 return m_annotation_type;
21224 }
21225
21226
21231 eProsima_user_DllExport void struct_type(
21232 const CompleteStructType& _struct_type)
21233 {
21234 struct_type_() = _struct_type;
21235 m__d = TK_STRUCTURE;
21236 }
21237
21242 eProsima_user_DllExport void struct_type(
21243 CompleteStructType&& _struct_type)
21244 {
21245 struct_type_() = _struct_type;
21246 m__d = TK_STRUCTURE;
21247 }
21248
21254 eProsima_user_DllExport const CompleteStructType& struct_type() const
21255 {
21256 if (0x00000003 != selected_member_)
21257 {
21258 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21259 }
21260
21261 return m_struct_type;
21262 }
21263
21269 eProsima_user_DllExport CompleteStructType& struct_type()
21270 {
21271 if (0x00000003 != selected_member_)
21272 {
21273 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21274 }
21275
21276 return m_struct_type;
21277 }
21278
21279
21284 eProsima_user_DllExport void union_type(
21285 const CompleteUnionType& _union_type)
21286 {
21287 union_type_() = _union_type;
21288 m__d = TK_UNION;
21289 }
21290
21295 eProsima_user_DllExport void union_type(
21296 CompleteUnionType&& _union_type)
21297 {
21298 union_type_() = _union_type;
21299 m__d = TK_UNION;
21300 }
21301
21307 eProsima_user_DllExport const CompleteUnionType& union_type() const
21308 {
21309 if (0x00000004 != selected_member_)
21310 {
21311 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21312 }
21313
21314 return m_union_type;
21315 }
21316
21322 eProsima_user_DllExport CompleteUnionType& union_type()
21323 {
21324 if (0x00000004 != selected_member_)
21325 {
21326 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21327 }
21328
21329 return m_union_type;
21330 }
21331
21332
21337 eProsima_user_DllExport void bitset_type(
21338 const CompleteBitsetType& _bitset_type)
21339 {
21340 bitset_type_() = _bitset_type;
21341 m__d = TK_BITSET;
21342 }
21343
21348 eProsima_user_DllExport void bitset_type(
21349 CompleteBitsetType&& _bitset_type)
21350 {
21351 bitset_type_() = _bitset_type;
21352 m__d = TK_BITSET;
21353 }
21354
21360 eProsima_user_DllExport const CompleteBitsetType& bitset_type() const
21361 {
21362 if (0x00000005 != selected_member_)
21363 {
21364 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21365 }
21366
21367 return m_bitset_type;
21368 }
21369
21375 eProsima_user_DllExport CompleteBitsetType& bitset_type()
21376 {
21377 if (0x00000005 != selected_member_)
21378 {
21379 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21380 }
21381
21382 return m_bitset_type;
21383 }
21384
21385
21390 eProsima_user_DllExport void sequence_type(
21391 const CompleteSequenceType& _sequence_type)
21392 {
21393 sequence_type_() = _sequence_type;
21394 m__d = TK_SEQUENCE;
21395 }
21396
21401 eProsima_user_DllExport void sequence_type(
21402 CompleteSequenceType&& _sequence_type)
21403 {
21404 sequence_type_() = _sequence_type;
21405 m__d = TK_SEQUENCE;
21406 }
21407
21413 eProsima_user_DllExport const CompleteSequenceType& sequence_type() const
21414 {
21415 if (0x00000006 != selected_member_)
21416 {
21417 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21418 }
21419
21420 return m_sequence_type;
21421 }
21422
21428 eProsima_user_DllExport CompleteSequenceType& sequence_type()
21429 {
21430 if (0x00000006 != selected_member_)
21431 {
21432 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21433 }
21434
21435 return m_sequence_type;
21436 }
21437
21438
21443 eProsima_user_DllExport void array_type(
21444 const CompleteArrayType& _array_type)
21445 {
21446 array_type_() = _array_type;
21447 m__d = TK_ARRAY;
21448 }
21449
21454 eProsima_user_DllExport void array_type(
21455 CompleteArrayType&& _array_type)
21456 {
21457 array_type_() = _array_type;
21458 m__d = TK_ARRAY;
21459 }
21460
21466 eProsima_user_DllExport const CompleteArrayType& array_type() const
21467 {
21468 if (0x00000007 != selected_member_)
21469 {
21470 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21471 }
21472
21473 return m_array_type;
21474 }
21475
21481 eProsima_user_DllExport CompleteArrayType& array_type()
21482 {
21483 if (0x00000007 != selected_member_)
21484 {
21485 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21486 }
21487
21488 return m_array_type;
21489 }
21490
21491
21496 eProsima_user_DllExport void map_type(
21497 const CompleteMapType& _map_type)
21498 {
21499 map_type_() = _map_type;
21500 m__d = TK_MAP;
21501 }
21502
21507 eProsima_user_DllExport void map_type(
21508 CompleteMapType&& _map_type)
21509 {
21510 map_type_() = _map_type;
21511 m__d = TK_MAP;
21512 }
21513
21519 eProsima_user_DllExport const CompleteMapType& map_type() const
21520 {
21521 if (0x00000008 != selected_member_)
21522 {
21523 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21524 }
21525
21526 return m_map_type;
21527 }
21528
21534 eProsima_user_DllExport CompleteMapType& map_type()
21535 {
21536 if (0x00000008 != selected_member_)
21537 {
21538 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21539 }
21540
21541 return m_map_type;
21542 }
21543
21544
21549 eProsima_user_DllExport void enumerated_type(
21550 const CompleteEnumeratedType& _enumerated_type)
21551 {
21552 enumerated_type_() = _enumerated_type;
21553 m__d = TK_ENUM;
21554 }
21555
21560 eProsima_user_DllExport void enumerated_type(
21561 CompleteEnumeratedType&& _enumerated_type)
21562 {
21563 enumerated_type_() = _enumerated_type;
21564 m__d = TK_ENUM;
21565 }
21566
21572 eProsima_user_DllExport const CompleteEnumeratedType& enumerated_type() const
21573 {
21574 if (0x00000009 != selected_member_)
21575 {
21576 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21577 }
21578
21579 return m_enumerated_type;
21580 }
21581
21587 eProsima_user_DllExport CompleteEnumeratedType& enumerated_type()
21588 {
21589 if (0x00000009 != selected_member_)
21590 {
21591 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21592 }
21593
21594 return m_enumerated_type;
21595 }
21596
21597
21602 eProsima_user_DllExport void bitmask_type(
21603 const CompleteBitmaskType& _bitmask_type)
21604 {
21605 bitmask_type_() = _bitmask_type;
21606 m__d = TK_BITMASK;
21607 }
21608
21613 eProsima_user_DllExport void bitmask_type(
21614 CompleteBitmaskType&& _bitmask_type)
21615 {
21616 bitmask_type_() = _bitmask_type;
21617 m__d = TK_BITMASK;
21618 }
21619
21625 eProsima_user_DllExport const CompleteBitmaskType& bitmask_type() const
21626 {
21627 if (0x0000000a != selected_member_)
21628 {
21629 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21630 }
21631
21632 return m_bitmask_type;
21633 }
21634
21640 eProsima_user_DllExport CompleteBitmaskType& bitmask_type()
21641 {
21642 if (0x0000000a != selected_member_)
21643 {
21644 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21645 }
21646
21647 return m_bitmask_type;
21648 }
21649
21650
21655 eProsima_user_DllExport void extended_type(
21656 const CompleteExtendedType& _extended_type)
21657 {
21658 extended_type_() = _extended_type;
21659 m__d = 127;
21660 }
21661
21666 eProsima_user_DllExport void extended_type(
21667 CompleteExtendedType&& _extended_type)
21668 {
21669 extended_type_() = _extended_type;
21670 m__d = 127;
21671 }
21672
21678 eProsima_user_DllExport const CompleteExtendedType& extended_type() const
21679 {
21680 if (0x0000000b != selected_member_)
21681 {
21682 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21683 }
21684
21685 return m_extended_type;
21686 }
21687
21693 eProsima_user_DllExport CompleteExtendedType& extended_type()
21694 {
21695 if (0x0000000b != selected_member_)
21696 {
21697 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21698 }
21699
21700 return m_extended_type;
21701 }
21702
21703
21704
21705private:
21706
21707 CompleteAliasType& alias_type_()
21708 {
21709 if (0x00000001 != selected_member_)
21710 {
21711 if (member_destructor_)
21712 {
21713 member_destructor_();
21714 }
21715
21716 selected_member_ = 0x00000001;
21717 member_destructor_ = [&]() {m_alias_type.~CompleteAliasType();};
21718 new(&m_alias_type) CompleteAliasType();
21719 ;
21720 }
21721
21722 return m_alias_type;
21723 }
21724
21725 CompleteAnnotationType& annotation_type_()
21726 {
21727 if (0x00000002 != selected_member_)
21728 {
21729 if (member_destructor_)
21730 {
21731 member_destructor_();
21732 }
21733
21734 selected_member_ = 0x00000002;
21735 member_destructor_ = [&]() {m_annotation_type.~CompleteAnnotationType();};
21736 new(&m_annotation_type) CompleteAnnotationType();
21737 ;
21738 }
21739
21740 return m_annotation_type;
21741 }
21742
21743 CompleteStructType& struct_type_()
21744 {
21745 if (0x00000003 != selected_member_)
21746 {
21747 if (member_destructor_)
21748 {
21749 member_destructor_();
21750 }
21751
21752 selected_member_ = 0x00000003;
21753 member_destructor_ = [&]() {m_struct_type.~CompleteStructType();};
21754 new(&m_struct_type) CompleteStructType();
21755 ;
21756 }
21757
21758 return m_struct_type;
21759 }
21760
21761 CompleteUnionType& union_type_()
21762 {
21763 if (0x00000004 != selected_member_)
21764 {
21765 if (member_destructor_)
21766 {
21767 member_destructor_();
21768 }
21769
21770 selected_member_ = 0x00000004;
21771 member_destructor_ = [&]() {m_union_type.~CompleteUnionType();};
21772 new(&m_union_type) CompleteUnionType();
21773 ;
21774 }
21775
21776 return m_union_type;
21777 }
21778
21779 CompleteBitsetType& bitset_type_()
21780 {
21781 if (0x00000005 != selected_member_)
21782 {
21783 if (member_destructor_)
21784 {
21785 member_destructor_();
21786 }
21787
21788 selected_member_ = 0x00000005;
21789 member_destructor_ = [&]() {m_bitset_type.~CompleteBitsetType();};
21790 new(&m_bitset_type) CompleteBitsetType();
21791 ;
21792 }
21793
21794 return m_bitset_type;
21795 }
21796
21797 CompleteSequenceType& sequence_type_()
21798 {
21799 if (0x00000006 != selected_member_)
21800 {
21801 if (member_destructor_)
21802 {
21803 member_destructor_();
21804 }
21805
21806 selected_member_ = 0x00000006;
21807 member_destructor_ = [&]() {m_sequence_type.~CompleteSequenceType();};
21808 new(&m_sequence_type) CompleteSequenceType();
21809 ;
21810 }
21811
21812 return m_sequence_type;
21813 }
21814
21815 CompleteArrayType& array_type_()
21816 {
21817 if (0x00000007 != selected_member_)
21818 {
21819 if (member_destructor_)
21820 {
21821 member_destructor_();
21822 }
21823
21824 selected_member_ = 0x00000007;
21825 member_destructor_ = [&]() {m_array_type.~CompleteArrayType();};
21826 new(&m_array_type) CompleteArrayType();
21827 ;
21828 }
21829
21830 return m_array_type;
21831 }
21832
21833 CompleteMapType& map_type_()
21834 {
21835 if (0x00000008 != selected_member_)
21836 {
21837 if (member_destructor_)
21838 {
21839 member_destructor_();
21840 }
21841
21842 selected_member_ = 0x00000008;
21843 member_destructor_ = [&]() {m_map_type.~CompleteMapType();};
21844 new(&m_map_type) CompleteMapType();
21845 ;
21846 }
21847
21848 return m_map_type;
21849 }
21850
21851 CompleteEnumeratedType& enumerated_type_()
21852 {
21853 if (0x00000009 != selected_member_)
21854 {
21855 if (member_destructor_)
21856 {
21857 member_destructor_();
21858 }
21859
21860 selected_member_ = 0x00000009;
21861 member_destructor_ = [&]() {m_enumerated_type.~CompleteEnumeratedType();};
21862 new(&m_enumerated_type) CompleteEnumeratedType();
21863 ;
21864 }
21865
21866 return m_enumerated_type;
21867 }
21868
21869 CompleteBitmaskType& bitmask_type_()
21870 {
21871 if (0x0000000a != selected_member_)
21872 {
21873 if (member_destructor_)
21874 {
21875 member_destructor_();
21876 }
21877
21878 selected_member_ = 0x0000000a;
21879 member_destructor_ = [&]() {m_bitmask_type.~CompleteBitmaskType();};
21880 new(&m_bitmask_type) CompleteBitmaskType();
21881 ;
21882 }
21883
21884 return m_bitmask_type;
21885 }
21886
21887 CompleteExtendedType& extended_type_()
21888 {
21889 if (0x0000000b != selected_member_)
21890 {
21891 if (member_destructor_)
21892 {
21893 member_destructor_();
21894 }
21895
21896 selected_member_ = 0x0000000b;
21897 member_destructor_ = [&]() {m_extended_type.~CompleteExtendedType();};
21898 new(&m_extended_type) CompleteExtendedType();
21899 ;
21900 }
21901
21902 return m_extended_type;
21903 }
21904
21905
21906 uint8_t m__d {TK_NONE};
21907
21908 union
21909 {
21921 };
21922
21923 uint32_t selected_member_ {0x0FFFFFFFu};
21924
21925 std::function<void()> member_destructor_;
21926};
21932{
21933public:
21934
21938 eProsima_user_DllExport MinimalExtendedType()
21939 {
21940 }
21941
21945 eProsima_user_DllExport ~MinimalExtendedType()
21946 {
21947 }
21948
21953 eProsima_user_DllExport MinimalExtendedType(
21954 const MinimalExtendedType& x)
21955 {
21956 static_cast<void>(x);
21957 }
21958
21963 eProsima_user_DllExport MinimalExtendedType(
21964 MinimalExtendedType&& x) noexcept
21965 {
21966 static_cast<void>(x);
21967 }
21968
21973 eProsima_user_DllExport MinimalExtendedType& operator =(
21974 const MinimalExtendedType& x)
21975 {
21976
21977 static_cast<void>(x);
21978
21979 return *this;
21980 }
21981
21986 eProsima_user_DllExport MinimalExtendedType& operator =(
21987 MinimalExtendedType&& x) noexcept
21988 {
21989
21990 static_cast<void>(x);
21991
21992 return *this;
21993 }
21994
21999 eProsima_user_DllExport bool operator ==(
22000 const MinimalExtendedType& x) const
22001 {
22002 static_cast<void>(x);
22003 return true;
22004 }
22005
22010 eProsima_user_DllExport bool operator !=(
22011 const MinimalExtendedType& x) const
22012 {
22013 return !(*this == x);
22014 }
22015
22016
22017
22018private:
22019
22020
22021};
22027{
22028public:
22029
22033 eProsima_user_DllExport MinimalTypeObject()
22034 {
22035 extended_type_();
22036 }
22037
22041 eProsima_user_DllExport ~MinimalTypeObject()
22042 {
22043 if (member_destructor_)
22044 {
22045 member_destructor_();
22046 }
22047 }
22048
22053 eProsima_user_DllExport MinimalTypeObject(
22054 const MinimalTypeObject& x)
22055 {
22056 m__d = x.m__d;
22057
22058 switch (x.selected_member_)
22059 {
22060 case 0x00000001:
22061 alias_type_() = x.m_alias_type;
22062 break;
22063
22064 case 0x00000002:
22065 annotation_type_() = x.m_annotation_type;
22066 break;
22067
22068 case 0x00000003:
22069 struct_type_() = x.m_struct_type;
22070 break;
22071
22072 case 0x00000004:
22073 union_type_() = x.m_union_type;
22074 break;
22075
22076 case 0x00000005:
22077 bitset_type_() = x.m_bitset_type;
22078 break;
22079
22080 case 0x00000006:
22081 sequence_type_() = x.m_sequence_type;
22082 break;
22083
22084 case 0x00000007:
22085 array_type_() = x.m_array_type;
22086 break;
22087
22088 case 0x00000008:
22089 map_type_() = x.m_map_type;
22090 break;
22091
22092 case 0x00000009:
22093 enumerated_type_() = x.m_enumerated_type;
22094 break;
22095
22096 case 0x0000000a:
22097 bitmask_type_() = x.m_bitmask_type;
22098 break;
22099
22100 case 0x0000000b:
22101 extended_type_() = x.m_extended_type;
22102 break;
22103
22104 }
22105 }
22106
22111 eProsima_user_DllExport MinimalTypeObject(
22112 MinimalTypeObject&& x) noexcept
22113 {
22114 m__d = x.m__d;
22115
22116 switch (x.selected_member_)
22117 {
22118 case 0x00000001:
22119 alias_type_() = std::move(x.m_alias_type);
22120 break;
22121
22122 case 0x00000002:
22123 annotation_type_() = std::move(x.m_annotation_type);
22124 break;
22125
22126 case 0x00000003:
22127 struct_type_() = std::move(x.m_struct_type);
22128 break;
22129
22130 case 0x00000004:
22131 union_type_() = std::move(x.m_union_type);
22132 break;
22133
22134 case 0x00000005:
22135 bitset_type_() = std::move(x.m_bitset_type);
22136 break;
22137
22138 case 0x00000006:
22139 sequence_type_() = std::move(x.m_sequence_type);
22140 break;
22141
22142 case 0x00000007:
22143 array_type_() = std::move(x.m_array_type);
22144 break;
22145
22146 case 0x00000008:
22147 map_type_() = std::move(x.m_map_type);
22148 break;
22149
22150 case 0x00000009:
22151 enumerated_type_() = std::move(x.m_enumerated_type);
22152 break;
22153
22154 case 0x0000000a:
22155 bitmask_type_() = std::move(x.m_bitmask_type);
22156 break;
22157
22158 case 0x0000000b:
22159 extended_type_() = std::move(x.m_extended_type);
22160 break;
22161
22162 }
22163 }
22164
22169 eProsima_user_DllExport MinimalTypeObject& operator =(
22170 const MinimalTypeObject& x)
22171 {
22172 m__d = x.m__d;
22173
22174 switch (x.selected_member_)
22175 {
22176 case 0x00000001:
22177 alias_type_() = x.m_alias_type;
22178 break;
22179
22180 case 0x00000002:
22181 annotation_type_() = x.m_annotation_type;
22182 break;
22183
22184 case 0x00000003:
22185 struct_type_() = x.m_struct_type;
22186 break;
22187
22188 case 0x00000004:
22189 union_type_() = x.m_union_type;
22190 break;
22191
22192 case 0x00000005:
22193 bitset_type_() = x.m_bitset_type;
22194 break;
22195
22196 case 0x00000006:
22197 sequence_type_() = x.m_sequence_type;
22198 break;
22199
22200 case 0x00000007:
22201 array_type_() = x.m_array_type;
22202 break;
22203
22204 case 0x00000008:
22205 map_type_() = x.m_map_type;
22206 break;
22207
22208 case 0x00000009:
22209 enumerated_type_() = x.m_enumerated_type;
22210 break;
22211
22212 case 0x0000000a:
22213 bitmask_type_() = x.m_bitmask_type;
22214 break;
22215
22216 case 0x0000000b:
22217 extended_type_() = x.m_extended_type;
22218 break;
22219
22220 }
22221
22222 return *this;
22223 }
22224
22229 eProsima_user_DllExport MinimalTypeObject& operator =(
22230 MinimalTypeObject&& x) noexcept
22231 {
22232 m__d = x.m__d;
22233
22234 switch (x.selected_member_)
22235 {
22236 case 0x00000001:
22237 alias_type_() = std::move(x.m_alias_type);
22238 break;
22239
22240 case 0x00000002:
22241 annotation_type_() = std::move(x.m_annotation_type);
22242 break;
22243
22244 case 0x00000003:
22245 struct_type_() = std::move(x.m_struct_type);
22246 break;
22247
22248 case 0x00000004:
22249 union_type_() = std::move(x.m_union_type);
22250 break;
22251
22252 case 0x00000005:
22253 bitset_type_() = std::move(x.m_bitset_type);
22254 break;
22255
22256 case 0x00000006:
22257 sequence_type_() = std::move(x.m_sequence_type);
22258 break;
22259
22260 case 0x00000007:
22261 array_type_() = std::move(x.m_array_type);
22262 break;
22263
22264 case 0x00000008:
22265 map_type_() = std::move(x.m_map_type);
22266 break;
22267
22268 case 0x00000009:
22269 enumerated_type_() = std::move(x.m_enumerated_type);
22270 break;
22271
22272 case 0x0000000a:
22273 bitmask_type_() = std::move(x.m_bitmask_type);
22274 break;
22275
22276 case 0x0000000b:
22277 extended_type_() = std::move(x.m_extended_type);
22278 break;
22279
22280 }
22281
22282 return *this;
22283 }
22284
22289 eProsima_user_DllExport bool operator ==(
22290 const MinimalTypeObject& x) const
22291 {
22292 bool ret_value {false};
22293
22294 if (m__d == x.m__d &&
22295 selected_member_ == x.selected_member_)
22296 {
22297 switch (selected_member_)
22298 {
22299 case 0x00000001:
22300 ret_value = (m_alias_type == x.m_alias_type);
22301 break;
22302
22303 case 0x00000002:
22304 ret_value = (m_annotation_type == x.m_annotation_type);
22305 break;
22306
22307 case 0x00000003:
22308 ret_value = (m_struct_type == x.m_struct_type);
22309 break;
22310
22311 case 0x00000004:
22312 ret_value = (m_union_type == x.m_union_type);
22313 break;
22314
22315 case 0x00000005:
22316 ret_value = (m_bitset_type == x.m_bitset_type);
22317 break;
22318
22319 case 0x00000006:
22320 ret_value = (m_sequence_type == x.m_sequence_type);
22321 break;
22322
22323 case 0x00000007:
22324 ret_value = (m_array_type == x.m_array_type);
22325 break;
22326
22327 case 0x00000008:
22328 ret_value = (m_map_type == x.m_map_type);
22329 break;
22330
22331 case 0x00000009:
22332 ret_value = (m_enumerated_type == x.m_enumerated_type);
22333 break;
22334
22335 case 0x0000000a:
22336 ret_value = (m_bitmask_type == x.m_bitmask_type);
22337 break;
22338
22339 case 0x0000000b:
22340 ret_value = (m_extended_type == x.m_extended_type);
22341 break;
22342
22343 }
22344 }
22345
22346 return ret_value;
22347 }
22348
22353 eProsima_user_DllExport bool operator !=(
22354 const MinimalTypeObject& x) const
22355 {
22356 return !(*this == x);
22357 }
22358
22364 eProsima_user_DllExport void _d(
22365 uint8_t __d)
22366 {
22367 bool valid_discriminator = false;
22368
22369 switch (__d)
22370 {
22371 case TK_ALIAS:
22372 if (0x00000001 == selected_member_)
22373 {
22374 valid_discriminator = true;
22375 }
22376 break;
22377
22378 case TK_ANNOTATION:
22379 if (0x00000002 == selected_member_)
22380 {
22381 valid_discriminator = true;
22382 }
22383 break;
22384
22385 case TK_STRUCTURE:
22386 if (0x00000003 == selected_member_)
22387 {
22388 valid_discriminator = true;
22389 }
22390 break;
22391
22392 case TK_UNION:
22393 if (0x00000004 == selected_member_)
22394 {
22395 valid_discriminator = true;
22396 }
22397 break;
22398
22399 case TK_BITSET:
22400 if (0x00000005 == selected_member_)
22401 {
22402 valid_discriminator = true;
22403 }
22404 break;
22405
22406 case TK_SEQUENCE:
22407 if (0x00000006 == selected_member_)
22408 {
22409 valid_discriminator = true;
22410 }
22411 break;
22412
22413 case TK_ARRAY:
22414 if (0x00000007 == selected_member_)
22415 {
22416 valid_discriminator = true;
22417 }
22418 break;
22419
22420 case TK_MAP:
22421 if (0x00000008 == selected_member_)
22422 {
22423 valid_discriminator = true;
22424 }
22425 break;
22426
22427 case TK_ENUM:
22428 if (0x00000009 == selected_member_)
22429 {
22430 valid_discriminator = true;
22431 }
22432 break;
22433
22434 case TK_BITMASK:
22435 if (0x0000000a == selected_member_)
22436 {
22437 valid_discriminator = true;
22438 }
22439 break;
22440
22441 default:
22442 if (0x0000000b == selected_member_)
22443 {
22444 valid_discriminator = true;
22445 }
22446 break;
22447
22448 }
22449
22450 if (!valid_discriminator)
22451 {
22452 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
22453 }
22454
22455 m__d = __d;
22456 }
22457
22462 eProsima_user_DllExport uint8_t _d() const
22463 {
22464 return m__d;
22465 }
22466
22471 eProsima_user_DllExport void alias_type(
22472 const MinimalAliasType& _alias_type)
22473 {
22474 alias_type_() = _alias_type;
22475 m__d = TK_ALIAS;
22476 }
22477
22482 eProsima_user_DllExport void alias_type(
22483 MinimalAliasType&& _alias_type)
22484 {
22485 alias_type_() = _alias_type;
22486 m__d = TK_ALIAS;
22487 }
22488
22494 eProsima_user_DllExport const MinimalAliasType& alias_type() const
22495 {
22496 if (0x00000001 != selected_member_)
22497 {
22498 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22499 }
22500
22501 return m_alias_type;
22502 }
22503
22509 eProsima_user_DllExport MinimalAliasType& alias_type()
22510 {
22511 if (0x00000001 != selected_member_)
22512 {
22513 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22514 }
22515
22516 return m_alias_type;
22517 }
22518
22519
22524 eProsima_user_DllExport void annotation_type(
22525 const MinimalAnnotationType& _annotation_type)
22526 {
22527 annotation_type_() = _annotation_type;
22528 m__d = TK_ANNOTATION;
22529 }
22530
22535 eProsima_user_DllExport void annotation_type(
22536 MinimalAnnotationType&& _annotation_type)
22537 {
22538 annotation_type_() = _annotation_type;
22539 m__d = TK_ANNOTATION;
22540 }
22541
22547 eProsima_user_DllExport const MinimalAnnotationType& annotation_type() const
22548 {
22549 if (0x00000002 != selected_member_)
22550 {
22551 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22552 }
22553
22554 return m_annotation_type;
22555 }
22556
22562 eProsima_user_DllExport MinimalAnnotationType& annotation_type()
22563 {
22564 if (0x00000002 != selected_member_)
22565 {
22566 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22567 }
22568
22569 return m_annotation_type;
22570 }
22571
22572
22577 eProsima_user_DllExport void struct_type(
22578 const MinimalStructType& _struct_type)
22579 {
22580 struct_type_() = _struct_type;
22581 m__d = TK_STRUCTURE;
22582 }
22583
22588 eProsima_user_DllExport void struct_type(
22589 MinimalStructType&& _struct_type)
22590 {
22591 struct_type_() = _struct_type;
22592 m__d = TK_STRUCTURE;
22593 }
22594
22600 eProsima_user_DllExport const MinimalStructType& struct_type() const
22601 {
22602 if (0x00000003 != selected_member_)
22603 {
22604 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22605 }
22606
22607 return m_struct_type;
22608 }
22609
22615 eProsima_user_DllExport MinimalStructType& struct_type()
22616 {
22617 if (0x00000003 != selected_member_)
22618 {
22619 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22620 }
22621
22622 return m_struct_type;
22623 }
22624
22625
22630 eProsima_user_DllExport void union_type(
22631 const MinimalUnionType& _union_type)
22632 {
22633 union_type_() = _union_type;
22634 m__d = TK_UNION;
22635 }
22636
22641 eProsima_user_DllExport void union_type(
22642 MinimalUnionType&& _union_type)
22643 {
22644 union_type_() = _union_type;
22645 m__d = TK_UNION;
22646 }
22647
22653 eProsima_user_DllExport const MinimalUnionType& union_type() const
22654 {
22655 if (0x00000004 != selected_member_)
22656 {
22657 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22658 }
22659
22660 return m_union_type;
22661 }
22662
22668 eProsima_user_DllExport MinimalUnionType& union_type()
22669 {
22670 if (0x00000004 != selected_member_)
22671 {
22672 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22673 }
22674
22675 return m_union_type;
22676 }
22677
22678
22683 eProsima_user_DllExport void bitset_type(
22684 const MinimalBitsetType& _bitset_type)
22685 {
22686 bitset_type_() = _bitset_type;
22687 m__d = TK_BITSET;
22688 }
22689
22694 eProsima_user_DllExport void bitset_type(
22695 MinimalBitsetType&& _bitset_type)
22696 {
22697 bitset_type_() = _bitset_type;
22698 m__d = TK_BITSET;
22699 }
22700
22706 eProsima_user_DllExport const MinimalBitsetType& bitset_type() const
22707 {
22708 if (0x00000005 != selected_member_)
22709 {
22710 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22711 }
22712
22713 return m_bitset_type;
22714 }
22715
22721 eProsima_user_DllExport MinimalBitsetType& bitset_type()
22722 {
22723 if (0x00000005 != selected_member_)
22724 {
22725 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22726 }
22727
22728 return m_bitset_type;
22729 }
22730
22731
22736 eProsima_user_DllExport void sequence_type(
22737 const MinimalSequenceType& _sequence_type)
22738 {
22739 sequence_type_() = _sequence_type;
22740 m__d = TK_SEQUENCE;
22741 }
22742
22747 eProsima_user_DllExport void sequence_type(
22748 MinimalSequenceType&& _sequence_type)
22749 {
22750 sequence_type_() = _sequence_type;
22751 m__d = TK_SEQUENCE;
22752 }
22753
22759 eProsima_user_DllExport const MinimalSequenceType& sequence_type() const
22760 {
22761 if (0x00000006 != selected_member_)
22762 {
22763 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22764 }
22765
22766 return m_sequence_type;
22767 }
22768
22774 eProsima_user_DllExport MinimalSequenceType& sequence_type()
22775 {
22776 if (0x00000006 != selected_member_)
22777 {
22778 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22779 }
22780
22781 return m_sequence_type;
22782 }
22783
22784
22789 eProsima_user_DllExport void array_type(
22790 const MinimalArrayType& _array_type)
22791 {
22792 array_type_() = _array_type;
22793 m__d = TK_ARRAY;
22794 }
22795
22800 eProsima_user_DllExport void array_type(
22801 MinimalArrayType&& _array_type)
22802 {
22803 array_type_() = _array_type;
22804 m__d = TK_ARRAY;
22805 }
22806
22812 eProsima_user_DllExport const MinimalArrayType& array_type() const
22813 {
22814 if (0x00000007 != selected_member_)
22815 {
22816 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22817 }
22818
22819 return m_array_type;
22820 }
22821
22827 eProsima_user_DllExport MinimalArrayType& array_type()
22828 {
22829 if (0x00000007 != selected_member_)
22830 {
22831 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22832 }
22833
22834 return m_array_type;
22835 }
22836
22837
22842 eProsima_user_DllExport void map_type(
22843 const MinimalMapType& _map_type)
22844 {
22845 map_type_() = _map_type;
22846 m__d = TK_MAP;
22847 }
22848
22853 eProsima_user_DllExport void map_type(
22854 MinimalMapType&& _map_type)
22855 {
22856 map_type_() = _map_type;
22857 m__d = TK_MAP;
22858 }
22859
22865 eProsima_user_DllExport const MinimalMapType& map_type() const
22866 {
22867 if (0x00000008 != selected_member_)
22868 {
22869 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22870 }
22871
22872 return m_map_type;
22873 }
22874
22880 eProsima_user_DllExport MinimalMapType& map_type()
22881 {
22882 if (0x00000008 != selected_member_)
22883 {
22884 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22885 }
22886
22887 return m_map_type;
22888 }
22889
22890
22895 eProsima_user_DllExport void enumerated_type(
22896 const MinimalEnumeratedType& _enumerated_type)
22897 {
22898 enumerated_type_() = _enumerated_type;
22899 m__d = TK_ENUM;
22900 }
22901
22906 eProsima_user_DllExport void enumerated_type(
22907 MinimalEnumeratedType&& _enumerated_type)
22908 {
22909 enumerated_type_() = _enumerated_type;
22910 m__d = TK_ENUM;
22911 }
22912
22918 eProsima_user_DllExport const MinimalEnumeratedType& enumerated_type() const
22919 {
22920 if (0x00000009 != selected_member_)
22921 {
22922 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22923 }
22924
22925 return m_enumerated_type;
22926 }
22927
22933 eProsima_user_DllExport MinimalEnumeratedType& enumerated_type()
22934 {
22935 if (0x00000009 != selected_member_)
22936 {
22937 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22938 }
22939
22940 return m_enumerated_type;
22941 }
22942
22943
22948 eProsima_user_DllExport void bitmask_type(
22949 const MinimalBitmaskType& _bitmask_type)
22950 {
22951 bitmask_type_() = _bitmask_type;
22952 m__d = TK_BITMASK;
22953 }
22954
22959 eProsima_user_DllExport void bitmask_type(
22960 MinimalBitmaskType&& _bitmask_type)
22961 {
22962 bitmask_type_() = _bitmask_type;
22963 m__d = TK_BITMASK;
22964 }
22965
22971 eProsima_user_DllExport const MinimalBitmaskType& bitmask_type() const
22972 {
22973 if (0x0000000a != selected_member_)
22974 {
22975 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22976 }
22977
22978 return m_bitmask_type;
22979 }
22980
22986 eProsima_user_DllExport MinimalBitmaskType& bitmask_type()
22987 {
22988 if (0x0000000a != selected_member_)
22989 {
22990 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22991 }
22992
22993 return m_bitmask_type;
22994 }
22995
22996
23001 eProsima_user_DllExport void extended_type(
23002 const MinimalExtendedType& _extended_type)
23003 {
23004 extended_type_() = _extended_type;
23005 m__d = 127;
23006 }
23007
23012 eProsima_user_DllExport void extended_type(
23013 MinimalExtendedType&& _extended_type)
23014 {
23015 extended_type_() = _extended_type;
23016 m__d = 127;
23017 }
23018
23024 eProsima_user_DllExport const MinimalExtendedType& extended_type() const
23025 {
23026 if (0x0000000b != selected_member_)
23027 {
23028 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23029 }
23030
23031 return m_extended_type;
23032 }
23033
23039 eProsima_user_DllExport MinimalExtendedType& extended_type()
23040 {
23041 if (0x0000000b != selected_member_)
23042 {
23043 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23044 }
23045
23046 return m_extended_type;
23047 }
23048
23049
23050
23051private:
23052
23053 MinimalAliasType& alias_type_()
23054 {
23055 if (0x00000001 != selected_member_)
23056 {
23057 if (member_destructor_)
23058 {
23059 member_destructor_();
23060 }
23061
23062 selected_member_ = 0x00000001;
23063 member_destructor_ = [&]() {m_alias_type.~MinimalAliasType();};
23064 new(&m_alias_type) MinimalAliasType();
23065 ;
23066 }
23067
23068 return m_alias_type;
23069 }
23070
23071 MinimalAnnotationType& annotation_type_()
23072 {
23073 if (0x00000002 != selected_member_)
23074 {
23075 if (member_destructor_)
23076 {
23077 member_destructor_();
23078 }
23079
23080 selected_member_ = 0x00000002;
23081 member_destructor_ = [&]() {m_annotation_type.~MinimalAnnotationType();};
23082 new(&m_annotation_type) MinimalAnnotationType();
23083 ;
23084 }
23085
23086 return m_annotation_type;
23087 }
23088
23089 MinimalStructType& struct_type_()
23090 {
23091 if (0x00000003 != selected_member_)
23092 {
23093 if (member_destructor_)
23094 {
23095 member_destructor_();
23096 }
23097
23098 selected_member_ = 0x00000003;
23099 member_destructor_ = [&]() {m_struct_type.~MinimalStructType();};
23100 new(&m_struct_type) MinimalStructType();
23101 ;
23102 }
23103
23104 return m_struct_type;
23105 }
23106
23107 MinimalUnionType& union_type_()
23108 {
23109 if (0x00000004 != selected_member_)
23110 {
23111 if (member_destructor_)
23112 {
23113 member_destructor_();
23114 }
23115
23116 selected_member_ = 0x00000004;
23117 member_destructor_ = [&]() {m_union_type.~MinimalUnionType();};
23118 new(&m_union_type) MinimalUnionType();
23119 ;
23120 }
23121
23122 return m_union_type;
23123 }
23124
23125 MinimalBitsetType& bitset_type_()
23126 {
23127 if (0x00000005 != selected_member_)
23128 {
23129 if (member_destructor_)
23130 {
23131 member_destructor_();
23132 }
23133
23134 selected_member_ = 0x00000005;
23135 member_destructor_ = [&]() {m_bitset_type.~MinimalBitsetType();};
23136 new(&m_bitset_type) MinimalBitsetType();
23137 ;
23138 }
23139
23140 return m_bitset_type;
23141 }
23142
23143 MinimalSequenceType& sequence_type_()
23144 {
23145 if (0x00000006 != selected_member_)
23146 {
23147 if (member_destructor_)
23148 {
23149 member_destructor_();
23150 }
23151
23152 selected_member_ = 0x00000006;
23153 member_destructor_ = [&]() {m_sequence_type.~MinimalSequenceType();};
23154 new(&m_sequence_type) MinimalSequenceType();
23155 ;
23156 }
23157
23158 return m_sequence_type;
23159 }
23160
23161 MinimalArrayType& array_type_()
23162 {
23163 if (0x00000007 != selected_member_)
23164 {
23165 if (member_destructor_)
23166 {
23167 member_destructor_();
23168 }
23169
23170 selected_member_ = 0x00000007;
23171 member_destructor_ = [&]() {m_array_type.~MinimalArrayType();};
23172 new(&m_array_type) MinimalArrayType();
23173 ;
23174 }
23175
23176 return m_array_type;
23177 }
23178
23179 MinimalMapType& map_type_()
23180 {
23181 if (0x00000008 != selected_member_)
23182 {
23183 if (member_destructor_)
23184 {
23185 member_destructor_();
23186 }
23187
23188 selected_member_ = 0x00000008;
23189 member_destructor_ = [&]() {m_map_type.~MinimalMapType();};
23190 new(&m_map_type) MinimalMapType();
23191 ;
23192 }
23193
23194 return m_map_type;
23195 }
23196
23197 MinimalEnumeratedType& enumerated_type_()
23198 {
23199 if (0x00000009 != selected_member_)
23200 {
23201 if (member_destructor_)
23202 {
23203 member_destructor_();
23204 }
23205
23206 selected_member_ = 0x00000009;
23207 member_destructor_ = [&]() {m_enumerated_type.~MinimalEnumeratedType();};
23208 new(&m_enumerated_type) MinimalEnumeratedType();
23209 ;
23210 }
23211
23212 return m_enumerated_type;
23213 }
23214
23215 MinimalBitmaskType& bitmask_type_()
23216 {
23217 if (0x0000000a != selected_member_)
23218 {
23219 if (member_destructor_)
23220 {
23221 member_destructor_();
23222 }
23223
23224 selected_member_ = 0x0000000a;
23225 member_destructor_ = [&]() {m_bitmask_type.~MinimalBitmaskType();};
23226 new(&m_bitmask_type) MinimalBitmaskType();
23227 ;
23228 }
23229
23230 return m_bitmask_type;
23231 }
23232
23233 MinimalExtendedType& extended_type_()
23234 {
23235 if (0x0000000b != selected_member_)
23236 {
23237 if (member_destructor_)
23238 {
23239 member_destructor_();
23240 }
23241
23242 selected_member_ = 0x0000000b;
23243 member_destructor_ = [&]() {m_extended_type.~MinimalExtendedType();};
23244 new(&m_extended_type) MinimalExtendedType();
23245 ;
23246 }
23247
23248 return m_extended_type;
23249 }
23250
23251
23252 uint8_t m__d {TK_NONE};
23253
23254 union
23255 {
23267 };
23268
23269 uint32_t selected_member_ {0x0FFFFFFFu};
23270
23271 std::function<void()> member_destructor_;
23272};
23278{
23279public:
23280
23284 eProsima_user_DllExport TypeObject()
23285 {
23286 }
23287
23291 eProsima_user_DllExport ~TypeObject()
23292 {
23293 if (member_destructor_)
23294 {
23295 member_destructor_();
23296 }
23297 }
23298
23303 eProsima_user_DllExport TypeObject(
23304 const TypeObject& x)
23305 {
23306 m__d = x.m__d;
23307
23308 switch (x.selected_member_)
23309 {
23310 case 0x00000001:
23311 complete_() = x.m_complete;
23312 break;
23313
23314 case 0x00000002:
23315 minimal_() = x.m_minimal;
23316 break;
23317
23318 }
23319 }
23320
23325 eProsima_user_DllExport TypeObject(
23326 TypeObject&& x) noexcept
23327 {
23328 m__d = x.m__d;
23329
23330 switch (x.selected_member_)
23331 {
23332 case 0x00000001:
23333 complete_() = std::move(x.m_complete);
23334 break;
23335
23336 case 0x00000002:
23337 minimal_() = std::move(x.m_minimal);
23338 break;
23339
23340 }
23341 }
23342
23347 eProsima_user_DllExport TypeObject& operator =(
23348 const TypeObject& x)
23349 {
23350 m__d = x.m__d;
23351
23352 switch (x.selected_member_)
23353 {
23354 case 0x00000001:
23355 complete_() = x.m_complete;
23356 break;
23357
23358 case 0x00000002:
23359 minimal_() = x.m_minimal;
23360 break;
23361
23362 }
23363
23364 return *this;
23365 }
23366
23371 eProsima_user_DllExport TypeObject& operator =(
23372 TypeObject&& x) noexcept
23373 {
23374 m__d = x.m__d;
23375
23376 switch (x.selected_member_)
23377 {
23378 case 0x00000001:
23379 complete_() = std::move(x.m_complete);
23380 break;
23381
23382 case 0x00000002:
23383 minimal_() = std::move(x.m_minimal);
23384 break;
23385
23386 }
23387
23388 return *this;
23389 }
23390
23395 eProsima_user_DllExport bool operator ==(
23396 const TypeObject& x) const
23397 {
23398 bool ret_value {false};
23399
23400 if (m__d == x.m__d &&
23401 selected_member_ == x.selected_member_)
23402 {
23403 switch (selected_member_)
23404 {
23405 case 0x00000001:
23406 ret_value = (m_complete == x.m_complete);
23407 break;
23408
23409 case 0x00000002:
23410 ret_value = (m_minimal == x.m_minimal);
23411 break;
23412
23413 }
23414 }
23415
23416 return ret_value;
23417 }
23418
23423 eProsima_user_DllExport bool operator !=(
23424 const TypeObject& x) const
23425 {
23426 return !(*this == x);
23427 }
23428
23434 eProsima_user_DllExport void _d(
23435 uint8_t __d)
23436 {
23437 bool valid_discriminator = false;
23438
23439 switch (__d)
23440 {
23441 case EK_COMPLETE:
23442 if (0x00000001 == selected_member_)
23443 {
23444 valid_discriminator = true;
23445 }
23446 break;
23447
23448 case EK_MINIMAL:
23449 if (0x00000002 == selected_member_)
23450 {
23451 valid_discriminator = true;
23452 }
23453 break;
23454
23455 }
23456
23457 if (!valid_discriminator)
23458 {
23459 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
23460 }
23461
23462 m__d = __d;
23463 }
23464
23469 eProsima_user_DllExport uint8_t _d() const
23470 {
23471 return m__d;
23472 }
23473
23478 eProsima_user_DllExport void complete(
23479 const CompleteTypeObject& _complete)
23480 {
23481 complete_() = _complete;
23482 m__d = EK_COMPLETE;
23483 }
23484
23489 eProsima_user_DllExport void complete(
23490 CompleteTypeObject&& _complete)
23491 {
23492 complete_() = _complete;
23493 m__d = EK_COMPLETE;
23494 }
23495
23501 eProsima_user_DllExport const CompleteTypeObject& complete() const
23502 {
23503 if (0x00000001 != selected_member_)
23504 {
23505 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23506 }
23507
23508 return m_complete;
23509 }
23510
23516 eProsima_user_DllExport CompleteTypeObject& complete()
23517 {
23518 if (0x00000001 != selected_member_)
23519 {
23520 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23521 }
23522
23523 return m_complete;
23524 }
23525
23526
23531 eProsima_user_DllExport void minimal(
23532 const MinimalTypeObject& _minimal)
23533 {
23534 minimal_() = _minimal;
23535 m__d = EK_MINIMAL;
23536 }
23537
23542 eProsima_user_DllExport void minimal(
23543 MinimalTypeObject&& _minimal)
23544 {
23545 minimal_() = _minimal;
23546 m__d = EK_MINIMAL;
23547 }
23548
23554 eProsima_user_DllExport const MinimalTypeObject& minimal() const
23555 {
23556 if (0x00000002 != selected_member_)
23557 {
23558 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23559 }
23560
23561 return m_minimal;
23562 }
23563
23569 eProsima_user_DllExport MinimalTypeObject& minimal()
23570 {
23571 if (0x00000002 != selected_member_)
23572 {
23573 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23574 }
23575
23576 return m_minimal;
23577 }
23578
23579
23581 {
23582 if (member_destructor_)
23583 {
23584 member_destructor_();
23585 }
23586
23587 selected_member_ = 0x0FFFFFFFu;
23588 }
23589
23590
23591private:
23592
23593 CompleteTypeObject& complete_()
23594 {
23595 if (0x00000001 != selected_member_)
23596 {
23597 if (member_destructor_)
23598 {
23599 member_destructor_();
23600 }
23601
23602 selected_member_ = 0x00000001;
23603 member_destructor_ = [&]() {m_complete.~CompleteTypeObject();};
23604 new(&m_complete) CompleteTypeObject();
23605 ;
23606 }
23607
23608 return m_complete;
23609 }
23610
23611 MinimalTypeObject& minimal_()
23612 {
23613 if (0x00000002 != selected_member_)
23614 {
23615 if (member_destructor_)
23616 {
23617 member_destructor_();
23618 }
23619
23620 selected_member_ = 0x00000002;
23621 member_destructor_ = [&]() {m_minimal.~MinimalTypeObject();};
23622 new(&m_minimal) MinimalTypeObject();
23623 ;
23624 }
23625
23626 return m_minimal;
23627 }
23628
23629
23630 uint8_t m__d {TK_NONE};
23631
23632 union
23633 {
23636 };
23637
23638 uint32_t selected_member_ {0x0FFFFFFFu};
23639
23640 std::function<void()> member_destructor_;
23641};
23642typedef std::vector<TypeObject> TypeObjectSeq;
23643
23645
23651{
23652public:
23653
23657 eProsima_user_DllExport TypeIdentifierTypeObjectPair()
23658 {
23659 }
23660
23664 eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
23665 {
23666 }
23667
23672 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23674 {
23675 m_type_identifier = x.m_type_identifier;
23676
23677 m_type_object = x.m_type_object;
23678
23679 }
23680
23685 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23686 TypeIdentifierTypeObjectPair&& x) noexcept
23687 {
23688 m_type_identifier = std::move(x.m_type_identifier);
23689 m_type_object = std::move(x.m_type_object);
23690 }
23691
23698 {
23699
23700 m_type_identifier = x.m_type_identifier;
23701
23702 m_type_object = x.m_type_object;
23703
23704 return *this;
23705 }
23706
23712 TypeIdentifierTypeObjectPair&& x) noexcept
23713 {
23714
23715 m_type_identifier = std::move(x.m_type_identifier);
23716 m_type_object = std::move(x.m_type_object);
23717 return *this;
23718 }
23719
23724 eProsima_user_DllExport bool operator ==(
23725 const TypeIdentifierTypeObjectPair& x) const
23726 {
23727 return (m_type_identifier == x.m_type_identifier &&
23728 m_type_object == x.m_type_object);
23729 }
23730
23735 eProsima_user_DllExport bool operator !=(
23736 const TypeIdentifierTypeObjectPair& x) const
23737 {
23738 return !(*this == x);
23739 }
23740
23745 eProsima_user_DllExport void type_identifier(
23746 const TypeIdentifier& _type_identifier)
23747 {
23748 m_type_identifier = _type_identifier;
23749 }
23750
23755 eProsima_user_DllExport void type_identifier(
23756 TypeIdentifier&& _type_identifier)
23757 {
23758 m_type_identifier = std::move(_type_identifier);
23759 }
23760
23765 eProsima_user_DllExport const TypeIdentifier& type_identifier() const
23766 {
23767 return m_type_identifier;
23768 }
23769
23774 eProsima_user_DllExport TypeIdentifier& type_identifier()
23775 {
23776 return m_type_identifier;
23777 }
23778
23779
23784 eProsima_user_DllExport void type_object(
23785 const TypeObject& _type_object)
23786 {
23787 m_type_object = _type_object;
23788 }
23789
23794 eProsima_user_DllExport void type_object(
23795 TypeObject&& _type_object)
23796 {
23797 m_type_object = std::move(_type_object);
23798 }
23799
23804 eProsima_user_DllExport const TypeObject& type_object() const
23805 {
23806 return m_type_object;
23807 }
23808
23813 eProsima_user_DllExport TypeObject& type_object()
23814 {
23815 return m_type_object;
23816 }
23817
23818
23819
23820private:
23821
23822 TypeIdentifier m_type_identifier;
23823 TypeObject m_type_object;
23824
23825};
23826typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
23827
23833{
23834public:
23835
23839 eProsima_user_DllExport TypeIdentifierPair()
23840 {
23841 }
23842
23846 eProsima_user_DllExport ~TypeIdentifierPair()
23847 {
23848 }
23849
23854 eProsima_user_DllExport TypeIdentifierPair(
23855 const TypeIdentifierPair& x)
23856 {
23857 m_type_identifier1 = x.m_type_identifier1;
23858
23859 m_type_identifier2 = x.m_type_identifier2;
23860
23861 }
23862
23867 eProsima_user_DllExport TypeIdentifierPair(
23868 TypeIdentifierPair&& x) noexcept
23869 {
23870 m_type_identifier1 = std::move(x.m_type_identifier1);
23871 m_type_identifier2 = std::move(x.m_type_identifier2);
23872 }
23873
23878 eProsima_user_DllExport TypeIdentifierPair& operator =(
23879 const TypeIdentifierPair& x)
23880 {
23881
23882 m_type_identifier1 = x.m_type_identifier1;
23883
23884 m_type_identifier2 = x.m_type_identifier2;
23885
23886 return *this;
23887 }
23888
23893 eProsima_user_DllExport TypeIdentifierPair& operator =(
23894 TypeIdentifierPair&& x) noexcept
23895 {
23896
23897 m_type_identifier1 = std::move(x.m_type_identifier1);
23898 m_type_identifier2 = std::move(x.m_type_identifier2);
23899 return *this;
23900 }
23901
23906 eProsima_user_DllExport bool operator ==(
23907 const TypeIdentifierPair& x) const
23908 {
23909 return (m_type_identifier1 == x.m_type_identifier1 &&
23910 m_type_identifier2 == x.m_type_identifier2);
23911 }
23912
23917 eProsima_user_DllExport bool operator !=(
23918 const TypeIdentifierPair& x) const
23919 {
23920 return !(*this == x);
23921 }
23922
23927 eProsima_user_DllExport void type_identifier1(
23928 const TypeIdentifier& _type_identifier1)
23929 {
23930 m_type_identifier1 = _type_identifier1;
23931 }
23932
23937 eProsima_user_DllExport void type_identifier1(
23938 TypeIdentifier&& _type_identifier1)
23939 {
23940 m_type_identifier1 = std::move(_type_identifier1);
23941 }
23942
23947 eProsima_user_DllExport const TypeIdentifier& type_identifier1() const
23948 {
23949 return m_type_identifier1;
23950 }
23951
23956 eProsima_user_DllExport TypeIdentifier& type_identifier1()
23957 {
23958 return m_type_identifier1;
23959 }
23960
23961
23966 eProsima_user_DllExport void type_identifier2(
23967 const TypeIdentifier& _type_identifier2)
23968 {
23969 m_type_identifier2 = _type_identifier2;
23970 }
23971
23976 eProsima_user_DllExport void type_identifier2(
23977 TypeIdentifier&& _type_identifier2)
23978 {
23979 m_type_identifier2 = std::move(_type_identifier2);
23980 }
23981
23986 eProsima_user_DllExport const TypeIdentifier& type_identifier2() const
23987 {
23988 return m_type_identifier2;
23989 }
23990
23995 eProsima_user_DllExport TypeIdentifier& type_identifier2()
23996 {
23997 return m_type_identifier2;
23998 }
23999
24000
24001
24002private:
24003
24004 TypeIdentifier m_type_identifier1;
24005 TypeIdentifier m_type_identifier2;
24006
24007};
24008typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
24009
24015{
24016public:
24017
24021 eProsima_user_DllExport TypeIdentfierWithSize()
24022 {
24023 }
24024
24028 eProsima_user_DllExport ~TypeIdentfierWithSize()
24029 {
24030 }
24031
24036 eProsima_user_DllExport TypeIdentfierWithSize(
24037 const TypeIdentfierWithSize& x)
24038 {
24039 m_type_id = x.m_type_id;
24040
24041 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24042
24043 }
24044
24049 eProsima_user_DllExport TypeIdentfierWithSize(
24050 TypeIdentfierWithSize&& x) noexcept
24051 {
24052 m_type_id = std::move(x.m_type_id);
24053 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24054 }
24055
24060 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24061 const TypeIdentfierWithSize& x)
24062 {
24063
24064 m_type_id = x.m_type_id;
24065
24066 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24067
24068 return *this;
24069 }
24070
24075 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24076 TypeIdentfierWithSize&& x) noexcept
24077 {
24078
24079 m_type_id = std::move(x.m_type_id);
24080 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24081 return *this;
24082 }
24083
24088 eProsima_user_DllExport bool operator ==(
24089 const TypeIdentfierWithSize& x) const
24090 {
24091 return (m_type_id == x.m_type_id &&
24092 m_typeobject_serialized_size == x.m_typeobject_serialized_size);
24093 }
24094
24099 eProsima_user_DllExport bool operator !=(
24100 const TypeIdentfierWithSize& x) const
24101 {
24102 return !(*this == x);
24103 }
24104
24109 eProsima_user_DllExport void type_id(
24110 const TypeIdentifier& _type_id)
24111 {
24112 m_type_id = _type_id;
24113 }
24114
24119 eProsima_user_DllExport void type_id(
24120 TypeIdentifier&& _type_id)
24121 {
24122 m_type_id = std::move(_type_id);
24123 }
24124
24129 eProsima_user_DllExport const TypeIdentifier& type_id() const
24130 {
24131 return m_type_id;
24132 }
24133
24138 eProsima_user_DllExport TypeIdentifier& type_id()
24139 {
24140 return m_type_id;
24141 }
24142
24143
24148 eProsima_user_DllExport void typeobject_serialized_size(
24149 uint32_t _typeobject_serialized_size)
24150 {
24151 m_typeobject_serialized_size = _typeobject_serialized_size;
24152 }
24153
24158 eProsima_user_DllExport uint32_t typeobject_serialized_size() const
24159 {
24160 return m_typeobject_serialized_size;
24161 }
24162
24167 eProsima_user_DllExport uint32_t& typeobject_serialized_size()
24168 {
24169 return m_typeobject_serialized_size;
24170 }
24171
24172
24173
24174private:
24175
24176 TypeIdentifier m_type_id;
24177 uint32_t m_typeobject_serialized_size{0};
24178
24179};
24180typedef std::vector<TypeIdentfierWithSize> TypeIdentfierWithSizeSeq;
24181
24187{
24188public:
24189
24193 eProsima_user_DllExport TypeIdentifierWithDependencies()
24194 {
24195 }
24196
24200 eProsima_user_DllExport ~TypeIdentifierWithDependencies()
24201 {
24202 }
24203
24208 eProsima_user_DllExport TypeIdentifierWithDependencies(
24210 {
24211 m_typeid_with_size = x.m_typeid_with_size;
24212
24213 m_dependent_typeid_count = x.m_dependent_typeid_count;
24214
24215 m_dependent_typeids = x.m_dependent_typeids;
24216
24217 }
24218
24223 eProsima_user_DllExport TypeIdentifierWithDependencies(
24224 TypeIdentifierWithDependencies&& x) noexcept
24225 {
24226 m_typeid_with_size = std::move(x.m_typeid_with_size);
24227 m_dependent_typeid_count = x.m_dependent_typeid_count;
24228 m_dependent_typeids = std::move(x.m_dependent_typeids);
24229 }
24230
24237 {
24238
24239 m_typeid_with_size = x.m_typeid_with_size;
24240
24241 m_dependent_typeid_count = x.m_dependent_typeid_count;
24242
24243 m_dependent_typeids = x.m_dependent_typeids;
24244
24245 return *this;
24246 }
24247
24253 TypeIdentifierWithDependencies&& x) noexcept
24254 {
24255
24256 m_typeid_with_size = std::move(x.m_typeid_with_size);
24257 m_dependent_typeid_count = x.m_dependent_typeid_count;
24258 m_dependent_typeids = std::move(x.m_dependent_typeids);
24259 return *this;
24260 }
24261
24266 eProsima_user_DllExport bool operator ==(
24267 const TypeIdentifierWithDependencies& x) const
24268 {
24269 return (m_typeid_with_size == x.m_typeid_with_size &&
24270 m_dependent_typeid_count == x.m_dependent_typeid_count &&
24271 m_dependent_typeids == x.m_dependent_typeids);
24272 }
24273
24278 eProsima_user_DllExport bool operator !=(
24279 const TypeIdentifierWithDependencies& x) const
24280 {
24281 return !(*this == x);
24282 }
24283
24288 eProsima_user_DllExport void typeid_with_size(
24289 const TypeIdentfierWithSize& _typeid_with_size)
24290 {
24291 m_typeid_with_size = _typeid_with_size;
24292 }
24293
24298 eProsima_user_DllExport void typeid_with_size(
24299 TypeIdentfierWithSize&& _typeid_with_size)
24300 {
24301 m_typeid_with_size = std::move(_typeid_with_size);
24302 }
24303
24308 eProsima_user_DllExport const TypeIdentfierWithSize& typeid_with_size() const
24309 {
24310 return m_typeid_with_size;
24311 }
24312
24317 eProsima_user_DllExport TypeIdentfierWithSize& typeid_with_size()
24318 {
24319 return m_typeid_with_size;
24320 }
24321
24322
24327 eProsima_user_DllExport void dependent_typeid_count(
24328 int32_t _dependent_typeid_count)
24329 {
24330 m_dependent_typeid_count = _dependent_typeid_count;
24331 }
24332
24337 eProsima_user_DllExport int32_t dependent_typeid_count() const
24338 {
24339 return m_dependent_typeid_count;
24340 }
24341
24346 eProsima_user_DllExport int32_t& dependent_typeid_count()
24347 {
24348 return m_dependent_typeid_count;
24349 }
24350
24351
24356 eProsima_user_DllExport void dependent_typeids(
24357 const std::vector<TypeIdentfierWithSize>& _dependent_typeids)
24358 {
24359 m_dependent_typeids = _dependent_typeids;
24360 }
24361
24366 eProsima_user_DllExport void dependent_typeids(
24367 std::vector<TypeIdentfierWithSize>&& _dependent_typeids)
24368 {
24369 m_dependent_typeids = std::move(_dependent_typeids);
24370 }
24371
24376 eProsima_user_DllExport const std::vector<TypeIdentfierWithSize>& dependent_typeids() const
24377 {
24378 return m_dependent_typeids;
24379 }
24380
24385 eProsima_user_DllExport std::vector<TypeIdentfierWithSize>& dependent_typeids()
24386 {
24387 return m_dependent_typeids;
24388 }
24389
24390
24391
24392private:
24393
24394 TypeIdentfierWithSize m_typeid_with_size;
24395 int32_t m_dependent_typeid_count{0};
24396 std::vector<TypeIdentfierWithSize> m_dependent_typeids;
24397
24398};
24399typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
24400
24406{
24407public:
24408
24412 eProsima_user_DllExport TypeInformation()
24413 {
24414 }
24415
24419 eProsima_user_DllExport ~TypeInformation()
24420 {
24421 }
24422
24427 eProsima_user_DllExport TypeInformation(
24428 const TypeInformation& x)
24429 {
24430 m_minimal = x.m_minimal;
24431
24432 m_complete = x.m_complete;
24433
24434 }
24435
24440 eProsima_user_DllExport TypeInformation(
24441 TypeInformation&& x) noexcept
24442 {
24443 m_minimal = std::move(x.m_minimal);
24444 m_complete = std::move(x.m_complete);
24445 }
24446
24451 eProsima_user_DllExport TypeInformation& operator =(
24452 const TypeInformation& x)
24453 {
24454
24455 m_minimal = x.m_minimal;
24456
24457 m_complete = x.m_complete;
24458
24459 return *this;
24460 }
24461
24466 eProsima_user_DllExport TypeInformation& operator =(
24467 TypeInformation&& x) noexcept
24468 {
24469
24470 m_minimal = std::move(x.m_minimal);
24471 m_complete = std::move(x.m_complete);
24472 return *this;
24473 }
24474
24479 eProsima_user_DllExport bool operator ==(
24480 const TypeInformation& x) const
24481 {
24482 return (m_minimal == x.m_minimal &&
24483 m_complete == x.m_complete);
24484 }
24485
24490 eProsima_user_DllExport bool operator !=(
24491 const TypeInformation& x) const
24492 {
24493 return !(*this == x);
24494 }
24495
24500 eProsima_user_DllExport void minimal(
24501 const TypeIdentifierWithDependencies& _minimal)
24502 {
24503 m_minimal = _minimal;
24504 }
24505
24510 eProsima_user_DllExport void minimal(
24512 {
24513 m_minimal = std::move(_minimal);
24514 }
24515
24520 eProsima_user_DllExport const TypeIdentifierWithDependencies& minimal() const
24521 {
24522 return m_minimal;
24523 }
24524
24529 eProsima_user_DllExport TypeIdentifierWithDependencies& minimal()
24530 {
24531 return m_minimal;
24532 }
24533
24534
24539 eProsima_user_DllExport void complete(
24540 const TypeIdentifierWithDependencies& _complete)
24541 {
24542 m_complete = _complete;
24543 }
24544
24549 eProsima_user_DllExport void complete(
24551 {
24552 m_complete = std::move(_complete);
24553 }
24554
24559 eProsima_user_DllExport const TypeIdentifierWithDependencies& complete() const
24560 {
24561 return m_complete;
24562 }
24563
24568 eProsima_user_DllExport TypeIdentifierWithDependencies& complete()
24569 {
24570 return m_complete;
24571 }
24572
24573
24574
24575private:
24576
24579
24580};
24581typedef std::vector<TypeInformation> TypeInformationSeq;
24582
24583
24584} // namespace xtypes
24585
24586
24587} // namespace dds
24588
24589} // namespace fastdds
24590
24591} // namespace eprosima
24592
24593
24594#endif // _FAST_DDS_GENERATED_EPROSIMA_FASTDDS_DDS_XTYPES_DDS_XTYPES_TYPEOBJECT_HPP_
24595
24596
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:4276
eProsima_user_DllExport bool operator!=(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4762
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:5661
eProsima_user_DllExport void boolean_value(bool _boolean_value)
This function sets a value in member boolean_value.
Definition dds_xtypes_typeobject.hpp:4936
ExtendedAnnotationParameterValue m_extended_value
Definition dds_xtypes_typeobject.hpp:6131
eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > m_string8_value
Definition dds_xtypes_typeobject.hpp:6129
wchar_t m_wchar_value
Definition dds_xtypes_typeobject.hpp:6127
eProsima_user_DllExport void int8_value(int8_t _int8_value)
This function sets a value in member int8_value.
Definition dds_xtypes_typeobject.hpp:5020
eProsima_user_DllExport void float32_value(float _float32_value)
This function sets a value in member float32_value.
Definition dds_xtypes_typeobject.hpp:5356
eProsima_user_DllExport void uint8_value(uint8_t _uint8_value)
This function sets a value in member uint8_value.
Definition dds_xtypes_typeobject.hpp:5062
float m_float32_value
Definition dds_xtypes_typeobject.hpp:6123
eProsima_user_DllExport double & float64_value()
This function returns a reference to member float64_value.
Definition dds_xtypes_typeobject.hpp:5425
eProsima_user_DllExport uint64_t & uint64_value()
This function returns a reference to member uint64_value.
Definition dds_xtypes_typeobject.hpp:5341
eProsima_user_DllExport const std::wstring & string16_value() const
This function returns a constant reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5684
eProsima_user_DllExport void uint32_value(uint32_t _uint32_value)
This function sets a value in member uint32_value.
Definition dds_xtypes_typeobject.hpp:5230
eProsima_user_DllExport void extended_value(const ExtendedAnnotationParameterValue &_extended_value)
This function copies the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5714
eProsima_user_DllExport int32_t enumerated_value() const
This function returns the value of member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5578
eProsima_user_DllExport void wchar_value(wchar_t _wchar_value)
This function sets a value in member wchar_value.
Definition dds_xtypes_typeobject.hpp:5524
eProsima_user_DllExport void float128_value(long double _float128_value)
This function sets a value in member float128_value.
Definition dds_xtypes_typeobject.hpp:5440
eProsima_user_DllExport void char_value(char _char_value)
This function sets a value in member char_value.
Definition dds_xtypes_typeobject.hpp:5482
bool m_boolean_value
Definition dds_xtypes_typeobject.hpp:6113
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:5619
int32_t m_enumerated_value
Definition dds_xtypes_typeobject.hpp:6128
eProsima_user_DllExport void extended_value(ExtendedAnnotationParameterValue &&_extended_value)
This function moves the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5725
eProsima_user_DllExport float float32_value() const
This function returns the value of member float32_value.
Definition dds_xtypes_typeobject.hpp:5368
eProsima_user_DllExport char char_value() const
This function returns the value of member char_value.
Definition dds_xtypes_typeobject.hpp:5494
eProsima_user_DllExport void byte_value(uint8_t _byte_value)
This function sets a value in member byte_value.
Definition dds_xtypes_typeobject.hpp:4978
eProsima_user_DllExport void string16_value(std::wstring &&_string16_value)
This function moves the value in member string16_value.
Definition dds_xtypes_typeobject.hpp:5672
int8_t m_int8_value
Definition dds_xtypes_typeobject.hpp:6115
eProsima_user_DllExport int16_t & int16_value()
This function returns a reference to member int16_value.
Definition dds_xtypes_typeobject.hpp:5131
uint8_t m_uint8_value
Definition dds_xtypes_typeobject.hpp:6116
eProsima_user_DllExport int8_t & int8_value()
This function returns a reference to member int8_value.
Definition dds_xtypes_typeobject.hpp:5047
eProsima_user_DllExport uint8_t byte_value() const
This function returns the value of member byte_value.
Definition dds_xtypes_typeobject.hpp:4990
eProsima_user_DllExport int32_t & enumerated_value()
This function returns a reference to member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5593
uint8_t m_byte_value
Definition dds_xtypes_typeobject.hpp:6114
eProsima_user_DllExport uint16_t uint_16_value() const
This function returns the value of member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5158
eProsima_user_DllExport ExtendedAnnotationParameterValue & extended_value()
This function returns a reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5752
char m_char_value
Definition dds_xtypes_typeobject.hpp:6126
eProsima_user_DllExport uint16_t & uint_16_value()
This function returns a reference to member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5173
eProsima_user_DllExport void float64_value(double _float64_value)
This function sets a value in member float64_value.
Definition dds_xtypes_typeobject.hpp:5398
eProsima_user_DllExport bool operator==(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4666
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:5631
eProsima_user_DllExport std::wstring & string16_value()
This function returns a reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5699
eProsima_user_DllExport long double float128_value() const
This function returns the value of member float128_value.
Definition dds_xtypes_typeobject.hpp:5452
eProsima_user_DllExport int32_t int32_value() const
This function returns the value of member int32_value.
Definition dds_xtypes_typeobject.hpp:5200
eProsima_user_DllExport wchar_t & wchar_value()
This function returns a reference to member wchar_value.
Definition dds_xtypes_typeobject.hpp:5551
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:5146
eProsima_user_DllExport AnnotationParameterValue & operator=(const AnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4482
eProsima_user_DllExport uint32_t uint32_value() const
This function returns the value of member uint32_value.
Definition dds_xtypes_typeobject.hpp:5242
int64_t m_int64_value
Definition dds_xtypes_typeobject.hpp:6121
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:5646
eProsima_user_DllExport char & char_value()
This function returns a reference to member char_value.
Definition dds_xtypes_typeobject.hpp:5509
eProsima_user_DllExport const ExtendedAnnotationParameterValue & extended_value() const
This function returns a constant reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5737
eProsima_user_DllExport AnnotationParameterValue(AnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4392
eProsima_user_DllExport uint64_t uint64_value() const
This function returns the value of member uint64_value.
Definition dds_xtypes_typeobject.hpp:5326
eProsima_user_DllExport uint8_t & uint8_value()
This function returns a reference to member uint8_value.
Definition dds_xtypes_typeobject.hpp:5089
std::wstring m_string16_value
Definition dds_xtypes_typeobject.hpp:6130
int16_t m_int16_value
Definition dds_xtypes_typeobject.hpp:6117
eProsima_user_DllExport void uint64_value(uint64_t _uint64_value)
This function sets a value in member uint64_value.
Definition dds_xtypes_typeobject.hpp:5314
eProsima_user_DllExport double float64_value() const
This function returns the value of member float64_value.
Definition dds_xtypes_typeobject.hpp:5410
eProsima_user_DllExport uint8_t & byte_value()
This function returns a reference to member byte_value.
Definition dds_xtypes_typeobject.hpp:5005
eProsima_user_DllExport ~AnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4290
uint64_t m_uint64_value
Definition dds_xtypes_typeobject.hpp:6122
long double m_float128_value
Definition dds_xtypes_typeobject.hpp:6125
eProsima_user_DllExport wchar_t wchar_value() const
This function returns the value of member wchar_value.
Definition dds_xtypes_typeobject.hpp:5536
eProsima_user_DllExport float & float32_value()
This function returns a reference to member float32_value.
Definition dds_xtypes_typeobject.hpp:5383
eProsima_user_DllExport bool & boolean_value()
This function returns a reference to member boolean_value.
Definition dds_xtypes_typeobject.hpp:4963
eProsima_user_DllExport AnnotationParameterValue(const AnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4302
eProsima_user_DllExport long double & float128_value()
This function returns a reference to member float128_value.
Definition dds_xtypes_typeobject.hpp:5467
eProsima_user_DllExport void int16_value(int16_t _int16_value)
This function sets a value in member int16_value.
Definition dds_xtypes_typeobject.hpp:5104
eProsima_user_DllExport int16_t int16_value() const
This function returns the value of member int16_value.
Definition dds_xtypes_typeobject.hpp:5116
eProsima_user_DllExport void int32_value(int32_t _int32_value)
This function sets a value in member int32_value.
Definition dds_xtypes_typeobject.hpp:5188
eProsima_user_DllExport void int64_value(int64_t _int64_value)
This function sets a value in member int64_value.
Definition dds_xtypes_typeobject.hpp:5272
eProsima_user_DllExport int8_t int8_value() const
This function returns the value of member int8_value.
Definition dds_xtypes_typeobject.hpp:5032
eProsima_user_DllExport void enumerated_value(int32_t _enumerated_value)
This function sets a value in member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5566
eProsima_user_DllExport AnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4282
eProsima_user_DllExport int64_t int64_value() const
This function returns the value of member int64_value.
Definition dds_xtypes_typeobject.hpp:5284
int32_t m_int32_value
Definition dds_xtypes_typeobject.hpp:6119
eProsima_user_DllExport uint32_t & uint32_value()
This function returns a reference to member uint32_value.
Definition dds_xtypes_typeobject.hpp:5257
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:4773
uint16_t m_uint_16_value
Definition dds_xtypes_typeobject.hpp:6118
eProsima_user_DllExport int32_t & int32_value()
This function returns a reference to member int32_value.
Definition dds_xtypes_typeobject.hpp:5215
eProsima_user_DllExport uint8_t uint8_value() const
This function returns the value of member uint8_value.
Definition dds_xtypes_typeobject.hpp:5074
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:5608
eProsima_user_DllExport bool boolean_value() const
This function returns the value of member boolean_value.
Definition dds_xtypes_typeobject.hpp:4948
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:4927
uint32_t m_uint32_value
Definition dds_xtypes_typeobject.hpp:6120
eProsima_user_DllExport int64_t & int64_value()
This function returns a reference to member int64_value.
Definition dds_xtypes_typeobject.hpp:5299
double m_float64_value
Definition dds_xtypes_typeobject.hpp:6124
This class represents the structure AppliedAnnotation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6325
eProsima_user_DllExport AppliedAnnotation(AppliedAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6359
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:6468
eProsima_user_DllExport ~AppliedAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6338
eProsima_user_DllExport const TypeIdentifier & annotation_typeid() const
This function returns a constant reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6439
eProsima_user_DllExport void annotation_typeid(TypeIdentifier &&_annotation_typeid)
This function moves the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6429
eProsima_user_DllExport bool operator!=(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6409
eProsima_user_DllExport AppliedAnnotation & operator=(const AppliedAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6370
eProsima_user_DllExport AppliedAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6331
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:6458
eProsima_user_DllExport TypeIdentifier & annotation_typeid()
This function returns a reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6448
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:6478
eProsima_user_DllExport AppliedAnnotation(const AppliedAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6346
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > & param_seq()
This function returns a reference to member param_seq.
Definition dds_xtypes_typeobject.hpp:6487
eProsima_user_DllExport bool operator==(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6398
eProsima_user_DllExport void annotation_typeid(const TypeIdentifier &_annotation_typeid)
This function copies the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6419
This class represents the structure AppliedAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6143
eProsima_user_DllExport bool operator==(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6216
eProsima_user_DllExport bool operator!=(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6227
eProsima_user_DllExport AppliedAnnotationParameter & operator=(const AppliedAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6188
eProsima_user_DllExport AppliedAnnotationParameter(AppliedAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6177
eProsima_user_DllExport const AnnotationParameterValue & value() const
This function returns a constant reference to member value.
Definition dds_xtypes_typeobject.hpp:6296
eProsima_user_DllExport void paramname_hash(const NameHash &_paramname_hash)
This function copies the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6237
eProsima_user_DllExport void value(AnnotationParameterValue &&_value)
This function moves the value in member value.
Definition dds_xtypes_typeobject.hpp:6286
eProsima_user_DllExport const NameHash & paramname_hash() const
This function returns a constant reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6257
eProsima_user_DllExport AnnotationParameterValue & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:6305
eProsima_user_DllExport AppliedAnnotationParameter(const AppliedAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6164
eProsima_user_DllExport void paramname_hash(NameHash &&_paramname_hash)
This function moves the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6247
eProsima_user_DllExport void value(const AnnotationParameterValue &_value)
This function copies the value in member value.
Definition dds_xtypes_typeobject.hpp:6276
eProsima_user_DllExport ~AppliedAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6156
eProsima_user_DllExport NameHash & paramname_hash()
This function returns a reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6266
eProsima_user_DllExport AppliedAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6149
This class represents the structure AppliedBuiltinMemberAnnotations defined by the user in the IDL fi...
Definition dds_xtypes_typeobject.hpp:6734
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & min()
This function returns a reference to member min.
Definition dds_xtypes_typeobject.hpp:6910
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(const AppliedBuiltinMemberAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6755
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:6979
eProsima_user_DllExport void max(eprosima::fastcdr::optional< AnnotationParameterValue > &&_max)
This function moves the value in member max.
Definition dds_xtypes_typeobject.hpp:6930
eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6747
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:6842
eProsima_user_DllExport void min(eprosima::fastcdr::optional< AnnotationParameterValue > &&_min)
This function moves the value in member min.
Definition dds_xtypes_typeobject.hpp:6891
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:6969
eProsima_user_DllExport void max(const eprosima::fastcdr::optional< AnnotationParameterValue > &_max)
This function copies the value in member max.
Definition dds_xtypes_typeobject.hpp:6920
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & max()
This function returns a reference to member max.
Definition dds_xtypes_typeobject.hpp:6949
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & hash_id()
This function returns a reference to member hash_id.
Definition dds_xtypes_typeobject.hpp:6988
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:6862
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & max() const
This function returns a constant reference to member max.
Definition dds_xtypes_typeobject.hpp:6940
eProsima_user_DllExport void min(const eprosima::fastcdr::optional< AnnotationParameterValue > &_min)
This function copies the value in member min.
Definition dds_xtypes_typeobject.hpp:6881
eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6740
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & min() const
This function returns a constant reference to member min.
Definition dds_xtypes_typeobject.hpp:6901
eProsima_user_DllExport void unit(eprosima::fastcdr::optional< std::string > &&_unit)
This function moves the value in member unit.
Definition dds_xtypes_typeobject.hpp:6852
eProsima_user_DllExport bool operator==(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6819
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(AppliedBuiltinMemberAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6772
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:6959
eProsima_user_DllExport AppliedBuiltinMemberAnnotations & operator=(const AppliedBuiltinMemberAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6785
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & unit()
This function returns a reference to member unit.
Definition dds_xtypes_typeobject.hpp:6871
eProsima_user_DllExport bool operator!=(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6832
This class represents the structure AppliedBuiltinTypeAnnotations defined by the user in the IDL file...
Definition dds_xtypes_typeobject.hpp:7949
eProsima_user_DllExport bool operator!=(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8026
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7981
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim() const
This function returns a constant reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8056
eProsima_user_DllExport void verbatim(const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &_verbatim)
This function copies the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8036
eProsima_user_DllExport void verbatim(eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &&_verbatim)
This function moves the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8046
eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7955
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7970
eProsima_user_DllExport bool operator==(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8016
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim()
This function returns a reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8065
eProsima_user_DllExport AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7991
eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7962
This class represents the structure AppliedVerbatimAnnotation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6507
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:6628
eProsima_user_DllExport bool operator!=(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6598
eProsima_user_DllExport void text(const std::string &_text)
This function copies the value in member text.
Definition dds_xtypes_typeobject.hpp:6686
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & language()
This function returns a reference to member language.
Definition dds_xtypes_typeobject.hpp:6676
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:6647
eProsima_user_DllExport AppliedVerbatimAnnotation(AppliedVerbatimAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6543
eProsima_user_DllExport void language(eprosima::fastcdr::fixed_string< 32 > &&_language)
This function moves the value in member language.
Definition dds_xtypes_typeobject.hpp:6657
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:6608
eProsima_user_DllExport void placement(eprosima::fastcdr::fixed_string< 32 > &&_placement)
This function moves the value in member placement.
Definition dds_xtypes_typeobject.hpp:6618
eProsima_user_DllExport AppliedVerbatimAnnotation & operator=(const AppliedVerbatimAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6555
eProsima_user_DllExport AppliedVerbatimAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6513
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & placement()
This function returns a reference to member placement.
Definition dds_xtypes_typeobject.hpp:6637
eProsima_user_DllExport AppliedVerbatimAnnotation(const AppliedVerbatimAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6528
eProsima_user_DllExport ~AppliedVerbatimAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6520
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:6667
eProsima_user_DllExport std::string & text()
This function returns a reference to member text.
Definition dds_xtypes_typeobject.hpp:6715
eProsima_user_DllExport bool operator==(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6586
eProsima_user_DllExport void text(std::string &&_text)
This function moves the value in member text.
Definition dds_xtypes_typeobject.hpp:6696
eProsima_user_DllExport const std::string & text() const
This function returns a constant reference to member text.
Definition dds_xtypes_typeobject.hpp:6706
This class represents the structure CommonAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12522
eProsima_user_DllExport const AliasMemberFlag & related_flags() const
This function returns a constant reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12636
eProsima_user_DllExport CommonAliasBody(const CommonAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12543
eProsima_user_DllExport CommonAliasBody & operator=(const CommonAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12567
eProsima_user_DllExport void related_flags(const AliasMemberFlag &_related_flags)
This function copies the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12616
eProsima_user_DllExport void related_type(TypeIdentifier &&_related_type)
This function moves the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12665
eProsima_user_DllExport const TypeIdentifier & related_type() const
This function returns a constant reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12675
eProsima_user_DllExport bool operator!=(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12606
eProsima_user_DllExport ~CommonAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12535
eProsima_user_DllExport void related_type(const TypeIdentifier &_related_type)
This function copies the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12655
eProsima_user_DllExport void related_flags(AliasMemberFlag &&_related_flags)
This function moves the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12626
eProsima_user_DllExport bool operator==(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12595
eProsima_user_DllExport AliasMemberFlag & related_flags()
This function returns a reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12645
eProsima_user_DllExport TypeIdentifier & related_type()
This function returns a reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12684
eProsima_user_DllExport CommonAliasBody(CommonAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12556
eProsima_user_DllExport CommonAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12528
This class represents the structure CommonAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11202
eProsima_user_DllExport AnnotationParameterFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11325
eProsima_user_DllExport void member_flags(const AnnotationParameterFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11296
eProsima_user_DllExport bool operator!=(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11286
eProsima_user_DllExport CommonAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11208
eProsima_user_DllExport const AnnotationParameterFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11316
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:11345
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:11364
eProsima_user_DllExport void member_flags(AnnotationParameterFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11306
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:11335
eProsima_user_DllExport ~CommonAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11215
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:11355
eProsima_user_DllExport CommonAnnotationParameter(CommonAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11236
eProsima_user_DllExport CommonAnnotationParameter(const CommonAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11223
eProsima_user_DllExport bool operator==(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11275
eProsima_user_DllExport CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11247
This class represents the structure CommonArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15307
eProsima_user_DllExport LBoundSeq & bound_seq()
This function returns a reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15423
eProsima_user_DllExport const LBoundSeq & bound_seq() const
This function returns a constant reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15414
eProsima_user_DllExport bool operator!=(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15384
eProsima_user_DllExport CommonArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15313
eProsima_user_DllExport CommonArrayHeader(const CommonArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15328
eProsima_user_DllExport void bound_seq(const LBoundSeq &_bound_seq)
This function copies the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15394
eProsima_user_DllExport void bound_seq(LBoundSeq &&_bound_seq)
This function moves the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15404
eProsima_user_DllExport CommonArrayHeader & operator=(const CommonArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15349
eProsima_user_DllExport ~CommonArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15320
eProsima_user_DllExport CommonArrayHeader(CommonArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15339
eProsima_user_DllExport bool operator==(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15374
This class represents the structure CommonBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19296
eProsima_user_DllExport uint8_t & bitcount()
This function returns a reference to member bitcount.
Definition dds_xtypes_typeobject.hpp:19491
eProsima_user_DllExport const BitsetMemberFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:19453
eProsima_user_DllExport bool operator!=(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19394
eProsima_user_DllExport BitsetMemberFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:19462
eProsima_user_DllExport bool operator==(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19381
eProsima_user_DllExport void bitcount(uint8_t _bitcount)
This function sets a value in member bitcount.
Definition dds_xtypes_typeobject.hpp:19472
eProsima_user_DllExport CommonBitfield(CommonBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19334
eProsima_user_DllExport CommonBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19302
eProsima_user_DllExport uint8_t bitcount() const
This function returns the value of member bitcount.
Definition dds_xtypes_typeobject.hpp:19482
eProsima_user_DllExport void holder_type(TypeKind _holder_type)
This function sets a value in member holder_type.
Definition dds_xtypes_typeobject.hpp:19501
eProsima_user_DllExport void flags(BitsetMemberFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:19443
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:19423
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:19414
eProsima_user_DllExport ~CommonBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19309
eProsima_user_DllExport void flags(const BitsetMemberFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:19433
eProsima_user_DllExport CommonBitfield(const CommonBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19317
eProsima_user_DllExport TypeKind & holder_type()
This function returns a reference to member holder_type.
Definition dds_xtypes_typeobject.hpp:19520
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:19404
eProsima_user_DllExport TypeKind holder_type() const
This function returns the value of member holder_type.
Definition dds_xtypes_typeobject.hpp:19511
eProsima_user_DllExport CommonBitfield & operator=(const CommonBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19347
This class represents the structure CommonBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18181
eProsima_user_DllExport void flags(BitflagFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:18314
eProsima_user_DllExport CommonBitflag & operator=(const CommonBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18226
eProsima_user_DllExport CommonBitflag(CommonBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18215
eProsima_user_DllExport bool operator==(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18254
eProsima_user_DllExport const BitflagFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:18324
eProsima_user_DllExport CommonBitflag(const CommonBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18202
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:18294
eProsima_user_DllExport bool operator!=(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18265
eProsima_user_DllExport CommonBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18187
eProsima_user_DllExport void flags(const BitflagFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:18304
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:18285
eProsima_user_DllExport BitflagFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:18333
eProsima_user_DllExport ~CommonBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18194
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:18275
This class represents the structure CommonBitmaskHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18715
eProsima_user_DllExport CommonBitmaskHeader(const CommonBitmaskHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18736
eProsima_user_DllExport ~CommonBitmaskHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18728
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:18802
eProsima_user_DllExport CommonBitmaskHeader(CommonBitmaskHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18747
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:18812
eProsima_user_DllExport CommonBitmaskHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18721
eProsima_user_DllExport bool operator==(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18782
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:18821
eProsima_user_DllExport bool operator!=(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18792
eProsima_user_DllExport CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18757
This class represents the structure CommonCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13924
eProsima_user_DllExport const TypeIdentifier & type() const
This function returns a constant reference to member type.
Definition dds_xtypes_typeobject.hpp:14077
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14047
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14028
eProsima_user_DllExport CommonCollectionElement & operator=(const CommonCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13969
eProsima_user_DllExport bool operator!=(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14008
eProsima_user_DllExport CommonCollectionElement(const CommonCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13945
eProsima_user_DllExport void type(const TypeIdentifier &_type)
This function copies the value in member type.
Definition dds_xtypes_typeobject.hpp:14057
eProsima_user_DllExport TypeIdentifier & type()
This function returns a reference to member type.
Definition dds_xtypes_typeobject.hpp:14086
eProsima_user_DllExport CommonCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13930
eProsima_user_DllExport ~CommonCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13937
eProsima_user_DllExport bool operator==(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13997
eProsima_user_DllExport void type(TypeIdentifier &&_type)
This function moves the value in member type.
Definition dds_xtypes_typeobject.hpp:14067
eProsima_user_DllExport CommonCollectionElement(CommonCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13958
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14018
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14038
This class represents the structure CommonCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14417
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:14523
eProsima_user_DllExport bool operator!=(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14494
eProsima_user_DllExport CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14459
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:14504
eProsima_user_DllExport CommonCollectionHeader(CommonCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14449
eProsima_user_DllExport CommonCollectionHeader(const CommonCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14438
eProsima_user_DllExport ~CommonCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14430
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:14514
eProsima_user_DllExport CommonCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14423
eProsima_user_DllExport bool operator==(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14484
This class represents the structure CommonDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9848
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10001
eProsima_user_DllExport void member_flags(UnionDiscriminatorFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9952
eProsima_user_DllExport void member_flags(const UnionDiscriminatorFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9942
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10010
eProsima_user_DllExport bool operator==(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9921
eProsima_user_DllExport const UnionDiscriminatorFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9962
eProsima_user_DllExport ~CommonDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9861
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9991
eProsima_user_DllExport UnionDiscriminatorFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9971
eProsima_user_DllExport bool operator!=(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9932
eProsima_user_DllExport CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9893
eProsima_user_DllExport CommonDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9854
eProsima_user_DllExport CommonDiscriminatorMember(CommonDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9882
eProsima_user_DllExport CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9869
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9981
This class represents the structure CommonEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17291
eProsima_user_DllExport bool operator==(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17358
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:17378
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:17388
eProsima_user_DllExport CommonEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17297
eProsima_user_DllExport bool operator!=(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17368
eProsima_user_DllExport CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17312
eProsima_user_DllExport CommonEnumeratedHeader(CommonEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17323
eProsima_user_DllExport ~CommonEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17304
eProsima_user_DllExport CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17333
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:17397
This class represents the structure CommonEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16757
eProsima_user_DllExport void flags(EnumeratedLiteralFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:16890
eProsima_user_DllExport const EnumeratedLiteralFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:16900
eProsima_user_DllExport int32_t & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:16870
eProsima_user_DllExport void value(int32_t _value)
This function sets a value in member value.
Definition dds_xtypes_typeobject.hpp:16851
eProsima_user_DllExport CommonEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16763
eProsima_user_DllExport ~CommonEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16770
eProsima_user_DllExport void flags(const EnumeratedLiteralFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:16880
eProsima_user_DllExport EnumeratedLiteralFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:16909
eProsima_user_DllExport int32_t value() const
This function returns the value of member value.
Definition dds_xtypes_typeobject.hpp:16861
eProsima_user_DllExport bool operator==(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16830
eProsima_user_DllExport CommonEnumeratedLiteral(CommonEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16791
eProsima_user_DllExport CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16778
eProsima_user_DllExport CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16802
eProsima_user_DllExport bool operator!=(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16841
This class represents the structure CommonStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7008
eProsima_user_DllExport void member_flags(const StructMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7138
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:7187
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:7206
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:7177
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:7197
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:7128
eProsima_user_DllExport CommonStructMember & operator=(const CommonStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7056
eProsima_user_DllExport bool operator==(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7087
eProsima_user_DllExport ~CommonStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7021
eProsima_user_DllExport CommonStructMember(CommonStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7044
eProsima_user_DllExport CommonStructMember(const CommonStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7029
eProsima_user_DllExport StructMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7167
eProsima_user_DllExport CommonStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7014
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:7109
eProsima_user_DllExport const StructMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7158
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:7119
eProsima_user_DllExport bool operator!=(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7099
eProsima_user_DllExport void member_flags(StructMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7148
This class represents the structure CommonUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9220
eProsima_user_DllExport CommonUnionMember & operator=(const CommonUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9271
eProsima_user_DllExport CommonUnionMember(CommonUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9258
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9416
eProsima_user_DllExport void member_flags(const UnionMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9357
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9425
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9406
eProsima_user_DllExport bool operator==(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9305
eProsima_user_DllExport UnionMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9386
eProsima_user_DllExport const UnionMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9377
eProsima_user_DllExport void member_flags(UnionMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9367
eProsima_user_DllExport const UnionCaseLabelSeq & label_seq() const
This function returns a constant reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9455
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:9347
eProsima_user_DllExport CommonUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9226
eProsima_user_DllExport UnionCaseLabelSeq & label_seq()
This function returns a reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9464
eProsima_user_DllExport void label_seq(const UnionCaseLabelSeq &_label_seq)
This function copies the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9435
eProsima_user_DllExport ~CommonUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9233
eProsima_user_DllExport bool operator!=(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9318
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:9328
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:9338
eProsima_user_DllExport void label_seq(UnionCaseLabelSeq &&_label_seq)
This function moves the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9445
eProsima_user_DllExport CommonUnionMember(const CommonUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9241
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9396
This class represents the structure CompleteAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12702
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:12823
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:12910
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12871
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:12803
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:12852
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:12813
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:12901
eProsima_user_DllExport CompleteAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12708
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:12862
eProsima_user_DllExport CompleteAliasBody(CompleteAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12738
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:12881
eProsima_user_DllExport ~CompleteAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12715
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:12832
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:12842
eProsima_user_DllExport CompleteAliasBody & operator=(const CompleteAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12750
eProsima_user_DllExport CompleteAliasBody(const CompleteAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12723
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:12891
eProsima_user_DllExport bool operator==(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12781
eProsima_user_DllExport bool operator!=(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12793
This class represents the structure CompleteAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13062
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:13159
eProsima_user_DllExport bool operator!=(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13139
eProsima_user_DllExport CompleteAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13068
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:13178
eProsima_user_DllExport ~CompleteAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13075
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:13149
eProsima_user_DllExport CompleteAliasHeader(const CompleteAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13083
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:13169
eProsima_user_DllExport bool operator==(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13129
eProsima_user_DllExport CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13104
eProsima_user_DllExport CompleteAliasHeader(CompleteAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13094
This class represents the structure CompleteAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13290
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13411
eProsima_user_DllExport void header(const CompleteAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13430
eProsima_user_DllExport CompleteAliasType(CompleteAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13326
eProsima_user_DllExport void header(CompleteAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13440
eProsima_user_DllExport const CompleteAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13489
eProsima_user_DllExport bool operator!=(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13381
eProsima_user_DllExport bool operator==(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13369
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13391
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13401
eProsima_user_DllExport CompleteAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13296
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13420
eProsima_user_DllExport CompleteAliasType(const CompleteAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13311
eProsima_user_DllExport ~CompleteAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13303
eProsima_user_DllExport CompleteAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13498
eProsima_user_DllExport const CompleteAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13450
eProsima_user_DllExport CompleteAliasType & operator=(const CompleteAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13338
eProsima_user_DllExport void body(CompleteAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13479
eProsima_user_DllExport void body(const CompleteAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13469
eProsima_user_DllExport CompleteAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13459
This class represents the structure CompleteAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11840
eProsima_user_DllExport CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11882
eProsima_user_DllExport CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11861
eProsima_user_DllExport bool operator!=(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11917
eProsima_user_DllExport void annotation_name(QualifiedTypeName &&_annotation_name)
This function moves the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:11937
eProsima_user_DllExport const QualifiedTypeName & annotation_name() const
This function returns a constant reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:11947
eProsima_user_DllExport void annotation_name(const QualifiedTypeName &_annotation_name)
This function copies the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:11927
eProsima_user_DllExport bool operator==(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11907
eProsima_user_DllExport QualifiedTypeName & annotation_name()
This function returns a reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:11956
eProsima_user_DllExport CompleteAnnotationHeader(CompleteAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11872
eProsima_user_DllExport CompleteAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11846
eProsima_user_DllExport ~CompleteAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11853
This class represents the structure CompleteAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11382
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11503
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11483
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:11522
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:11551
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11581
eProsima_user_DllExport CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11403
eProsima_user_DllExport bool operator==(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11461
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11493
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:11542
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11512
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11590
eProsima_user_DllExport CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11430
eProsima_user_DllExport CompleteAnnotationParameter(CompleteAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11418
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11571
eProsima_user_DllExport bool operator!=(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11473
eProsima_user_DllExport ~CompleteAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11395
eProsima_user_DllExport CompleteAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11388
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11561
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:11532
This class represents the structure CompleteAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12068
eProsima_user_DllExport bool operator==(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12147
eProsima_user_DllExport ~CompleteAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12081
eProsima_user_DllExport const CompleteAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12228
eProsima_user_DllExport CompleteAnnotationType(const CompleteAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12089
eProsima_user_DllExport CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12116
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12198
eProsima_user_DllExport const CompleteAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12267
eProsima_user_DllExport CompleteAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12074
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12179
eProsima_user_DllExport void header(const CompleteAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12208
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12169
eProsima_user_DllExport void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12247
eProsima_user_DllExport CompleteAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12237
eProsima_user_DllExport void header(CompleteAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12218
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12189
eProsima_user_DllExport CompleteAnnotationType(CompleteAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12104
eProsima_user_DllExport CompleteAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12276
eProsima_user_DllExport void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12257
eProsima_user_DllExport bool operator!=(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12159
This class represents the structure CompleteArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15440
eProsima_user_DllExport bool operator==(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15513
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:15583
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:15602
eProsima_user_DllExport CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15485
eProsima_user_DllExport ~CompleteArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15453
eProsima_user_DllExport CompleteArrayHeader(CompleteArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15474
eProsima_user_DllExport CompleteArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15446
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:15573
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15544
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15563
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15554
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:15593
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15534
eProsima_user_DllExport bool operator!=(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15524
eProsima_user_DllExport CompleteArrayHeader(const CompleteArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15461
This class represents the structure CompleteArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15753
eProsima_user_DllExport CompleteArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15922
eProsima_user_DllExport CompleteArrayType & operator=(const CompleteArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15801
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15864
eProsima_user_DllExport const CompleteArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15913
eProsima_user_DllExport bool operator==(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15832
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15942
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15883
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15932
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15854
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15952
eProsima_user_DllExport CompleteArrayType(const CompleteArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15774
eProsima_user_DllExport CompleteArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15759
eProsima_user_DllExport CompleteArrayType(CompleteArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15789
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15874
eProsima_user_DllExport ~CompleteArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15766
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15961
eProsima_user_DllExport void header(const CompleteArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15893
eProsima_user_DllExport bool operator!=(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15844
eProsima_user_DllExport void header(CompleteArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15903
This class represents the structure CompleteBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19540
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19663
eProsima_user_DllExport CompleteBitfield(const CompleteBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19561
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:19673
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19654
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:19683
eProsima_user_DllExport CompleteBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19546
eProsima_user_DllExport bool operator==(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19613
eProsima_user_DllExport CompleteBitfield & operator=(const CompleteBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19585
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19634
eProsima_user_DllExport CompleteBitfield(CompleteBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19574
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:19702
eProsima_user_DllExport bool operator!=(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19624
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19644
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:19693
eProsima_user_DllExport ~CompleteBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19553
This class represents the structure CompleteBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18351
eProsima_user_DllExport CompleteBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18357
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18474
eProsima_user_DllExport ~CompleteBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18364
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18484
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18445
eProsima_user_DllExport bool operator==(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18424
eProsima_user_DllExport CompleteBitflag(CompleteBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18385
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18455
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18494
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18465
eProsima_user_DllExport bool operator!=(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18435
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18513
eProsima_user_DllExport CompleteBitflag(const CompleteBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18372
eProsima_user_DllExport CompleteBitflag & operator=(const CompleteBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18396
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18504
This class represents the structure CompleteBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18842
eProsima_user_DllExport CompleteBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19050
eProsima_user_DllExport void header(CompleteBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:18992
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18963
eProsima_user_DllExport const CompleteBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19002
eProsima_user_DllExport ~CompleteBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18855
eProsima_user_DllExport void flag_seq(const CompleteBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19021
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18943
eProsima_user_DllExport bool operator!=(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18933
eProsima_user_DllExport CompleteBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19011
eProsima_user_DllExport CompleteBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18848
eProsima_user_DllExport void flag_seq(CompleteBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19031
eProsima_user_DllExport const CompleteBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19041
eProsima_user_DllExport bool operator==(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18921
eProsima_user_DllExport void header(const CompleteBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:18982
eProsima_user_DllExport CompleteBitmaskType(CompleteBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18878
eProsima_user_DllExport CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18890
eProsima_user_DllExport CompleteBitmaskType(const CompleteBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18863
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18972
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18953
This class represents the structure CompleteBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19904
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:20001
eProsima_user_DllExport CompleteBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19910
eProsima_user_DllExport CompleteBitsetHeader(const CompleteBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19925
eProsima_user_DllExport bool operator!=(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19981
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:20020
eProsima_user_DllExport CompleteBitsetHeader(CompleteBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19936
eProsima_user_DllExport CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19946
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:19991
eProsima_user_DllExport ~CompleteBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19917
eProsima_user_DllExport bool operator==(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19971
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:20011
This class represents the structure CompleteBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20132
eProsima_user_DllExport bool operator==(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20211
eProsima_user_DllExport bool operator!=(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20223
eProsima_user_DllExport void field_seq(const CompleteBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20311
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20233
eProsima_user_DllExport CompleteBitsetType(const CompleteBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20153
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20253
eProsima_user_DllExport const CompleteBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20331
eProsima_user_DllExport void field_seq(CompleteBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20321
eProsima_user_DllExport const CompleteBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20292
eProsima_user_DllExport void header(CompleteBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20282
eProsima_user_DllExport CompleteBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20138
eProsima_user_DllExport CompleteBitsetType(CompleteBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20168
eProsima_user_DllExport ~CompleteBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20145
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20243
eProsima_user_DllExport CompleteBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20301
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20262
eProsima_user_DllExport CompleteBitsetType & operator=(const CompleteBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20180
eProsima_user_DllExport CompleteBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20340
eProsima_user_DllExport void header(const CompleteBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20272
This class represents the structure CompleteCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14104
eProsima_user_DllExport CompleteElementDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14266
eProsima_user_DllExport bool operator!=(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14188
eProsima_user_DllExport ~CompleteCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14117
eProsima_user_DllExport CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14149
eProsima_user_DllExport void detail(const CompleteElementDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14237
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14198
eProsima_user_DllExport CompleteCollectionElement(const CompleteCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14125
eProsima_user_DllExport void detail(CompleteElementDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14247
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14218
eProsima_user_DllExport const CompleteElementDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14257
eProsima_user_DllExport CompleteCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14110
eProsima_user_DllExport CompleteCollectionElement(CompleteCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14138
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14227
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14208
eProsima_user_DllExport bool operator==(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14177
This class represents the structure CompleteCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14540
eProsima_user_DllExport bool operator==(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14613
eProsima_user_DllExport CompleteCollectionHeader(const CompleteCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14561
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14663
eProsima_user_DllExport ~CompleteCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14553
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14654
eProsima_user_DllExport CompleteCollectionHeader(CompleteCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14574
eProsima_user_DllExport CompleteCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14546
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14634
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14644
eProsima_user_DllExport void detail(eprosima::fastcdr::optional< CompleteTypeDetail > &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14683
eProsima_user_DllExport const eprosima::fastcdr::optional< CompleteTypeDetail > & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14693
eProsima_user_DllExport CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14585
eProsima_user_DllExport void detail(const eprosima::fastcdr::optional< CompleteTypeDetail > &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14673
eProsima_user_DllExport bool operator!=(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14624
eProsima_user_DllExport eprosima::fastcdr::optional< CompleteTypeDetail > & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14702
This class represents the structure CompleteDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10028
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10197
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:10168
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:10236
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10158
eProsima_user_DllExport ~CompleteDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10041
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:10188
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:10227
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10149
eProsima_user_DllExport bool operator==(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10107
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:10178
eProsima_user_DllExport CompleteDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10034
eProsima_user_DllExport CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10064
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:10207
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:10217
eProsima_user_DllExport CompleteDiscriminatorMember(const CompleteDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10049
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10139
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10129
eProsima_user_DllExport CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10076
eProsima_user_DllExport bool operator!=(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10119
This class represents the structure CompleteElementDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13744
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:13906
eProsima_user_DllExport CompleteElementDetail(CompleteElementDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13778
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13867
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:13848
eProsima_user_DllExport bool operator!=(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13828
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:13897
eProsima_user_DllExport CompleteElementDetail(const CompleteElementDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13765
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:13858
eProsima_user_DllExport CompleteElementDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13750
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:13877
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:13838
eProsima_user_DllExport ~CompleteElementDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13757
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:13887
eProsima_user_DllExport CompleteElementDetail & operator=(const CompleteElementDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13789
eProsima_user_DllExport bool operator==(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13817
This class represents the structure CompleteEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17414
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17557
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17576
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17537
eProsima_user_DllExport ~CompleteEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17427
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17547
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17528
eProsima_user_DllExport CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17459
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17508
eProsima_user_DllExport CompleteEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17420
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17567
eProsima_user_DllExport bool operator==(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17487
eProsima_user_DllExport CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17448
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17498
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17518
eProsima_user_DllExport CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17435
This class represents the structure CompleteEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16927
eProsima_user_DllExport CompleteEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16933
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17041
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17060
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17011
eProsima_user_DllExport CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16972
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17070
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17050
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17089
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17021
eProsima_user_DllExport ~CompleteEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16940
eProsima_user_DllExport CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16961
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17080
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17031
eProsima_user_DllExport CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16948
eProsima_user_DllExport bool operator==(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17000
This class represents the structure CompleteEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17727
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17857
eProsima_user_DllExport const CompleteEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:17887
eProsima_user_DllExport void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17906
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17828
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17838
eProsima_user_DllExport const CompleteEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:17926
eProsima_user_DllExport CompleteEnumeratedType(CompleteEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17763
eProsima_user_DllExport ~CompleteEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17740
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17818
eProsima_user_DllExport bool operator==(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17806
eProsima_user_DllExport CompleteEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:17935
eProsima_user_DllExport CompleteEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:17896
eProsima_user_DllExport void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17916
eProsima_user_DllExport CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17775
eProsima_user_DllExport CompleteEnumeratedType(const CompleteEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17748
eProsima_user_DllExport void header(CompleteEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:17877
eProsima_user_DllExport CompleteEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17733
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17848
eProsima_user_DllExport void header(const CompleteEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:17867
This class represents the structure CompleteExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20586
eProsima_user_DllExport CompleteExtendedType & operator=(const CompleteExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20627
eProsima_user_DllExport CompleteExtendedType(const CompleteExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20607
eProsima_user_DllExport CompleteExtendedType(CompleteExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20617
eProsima_user_DllExport CompleteExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20592
eProsima_user_DllExport bool operator!=(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20664
eProsima_user_DllExport ~CompleteExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20599
eProsima_user_DllExport bool operator==(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20653
This class represents the structure CompleteMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16207
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16325
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16442
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16364
eProsima_user_DllExport void key(CompleteCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16403
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16374
eProsima_user_DllExport const CompleteCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16413
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16354
eProsima_user_DllExport CompleteMapType & operator=(const CompleteMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16258
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16344
eProsima_user_DllExport CompleteMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16213
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16383
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16432
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16315
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16452
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16335
eProsima_user_DllExport CompleteCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16422
eProsima_user_DllExport CompleteMapType(const CompleteMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16228
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16461
eProsima_user_DllExport void key(const CompleteCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16393
eProsima_user_DllExport bool operator!=(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16305
eProsima_user_DllExport ~CompleteMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16220
eProsima_user_DllExport bool operator==(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16292
eProsima_user_DllExport CompleteMapType(CompleteMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16245
This class represents the structure CompleteMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7225
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:7433
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:7326
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7394
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:7375
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:7355
eProsima_user_DllExport bool operator!=(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7316
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:7424
eProsima_user_DllExport CompleteMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7231
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:7346
eProsima_user_DllExport CompleteMemberDetail(const CompleteMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7246
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:7385
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:7404
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:7365
eProsima_user_DllExport CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7273
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:7414
eProsima_user_DllExport bool operator==(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7304
eProsima_user_DllExport ~CompleteMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7238
eProsima_user_DllExport CompleteMemberDetail(CompleteMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7261
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:7336
This class represents the structure CompleteSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14853
eProsima_user_DllExport CompleteSequenceType & operator=(const CompleteSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14901
eProsima_user_DllExport CompleteSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14859
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:14964
eProsima_user_DllExport bool operator==(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14932
eProsima_user_DllExport CompleteSequenceType(CompleteSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14889
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15042
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15003
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15013
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:14993
eProsima_user_DllExport bool operator!=(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14944
eProsima_user_DllExport ~CompleteSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14866
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:14983
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15022
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15032
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:14954
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15052
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:14974
eProsima_user_DllExport CompleteSequenceType(const CompleteSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14874
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15061
This class represents the structure CompleteStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8404
eProsima_user_DllExport ~CompleteStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8417
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8547
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8566
eProsima_user_DllExport CompleteStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8410
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8508
eProsima_user_DllExport CompleteStructHeader(CompleteStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8438
eProsima_user_DllExport bool operator!=(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8488
eProsima_user_DllExport bool operator==(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8477
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8537
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8498
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8527
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8557
eProsima_user_DllExport CompleteStructHeader(const CompleteStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8425
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8518
eProsima_user_DllExport CompleteStructHeader & operator=(const CompleteStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8449
This class represents the structure CompleteStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7585
eProsima_user_DllExport CompleteStructMember(CompleteStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7619
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7718
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7679
eProsima_user_DllExport CompleteStructMember(const CompleteStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7606
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7728
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7708
eProsima_user_DllExport ~CompleteStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7598
eProsima_user_DllExport bool operator!=(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7669
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7747
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7699
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7689
eProsima_user_DllExport CompleteStructMember & operator=(const CompleteStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7630
eProsima_user_DllExport CompleteStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7591
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7738
eProsima_user_DllExport bool operator==(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7658
This class represents the structure CompleteStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8764
eProsima_user_DllExport const CompleteStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:8924
eProsima_user_DllExport CompleteStructType(CompleteStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8800
eProsima_user_DllExport bool operator!=(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8855
eProsima_user_DllExport CompleteStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:8933
eProsima_user_DllExport ~CompleteStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8777
eProsima_user_DllExport CompleteStructType(const CompleteStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8785
eProsima_user_DllExport void header(const CompleteStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:8904
eProsima_user_DllExport CompleteStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8770
eProsima_user_DllExport CompleteStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:8972
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8875
eProsima_user_DllExport void member_seq(CompleteStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:8953
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8865
eProsima_user_DllExport CompleteStructType & operator=(const CompleteStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8812
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8885
eProsima_user_DllExport void header(CompleteStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:8914
eProsima_user_DllExport void member_seq(const CompleteStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:8943
eProsima_user_DllExport const CompleteStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:8963
eProsima_user_DllExport bool operator==(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8843
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8894
This class represents the structure CompleteTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8177
eProsima_user_DllExport CompleteTypeDetail(const CompleteTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8198
eProsima_user_DllExport const QualifiedTypeName & type_name() const
This function returns a constant reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8376
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8307
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:8278
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:8346
eProsima_user_DllExport bool operator==(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8256
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:8298
eProsima_user_DllExport CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8225
eProsima_user_DllExport QualifiedTypeName & type_name()
This function returns a reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8385
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:8337
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:8288
eProsima_user_DllExport void type_name(const QualifiedTypeName &_type_name)
This function copies the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8356
eProsima_user_DllExport CompleteTypeDetail(CompleteTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8213
eProsima_user_DllExport void type_name(QualifiedTypeName &&_type_name)
This function moves the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8366
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:8317
eProsima_user_DllExport bool operator!=(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8268
eProsima_user_DllExport ~CompleteTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8190
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:8327
eProsima_user_DllExport CompleteTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8183
This class represents the union CompleteTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20681
CompleteStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:21912
eProsima_user_DllExport const CompleteBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21625
eProsima_user_DllExport const CompleteMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21519
eProsima_user_DllExport CompleteBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21375
CompleteExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:21920
CompleteAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:21910
eProsima_user_DllExport void array_type(CompleteArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21454
eProsima_user_DllExport void bitset_type(CompleteBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21348
eProsima_user_DllExport const CompleteBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21360
eProsima_user_DllExport CompleteAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21216
eProsima_user_DllExport CompleteAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21163
eProsima_user_DllExport void map_type(const CompleteMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21496
eProsima_user_DllExport void annotation_type(CompleteAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21189
CompleteBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:21914
eProsima_user_DllExport void struct_type(const CompleteStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21231
eProsima_user_DllExport void bitmask_type(CompleteBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21613
eProsima_user_DllExport const CompleteAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21201
eProsima_user_DllExport void struct_type(CompleteStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21242
eProsima_user_DllExport void bitmask_type(const CompleteBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21602
eProsima_user_DllExport const CompleteStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21254
eProsima_user_DllExport CompleteTypeObject(const CompleteTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20707
CompleteAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:21911
eProsima_user_DllExport CompleteBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21640
eProsima_user_DllExport CompleteStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21269
eProsima_user_DllExport CompleteTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20687
eProsima_user_DllExport CompleteTypeObject(CompleteTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20765
eProsima_user_DllExport void sequence_type(const CompleteSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21390
eProsima_user_DllExport bool operator==(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20943
eProsima_user_DllExport void bitset_type(const CompleteBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21337
eProsima_user_DllExport void union_type(CompleteUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21295
eProsima_user_DllExport CompleteUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21322
eProsima_user_DllExport ~CompleteTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20695
eProsima_user_DllExport bool operator!=(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:21007
eProsima_user_DllExport CompleteTypeObject & operator=(const CompleteTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20823
eProsima_user_DllExport void alias_type(const CompleteAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21125
eProsima_user_DllExport const CompleteSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21413
eProsima_user_DllExport void union_type(const CompleteUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21284
CompleteArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:21916
eProsima_user_DllExport CompleteEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21587
eProsima_user_DllExport const CompleteEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21572
CompleteEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:21918
eProsima_user_DllExport void sequence_type(CompleteSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21401
eProsima_user_DllExport CompleteExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21693
eProsima_user_DllExport void enumerated_type(CompleteEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21560
eProsima_user_DllExport const CompleteArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21466
eProsima_user_DllExport void alias_type(CompleteAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21136
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:21018
eProsima_user_DllExport CompleteArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21481
eProsima_user_DllExport void extended_type(CompleteExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21666
CompleteBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:21919
CompleteMapType m_map_type
Definition dds_xtypes_typeobject.hpp:21917
eProsima_user_DllExport void map_type(CompleteMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21507
eProsima_user_DllExport CompleteSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21428
CompleteSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:21915
eProsima_user_DllExport const CompleteUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21307
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:21116
eProsima_user_DllExport void extended_type(const CompleteExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21655
eProsima_user_DllExport const CompleteExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21678
eProsima_user_DllExport CompleteMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21534
eProsima_user_DllExport void enumerated_type(const CompleteEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21549
eProsima_user_DllExport void annotation_type(const CompleteAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21178
CompleteUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:21913
eProsima_user_DllExport void array_type(const CompleteArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21443
eProsima_user_DllExport const CompleteAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21148
This class represents the structure CompleteUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10388
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10485
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10504
eProsima_user_DllExport ~CompleteUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10401
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10475
eProsima_user_DllExport bool operator!=(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10465
eProsima_user_DllExport CompleteUnionHeader(const CompleteUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10409
eProsima_user_DllExport CompleteUnionHeader(CompleteUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10420
eProsima_user_DllExport bool operator==(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10455
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10495
eProsima_user_DllExport CompleteUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10394
eProsima_user_DllExport CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10430
This class represents the structure CompleteUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9484
eProsima_user_DllExport CompleteUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9490
eProsima_user_DllExport CompleteUnionMember(const CompleteUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9505
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9578
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9617
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9588
eProsima_user_DllExport ~CompleteUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9497
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9607
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9627
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9598
eProsima_user_DllExport CompleteUnionMember & operator=(const CompleteUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9529
eProsima_user_DllExport bool operator!=(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9568
eProsima_user_DllExport bool operator==(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9557
eProsima_user_DllExport CompleteUnionMember(CompleteUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9518
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9646
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9637
This class represents the structure CompleteUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10654
eProsima_user_DllExport bool operator==(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10739
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10772
eProsima_user_DllExport CompleteUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10908
eProsima_user_DllExport CompleteUnionType(CompleteUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10692
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10762
eProsima_user_DllExport CompleteUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10660
eProsima_user_DllExport const CompleteUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10899
eProsima_user_DllExport ~CompleteUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10667
eProsima_user_DllExport void discriminator(CompleteDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10850
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10791
eProsima_user_DllExport CompleteUnionType & operator=(const CompleteUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10705
eProsima_user_DllExport void member_seq(CompleteUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10889
eProsima_user_DllExport bool operator!=(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10752
eProsima_user_DllExport const CompleteDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10860
eProsima_user_DllExport void discriminator(const CompleteDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10840
eProsima_user_DllExport CompleteDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10869
eProsima_user_DllExport const CompleteUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:10821
eProsima_user_DllExport void header(CompleteUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:10811
eProsima_user_DllExport void header(const CompleteUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:10801
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10782
eProsima_user_DllExport CompleteUnionType(const CompleteUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10675
eProsima_user_DllExport void member_seq(const CompleteUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10879
eProsima_user_DllExport CompleteUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:10830
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:4181
eProsima_user_DllExport ExtendedAnnotationParameterValue(ExtendedAnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4212
eProsima_user_DllExport bool operator==(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4248
eProsima_user_DllExport ExtendedAnnotationParameterValue & operator=(const ExtendedAnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4222
eProsima_user_DllExport bool operator!=(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4259
eProsima_user_DllExport ExtendedAnnotationParameterValue(const ExtendedAnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4202
eProsima_user_DllExport ExtendedAnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4187
eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4194
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:12929
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:13036
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:13016
eProsima_user_DllExport MinimalAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12935
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:13026
eProsima_user_DllExport MinimalAliasBody(MinimalAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12961
eProsima_user_DllExport bool operator==(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12996
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:13045
eProsima_user_DllExport ~MinimalAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12942
eProsima_user_DllExport MinimalAliasBody(const MinimalAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12950
eProsima_user_DllExport MinimalAliasBody & operator=(const MinimalAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12971
eProsima_user_DllExport bool operator!=(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13006
This class represents the structure MinimalAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13195
eProsima_user_DllExport MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13236
eProsima_user_DllExport MinimalAliasHeader(const MinimalAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13216
eProsima_user_DllExport MinimalAliasHeader(MinimalAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13226
eProsima_user_DllExport ~MinimalAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13208
eProsima_user_DllExport bool operator==(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13262
eProsima_user_DllExport bool operator!=(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13273
eProsima_user_DllExport MinimalAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13201
This class represents the structure MinimalAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13517
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13638
eProsima_user_DllExport MinimalAliasType & operator=(const MinimalAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13565
eProsima_user_DllExport MinimalAliasType(const MinimalAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13538
eProsima_user_DllExport void body(const MinimalAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13696
eProsima_user_DllExport MinimalAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13523
eProsima_user_DllExport void header(const MinimalAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13657
eProsima_user_DllExport void header(MinimalAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13667
eProsima_user_DllExport MinimalAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13725
eProsima_user_DllExport bool operator==(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13596
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13618
eProsima_user_DllExport bool operator!=(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13608
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13628
eProsima_user_DllExport ~MinimalAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13530
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13647
eProsima_user_DllExport void body(MinimalAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13706
eProsima_user_DllExport const MinimalAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13716
eProsima_user_DllExport const MinimalAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13677
eProsima_user_DllExport MinimalAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13686
eProsima_user_DllExport MinimalAliasType(MinimalAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13553
This class represents the structure MinimalAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11973
eProsima_user_DllExport MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12014
eProsima_user_DllExport MinimalAnnotationHeader(MinimalAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12004
eProsima_user_DllExport MinimalAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11979
eProsima_user_DllExport bool operator!=(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12051
eProsima_user_DllExport ~MinimalAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11986
eProsima_user_DllExport MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11994
eProsima_user_DllExport bool operator==(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12040
This class represents the structure MinimalAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11611
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11732
eProsima_user_DllExport bool operator!=(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11702
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11712
eProsima_user_DllExport bool operator==(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11690
eProsima_user_DllExport MinimalAnnotationParameter(MinimalAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11647
eProsima_user_DllExport MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11659
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11810
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11751
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11722
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11741
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11819
eProsima_user_DllExport ~MinimalAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11624
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11800
eProsima_user_DllExport MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11632
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11790
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11771
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11761
eProsima_user_DllExport MinimalAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11617
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11780
This class represents the structure MinimalAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12295
eProsima_user_DllExport MinimalAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12464
eProsima_user_DllExport void header(MinimalAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12445
eProsima_user_DllExport MinimalAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12503
eProsima_user_DllExport ~MinimalAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12308
eProsima_user_DllExport MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12343
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12425
eProsima_user_DllExport MinimalAnnotationType(MinimalAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12331
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12406
eProsima_user_DllExport const MinimalAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12455
eProsima_user_DllExport bool operator==(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12374
eProsima_user_DllExport MinimalAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12301
eProsima_user_DllExport MinimalAnnotationType(const MinimalAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12316
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12396
eProsima_user_DllExport void header(const MinimalAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12435
eProsima_user_DllExport void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12484
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12416
eProsima_user_DllExport void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12474
eProsima_user_DllExport bool operator!=(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12386
eProsima_user_DllExport const MinimalAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12494
This class represents the structure MinimalArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15620
eProsima_user_DllExport MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15662
eProsima_user_DllExport ~MinimalArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15633
eProsima_user_DllExport bool operator==(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15687
eProsima_user_DllExport MinimalArrayHeader(MinimalArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15652
eProsima_user_DllExport MinimalArrayHeader(const MinimalArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15641
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15717
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15736
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15727
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15707
eProsima_user_DllExport MinimalArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15626
eProsima_user_DllExport bool operator!=(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15697
This class represents the structure MinimalArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15980
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16091
eProsima_user_DllExport void header(MinimalArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16130
eProsima_user_DllExport bool operator==(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16059
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16169
eProsima_user_DllExport void header(const MinimalArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16120
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16179
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16110
eProsima_user_DllExport const MinimalArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16140
eProsima_user_DllExport ~MinimalArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15993
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16081
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16159
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16101
eProsima_user_DllExport MinimalArrayType(MinimalArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16016
eProsima_user_DllExport bool operator!=(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16071
eProsima_user_DllExport MinimalArrayType & operator=(const MinimalArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16028
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16188
eProsima_user_DllExport MinimalArrayType(const MinimalArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16001
eProsima_user_DllExport MinimalArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15986
eProsima_user_DllExport MinimalArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16149
This class represents the structure MinimalBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19722
eProsima_user_DllExport MinimalBitfield(const MinimalBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19743
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19845
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19836
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19855
eProsima_user_DllExport bool operator!=(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19806
eProsima_user_DllExport MinimalBitfield & operator=(const MinimalBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19767
eProsima_user_DllExport MinimalBitfield(MinimalBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19756
eProsima_user_DllExport ~MinimalBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19735
eProsima_user_DllExport bool operator==(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19795
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19816
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19826
eProsima_user_DllExport MinimalBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19728
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19875
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19865
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19884
This class represents the structure MinimalBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18533
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18666
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18656
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18686
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18695
eProsima_user_DllExport MinimalBitflag(MinimalBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18567
eProsima_user_DllExport ~MinimalBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18546
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18627
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18637
eProsima_user_DllExport bool operator!=(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18617
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18647
eProsima_user_DllExport MinimalBitflag(const MinimalBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18554
eProsima_user_DllExport bool operator==(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18606
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18676
eProsima_user_DllExport MinimalBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18539
eProsima_user_DllExport MinimalBitflag & operator=(const MinimalBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18578
This class represents the structure MinimalBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19069
eProsima_user_DllExport void header(const MinimalBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:19209
eProsima_user_DllExport ~MinimalBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19082
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19190
eProsima_user_DllExport MinimalBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19238
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19170
eProsima_user_DllExport MinimalBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19075
eProsima_user_DllExport const MinimalBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19268
eProsima_user_DllExport MinimalBitmaskType(MinimalBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19105
eProsima_user_DllExport void flag_seq(MinimalBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19258
eProsima_user_DllExport bool operator==(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19148
eProsima_user_DllExport MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19117
eProsima_user_DllExport void header(MinimalBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:19219
eProsima_user_DllExport void flag_seq(const MinimalBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19248
eProsima_user_DllExport MinimalBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19277
eProsima_user_DllExport bool operator!=(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19160
eProsima_user_DllExport MinimalBitmaskType(const MinimalBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19090
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19199
eProsima_user_DllExport const MinimalBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19229
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19180
This class represents the structure MinimalBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20037
eProsima_user_DllExport MinimalBitsetHeader(MinimalBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20068
eProsima_user_DllExport MinimalBitsetHeader(const MinimalBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20058
eProsima_user_DllExport ~MinimalBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20050
eProsima_user_DllExport bool operator!=(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20115
eProsima_user_DllExport MinimalBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20043
eProsima_user_DllExport MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20078
eProsima_user_DllExport bool operator==(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20104
This class represents the structure MinimalBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20359
eProsima_user_DllExport MinimalBitsetType(MinimalBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20395
eProsima_user_DllExport ~MinimalBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20372
eProsima_user_DllExport void field_seq(const MinimalBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20538
eProsima_user_DllExport void header(const MinimalBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20499
eProsima_user_DllExport void field_seq(MinimalBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20548
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20460
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20480
eProsima_user_DllExport bool operator==(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20438
eProsima_user_DllExport MinimalBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20365
eProsima_user_DllExport MinimalBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20567
eProsima_user_DllExport const MinimalBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20558
eProsima_user_DllExport MinimalBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20528
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20470
eProsima_user_DllExport const MinimalBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20519
eProsima_user_DllExport MinimalBitsetType & operator=(const MinimalBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20407
eProsima_user_DllExport MinimalBitsetType(const MinimalBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20380
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20489
eProsima_user_DllExport bool operator!=(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20450
eProsima_user_DllExport void header(MinimalBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20509
This class represents the structure MinimalCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14284
eProsima_user_DllExport MinimalCollectionElement(MinimalCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14316
eProsima_user_DllExport MinimalCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14290
eProsima_user_DllExport bool operator!=(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14361
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14371
eProsima_user_DllExport MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14326
eProsima_user_DllExport MinimalCollectionElement(const MinimalCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14305
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14391
eProsima_user_DllExport bool operator==(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14351
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14400
eProsima_user_DllExport ~MinimalCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14297
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14381
This class represents the structure MinimalCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14720
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14836
eProsima_user_DllExport MinimalCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14726
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14827
eProsima_user_DllExport bool operator==(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14787
eProsima_user_DllExport bool operator!=(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14797
eProsima_user_DllExport ~MinimalCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14733
eProsima_user_DllExport MinimalCollectionHeader(MinimalCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14752
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14807
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14817
eProsima_user_DllExport MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14762
eProsima_user_DllExport MinimalCollectionHeader(const MinimalCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14741
This class represents the structure MinimalDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10255
eProsima_user_DllExport MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10276
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10371
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10362
eProsima_user_DllExport MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10297
eProsima_user_DllExport bool operator==(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10322
eProsima_user_DllExport ~MinimalDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10268
eProsima_user_DllExport MinimalDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10261
eProsima_user_DllExport bool operator!=(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10332
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10352
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10342
eProsima_user_DllExport MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10287
This class represents the structure MinimalEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17594
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17710
eProsima_user_DllExport MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17626
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17701
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17671
eProsima_user_DllExport ~MinimalEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17607
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17681
eProsima_user_DllExport MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17615
eProsima_user_DllExport MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17636
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17691
eProsima_user_DllExport bool operator==(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17661
eProsima_user_DllExport MinimalEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17600
This class represents the structure MinimalEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17109
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17242
eProsima_user_DllExport MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17154
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17262
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17271
eProsima_user_DllExport bool operator==(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17182
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17223
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17232
eProsima_user_DllExport ~MinimalEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17122
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17252
eProsima_user_DllExport MinimalEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17115
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17193
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17203
eProsima_user_DllExport MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17130
eProsima_user_DllExport MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17143
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17213
This class represents the structure MinimalEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17954
eProsima_user_DllExport MinimalEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:18123
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18084
eProsima_user_DllExport MinimalEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18162
eProsima_user_DllExport MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18002
eProsima_user_DllExport MinimalEnumeratedType(MinimalEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17990
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18055
eProsima_user_DllExport bool operator==(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18033
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18045
eProsima_user_DllExport void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18143
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18065
eProsima_user_DllExport void header(MinimalEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:18104
eProsima_user_DllExport void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18133
eProsima_user_DllExport ~MinimalEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17967
eProsima_user_DllExport void header(const MinimalEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:18094
eProsima_user_DllExport const MinimalEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18153
eProsima_user_DllExport MinimalEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17960
eProsima_user_DllExport const MinimalEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:18114
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18075
eProsima_user_DllExport MinimalEnumeratedType(const MinimalEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17975
This class represents the structure MinimalExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:21932
eProsima_user_DllExport MinimalExtendedType & operator=(const MinimalExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:21973
eProsima_user_DllExport bool operator==(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:21999
eProsima_user_DllExport bool operator!=(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22010
eProsima_user_DllExport MinimalExtendedType(MinimalExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:21963
eProsima_user_DllExport MinimalExtendedType(const MinimalExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:21953
eProsima_user_DllExport MinimalExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:21938
eProsima_user_DllExport ~MinimalExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:21945
This class represents the structure MinimalMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16481
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16599
eProsima_user_DllExport bool operator!=(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16579
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16657
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16716
eProsima_user_DllExport void key(const MinimalCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16667
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16726
eProsima_user_DllExport MinimalCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16696
eProsima_user_DllExport ~MinimalMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16494
eProsima_user_DllExport MinimalMapType(MinimalMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16519
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16648
eProsima_user_DllExport void key(MinimalCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16677
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16618
eProsima_user_DllExport MinimalMapType(const MinimalMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16502
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16589
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16706
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16628
eProsima_user_DllExport MinimalMapType & operator=(const MinimalMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16532
eProsima_user_DllExport MinimalMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16487
eProsima_user_DllExport const MinimalCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16687
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16609
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16735
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16638
eProsima_user_DllExport bool operator==(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16566
This class represents the structure MinimalMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7452
eProsima_user_DllExport bool operator==(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7519
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7539
eProsima_user_DllExport ~MinimalMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7465
eProsima_user_DllExport MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7494
eProsima_user_DllExport bool operator!=(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7529
eProsima_user_DllExport MinimalMemberDetail(const MinimalMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7473
eProsima_user_DllExport MinimalMemberDetail(MinimalMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7484
eProsima_user_DllExport MinimalMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7458
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7559
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7549
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7568
This class represents the structure MinimalSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15080
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15191
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15249
eProsima_user_DllExport MinimalSequenceType(const MinimalSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15101
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15269
eProsima_user_DllExport bool operator!=(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15171
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15279
eProsima_user_DllExport MinimalSequenceType(MinimalSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15116
eProsima_user_DllExport MinimalSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15086
eProsima_user_DllExport bool operator==(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15159
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15240
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15210
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15181
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15259
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15220
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15201
eProsima_user_DllExport MinimalSequenceType & operator=(const MinimalSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15128
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15288
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15230
eProsima_user_DllExport ~MinimalSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15093
This class represents the structure MinimalStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8584
eProsima_user_DllExport bool operator==(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8657
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8746
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8717
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8688
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8737
eProsima_user_DllExport ~MinimalStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8597
eProsima_user_DllExport bool operator!=(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8668
eProsima_user_DllExport MinimalStructHeader & operator=(const MinimalStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8629
eProsima_user_DllExport MinimalStructHeader(const MinimalStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8605
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8678
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8707
eProsima_user_DllExport MinimalStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8590
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8698
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8727
eProsima_user_DllExport MinimalStructHeader(MinimalStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8618
This class represents the structure MinimalStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7767
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7900
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7920
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7929
eProsima_user_DllExport MinimalStructMember(MinimalStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7801
eProsima_user_DllExport MinimalStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7773
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7861
eProsima_user_DllExport MinimalStructMember & operator=(const MinimalStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7812
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7890
eProsima_user_DllExport MinimalStructMember(const MinimalStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7788
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7910
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7881
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7871
eProsima_user_DllExport ~MinimalStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7780
eProsima_user_DllExport bool operator==(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7840
eProsima_user_DllExport bool operator!=(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7851
This class represents the structure MinimalStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8991
eProsima_user_DllExport void header(const MinimalStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:9131
eProsima_user_DllExport const MinimalStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9190
eProsima_user_DllExport void header(MinimalStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:9141
eProsima_user_DllExport MinimalStructType & operator=(const MinimalStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9039
eProsima_user_DllExport MinimalStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8997
eProsima_user_DllExport MinimalStructType(const MinimalStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9012
eProsima_user_DllExport MinimalStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9199
eProsima_user_DllExport ~MinimalStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9004
eProsima_user_DllExport void member_seq(MinimalStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9180
eProsima_user_DllExport bool operator!=(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9082
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9102
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9092
eProsima_user_DllExport bool operator==(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9070
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9112
eProsima_user_DllExport const MinimalStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:9151
eProsima_user_DllExport MinimalStructType(MinimalStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9027
eProsima_user_DllExport void member_seq(const MinimalStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9170
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9121
eProsima_user_DllExport MinimalStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:9160
This class represents the structure MinimalTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8082
eProsima_user_DllExport bool operator!=(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8160
eProsima_user_DllExport MinimalTypeDetail(const MinimalTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8103
eProsima_user_DllExport MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8123
eProsima_user_DllExport MinimalTypeDetail(MinimalTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8113
eProsima_user_DllExport MinimalTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8088
eProsima_user_DllExport bool operator==(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8149
eProsima_user_DllExport ~MinimalTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8095
This class represents the union MinimalTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:22027
eProsima_user_DllExport MinimalStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22615
eProsima_user_DllExport void union_type(const MinimalUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22630
eProsima_user_DllExport const MinimalEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22918
eProsima_user_DllExport MinimalTypeObject & operator=(const MinimalTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:22169
eProsima_user_DllExport void bitmask_type(MinimalBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22959
MinimalExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:23266
eProsima_user_DllExport bool operator==(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22289
MinimalEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:23264
eProsima_user_DllExport void bitset_type(MinimalBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22694
eProsima_user_DllExport void bitmask_type(const MinimalBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22948
MinimalUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:23259
eProsima_user_DllExport void alias_type(const MinimalAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22471
MinimalAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:23256
eProsima_user_DllExport MinimalExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23039
eProsima_user_DllExport MinimalBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22721
eProsima_user_DllExport void enumerated_type(MinimalEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22906
eProsima_user_DllExport MinimalSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22774
eProsima_user_DllExport const MinimalExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23024
eProsima_user_DllExport void extended_type(MinimalExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23012
eProsima_user_DllExport void map_type(const MinimalMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22842
eProsima_user_DllExport const MinimalArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22812
eProsima_user_DllExport void array_type(MinimalArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22800
eProsima_user_DllExport MinimalAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22509
eProsima_user_DllExport const MinimalUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22653
eProsima_user_DllExport const MinimalStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22600
eProsima_user_DllExport MinimalTypeObject(const MinimalTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:22053
eProsima_user_DllExport MinimalTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:22033
eProsima_user_DllExport void sequence_type(MinimalSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22747
MinimalAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:23257
eProsima_user_DllExport MinimalEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22933
eProsima_user_DllExport void enumerated_type(const MinimalEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22895
eProsima_user_DllExport MinimalBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22986
eProsima_user_DllExport void extended_type(const MinimalExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23001
eProsima_user_DllExport const MinimalBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:22971
eProsima_user_DllExport MinimalAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22562
MinimalArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:23262
eProsima_user_DllExport void sequence_type(const MinimalSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22736
eProsima_user_DllExport const MinimalAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22494
eProsima_user_DllExport void annotation_type(MinimalAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22535
eProsima_user_DllExport void annotation_type(const MinimalAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22524
eProsima_user_DllExport void union_type(MinimalUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22641
eProsima_user_DllExport const MinimalSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22759
eProsima_user_DllExport void alias_type(MinimalAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22482
eProsima_user_DllExport void struct_type(MinimalStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22588
eProsima_user_DllExport MinimalUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22668
eProsima_user_DllExport void map_type(MinimalMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22853
eProsima_user_DllExport const MinimalAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22547
eProsima_user_DllExport void struct_type(const MinimalStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22577
MinimalMapType m_map_type
Definition dds_xtypes_typeobject.hpp:23263
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:22364
eProsima_user_DllExport MinimalTypeObject(MinimalTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:22111
eProsima_user_DllExport const MinimalBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22706
eProsima_user_DllExport MinimalArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22827
MinimalBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:23265
eProsima_user_DllExport void bitset_type(const MinimalBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22683
eProsima_user_DllExport MinimalMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:22880
eProsima_user_DllExport const MinimalMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:22865
eProsima_user_DllExport ~MinimalTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:22041
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:22462
MinimalStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:23258
eProsima_user_DllExport void array_type(const MinimalArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22789
MinimalBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:23260
MinimalSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:23261
eProsima_user_DllExport bool operator!=(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22353
This class represents the structure MinimalUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10521
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10637
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10608
eProsima_user_DllExport MinimalUnionHeader(MinimalUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10553
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10628
eProsima_user_DllExport MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10563
eProsima_user_DllExport bool operator!=(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10598
eProsima_user_DllExport MinimalUnionHeader(const MinimalUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10542
eProsima_user_DllExport MinimalUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10527
eProsima_user_DllExport ~MinimalUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10534
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10618
eProsima_user_DllExport bool operator==(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10588
This class represents the structure MinimalUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9666
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9799
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9819
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9828
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9760
eProsima_user_DllExport MinimalUnionMember & operator=(const MinimalUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9711
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9770
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9789
eProsima_user_DllExport bool operator!=(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9750
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9780
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9809
eProsima_user_DllExport ~MinimalUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9679
eProsima_user_DllExport MinimalUnionMember(const MinimalUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9687
eProsima_user_DllExport bool operator==(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9739
eProsima_user_DllExport MinimalUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9672
eProsima_user_DllExport MinimalUnionMember(MinimalUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9700
This class represents the structure MinimalUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10928
eProsima_user_DllExport void discriminator(MinimalDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11124
eProsima_user_DllExport MinimalDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11143
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11046
eProsima_user_DllExport MinimalUnionType(const MinimalUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10949
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11036
eProsima_user_DllExport void header(const MinimalUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:11075
eProsima_user_DllExport MinimalUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10934
eProsima_user_DllExport const MinimalDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11134
eProsima_user_DllExport void discriminator(const MinimalDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11114
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11065
eProsima_user_DllExport MinimalUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11182
eProsima_user_DllExport ~MinimalUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10941
eProsima_user_DllExport MinimalUnionType(MinimalUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10966
eProsima_user_DllExport bool operator!=(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11026
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11056
eProsima_user_DllExport void header(MinimalUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:11085
eProsima_user_DllExport void member_seq(MinimalUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11163
eProsima_user_DllExport MinimalUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:11104
eProsima_user_DllExport void member_seq(const MinimalUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11153
eProsima_user_DllExport const MinimalUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11173
eProsima_user_DllExport MinimalUnionType & operator=(const MinimalUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10979
eProsima_user_DllExport const MinimalUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:11095
eProsima_user_DllExport bool operator==(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11013
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:24015
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24129
eProsima_user_DllExport bool operator==(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24088
eProsima_user_DllExport bool operator!=(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24099
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24138
eProsima_user_DllExport TypeIdentfierWithSize(TypeIdentfierWithSize &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24049
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24119
eProsima_user_DllExport uint32_t typeobject_serialized_size() const
This function returns the value of member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24158
eProsima_user_DllExport ~TypeIdentfierWithSize()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24028
eProsima_user_DllExport uint32_t & typeobject_serialized_size()
This function returns a reference to member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24167
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:24148
eProsima_user_DllExport TypeIdentfierWithSize & operator=(const TypeIdentfierWithSize &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24060
eProsima_user_DllExport TypeIdentfierWithSize(const TypeIdentfierWithSize &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24036
eProsima_user_DllExport TypeIdentfierWithSize()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24021
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24109
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:3425
eProsima_user_DllExport TypeIdentifier(TypeIdentifier &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2895
Dummy m_no_value
Definition dds_xtypes_typeobject.hpp:4152
eProsima_user_DllExport void equivalence_hash(EquivalenceHash &&_equivalence_hash)
This function moves the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3837
eProsima_user_DllExport const EquivalenceHash & equivalence_hash() const
This function returns a constant reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3849
eProsima_user_DllExport ~TypeIdentifier()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2821
eProsima_user_DllExport PlainMapSTypeDefn & map_sdefn()
This function returns a reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3705
eProsima_user_DllExport void map_ldefn(const PlainMapLTypeDefn &_map_ldefn)
This function copies the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3720
StronglyConnectedComponentId m_sc_component_id
Definition dds_xtypes_typeobject.hpp:4161
eProsima_user_DllExport const PlainMapSTypeDefn & map_sdefn() const
This function returns a constant reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3690
eProsima_user_DllExport StringLTypeDefn & string_ldefn()
This function returns a reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3440
eProsima_user_DllExport void seq_sdefn(PlainSequenceSElemDefn &&_seq_sdefn)
This function moves the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3466
eProsima_user_DllExport void string_sdefn(StringSTypeDefn &&_string_sdefn)
This function moves the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3360
eProsima_user_DllExport void array_ldefn(PlainArrayLElemDefn &&_array_ldefn)
This function moves the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3625
eProsima_user_DllExport bool operator==(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3085
eProsima_user_DllExport const PlainMapLTypeDefn & map_ldefn() const
This function returns a constant reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3743
eProsima_user_DllExport TypeIdentifier & operator=(const TypeIdentifier &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2957
eProsima_user_DllExport void map_ldefn(PlainMapLTypeDefn &&_map_ldefn)
This function moves the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3731
eProsima_user_DllExport void string_ldefn(StringLTypeDefn &&_string_ldefn)
This function moves the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3413
eProsima_user_DllExport void string_ldefn(const StringLTypeDefn &_string_ldefn)
This function copies the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3402
PlainArrayLElemDefn m_array_ldefn
Definition dds_xtypes_typeobject.hpp:4158
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:3773
eProsima_user_DllExport TypeIdentifier(const TypeIdentifier &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2833
eProsima_user_DllExport ExtendedTypeDefn & extended_defn()
This function returns a reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3917
eProsima_user_DllExport void seq_ldefn(const PlainSequenceLElemDefn &_seq_ldefn)
This function copies the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3508
eProsima_user_DllExport void no_value(Dummy &&_no_value)
This function moves the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3307
eProsima_user_DllExport const StringSTypeDefn & string_sdefn() const
This function returns a constant reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3372
StringSTypeDefn m_string_sdefn
Definition dds_xtypes_typeobject.hpp:4153
PlainSequenceSElemDefn m_seq_sdefn
Definition dds_xtypes_typeobject.hpp:4155
eProsima_user_DllExport const PlainArrayLElemDefn & array_ldefn() const
This function returns a constant reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3637
eProsima_user_DllExport const Dummy & no_value() const
This function returns a constant reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3319
ExtendedTypeDefn m_extended_defn
Definition dds_xtypes_typeobject.hpp:4163
eProsima_user_DllExport const PlainSequenceLElemDefn & seq_ldefn() const
This function returns a constant reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3531
eProsima_user_DllExport void array_sdefn(const PlainArraySElemDefn &_array_sdefn)
This function copies the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3561
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:3153
eProsima_user_DllExport PlainSequenceLElemDefn & seq_ldefn()
This function returns a reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3546
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:3784
eProsima_user_DllExport const ExtendedTypeDefn & extended_defn() const
This function returns a constant reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3902
eProsima_user_DllExport const PlainSequenceSElemDefn & seq_sdefn() const
This function returns a constant reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3478
eProsima_user_DllExport void map_sdefn(PlainMapSTypeDefn &&_map_sdefn)
This function moves the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3678
PlainSequenceLElemDefn m_seq_ldefn
Definition dds_xtypes_typeobject.hpp:4156
eProsima_user_DllExport void array_ldefn(const PlainArrayLElemDefn &_array_ldefn)
This function copies the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3614
eProsima_user_DllExport EquivalenceHash & equivalence_hash()
This function returns a reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3864
eProsima_user_DllExport StringSTypeDefn & string_sdefn()
This function returns a reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3387
eProsima_user_DllExport const PlainArraySElemDefn & array_sdefn() const
This function returns a constant reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3584
eProsima_user_DllExport PlainArrayLElemDefn & array_ldefn()
This function returns a reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3652
StringLTypeDefn m_string_ldefn
Definition dds_xtypes_typeobject.hpp:4154
eProsima_user_DllExport void extended_defn(ExtendedTypeDefn &&_extended_defn)
This function moves the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3890
PlainArraySElemDefn m_array_sdefn
Definition dds_xtypes_typeobject.hpp:4157
eProsima_user_DllExport void no_value(const Dummy &_no_value)
This function copies the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3296
PlainMapSTypeDefn m_map_sdefn
Definition dds_xtypes_typeobject.hpp:4159
PlainMapLTypeDefn m_map_ldefn
Definition dds_xtypes_typeobject.hpp:4160
eProsima_user_DllExport void seq_sdefn(const PlainSequenceSElemDefn &_seq_sdefn)
This function copies the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3455
eProsima_user_DllExport void string_sdefn(const StringSTypeDefn &_string_sdefn)
This function copies the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3349
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:3164
EquivalenceHash m_equivalence_hash
Definition dds_xtypes_typeobject.hpp:4162
eProsima_user_DllExport void seq_ldefn(PlainSequenceLElemDefn &&_seq_ldefn)
This function moves the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3519
eProsima_user_DllExport PlainMapLTypeDefn & map_ldefn()
This function returns a reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3758
eProsima_user_DllExport void map_sdefn(const PlainMapSTypeDefn &_map_sdefn)
This function copies the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3667
eProsima_user_DllExport void array_sdefn(PlainArraySElemDefn &&_array_sdefn)
This function moves the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3572
eProsima_user_DllExport void extended_defn(const ExtendedTypeDefn &_extended_defn)
This function copies the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3879
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:3796
eProsima_user_DllExport PlainSequenceSElemDefn & seq_sdefn()
This function returns a reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3493
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:3287
eProsima_user_DllExport StronglyConnectedComponentId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3811
eProsima_user_DllExport Dummy & no_value()
This function returns a reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3334
eProsima_user_DllExport PlainArraySElemDefn & array_sdefn()
This function returns a reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3599
eProsima_user_DllExport void equivalence_hash(const EquivalenceHash &_equivalence_hash)
This function copies the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3826
This class represents the structure TypeIdentifierPair defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23833
eProsima_user_DllExport TypeIdentifierPair(TypeIdentifierPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23867
eProsima_user_DllExport TypeIdentifierPair(const TypeIdentifierPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23854
eProsima_user_DllExport void type_identifier1(const TypeIdentifier &_type_identifier1)
This function copies the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23927
eProsima_user_DllExport TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23878
eProsima_user_DllExport void type_identifier2(TypeIdentifier &&_type_identifier2)
This function moves the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23976
eProsima_user_DllExport TypeIdentifier & type_identifier1()
This function returns a reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23956
eProsima_user_DllExport void type_identifier1(TypeIdentifier &&_type_identifier1)
This function moves the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23937
eProsima_user_DllExport const TypeIdentifier & type_identifier2() const
This function returns a constant reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23986
eProsima_user_DllExport bool operator!=(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23917
eProsima_user_DllExport void type_identifier2(const TypeIdentifier &_type_identifier2)
This function copies the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23966
eProsima_user_DllExport TypeIdentifierPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23839
eProsima_user_DllExport const TypeIdentifier & type_identifier1() const
This function returns a constant reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23947
eProsima_user_DllExport ~TypeIdentifierPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23846
eProsima_user_DllExport TypeIdentifier & type_identifier2()
This function returns a reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:23995
eProsima_user_DllExport bool operator==(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23906
This class represents the structure TypeIdentifierTypeObjectPair defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23651
eProsima_user_DllExport const TypeObject & type_object() const
This function returns a constant reference to member type_object.
Definition dds_xtypes_typeobject.hpp:23804
eProsima_user_DllExport TypeIdentifierTypeObjectPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23657
eProsima_user_DllExport void type_identifier(TypeIdentifier &&_type_identifier)
This function moves the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23755
eProsima_user_DllExport void type_object(const TypeObject &_type_object)
This function copies the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23784
eProsima_user_DllExport TypeIdentifier & type_identifier()
This function returns a reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23774
eProsima_user_DllExport TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23696
eProsima_user_DllExport bool operator!=(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23735
eProsima_user_DllExport const TypeIdentifier & type_identifier() const
This function returns a constant reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23765
eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23664
eProsima_user_DllExport TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23672
eProsima_user_DllExport TypeObject & type_object()
This function returns a reference to member type_object.
Definition dds_xtypes_typeobject.hpp:23813
eProsima_user_DllExport bool operator==(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23724
eProsima_user_DllExport TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23685
eProsima_user_DllExport void type_identifier(const TypeIdentifier &_type_identifier)
This function copies the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23745
eProsima_user_DllExport void type_object(TypeObject &&_type_object)
This function moves the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23794
This class represents the structure TypeIdentifierWithDependencies defined by the user in the IDL fil...
Definition dds_xtypes_typeobject.hpp:24187
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:24327
eProsima_user_DllExport std::vector< TypeIdentfierWithSize > & dependent_typeids()
This function returns a reference to member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24385
eProsima_user_DllExport TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24208
eProsima_user_DllExport TypeIdentifierWithDependencies()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24193
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:24376
eProsima_user_DllExport TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24235
eProsima_user_DllExport int32_t dependent_typeid_count() const
This function returns the value of member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24337
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:24308
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:24356
eProsima_user_DllExport TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24223
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:24288
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:24366
eProsima_user_DllExport bool operator!=(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24278
eProsima_user_DllExport int32_t & dependent_typeid_count()
This function returns a reference to member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24346
eProsima_user_DllExport ~TypeIdentifierWithDependencies()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24200
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:24298
eProsima_user_DllExport bool operator==(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24266
eProsima_user_DllExport TypeIdentfierWithSize & typeid_with_size()
This function returns a reference to member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24317
This class represents the structure TypeInformation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24406
eProsima_user_DllExport TypeInformation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24412
eProsima_user_DllExport void minimal(TypeIdentifierWithDependencies &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24510
eProsima_user_DllExport bool operator!=(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24490
eProsima_user_DllExport const TypeIdentifierWithDependencies & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24520
eProsima_user_DllExport const TypeIdentifierWithDependencies & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:24559
eProsima_user_DllExport TypeIdentifierWithDependencies & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24529
eProsima_user_DllExport void complete(const TypeIdentifierWithDependencies &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:24539
eProsima_user_DllExport TypeInformation & operator=(const TypeInformation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24451
eProsima_user_DllExport TypeIdentifierWithDependencies & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:24568
eProsima_user_DllExport bool operator==(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24479
eProsima_user_DllExport void minimal(const TypeIdentifierWithDependencies &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24500
eProsima_user_DllExport ~TypeInformation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24419
eProsima_user_DllExport void complete(TypeIdentifierWithDependencies &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:24549
eProsima_user_DllExport TypeInformation(TypeInformation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24440
eProsima_user_DllExport TypeInformation(const TypeInformation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24427
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:23278
eProsima_user_DllExport const MinimalTypeObject & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23554
eProsima_user_DllExport void complete(CompleteTypeObject &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:23489
eProsima_user_DllExport bool operator!=(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23423
eProsima_user_DllExport TypeObject(const TypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23303
eProsima_user_DllExport CompleteTypeObject & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:23516
eProsima_user_DllExport ~TypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23291
eProsima_user_DllExport TypeObject(TypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23325
eProsima_user_DllExport void minimal(const MinimalTypeObject &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23531
eProsima_user_DllExport MinimalTypeObject & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23569
void _default()
Definition dds_xtypes_typeobject.hpp:23580
eProsima_user_DllExport TypeObject & operator=(const TypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23347
eProsima_user_DllExport const CompleteTypeObject & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:23501
MinimalTypeObject m_minimal
Definition dds_xtypes_typeobject.hpp:23635
eProsima_user_DllExport void minimal(MinimalTypeObject &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23542
CompleteTypeObject m_complete
Definition dds_xtypes_typeobject.hpp:23634
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:23434
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:23469
eProsima_user_DllExport TypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23284
eProsima_user_DllExport void complete(const CompleteTypeObject &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:23478
eProsima_user_DllExport bool operator==(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23395
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:19897
uint32_t MemberId
Definition dds_xtypes_typeobject.hpp:4172
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:23642
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition dds_xtypes_typeobject.hpp:24399
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:9659
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition dds_xtypes_typeobject.hpp:6500
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition dds_xtypes_typeobject.hpp:24008
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:17102
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:7942
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:17284
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:9841
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:24180
std::vector< AppliedAnnotationParameter > AppliedAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:6318
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:4170
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:11833
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:18708
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:19715
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:4175
const uint8_t TK_CHAR16
Definition dds_xtypes_typeobject.hpp:94
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18835
std::vector< int32_t > UnionCaseLabelSeq
Definition dds_xtypes_typeobject.hpp:9213
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:23826
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:16750
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:4174
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:24581
const uint8_t TI_PLAIN_ARRAY_SMALL
Definition dds_xtypes_typeobject.hpp:115
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition dds_xtypes_typeobject.hpp:18526
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:11604
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:18833
TypeObjectSeq StronglyConnectedComponent
Definition dds_xtypes_typeobject.hpp:23644
const uint8_t TI_STRING16_LARGE
Definition dds_xtypes_typeobject.hpp:112
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition dds_xtypes_typeobject.hpp:7760
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.