Fast DDS  Version 3.1.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 (x.selected_member_ == selected_member_)
254 {
255 if (0x0FFFFFFFu != selected_member_)
256 {
257 if (x.m__d == m__d)
258 {
259 switch (selected_member_)
260 {
261 case 0x00000001:
262 ret_value = (x.m_hash == m_hash);
263 break;
264
265 }
266 }
267 }
268 else
269 {
270 ret_value = true;
271 }
272 }
273
274 return ret_value;
275 }
276
281 eProsima_user_DllExport bool operator !=(
282 const TypeObjectHashId& x) const
283 {
284 return !(*this == x);
285 }
286
292 eProsima_user_DllExport void _d(
293 uint8_t __d)
294 {
295 bool valid_discriminator = false;
296
297 switch (__d)
298 {
299 case EK_COMPLETE:
300 case EK_MINIMAL:
301 if (0x00000001 == selected_member_)
302 {
303 valid_discriminator = true;
304 }
305 break;
306
307 }
308
309 if (!valid_discriminator)
310 {
311 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
312 }
313
314 m__d = __d;
315 }
316
321 eProsima_user_DllExport uint8_t _d() const
322 {
323 return m__d;
324 }
325
330 eProsima_user_DllExport void hash(
331 const EquivalenceHash& _hash)
332 {
333 hash_() = _hash;
334 m__d = EK_COMPLETE;
335 }
336
341 eProsima_user_DllExport void hash(
342 EquivalenceHash&& _hash)
343 {
344 hash_() = _hash;
345 m__d = EK_COMPLETE;
346 }
347
353 eProsima_user_DllExport const EquivalenceHash& hash() const
354 {
355 if (0x00000001 != selected_member_)
356 {
357 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
358 }
359
360 return m_hash;
361 }
362
368 eProsima_user_DllExport EquivalenceHash& hash()
369 {
370 if (0x00000001 != selected_member_)
371 {
372 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
373 }
374
375 return m_hash;
376 }
377
378
379 void _default()
380 {
381 if (member_destructor_)
382 {
383 member_destructor_();
384 }
385
386 selected_member_ = 0x0FFFFFFFu;
387 }
388
389
390private:
391
392 EquivalenceHash& hash_()
393 {
394 if (0x00000001 != selected_member_)
395 {
396 if (member_destructor_)
397 {
398 member_destructor_();
399 }
400
401 selected_member_ = 0x00000001;
402 member_destructor_ = [&]() {m_hash.~EquivalenceHash();};
403 new(&m_hash) EquivalenceHash();
404
405 }
406
407 return m_hash;
408 }
409
410
411 uint8_t m__d {127};
412
413 union
414 {
416 };
417
418 uint32_t selected_member_ {0x0FFFFFFFu};
419
420 std::function<void()> member_destructor_;
421};
426enum MemberFlagBits : uint16_t
427{
428 TRY_CONSTRUCT1 = 0x01ull << 0,
429 TRY_CONSTRUCT2 = 0x01ull << 1,
430 IS_EXTERNAL = 0x01ull << 2,
431 IS_OPTIONAL = 0x01ull << 3,
432 IS_MUST_UNDERSTAND = 0x01ull << 4,
433 IS_KEY = 0x01ull << 5,
434 IS_DEFAULT = 0x01ull << 6
436typedef uint16_t MemberFlag;
438
440
442
444
446
448
450
452
454
455const uint16_t MemberFlagMinimalMask = 0x003f;
460enum TypeFlagBits : uint16_t
461{
462 IS_FINAL = 0x01ull << 0,
463 IS_APPENDABLE = 0x01ull << 1,
464 IS_MUTABLE = 0x01ull << 2,
465 IS_NESTED = 0x01ull << 3,
466 IS_AUTOID_HASH = 0x01ull << 4
468typedef uint16_t TypeFlag;
470
472
474
476
478
480
482
484
485const uint16_t TypeFlagMinimalMask = 0x0007;
486class TypeIdentifier;
487
493{
494public:
495
499 eProsima_user_DllExport StringSTypeDefn()
500 {
501 }
502
506 eProsima_user_DllExport ~StringSTypeDefn()
507 {
508 }
509
514 eProsima_user_DllExport StringSTypeDefn(
515 const StringSTypeDefn& x)
516 {
517 m_bound = x.m_bound;
518
519 }
520
525 eProsima_user_DllExport StringSTypeDefn(
526 StringSTypeDefn&& x) noexcept
527 {
528 m_bound = x.m_bound;
529 }
530
535 eProsima_user_DllExport StringSTypeDefn& operator =(
536 const StringSTypeDefn& x)
537 {
538
539 m_bound = x.m_bound;
540
541 return *this;
542 }
543
548 eProsima_user_DllExport StringSTypeDefn& operator =(
549 StringSTypeDefn&& x) noexcept
550 {
551
552 m_bound = x.m_bound;
553 return *this;
554 }
555
560 eProsima_user_DllExport bool operator ==(
561 const StringSTypeDefn& x) const
562 {
563 return (m_bound == x.m_bound);
564 }
565
570 eProsima_user_DllExport bool operator !=(
571 const StringSTypeDefn& x) const
572 {
573 return !(*this == x);
574 }
575
580 eProsima_user_DllExport void bound(
581 SBound _bound)
582 {
583 m_bound = _bound;
584 }
585
590 eProsima_user_DllExport SBound bound() const
591 {
592 return m_bound;
593 }
594
599 eProsima_user_DllExport SBound& bound()
600 {
601 return m_bound;
602 }
603
604
605
606private:
607
608 SBound m_bound{0};
609
610};
616{
617public:
618
622 eProsima_user_DllExport StringLTypeDefn()
623 {
624 }
625
629 eProsima_user_DllExport ~StringLTypeDefn()
630 {
631 }
632
637 eProsima_user_DllExport StringLTypeDefn(
638 const StringLTypeDefn& x)
639 {
640 m_bound = x.m_bound;
641
642 }
643
648 eProsima_user_DllExport StringLTypeDefn(
649 StringLTypeDefn&& x) noexcept
650 {
651 m_bound = x.m_bound;
652 }
653
658 eProsima_user_DllExport StringLTypeDefn& operator =(
659 const StringLTypeDefn& x)
660 {
661
662 m_bound = x.m_bound;
663
664 return *this;
665 }
666
671 eProsima_user_DllExport StringLTypeDefn& operator =(
672 StringLTypeDefn&& x) noexcept
673 {
674
675 m_bound = x.m_bound;
676 return *this;
677 }
678
683 eProsima_user_DllExport bool operator ==(
684 const StringLTypeDefn& x) const
685 {
686 return (m_bound == x.m_bound);
687 }
688
693 eProsima_user_DllExport bool operator !=(
694 const StringLTypeDefn& x) const
695 {
696 return !(*this == x);
697 }
698
703 eProsima_user_DllExport void bound(
704 LBound _bound)
705 {
706 m_bound = _bound;
707 }
708
713 eProsima_user_DllExport LBound bound() const
714 {
715 return m_bound;
716 }
717
722 eProsima_user_DllExport LBound& bound()
723 {
724 return m_bound;
725 }
726
727
728
729private:
730
731 LBound m_bound{0};
732
733};
739{
740public:
741
745 eProsima_user_DllExport PlainCollectionHeader()
746 {
747 }
748
752 eProsima_user_DllExport ~PlainCollectionHeader()
753 {
754 }
755
760 eProsima_user_DllExport PlainCollectionHeader(
761 const PlainCollectionHeader& x)
762 {
763 m_equiv_kind = x.m_equiv_kind;
764
765 m_element_flags = x.m_element_flags;
766
767 }
768
773 eProsima_user_DllExport PlainCollectionHeader(
774 PlainCollectionHeader&& x) noexcept
775 {
776 m_equiv_kind = x.m_equiv_kind;
777 m_element_flags = std::move(x.m_element_flags);
778 }
779
784 eProsima_user_DllExport PlainCollectionHeader& operator =(
785 const PlainCollectionHeader& x)
786 {
787
788 m_equiv_kind = x.m_equiv_kind;
789
790 m_element_flags = x.m_element_flags;
791
792 return *this;
793 }
794
799 eProsima_user_DllExport PlainCollectionHeader& operator =(
800 PlainCollectionHeader&& x) noexcept
801 {
802
803 m_equiv_kind = x.m_equiv_kind;
804 m_element_flags = std::move(x.m_element_flags);
805 return *this;
806 }
807
812 eProsima_user_DllExport bool operator ==(
813 const PlainCollectionHeader& x) const
814 {
815 return (m_equiv_kind == x.m_equiv_kind &&
816 m_element_flags == x.m_element_flags);
817 }
818
823 eProsima_user_DllExport bool operator !=(
824 const PlainCollectionHeader& x) const
825 {
826 return !(*this == x);
827 }
828
833 eProsima_user_DllExport void equiv_kind(
834 EquivalenceKind _equiv_kind)
835 {
836 m_equiv_kind = _equiv_kind;
837 }
838
843 eProsima_user_DllExport EquivalenceKind equiv_kind() const
844 {
845 return m_equiv_kind;
846 }
847
852 eProsima_user_DllExport EquivalenceKind& equiv_kind()
853 {
854 return m_equiv_kind;
855 }
856
857
862 eProsima_user_DllExport void element_flags(
863 const CollectionElementFlag& _element_flags)
864 {
865 m_element_flags = _element_flags;
866 }
867
872 eProsima_user_DllExport void element_flags(
873 CollectionElementFlag&& _element_flags)
874 {
875 m_element_flags = std::move(_element_flags);
876 }
877
882 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
883 {
884 return m_element_flags;
885 }
886
891 eProsima_user_DllExport CollectionElementFlag& element_flags()
892 {
893 return m_element_flags;
894 }
895
896
897
898private:
899
900 EquivalenceKind m_equiv_kind{0};
901 CollectionElementFlag m_element_flags{0};
902
903};
909{
910public:
911
915 eProsima_user_DllExport PlainSequenceSElemDefn()
916 {
917 }
918
922 eProsima_user_DllExport ~PlainSequenceSElemDefn()
923 {
924 }
925
930 eProsima_user_DllExport PlainSequenceSElemDefn(
931 const PlainSequenceSElemDefn& x)
932 {
933 m_header = x.m_header;
934
935 m_bound = x.m_bound;
936
937 m_element_identifier = x.m_element_identifier;
938
939 }
940
945 eProsima_user_DllExport PlainSequenceSElemDefn(
946 PlainSequenceSElemDefn&& x) noexcept
947 {
948 m_header = std::move(x.m_header);
949 m_bound = x.m_bound;
950 m_element_identifier = std::move(x.m_element_identifier);
951 }
952
957 eProsima_user_DllExport PlainSequenceSElemDefn& operator =(
958 const PlainSequenceSElemDefn& x)
959 {
960
961 m_header = x.m_header;
962
963 m_bound = x.m_bound;
964
965 m_element_identifier = x.m_element_identifier;
966
967 return *this;
968 }
969
974 eProsima_user_DllExport PlainSequenceSElemDefn& operator =(
975 PlainSequenceSElemDefn&& x) noexcept
976 {
977
978 m_header = std::move(x.m_header);
979 m_bound = x.m_bound;
980 m_element_identifier = std::move(x.m_element_identifier);
981 return *this;
982 }
983
988 eProsima_user_DllExport bool operator ==(
989 const PlainSequenceSElemDefn& x) const
990 {
991 return (m_header == x.m_header &&
992 m_bound == x.m_bound &&
993 m_element_identifier == x.m_element_identifier);
994 }
995
1000 eProsima_user_DllExport bool operator !=(
1001 const PlainSequenceSElemDefn& x) const
1002 {
1003 return !(*this == x);
1004 }
1005
1010 eProsima_user_DllExport void header(
1011 const PlainCollectionHeader& _header)
1012 {
1013 m_header = _header;
1014 }
1015
1020 eProsima_user_DllExport void header(
1021 PlainCollectionHeader&& _header)
1022 {
1023 m_header = std::move(_header);
1024 }
1025
1030 eProsima_user_DllExport const PlainCollectionHeader& header() const
1031 {
1032 return m_header;
1033 }
1034
1039 eProsima_user_DllExport PlainCollectionHeader& header()
1040 {
1041 return m_header;
1042 }
1043
1044
1049 eProsima_user_DllExport void bound(
1050 SBound _bound)
1051 {
1052 m_bound = _bound;
1053 }
1054
1059 eProsima_user_DllExport SBound bound() const
1060 {
1061 return m_bound;
1062 }
1063
1068 eProsima_user_DllExport SBound& bound()
1069 {
1070 return m_bound;
1071 }
1072
1073
1078 eProsima_user_DllExport void element_identifier(
1079 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1080 {
1081 m_element_identifier = _element_identifier;
1082 }
1083
1088 eProsima_user_DllExport void element_identifier(
1089 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1090 {
1091 m_element_identifier = std::move(_element_identifier);
1092 }
1093
1098 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1099 {
1100 return m_element_identifier;
1101 }
1102
1107 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1108 {
1109 return m_element_identifier;
1110 }
1111
1112
1113
1114private:
1115
1116 PlainCollectionHeader m_header;
1117 SBound m_bound{0};
1118 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1119
1120};
1126{
1127public:
1128
1132 eProsima_user_DllExport PlainSequenceLElemDefn()
1133 {
1134 }
1135
1139 eProsima_user_DllExport ~PlainSequenceLElemDefn()
1140 {
1141 }
1142
1147 eProsima_user_DllExport PlainSequenceLElemDefn(
1148 const PlainSequenceLElemDefn& x)
1149 {
1150 m_header = x.m_header;
1151
1152 m_bound = x.m_bound;
1153
1154 m_element_identifier = x.m_element_identifier;
1155
1156 }
1157
1162 eProsima_user_DllExport PlainSequenceLElemDefn(
1163 PlainSequenceLElemDefn&& x) noexcept
1164 {
1165 m_header = std::move(x.m_header);
1166 m_bound = x.m_bound;
1167 m_element_identifier = std::move(x.m_element_identifier);
1168 }
1169
1174 eProsima_user_DllExport PlainSequenceLElemDefn& operator =(
1175 const PlainSequenceLElemDefn& x)
1176 {
1177
1178 m_header = x.m_header;
1179
1180 m_bound = x.m_bound;
1181
1182 m_element_identifier = x.m_element_identifier;
1183
1184 return *this;
1185 }
1186
1191 eProsima_user_DllExport PlainSequenceLElemDefn& operator =(
1192 PlainSequenceLElemDefn&& x) noexcept
1193 {
1194
1195 m_header = std::move(x.m_header);
1196 m_bound = x.m_bound;
1197 m_element_identifier = std::move(x.m_element_identifier);
1198 return *this;
1199 }
1200
1205 eProsima_user_DllExport bool operator ==(
1206 const PlainSequenceLElemDefn& x) const
1207 {
1208 return (m_header == x.m_header &&
1209 m_bound == x.m_bound &&
1210 m_element_identifier == x.m_element_identifier);
1211 }
1212
1217 eProsima_user_DllExport bool operator !=(
1218 const PlainSequenceLElemDefn& x) const
1219 {
1220 return !(*this == x);
1221 }
1222
1227 eProsima_user_DllExport void header(
1228 const PlainCollectionHeader& _header)
1229 {
1230 m_header = _header;
1231 }
1232
1237 eProsima_user_DllExport void header(
1238 PlainCollectionHeader&& _header)
1239 {
1240 m_header = std::move(_header);
1241 }
1242
1247 eProsima_user_DllExport const PlainCollectionHeader& header() const
1248 {
1249 return m_header;
1250 }
1251
1256 eProsima_user_DllExport PlainCollectionHeader& header()
1257 {
1258 return m_header;
1259 }
1260
1261
1266 eProsima_user_DllExport void bound(
1267 LBound _bound)
1268 {
1269 m_bound = _bound;
1270 }
1271
1276 eProsima_user_DllExport LBound bound() const
1277 {
1278 return m_bound;
1279 }
1280
1285 eProsima_user_DllExport LBound& bound()
1286 {
1287 return m_bound;
1288 }
1289
1290
1295 eProsima_user_DllExport void element_identifier(
1296 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1297 {
1298 m_element_identifier = _element_identifier;
1299 }
1300
1305 eProsima_user_DllExport void element_identifier(
1306 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1307 {
1308 m_element_identifier = std::move(_element_identifier);
1309 }
1310
1315 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1316 {
1317 return m_element_identifier;
1318 }
1319
1324 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1325 {
1326 return m_element_identifier;
1327 }
1328
1329
1330
1331private:
1332
1333 PlainCollectionHeader m_header;
1334 LBound m_bound{0};
1335 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1336
1337};
1343{
1344public:
1345
1349 eProsima_user_DllExport PlainArraySElemDefn()
1350 {
1351 }
1352
1356 eProsima_user_DllExport ~PlainArraySElemDefn()
1357 {
1358 }
1359
1364 eProsima_user_DllExport PlainArraySElemDefn(
1365 const PlainArraySElemDefn& x)
1366 {
1367 m_header = x.m_header;
1368
1369 m_array_bound_seq = x.m_array_bound_seq;
1370
1371 m_element_identifier = x.m_element_identifier;
1372
1373 }
1374
1379 eProsima_user_DllExport PlainArraySElemDefn(
1380 PlainArraySElemDefn&& x) noexcept
1381 {
1382 m_header = std::move(x.m_header);
1383 m_array_bound_seq = std::move(x.m_array_bound_seq);
1384 m_element_identifier = std::move(x.m_element_identifier);
1385 }
1386
1391 eProsima_user_DllExport PlainArraySElemDefn& operator =(
1392 const PlainArraySElemDefn& x)
1393 {
1394
1395 m_header = x.m_header;
1396
1397 m_array_bound_seq = x.m_array_bound_seq;
1398
1399 m_element_identifier = x.m_element_identifier;
1400
1401 return *this;
1402 }
1403
1408 eProsima_user_DllExport PlainArraySElemDefn& operator =(
1409 PlainArraySElemDefn&& x) noexcept
1410 {
1411
1412 m_header = std::move(x.m_header);
1413 m_array_bound_seq = std::move(x.m_array_bound_seq);
1414 m_element_identifier = std::move(x.m_element_identifier);
1415 return *this;
1416 }
1417
1422 eProsima_user_DllExport bool operator ==(
1423 const PlainArraySElemDefn& x) const
1424 {
1425 return (m_header == x.m_header &&
1426 m_array_bound_seq == x.m_array_bound_seq &&
1427 m_element_identifier == x.m_element_identifier);
1428 }
1429
1434 eProsima_user_DllExport bool operator !=(
1435 const PlainArraySElemDefn& x) const
1436 {
1437 return !(*this == x);
1438 }
1439
1444 eProsima_user_DllExport void header(
1445 const PlainCollectionHeader& _header)
1446 {
1447 m_header = _header;
1448 }
1449
1454 eProsima_user_DllExport void header(
1455 PlainCollectionHeader&& _header)
1456 {
1457 m_header = std::move(_header);
1458 }
1459
1464 eProsima_user_DllExport const PlainCollectionHeader& header() const
1465 {
1466 return m_header;
1467 }
1468
1473 eProsima_user_DllExport PlainCollectionHeader& header()
1474 {
1475 return m_header;
1476 }
1477
1478
1483 eProsima_user_DllExport void array_bound_seq(
1484 const SBoundSeq& _array_bound_seq)
1485 {
1486 m_array_bound_seq = _array_bound_seq;
1487 }
1488
1493 eProsima_user_DllExport void array_bound_seq(
1494 SBoundSeq&& _array_bound_seq)
1495 {
1496 m_array_bound_seq = std::move(_array_bound_seq);
1497 }
1498
1503 eProsima_user_DllExport const SBoundSeq& array_bound_seq() const
1504 {
1505 return m_array_bound_seq;
1506 }
1507
1512 eProsima_user_DllExport SBoundSeq& array_bound_seq()
1513 {
1514 return m_array_bound_seq;
1515 }
1516
1517
1522 eProsima_user_DllExport void element_identifier(
1523 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1524 {
1525 m_element_identifier = _element_identifier;
1526 }
1527
1532 eProsima_user_DllExport void element_identifier(
1533 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1534 {
1535 m_element_identifier = std::move(_element_identifier);
1536 }
1537
1542 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1543 {
1544 return m_element_identifier;
1545 }
1546
1551 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1552 {
1553 return m_element_identifier;
1554 }
1555
1556
1557
1558private:
1559
1560 PlainCollectionHeader m_header;
1561 SBoundSeq m_array_bound_seq;
1562 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1563
1564};
1570{
1571public:
1572
1576 eProsima_user_DllExport PlainArrayLElemDefn()
1577 {
1578 }
1579
1583 eProsima_user_DllExport ~PlainArrayLElemDefn()
1584 {
1585 }
1586
1591 eProsima_user_DllExport PlainArrayLElemDefn(
1592 const PlainArrayLElemDefn& x)
1593 {
1594 m_header = x.m_header;
1595
1596 m_array_bound_seq = x.m_array_bound_seq;
1597
1598 m_element_identifier = x.m_element_identifier;
1599
1600 }
1601
1606 eProsima_user_DllExport PlainArrayLElemDefn(
1607 PlainArrayLElemDefn&& x) noexcept
1608 {
1609 m_header = std::move(x.m_header);
1610 m_array_bound_seq = std::move(x.m_array_bound_seq);
1611 m_element_identifier = std::move(x.m_element_identifier);
1612 }
1613
1618 eProsima_user_DllExport PlainArrayLElemDefn& operator =(
1619 const PlainArrayLElemDefn& x)
1620 {
1621
1622 m_header = x.m_header;
1623
1624 m_array_bound_seq = x.m_array_bound_seq;
1625
1626 m_element_identifier = x.m_element_identifier;
1627
1628 return *this;
1629 }
1630
1635 eProsima_user_DllExport PlainArrayLElemDefn& operator =(
1636 PlainArrayLElemDefn&& x) noexcept
1637 {
1638
1639 m_header = std::move(x.m_header);
1640 m_array_bound_seq = std::move(x.m_array_bound_seq);
1641 m_element_identifier = std::move(x.m_element_identifier);
1642 return *this;
1643 }
1644
1649 eProsima_user_DllExport bool operator ==(
1650 const PlainArrayLElemDefn& x) const
1651 {
1652 return (m_header == x.m_header &&
1653 m_array_bound_seq == x.m_array_bound_seq &&
1654 m_element_identifier == x.m_element_identifier);
1655 }
1656
1661 eProsima_user_DllExport bool operator !=(
1662 const PlainArrayLElemDefn& x) const
1663 {
1664 return !(*this == x);
1665 }
1666
1671 eProsima_user_DllExport void header(
1672 const PlainCollectionHeader& _header)
1673 {
1674 m_header = _header;
1675 }
1676
1681 eProsima_user_DllExport void header(
1682 PlainCollectionHeader&& _header)
1683 {
1684 m_header = std::move(_header);
1685 }
1686
1691 eProsima_user_DllExport const PlainCollectionHeader& header() const
1692 {
1693 return m_header;
1694 }
1695
1700 eProsima_user_DllExport PlainCollectionHeader& header()
1701 {
1702 return m_header;
1703 }
1704
1705
1710 eProsima_user_DllExport void array_bound_seq(
1711 const LBoundSeq& _array_bound_seq)
1712 {
1713 m_array_bound_seq = _array_bound_seq;
1714 }
1715
1720 eProsima_user_DllExport void array_bound_seq(
1721 LBoundSeq&& _array_bound_seq)
1722 {
1723 m_array_bound_seq = std::move(_array_bound_seq);
1724 }
1725
1730 eProsima_user_DllExport const LBoundSeq& array_bound_seq() const
1731 {
1732 return m_array_bound_seq;
1733 }
1734
1739 eProsima_user_DllExport LBoundSeq& array_bound_seq()
1740 {
1741 return m_array_bound_seq;
1742 }
1743
1744
1749 eProsima_user_DllExport void element_identifier(
1750 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1751 {
1752 m_element_identifier = _element_identifier;
1753 }
1754
1759 eProsima_user_DllExport void element_identifier(
1760 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1761 {
1762 m_element_identifier = std::move(_element_identifier);
1763 }
1764
1769 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
1770 {
1771 return m_element_identifier;
1772 }
1773
1778 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
1779 {
1780 return m_element_identifier;
1781 }
1782
1783
1784
1785private:
1786
1787 PlainCollectionHeader m_header;
1788 LBoundSeq m_array_bound_seq;
1789 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
1790
1791};
1797{
1798public:
1799
1803 eProsima_user_DllExport PlainMapSTypeDefn()
1804 {
1805 }
1806
1810 eProsima_user_DllExport ~PlainMapSTypeDefn()
1811 {
1812 }
1813
1818 eProsima_user_DllExport PlainMapSTypeDefn(
1819 const PlainMapSTypeDefn& x)
1820 {
1821 m_header = x.m_header;
1822
1823 m_bound = x.m_bound;
1824
1825 m_element_identifier = x.m_element_identifier;
1826
1827 m_key_flags = x.m_key_flags;
1828
1829 m_key_identifier = x.m_key_identifier;
1830
1831 }
1832
1837 eProsima_user_DllExport PlainMapSTypeDefn(
1838 PlainMapSTypeDefn&& x) noexcept
1839 {
1840 m_header = std::move(x.m_header);
1841 m_bound = x.m_bound;
1842 m_element_identifier = std::move(x.m_element_identifier);
1843 m_key_flags = std::move(x.m_key_flags);
1844 m_key_identifier = std::move(x.m_key_identifier);
1845 }
1846
1851 eProsima_user_DllExport PlainMapSTypeDefn& operator =(
1852 const PlainMapSTypeDefn& x)
1853 {
1854
1855 m_header = x.m_header;
1856
1857 m_bound = x.m_bound;
1858
1859 m_element_identifier = x.m_element_identifier;
1860
1861 m_key_flags = x.m_key_flags;
1862
1863 m_key_identifier = x.m_key_identifier;
1864
1865 return *this;
1866 }
1867
1872 eProsima_user_DllExport PlainMapSTypeDefn& operator =(
1873 PlainMapSTypeDefn&& x) noexcept
1874 {
1875
1876 m_header = std::move(x.m_header);
1877 m_bound = x.m_bound;
1878 m_element_identifier = std::move(x.m_element_identifier);
1879 m_key_flags = std::move(x.m_key_flags);
1880 m_key_identifier = std::move(x.m_key_identifier);
1881 return *this;
1882 }
1883
1888 eProsima_user_DllExport bool operator ==(
1889 const PlainMapSTypeDefn& x) const
1890 {
1891 return (m_header == x.m_header &&
1892 m_bound == x.m_bound &&
1893 m_element_identifier == x.m_element_identifier &&
1894 m_key_flags == x.m_key_flags &&
1895 m_key_identifier == x.m_key_identifier);
1896 }
1897
1902 eProsima_user_DllExport bool operator !=(
1903 const PlainMapSTypeDefn& x) const
1904 {
1905 return !(*this == x);
1906 }
1907
1912 eProsima_user_DllExport void header(
1913 const PlainCollectionHeader& _header)
1914 {
1915 m_header = _header;
1916 }
1917
1922 eProsima_user_DllExport void header(
1923 PlainCollectionHeader&& _header)
1924 {
1925 m_header = std::move(_header);
1926 }
1927
1932 eProsima_user_DllExport const PlainCollectionHeader& header() const
1933 {
1934 return m_header;
1935 }
1936
1941 eProsima_user_DllExport PlainCollectionHeader& header()
1942 {
1943 return m_header;
1944 }
1945
1946
1951 eProsima_user_DllExport void bound(
1952 SBound _bound)
1953 {
1954 m_bound = _bound;
1955 }
1956
1961 eProsima_user_DllExport SBound bound() const
1962 {
1963 return m_bound;
1964 }
1965
1970 eProsima_user_DllExport SBound& bound()
1971 {
1972 return m_bound;
1973 }
1974
1975
1980 eProsima_user_DllExport void element_identifier(
1981 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
1982 {
1983 m_element_identifier = _element_identifier;
1984 }
1985
1990 eProsima_user_DllExport void element_identifier(
1991 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
1992 {
1993 m_element_identifier = std::move(_element_identifier);
1994 }
1995
2000 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
2001 {
2002 return m_element_identifier;
2003 }
2004
2009 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
2010 {
2011 return m_element_identifier;
2012 }
2013
2014
2019 eProsima_user_DllExport void key_flags(
2020 const CollectionElementFlag& _key_flags)
2021 {
2022 m_key_flags = _key_flags;
2023 }
2024
2029 eProsima_user_DllExport void key_flags(
2030 CollectionElementFlag&& _key_flags)
2031 {
2032 m_key_flags = std::move(_key_flags);
2033 }
2034
2039 eProsima_user_DllExport const CollectionElementFlag& key_flags() const
2040 {
2041 return m_key_flags;
2042 }
2043
2048 eProsima_user_DllExport CollectionElementFlag& key_flags()
2049 {
2050 return m_key_flags;
2051 }
2052
2053
2058 eProsima_user_DllExport void key_identifier(
2059 const eprosima::fastcdr::external<TypeIdentifier>& _key_identifier)
2060 {
2061 m_key_identifier = _key_identifier;
2062 }
2063
2068 eProsima_user_DllExport void key_identifier(
2069 eprosima::fastcdr::external<TypeIdentifier>&& _key_identifier)
2070 {
2071 m_key_identifier = std::move(_key_identifier);
2072 }
2073
2078 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& key_identifier() const
2079 {
2080 return m_key_identifier;
2081 }
2082
2087 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& key_identifier()
2088 {
2089 return m_key_identifier;
2090 }
2091
2092
2093
2094private:
2095
2096 PlainCollectionHeader m_header;
2097 SBound m_bound{0};
2098 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
2099 CollectionElementFlag m_key_flags{0};
2100 eprosima::fastcdr::external<TypeIdentifier> m_key_identifier;
2101
2102};
2108{
2109public:
2110
2114 eProsima_user_DllExport PlainMapLTypeDefn()
2115 {
2116 }
2117
2121 eProsima_user_DllExport ~PlainMapLTypeDefn()
2122 {
2123 }
2124
2129 eProsima_user_DllExport PlainMapLTypeDefn(
2130 const PlainMapLTypeDefn& x)
2131 {
2132 m_header = x.m_header;
2133
2134 m_bound = x.m_bound;
2135
2136 m_element_identifier = x.m_element_identifier;
2137
2138 m_key_flags = x.m_key_flags;
2139
2140 m_key_identifier = x.m_key_identifier;
2141
2142 }
2143
2148 eProsima_user_DllExport PlainMapLTypeDefn(
2149 PlainMapLTypeDefn&& x) noexcept
2150 {
2151 m_header = std::move(x.m_header);
2152 m_bound = x.m_bound;
2153 m_element_identifier = std::move(x.m_element_identifier);
2154 m_key_flags = std::move(x.m_key_flags);
2155 m_key_identifier = std::move(x.m_key_identifier);
2156 }
2157
2162 eProsima_user_DllExport PlainMapLTypeDefn& operator =(
2163 const PlainMapLTypeDefn& x)
2164 {
2165
2166 m_header = x.m_header;
2167
2168 m_bound = x.m_bound;
2169
2170 m_element_identifier = x.m_element_identifier;
2171
2172 m_key_flags = x.m_key_flags;
2173
2174 m_key_identifier = x.m_key_identifier;
2175
2176 return *this;
2177 }
2178
2183 eProsima_user_DllExport PlainMapLTypeDefn& operator =(
2184 PlainMapLTypeDefn&& x) noexcept
2185 {
2186
2187 m_header = std::move(x.m_header);
2188 m_bound = x.m_bound;
2189 m_element_identifier = std::move(x.m_element_identifier);
2190 m_key_flags = std::move(x.m_key_flags);
2191 m_key_identifier = std::move(x.m_key_identifier);
2192 return *this;
2193 }
2194
2199 eProsima_user_DllExport bool operator ==(
2200 const PlainMapLTypeDefn& x) const
2201 {
2202 return (m_header == x.m_header &&
2203 m_bound == x.m_bound &&
2204 m_element_identifier == x.m_element_identifier &&
2205 m_key_flags == x.m_key_flags &&
2206 m_key_identifier == x.m_key_identifier);
2207 }
2208
2213 eProsima_user_DllExport bool operator !=(
2214 const PlainMapLTypeDefn& x) const
2215 {
2216 return !(*this == x);
2217 }
2218
2223 eProsima_user_DllExport void header(
2224 const PlainCollectionHeader& _header)
2225 {
2226 m_header = _header;
2227 }
2228
2233 eProsima_user_DllExport void header(
2234 PlainCollectionHeader&& _header)
2235 {
2236 m_header = std::move(_header);
2237 }
2238
2243 eProsima_user_DllExport const PlainCollectionHeader& header() const
2244 {
2245 return m_header;
2246 }
2247
2252 eProsima_user_DllExport PlainCollectionHeader& header()
2253 {
2254 return m_header;
2255 }
2256
2257
2262 eProsima_user_DllExport void bound(
2263 LBound _bound)
2264 {
2265 m_bound = _bound;
2266 }
2267
2272 eProsima_user_DllExport LBound bound() const
2273 {
2274 return m_bound;
2275 }
2276
2281 eProsima_user_DllExport LBound& bound()
2282 {
2283 return m_bound;
2284 }
2285
2286
2291 eProsima_user_DllExport void element_identifier(
2292 const eprosima::fastcdr::external<TypeIdentifier>& _element_identifier)
2293 {
2294 m_element_identifier = _element_identifier;
2295 }
2296
2301 eProsima_user_DllExport void element_identifier(
2302 eprosima::fastcdr::external<TypeIdentifier>&& _element_identifier)
2303 {
2304 m_element_identifier = std::move(_element_identifier);
2305 }
2306
2311 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& element_identifier() const
2312 {
2313 return m_element_identifier;
2314 }
2315
2320 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& element_identifier()
2321 {
2322 return m_element_identifier;
2323 }
2324
2325
2330 eProsima_user_DllExport void key_flags(
2331 const CollectionElementFlag& _key_flags)
2332 {
2333 m_key_flags = _key_flags;
2334 }
2335
2340 eProsima_user_DllExport void key_flags(
2341 CollectionElementFlag&& _key_flags)
2342 {
2343 m_key_flags = std::move(_key_flags);
2344 }
2345
2350 eProsima_user_DllExport const CollectionElementFlag& key_flags() const
2351 {
2352 return m_key_flags;
2353 }
2354
2359 eProsima_user_DllExport CollectionElementFlag& key_flags()
2360 {
2361 return m_key_flags;
2362 }
2363
2364
2369 eProsima_user_DllExport void key_identifier(
2370 const eprosima::fastcdr::external<TypeIdentifier>& _key_identifier)
2371 {
2372 m_key_identifier = _key_identifier;
2373 }
2374
2379 eProsima_user_DllExport void key_identifier(
2380 eprosima::fastcdr::external<TypeIdentifier>&& _key_identifier)
2381 {
2382 m_key_identifier = std::move(_key_identifier);
2383 }
2384
2389 eProsima_user_DllExport const eprosima::fastcdr::external<TypeIdentifier>& key_identifier() const
2390 {
2391 return m_key_identifier;
2392 }
2393
2398 eProsima_user_DllExport eprosima::fastcdr::external<TypeIdentifier>& key_identifier()
2399 {
2400 return m_key_identifier;
2401 }
2402
2403
2404
2405private:
2406
2407 PlainCollectionHeader m_header;
2408 LBound m_bound{0};
2409 eprosima::fastcdr::external<TypeIdentifier> m_element_identifier;
2410 CollectionElementFlag m_key_flags{0};
2411 eprosima::fastcdr::external<TypeIdentifier> m_key_identifier;
2412
2413};
2419{
2420public:
2421
2425 eProsima_user_DllExport StronglyConnectedComponentId()
2426 {
2427 }
2428
2432 eProsima_user_DllExport ~StronglyConnectedComponentId()
2433 {
2434 }
2435
2440 eProsima_user_DllExport StronglyConnectedComponentId(
2442 {
2443 m_sc_component_id = x.m_sc_component_id;
2444
2445 m_scc_length = x.m_scc_length;
2446
2447 m_scc_index = x.m_scc_index;
2448
2449 }
2450
2455 eProsima_user_DllExport StronglyConnectedComponentId(
2456 StronglyConnectedComponentId&& x) noexcept
2457 {
2458 m_sc_component_id = std::move(x.m_sc_component_id);
2459 m_scc_length = x.m_scc_length;
2460 m_scc_index = x.m_scc_index;
2461 }
2462
2469 {
2470
2471 m_sc_component_id = x.m_sc_component_id;
2472
2473 m_scc_length = x.m_scc_length;
2474
2475 m_scc_index = x.m_scc_index;
2476
2477 return *this;
2478 }
2479
2485 StronglyConnectedComponentId&& x) noexcept
2486 {
2487
2488 m_sc_component_id = std::move(x.m_sc_component_id);
2489 m_scc_length = x.m_scc_length;
2490 m_scc_index = x.m_scc_index;
2491 return *this;
2492 }
2493
2498 eProsima_user_DllExport bool operator ==(
2499 const StronglyConnectedComponentId& x) const
2500 {
2501 return (m_sc_component_id == x.m_sc_component_id &&
2502 m_scc_length == x.m_scc_length &&
2503 m_scc_index == x.m_scc_index);
2504 }
2505
2510 eProsima_user_DllExport bool operator !=(
2511 const StronglyConnectedComponentId& x) const
2512 {
2513 return !(*this == x);
2514 }
2515
2520 eProsima_user_DllExport void sc_component_id(
2521 const TypeObjectHashId& _sc_component_id)
2522 {
2523 m_sc_component_id = _sc_component_id;
2524 }
2525
2530 eProsima_user_DllExport void sc_component_id(
2531 TypeObjectHashId&& _sc_component_id)
2532 {
2533 m_sc_component_id = std::move(_sc_component_id);
2534 }
2535
2540 eProsima_user_DllExport const TypeObjectHashId& sc_component_id() const
2541 {
2542 return m_sc_component_id;
2543 }
2544
2549 eProsima_user_DllExport TypeObjectHashId& sc_component_id()
2550 {
2551 return m_sc_component_id;
2552 }
2553
2554
2559 eProsima_user_DllExport void scc_length(
2560 int32_t _scc_length)
2561 {
2562 m_scc_length = _scc_length;
2563 }
2564
2569 eProsima_user_DllExport int32_t scc_length() const
2570 {
2571 return m_scc_length;
2572 }
2573
2578 eProsima_user_DllExport int32_t& scc_length()
2579 {
2580 return m_scc_length;
2581 }
2582
2583
2588 eProsima_user_DllExport void scc_index(
2589 int32_t _scc_index)
2590 {
2591 m_scc_index = _scc_index;
2592 }
2593
2598 eProsima_user_DllExport int32_t scc_index() const
2599 {
2600 return m_scc_index;
2601 }
2602
2607 eProsima_user_DllExport int32_t& scc_index()
2608 {
2609 return m_scc_index;
2610 }
2611
2612
2613
2614private:
2615
2616 TypeObjectHashId m_sc_component_id;
2617 int32_t m_scc_length{0};
2618 int32_t m_scc_index{0};
2619
2620};
2626{
2627public:
2628
2632 eProsima_user_DllExport ExtendedTypeDefn()
2633 {
2634 }
2635
2639 eProsima_user_DllExport ~ExtendedTypeDefn()
2640 {
2641 }
2642
2647 eProsima_user_DllExport ExtendedTypeDefn(
2648 const ExtendedTypeDefn& x)
2649 {
2650 static_cast<void>(x);
2651 }
2652
2657 eProsima_user_DllExport ExtendedTypeDefn(
2658 ExtendedTypeDefn&& x) noexcept
2659 {
2660 static_cast<void>(x);
2661 }
2662
2667 eProsima_user_DllExport ExtendedTypeDefn& operator =(
2668 const ExtendedTypeDefn& x)
2669 {
2670
2671 static_cast<void>(x);
2672
2673 return *this;
2674 }
2675
2680 eProsima_user_DllExport ExtendedTypeDefn& operator =(
2681 ExtendedTypeDefn&& x) noexcept
2682 {
2683
2684 static_cast<void>(x);
2685
2686 return *this;
2687 }
2688
2693 eProsima_user_DllExport bool operator ==(
2694 const ExtendedTypeDefn& x) const
2695 {
2696 static_cast<void>(x);
2697 return true;
2698 }
2699
2704 eProsima_user_DllExport bool operator !=(
2705 const ExtendedTypeDefn& x) const
2706 {
2707 return !(*this == x);
2708 }
2709
2710
2711
2712private:
2713
2714
2715};
2721{
2722public:
2723
2727 eProsima_user_DllExport Dummy()
2728 {
2729 }
2730
2734 eProsima_user_DllExport ~Dummy()
2735 {
2736 }
2737
2742 eProsima_user_DllExport Dummy(
2743 const Dummy& x)
2744 {
2745 static_cast<void>(x);
2746 }
2747
2752 eProsima_user_DllExport Dummy(
2753 Dummy&& x) noexcept
2754 {
2755 static_cast<void>(x);
2756 }
2757
2762 eProsima_user_DllExport Dummy& operator =(
2763 const Dummy& x)
2764 {
2765
2766 static_cast<void>(x);
2767
2768 return *this;
2769 }
2770
2775 eProsima_user_DllExport Dummy& operator =(
2776 Dummy&& x) noexcept
2777 {
2778
2779 static_cast<void>(x);
2780
2781 return *this;
2782 }
2783
2788 eProsima_user_DllExport bool operator ==(
2789 const Dummy& x) const
2790 {
2791 static_cast<void>(x);
2792 return true;
2793 }
2794
2799 eProsima_user_DllExport bool operator !=(
2800 const Dummy& x) const
2801 {
2802 return !(*this == x);
2803 }
2804
2805
2806
2807private:
2808
2809
2810};
2816{
2817public:
2818
2822 eProsima_user_DllExport TypeIdentifier()
2823 {
2824 selected_member_ = 0x00000001;
2825 member_destructor_ = [&]() {m_no_value.~Dummy();};
2826 new(&m_no_value) Dummy();
2827
2828 }
2829
2833 eProsima_user_DllExport ~TypeIdentifier()
2834 {
2835 if (member_destructor_)
2836 {
2837 member_destructor_();
2838 }
2839 }
2840
2845 eProsima_user_DllExport TypeIdentifier(
2846 const TypeIdentifier& x)
2847 {
2848 m__d = x.m__d;
2849
2850 switch (x.selected_member_)
2851 {
2852 case 0x00000001:
2853 no_value_() = x.m_no_value;
2854 break;
2855
2856 case 0x00000002:
2857 string_sdefn_() = x.m_string_sdefn;
2858 break;
2859
2860 case 0x00000003:
2861 string_ldefn_() = x.m_string_ldefn;
2862 break;
2863
2864 case 0x00000004:
2865 seq_sdefn_() = x.m_seq_sdefn;
2866 break;
2867
2868 case 0x00000005:
2869 seq_ldefn_() = x.m_seq_ldefn;
2870 break;
2871
2872 case 0x00000006:
2873 array_sdefn_() = x.m_array_sdefn;
2874 break;
2875
2876 case 0x00000007:
2877 array_ldefn_() = x.m_array_ldefn;
2878 break;
2879
2880 case 0x00000008:
2881 map_sdefn_() = x.m_map_sdefn;
2882 break;
2883
2884 case 0x00000009:
2885 map_ldefn_() = x.m_map_ldefn;
2886 break;
2887
2888 case 0x0000000a:
2889 sc_component_id_() = x.m_sc_component_id;
2890 break;
2891
2892 case 0x0000000b:
2893 equivalence_hash_() = x.m_equivalence_hash;
2894 break;
2895
2896 case 0x0000000c:
2897 extended_defn_() = x.m_extended_defn;
2898 break;
2899
2900 }
2901 }
2902
2907 eProsima_user_DllExport TypeIdentifier(
2908 TypeIdentifier&& x) noexcept
2909 {
2910 m__d = x.m__d;
2911
2912 switch (x.selected_member_)
2913 {
2914 case 0x00000001:
2915 no_value_() = std::move(x.m_no_value);
2916 break;
2917
2918 case 0x00000002:
2919 string_sdefn_() = std::move(x.m_string_sdefn);
2920 break;
2921
2922 case 0x00000003:
2923 string_ldefn_() = std::move(x.m_string_ldefn);
2924 break;
2925
2926 case 0x00000004:
2927 seq_sdefn_() = std::move(x.m_seq_sdefn);
2928 break;
2929
2930 case 0x00000005:
2931 seq_ldefn_() = std::move(x.m_seq_ldefn);
2932 break;
2933
2934 case 0x00000006:
2935 array_sdefn_() = std::move(x.m_array_sdefn);
2936 break;
2937
2938 case 0x00000007:
2939 array_ldefn_() = std::move(x.m_array_ldefn);
2940 break;
2941
2942 case 0x00000008:
2943 map_sdefn_() = std::move(x.m_map_sdefn);
2944 break;
2945
2946 case 0x00000009:
2947 map_ldefn_() = std::move(x.m_map_ldefn);
2948 break;
2949
2950 case 0x0000000a:
2951 sc_component_id_() = std::move(x.m_sc_component_id);
2952 break;
2953
2954 case 0x0000000b:
2955 equivalence_hash_() = std::move(x.m_equivalence_hash);
2956 break;
2957
2958 case 0x0000000c:
2959 extended_defn_() = std::move(x.m_extended_defn);
2960 break;
2961
2962 }
2963 }
2964
2969 eProsima_user_DllExport TypeIdentifier& operator =(
2970 const TypeIdentifier& x)
2971 {
2972 m__d = x.m__d;
2973
2974 switch (x.selected_member_)
2975 {
2976 case 0x00000001:
2977 no_value_() = x.m_no_value;
2978 break;
2979
2980 case 0x00000002:
2981 string_sdefn_() = x.m_string_sdefn;
2982 break;
2983
2984 case 0x00000003:
2985 string_ldefn_() = x.m_string_ldefn;
2986 break;
2987
2988 case 0x00000004:
2989 seq_sdefn_() = x.m_seq_sdefn;
2990 break;
2991
2992 case 0x00000005:
2993 seq_ldefn_() = x.m_seq_ldefn;
2994 break;
2995
2996 case 0x00000006:
2997 array_sdefn_() = x.m_array_sdefn;
2998 break;
2999
3000 case 0x00000007:
3001 array_ldefn_() = x.m_array_ldefn;
3002 break;
3003
3004 case 0x00000008:
3005 map_sdefn_() = x.m_map_sdefn;
3006 break;
3007
3008 case 0x00000009:
3009 map_ldefn_() = x.m_map_ldefn;
3010 break;
3011
3012 case 0x0000000a:
3013 sc_component_id_() = x.m_sc_component_id;
3014 break;
3015
3016 case 0x0000000b:
3017 equivalence_hash_() = x.m_equivalence_hash;
3018 break;
3019
3020 case 0x0000000c:
3021 extended_defn_() = x.m_extended_defn;
3022 break;
3023
3024 }
3025
3026 return *this;
3027 }
3028
3033 eProsima_user_DllExport TypeIdentifier& operator =(
3034 TypeIdentifier&& x) noexcept
3035 {
3036 m__d = x.m__d;
3037
3038 switch (x.selected_member_)
3039 {
3040 case 0x00000001:
3041 no_value_() = std::move(x.m_no_value);
3042 break;
3043
3044 case 0x00000002:
3045 string_sdefn_() = std::move(x.m_string_sdefn);
3046 break;
3047
3048 case 0x00000003:
3049 string_ldefn_() = std::move(x.m_string_ldefn);
3050 break;
3051
3052 case 0x00000004:
3053 seq_sdefn_() = std::move(x.m_seq_sdefn);
3054 break;
3055
3056 case 0x00000005:
3057 seq_ldefn_() = std::move(x.m_seq_ldefn);
3058 break;
3059
3060 case 0x00000006:
3061 array_sdefn_() = std::move(x.m_array_sdefn);
3062 break;
3063
3064 case 0x00000007:
3065 array_ldefn_() = std::move(x.m_array_ldefn);
3066 break;
3067
3068 case 0x00000008:
3069 map_sdefn_() = std::move(x.m_map_sdefn);
3070 break;
3071
3072 case 0x00000009:
3073 map_ldefn_() = std::move(x.m_map_ldefn);
3074 break;
3075
3076 case 0x0000000a:
3077 sc_component_id_() = std::move(x.m_sc_component_id);
3078 break;
3079
3080 case 0x0000000b:
3081 equivalence_hash_() = std::move(x.m_equivalence_hash);
3082 break;
3083
3084 case 0x0000000c:
3085 extended_defn_() = std::move(x.m_extended_defn);
3086 break;
3087
3088 }
3089
3090 return *this;
3091 }
3092
3097 eProsima_user_DllExport bool operator ==(
3098 const TypeIdentifier& x) const
3099 {
3100 bool ret_value {false};
3101
3102 if (x.selected_member_ == selected_member_)
3103 {
3104 if (0x0FFFFFFFu != selected_member_)
3105 {
3106 if (x.m__d == m__d)
3107 {
3108 switch (selected_member_)
3109 {
3110 case 0x00000001:
3111 ret_value = (x.m_no_value == m_no_value);
3112 break;
3113
3114 case 0x00000002:
3115 ret_value = (x.m_string_sdefn == m_string_sdefn);
3116 break;
3117
3118 case 0x00000003:
3119 ret_value = (x.m_string_ldefn == m_string_ldefn);
3120 break;
3121
3122 case 0x00000004:
3123 ret_value = (x.m_seq_sdefn == m_seq_sdefn);
3124 break;
3125
3126 case 0x00000005:
3127 ret_value = (x.m_seq_ldefn == m_seq_ldefn);
3128 break;
3129
3130 case 0x00000006:
3131 ret_value = (x.m_array_sdefn == m_array_sdefn);
3132 break;
3133
3134 case 0x00000007:
3135 ret_value = (x.m_array_ldefn == m_array_ldefn);
3136 break;
3137
3138 case 0x00000008:
3139 ret_value = (x.m_map_sdefn == m_map_sdefn);
3140 break;
3141
3142 case 0x00000009:
3143 ret_value = (x.m_map_ldefn == m_map_ldefn);
3144 break;
3145
3146 case 0x0000000a:
3147 ret_value = (x.m_sc_component_id == m_sc_component_id);
3148 break;
3149
3150 case 0x0000000b:
3151 ret_value = (x.m_equivalence_hash == m_equivalence_hash);
3152 break;
3153
3154 case 0x0000000c:
3155 ret_value = (x.m_extended_defn == m_extended_defn);
3156 break;
3157
3158 }
3159 }
3160 }
3161 else
3162 {
3163 ret_value = true;
3164 }
3165 }
3166
3167 return ret_value;
3168 }
3169
3174 eProsima_user_DllExport bool operator !=(
3175 const TypeIdentifier& x) const
3176 {
3177 return !(*this == x);
3178 }
3179
3185 eProsima_user_DllExport void _d(
3186 uint8_t __d)
3187 {
3188 bool valid_discriminator = false;
3189
3190 switch (__d)
3191 {
3192 case TK_NONE:
3193 case TK_BOOLEAN:
3194 case TK_BYTE:
3195 case TK_INT8:
3196 case TK_INT16:
3197 case TK_INT32:
3198 case TK_INT64:
3199 case TK_UINT8:
3200 case TK_UINT16:
3201 case TK_UINT32:
3202 case TK_UINT64:
3203 case TK_FLOAT32:
3204 case TK_FLOAT64:
3205 case TK_FLOAT128:
3206 case TK_CHAR8:
3207 case TK_CHAR16:
3208 if (0x00000001 == selected_member_)
3209 {
3210 valid_discriminator = true;
3211 }
3212 break;
3213
3214 case TI_STRING8_SMALL:
3215 case TI_STRING16_SMALL:
3216 if (0x00000002 == selected_member_)
3217 {
3218 valid_discriminator = true;
3219 }
3220 break;
3221
3222 case TI_STRING8_LARGE:
3223 case TI_STRING16_LARGE:
3224 if (0x00000003 == selected_member_)
3225 {
3226 valid_discriminator = true;
3227 }
3228 break;
3229
3231 if (0x00000004 == selected_member_)
3232 {
3233 valid_discriminator = true;
3234 }
3235 break;
3236
3238 if (0x00000005 == selected_member_)
3239 {
3240 valid_discriminator = true;
3241 }
3242 break;
3243
3245 if (0x00000006 == selected_member_)
3246 {
3247 valid_discriminator = true;
3248 }
3249 break;
3250
3252 if (0x00000007 == selected_member_)
3253 {
3254 valid_discriminator = true;
3255 }
3256 break;
3257
3258 case TI_PLAIN_MAP_SMALL:
3259 if (0x00000008 == selected_member_)
3260 {
3261 valid_discriminator = true;
3262 }
3263 break;
3264
3265 case TI_PLAIN_MAP_LARGE:
3266 if (0x00000009 == selected_member_)
3267 {
3268 valid_discriminator = true;
3269 }
3270 break;
3271
3273 if (0x0000000a == selected_member_)
3274 {
3275 valid_discriminator = true;
3276 }
3277 break;
3278
3279 case EK_COMPLETE:
3280 case EK_MINIMAL:
3281 if (0x0000000b == selected_member_)
3282 {
3283 valid_discriminator = true;
3284 }
3285 break;
3286
3287 default:
3288 if (0x0000000c == selected_member_)
3289 {
3290 valid_discriminator = true;
3291 }
3292 break;
3293
3294 }
3295
3296 if (!valid_discriminator)
3297 {
3298 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
3299 }
3300
3301 m__d = __d;
3302 }
3303
3308 eProsima_user_DllExport uint8_t _d() const
3309 {
3310 return m__d;
3311 }
3312
3317 eProsima_user_DllExport void no_value(
3318 const Dummy& _no_value)
3319 {
3320 no_value_() = _no_value;
3321 m__d = TK_NONE;
3322 }
3323
3328 eProsima_user_DllExport void no_value(
3329 Dummy&& _no_value)
3330 {
3331 no_value_() = _no_value;
3332 m__d = TK_NONE;
3333 }
3334
3340 eProsima_user_DllExport const Dummy& no_value() const
3341 {
3342 if (0x00000001 != selected_member_)
3343 {
3344 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3345 }
3346
3347 return m_no_value;
3348 }
3349
3355 eProsima_user_DllExport Dummy& no_value()
3356 {
3357 if (0x00000001 != selected_member_)
3358 {
3359 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3360 }
3361
3362 return m_no_value;
3363 }
3364
3365
3370 eProsima_user_DllExport void string_sdefn(
3371 const StringSTypeDefn& _string_sdefn)
3372 {
3373 string_sdefn_() = _string_sdefn;
3374 m__d = TI_STRING8_SMALL;
3375 }
3376
3381 eProsima_user_DllExport void string_sdefn(
3382 StringSTypeDefn&& _string_sdefn)
3383 {
3384 string_sdefn_() = _string_sdefn;
3385 m__d = TI_STRING8_SMALL;
3386 }
3387
3393 eProsima_user_DllExport const StringSTypeDefn& string_sdefn() const
3394 {
3395 if (0x00000002 != selected_member_)
3396 {
3397 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3398 }
3399
3400 return m_string_sdefn;
3401 }
3402
3408 eProsima_user_DllExport StringSTypeDefn& string_sdefn()
3409 {
3410 if (0x00000002 != selected_member_)
3411 {
3412 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3413 }
3414
3415 return m_string_sdefn;
3416 }
3417
3418
3423 eProsima_user_DllExport void string_ldefn(
3424 const StringLTypeDefn& _string_ldefn)
3425 {
3426 string_ldefn_() = _string_ldefn;
3427 m__d = TI_STRING8_LARGE;
3428 }
3429
3434 eProsima_user_DllExport void string_ldefn(
3435 StringLTypeDefn&& _string_ldefn)
3436 {
3437 string_ldefn_() = _string_ldefn;
3438 m__d = TI_STRING8_LARGE;
3439 }
3440
3446 eProsima_user_DllExport const StringLTypeDefn& string_ldefn() const
3447 {
3448 if (0x00000003 != selected_member_)
3449 {
3450 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3451 }
3452
3453 return m_string_ldefn;
3454 }
3455
3461 eProsima_user_DllExport StringLTypeDefn& string_ldefn()
3462 {
3463 if (0x00000003 != selected_member_)
3464 {
3465 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3466 }
3467
3468 return m_string_ldefn;
3469 }
3470
3471
3476 eProsima_user_DllExport void seq_sdefn(
3477 const PlainSequenceSElemDefn& _seq_sdefn)
3478 {
3479 seq_sdefn_() = _seq_sdefn;
3481 }
3482
3487 eProsima_user_DllExport void seq_sdefn(
3488 PlainSequenceSElemDefn&& _seq_sdefn)
3489 {
3490 seq_sdefn_() = _seq_sdefn;
3492 }
3493
3499 eProsima_user_DllExport const PlainSequenceSElemDefn& seq_sdefn() const
3500 {
3501 if (0x00000004 != selected_member_)
3502 {
3503 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3504 }
3505
3506 return m_seq_sdefn;
3507 }
3508
3514 eProsima_user_DllExport PlainSequenceSElemDefn& seq_sdefn()
3515 {
3516 if (0x00000004 != selected_member_)
3517 {
3518 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3519 }
3520
3521 return m_seq_sdefn;
3522 }
3523
3524
3529 eProsima_user_DllExport void seq_ldefn(
3530 const PlainSequenceLElemDefn& _seq_ldefn)
3531 {
3532 seq_ldefn_() = _seq_ldefn;
3534 }
3535
3540 eProsima_user_DllExport void seq_ldefn(
3541 PlainSequenceLElemDefn&& _seq_ldefn)
3542 {
3543 seq_ldefn_() = _seq_ldefn;
3545 }
3546
3552 eProsima_user_DllExport const PlainSequenceLElemDefn& seq_ldefn() const
3553 {
3554 if (0x00000005 != selected_member_)
3555 {
3556 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3557 }
3558
3559 return m_seq_ldefn;
3560 }
3561
3567 eProsima_user_DllExport PlainSequenceLElemDefn& seq_ldefn()
3568 {
3569 if (0x00000005 != selected_member_)
3570 {
3571 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3572 }
3573
3574 return m_seq_ldefn;
3575 }
3576
3577
3582 eProsima_user_DllExport void array_sdefn(
3583 const PlainArraySElemDefn& _array_sdefn)
3584 {
3585 array_sdefn_() = _array_sdefn;
3586 m__d = TI_PLAIN_ARRAY_SMALL;
3587 }
3588
3593 eProsima_user_DllExport void array_sdefn(
3594 PlainArraySElemDefn&& _array_sdefn)
3595 {
3596 array_sdefn_() = _array_sdefn;
3597 m__d = TI_PLAIN_ARRAY_SMALL;
3598 }
3599
3605 eProsima_user_DllExport const PlainArraySElemDefn& array_sdefn() const
3606 {
3607 if (0x00000006 != selected_member_)
3608 {
3609 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3610 }
3611
3612 return m_array_sdefn;
3613 }
3614
3620 eProsima_user_DllExport PlainArraySElemDefn& array_sdefn()
3621 {
3622 if (0x00000006 != selected_member_)
3623 {
3624 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3625 }
3626
3627 return m_array_sdefn;
3628 }
3629
3630
3635 eProsima_user_DllExport void array_ldefn(
3636 const PlainArrayLElemDefn& _array_ldefn)
3637 {
3638 array_ldefn_() = _array_ldefn;
3639 m__d = TI_PLAIN_ARRAY_LARGE;
3640 }
3641
3646 eProsima_user_DllExport void array_ldefn(
3647 PlainArrayLElemDefn&& _array_ldefn)
3648 {
3649 array_ldefn_() = _array_ldefn;
3650 m__d = TI_PLAIN_ARRAY_LARGE;
3651 }
3652
3658 eProsima_user_DllExport const PlainArrayLElemDefn& array_ldefn() const
3659 {
3660 if (0x00000007 != selected_member_)
3661 {
3662 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3663 }
3664
3665 return m_array_ldefn;
3666 }
3667
3673 eProsima_user_DllExport PlainArrayLElemDefn& array_ldefn()
3674 {
3675 if (0x00000007 != selected_member_)
3676 {
3677 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3678 }
3679
3680 return m_array_ldefn;
3681 }
3682
3683
3688 eProsima_user_DllExport void map_sdefn(
3689 const PlainMapSTypeDefn& _map_sdefn)
3690 {
3691 map_sdefn_() = _map_sdefn;
3692 m__d = TI_PLAIN_MAP_SMALL;
3693 }
3694
3699 eProsima_user_DllExport void map_sdefn(
3700 PlainMapSTypeDefn&& _map_sdefn)
3701 {
3702 map_sdefn_() = _map_sdefn;
3703 m__d = TI_PLAIN_MAP_SMALL;
3704 }
3705
3711 eProsima_user_DllExport const PlainMapSTypeDefn& map_sdefn() const
3712 {
3713 if (0x00000008 != selected_member_)
3714 {
3715 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3716 }
3717
3718 return m_map_sdefn;
3719 }
3720
3726 eProsima_user_DllExport PlainMapSTypeDefn& map_sdefn()
3727 {
3728 if (0x00000008 != selected_member_)
3729 {
3730 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3731 }
3732
3733 return m_map_sdefn;
3734 }
3735
3736
3741 eProsima_user_DllExport void map_ldefn(
3742 const PlainMapLTypeDefn& _map_ldefn)
3743 {
3744 map_ldefn_() = _map_ldefn;
3745 m__d = TI_PLAIN_MAP_LARGE;
3746 }
3747
3752 eProsima_user_DllExport void map_ldefn(
3753 PlainMapLTypeDefn&& _map_ldefn)
3754 {
3755 map_ldefn_() = _map_ldefn;
3756 m__d = TI_PLAIN_MAP_LARGE;
3757 }
3758
3764 eProsima_user_DllExport const PlainMapLTypeDefn& map_ldefn() const
3765 {
3766 if (0x00000009 != selected_member_)
3767 {
3768 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3769 }
3770
3771 return m_map_ldefn;
3772 }
3773
3779 eProsima_user_DllExport PlainMapLTypeDefn& map_ldefn()
3780 {
3781 if (0x00000009 != selected_member_)
3782 {
3783 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3784 }
3785
3786 return m_map_ldefn;
3787 }
3788
3789
3794 eProsima_user_DllExport void sc_component_id(
3795 const StronglyConnectedComponentId& _sc_component_id)
3796 {
3797 sc_component_id_() = _sc_component_id;
3799 }
3800
3805 eProsima_user_DllExport void sc_component_id(
3806 StronglyConnectedComponentId&& _sc_component_id)
3807 {
3808 sc_component_id_() = _sc_component_id;
3810 }
3811
3817 eProsima_user_DllExport const StronglyConnectedComponentId& sc_component_id() const
3818 {
3819 if (0x0000000a != selected_member_)
3820 {
3821 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3822 }
3823
3824 return m_sc_component_id;
3825 }
3826
3833 {
3834 if (0x0000000a != selected_member_)
3835 {
3836 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3837 }
3838
3839 return m_sc_component_id;
3840 }
3841
3842
3847 eProsima_user_DllExport void equivalence_hash(
3848 const EquivalenceHash& _equivalence_hash)
3849 {
3850 equivalence_hash_() = _equivalence_hash;
3851 m__d = EK_COMPLETE;
3852 }
3853
3858 eProsima_user_DllExport void equivalence_hash(
3859 EquivalenceHash&& _equivalence_hash)
3860 {
3861 equivalence_hash_() = _equivalence_hash;
3862 m__d = EK_COMPLETE;
3863 }
3864
3870 eProsima_user_DllExport const EquivalenceHash& equivalence_hash() const
3871 {
3872 if (0x0000000b != selected_member_)
3873 {
3874 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3875 }
3876
3877 return m_equivalence_hash;
3878 }
3879
3885 eProsima_user_DllExport EquivalenceHash& equivalence_hash()
3886 {
3887 if (0x0000000b != selected_member_)
3888 {
3889 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3890 }
3891
3892 return m_equivalence_hash;
3893 }
3894
3895
3900 eProsima_user_DllExport void extended_defn(
3901 const ExtendedTypeDefn& _extended_defn)
3902 {
3903 extended_defn_() = _extended_defn;
3904 m__d = 127;
3905 }
3906
3911 eProsima_user_DllExport void extended_defn(
3912 ExtendedTypeDefn&& _extended_defn)
3913 {
3914 extended_defn_() = _extended_defn;
3915 m__d = 127;
3916 }
3917
3923 eProsima_user_DllExport const ExtendedTypeDefn& extended_defn() const
3924 {
3925 if (0x0000000c != selected_member_)
3926 {
3927 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3928 }
3929
3930 return m_extended_defn;
3931 }
3932
3938 eProsima_user_DllExport ExtendedTypeDefn& extended_defn()
3939 {
3940 if (0x0000000c != selected_member_)
3941 {
3942 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
3943 }
3944
3945 return m_extended_defn;
3946 }
3947
3948
3949
3950private:
3951
3952 Dummy& no_value_()
3953 {
3954 if (0x00000001 != selected_member_)
3955 {
3956 if (member_destructor_)
3957 {
3958 member_destructor_();
3959 }
3960
3961 selected_member_ = 0x00000001;
3962 member_destructor_ = [&]() {m_no_value.~Dummy();};
3963 new(&m_no_value) Dummy();
3964
3965 }
3966
3967 return m_no_value;
3968 }
3969
3970 StringSTypeDefn& string_sdefn_()
3971 {
3972 if (0x00000002 != selected_member_)
3973 {
3974 if (member_destructor_)
3975 {
3976 member_destructor_();
3977 }
3978
3979 selected_member_ = 0x00000002;
3980 member_destructor_ = [&]() {m_string_sdefn.~StringSTypeDefn();};
3981 new(&m_string_sdefn) StringSTypeDefn();
3982
3983 }
3984
3985 return m_string_sdefn;
3986 }
3987
3988 StringLTypeDefn& string_ldefn_()
3989 {
3990 if (0x00000003 != selected_member_)
3991 {
3992 if (member_destructor_)
3993 {
3994 member_destructor_();
3995 }
3996
3997 selected_member_ = 0x00000003;
3998 member_destructor_ = [&]() {m_string_ldefn.~StringLTypeDefn();};
3999 new(&m_string_ldefn) StringLTypeDefn();
4000
4001 }
4002
4003 return m_string_ldefn;
4004 }
4005
4006 PlainSequenceSElemDefn& seq_sdefn_()
4007 {
4008 if (0x00000004 != selected_member_)
4009 {
4010 if (member_destructor_)
4011 {
4012 member_destructor_();
4013 }
4014
4015 selected_member_ = 0x00000004;
4016 member_destructor_ = [&]() {m_seq_sdefn.~PlainSequenceSElemDefn();};
4017 new(&m_seq_sdefn) PlainSequenceSElemDefn();
4018
4019 }
4020
4021 return m_seq_sdefn;
4022 }
4023
4024 PlainSequenceLElemDefn& seq_ldefn_()
4025 {
4026 if (0x00000005 != selected_member_)
4027 {
4028 if (member_destructor_)
4029 {
4030 member_destructor_();
4031 }
4032
4033 selected_member_ = 0x00000005;
4034 member_destructor_ = [&]() {m_seq_ldefn.~PlainSequenceLElemDefn();};
4035 new(&m_seq_ldefn) PlainSequenceLElemDefn();
4036
4037 }
4038
4039 return m_seq_ldefn;
4040 }
4041
4042 PlainArraySElemDefn& array_sdefn_()
4043 {
4044 if (0x00000006 != selected_member_)
4045 {
4046 if (member_destructor_)
4047 {
4048 member_destructor_();
4049 }
4050
4051 selected_member_ = 0x00000006;
4052 member_destructor_ = [&]() {m_array_sdefn.~PlainArraySElemDefn();};
4053 new(&m_array_sdefn) PlainArraySElemDefn();
4054
4055 }
4056
4057 return m_array_sdefn;
4058 }
4059
4060 PlainArrayLElemDefn& array_ldefn_()
4061 {
4062 if (0x00000007 != selected_member_)
4063 {
4064 if (member_destructor_)
4065 {
4066 member_destructor_();
4067 }
4068
4069 selected_member_ = 0x00000007;
4070 member_destructor_ = [&]() {m_array_ldefn.~PlainArrayLElemDefn();};
4071 new(&m_array_ldefn) PlainArrayLElemDefn();
4072
4073 }
4074
4075 return m_array_ldefn;
4076 }
4077
4078 PlainMapSTypeDefn& map_sdefn_()
4079 {
4080 if (0x00000008 != selected_member_)
4081 {
4082 if (member_destructor_)
4083 {
4084 member_destructor_();
4085 }
4086
4087 selected_member_ = 0x00000008;
4088 member_destructor_ = [&]() {m_map_sdefn.~PlainMapSTypeDefn();};
4089 new(&m_map_sdefn) PlainMapSTypeDefn();
4090
4091 }
4092
4093 return m_map_sdefn;
4094 }
4095
4096 PlainMapLTypeDefn& map_ldefn_()
4097 {
4098 if (0x00000009 != selected_member_)
4099 {
4100 if (member_destructor_)
4101 {
4102 member_destructor_();
4103 }
4104
4105 selected_member_ = 0x00000009;
4106 member_destructor_ = [&]() {m_map_ldefn.~PlainMapLTypeDefn();};
4107 new(&m_map_ldefn) PlainMapLTypeDefn();
4108
4109 }
4110
4111 return m_map_ldefn;
4112 }
4113
4114 StronglyConnectedComponentId& sc_component_id_()
4115 {
4116 if (0x0000000a != selected_member_)
4117 {
4118 if (member_destructor_)
4119 {
4120 member_destructor_();
4121 }
4122
4123 selected_member_ = 0x0000000a;
4124 member_destructor_ = [&]() {m_sc_component_id.~StronglyConnectedComponentId();};
4125 new(&m_sc_component_id) StronglyConnectedComponentId();
4126
4127 }
4128
4129 return m_sc_component_id;
4130 }
4131
4132 EquivalenceHash& equivalence_hash_()
4133 {
4134 if (0x0000000b != selected_member_)
4135 {
4136 if (member_destructor_)
4137 {
4138 member_destructor_();
4139 }
4140
4141 selected_member_ = 0x0000000b;
4142 member_destructor_ = [&]() {m_equivalence_hash.~EquivalenceHash();};
4144
4145 }
4146
4147 return m_equivalence_hash;
4148 }
4149
4150 ExtendedTypeDefn& extended_defn_()
4151 {
4152 if (0x0000000c != selected_member_)
4153 {
4154 if (member_destructor_)
4155 {
4156 member_destructor_();
4157 }
4158
4159 selected_member_ = 0x0000000c;
4160 member_destructor_ = [&]() {m_extended_defn.~ExtendedTypeDefn();};
4161 new(&m_extended_defn) ExtendedTypeDefn();
4162
4163 }
4164
4165 return m_extended_defn;
4166 }
4167
4168
4169 uint8_t m__d {TK_NONE};
4170
4171 union
4172 {
4185 };
4186
4187 uint32_t selected_member_ {0x0FFFFFFFu};
4188
4189 std::function<void()> member_destructor_;
4190};
4191typedef std::vector<TypeIdentifier> TypeIdentifierSeq;
4192
4193typedef uint32_t MemberId;
4194
4195const uint32_t ANNOTATION_STR_VALUE_MAX_LEN = 128;
4202{
4203public:
4204
4208 eProsima_user_DllExport ExtendedAnnotationParameterValue()
4209 {
4210 }
4211
4215 eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
4216 {
4217 }
4218
4223 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4225 {
4226 static_cast<void>(x);
4227 }
4228
4233 eProsima_user_DllExport ExtendedAnnotationParameterValue(
4235 {
4236 static_cast<void>(x);
4237 }
4238
4245 {
4246
4247 static_cast<void>(x);
4248
4249 return *this;
4250 }
4251
4258 {
4259
4260 static_cast<void>(x);
4261
4262 return *this;
4263 }
4264
4269 eProsima_user_DllExport bool operator ==(
4270 const ExtendedAnnotationParameterValue& x) const
4271 {
4272 static_cast<void>(x);
4273 return true;
4274 }
4275
4280 eProsima_user_DllExport bool operator !=(
4281 const ExtendedAnnotationParameterValue& x) const
4282 {
4283 return !(*this == x);
4284 }
4285
4286
4287
4288private:
4289
4290
4291};
4297{
4298public:
4299
4303 eProsima_user_DllExport AnnotationParameterValue()
4304 {
4305 selected_member_ = 0x00000013;
4306 member_destructor_ = [&]() {m_extended_value.~ExtendedAnnotationParameterValue();};
4308
4309 }
4310
4314 eProsima_user_DllExport ~AnnotationParameterValue()
4315 {
4316 if (member_destructor_)
4317 {
4318 member_destructor_();
4319 }
4320 }
4321
4326 eProsima_user_DllExport AnnotationParameterValue(
4327 const AnnotationParameterValue& x)
4328 {
4329 m__d = x.m__d;
4330
4331 switch (x.selected_member_)
4332 {
4333 case 0x00000001:
4334 boolean_value_() = x.m_boolean_value;
4335 break;
4336
4337 case 0x00000002:
4338 byte_value_() = x.m_byte_value;
4339 break;
4340
4341 case 0x00000003:
4342 int8_value_() = x.m_int8_value;
4343 break;
4344
4345 case 0x00000004:
4346 uint8_value_() = x.m_uint8_value;
4347 break;
4348
4349 case 0x00000005:
4350 int16_value_() = x.m_int16_value;
4351 break;
4352
4353 case 0x00000006:
4354 uint_16_value_() = x.m_uint_16_value;
4355 break;
4356
4357 case 0x00000007:
4358 int32_value_() = x.m_int32_value;
4359 break;
4360
4361 case 0x00000008:
4362 uint32_value_() = x.m_uint32_value;
4363 break;
4364
4365 case 0x00000009:
4366 int64_value_() = x.m_int64_value;
4367 break;
4368
4369 case 0x0000000a:
4370 uint64_value_() = x.m_uint64_value;
4371 break;
4372
4373 case 0x0000000b:
4374 float32_value_() = x.m_float32_value;
4375 break;
4376
4377 case 0x0000000c:
4378 float64_value_() = x.m_float64_value;
4379 break;
4380
4381 case 0x0000000d:
4382 float128_value_() = x.m_float128_value;
4383 break;
4384
4385 case 0x0000000e:
4386 char_value_() = x.m_char_value;
4387 break;
4388
4389 case 0x0000000f:
4390 wchar_value_() = x.m_wchar_value;
4391 break;
4392
4393 case 0x00000010:
4394 enumerated_value_() = x.m_enumerated_value;
4395 break;
4396
4397 case 0x00000011:
4398 string8_value_() = x.m_string8_value;
4399 break;
4400
4401 case 0x00000012:
4402 string16_value_() = x.m_string16_value;
4403 break;
4404
4405 case 0x00000013:
4406 extended_value_() = x.m_extended_value;
4407 break;
4408
4409 }
4410 }
4411
4416 eProsima_user_DllExport AnnotationParameterValue(
4417 AnnotationParameterValue&& x) noexcept
4418 {
4419 m__d = x.m__d;
4420
4421 switch (x.selected_member_)
4422 {
4423 case 0x00000001:
4424 boolean_value_() = std::move(x.m_boolean_value);
4425 break;
4426
4427 case 0x00000002:
4428 byte_value_() = std::move(x.m_byte_value);
4429 break;
4430
4431 case 0x00000003:
4432 int8_value_() = std::move(x.m_int8_value);
4433 break;
4434
4435 case 0x00000004:
4436 uint8_value_() = std::move(x.m_uint8_value);
4437 break;
4438
4439 case 0x00000005:
4440 int16_value_() = std::move(x.m_int16_value);
4441 break;
4442
4443 case 0x00000006:
4444 uint_16_value_() = std::move(x.m_uint_16_value);
4445 break;
4446
4447 case 0x00000007:
4448 int32_value_() = std::move(x.m_int32_value);
4449 break;
4450
4451 case 0x00000008:
4452 uint32_value_() = std::move(x.m_uint32_value);
4453 break;
4454
4455 case 0x00000009:
4456 int64_value_() = std::move(x.m_int64_value);
4457 break;
4458
4459 case 0x0000000a:
4460 uint64_value_() = std::move(x.m_uint64_value);
4461 break;
4462
4463 case 0x0000000b:
4464 float32_value_() = std::move(x.m_float32_value);
4465 break;
4466
4467 case 0x0000000c:
4468 float64_value_() = std::move(x.m_float64_value);
4469 break;
4470
4471 case 0x0000000d:
4472 float128_value_() = std::move(x.m_float128_value);
4473 break;
4474
4475 case 0x0000000e:
4476 char_value_() = std::move(x.m_char_value);
4477 break;
4478
4479 case 0x0000000f:
4480 wchar_value_() = std::move(x.m_wchar_value);
4481 break;
4482
4483 case 0x00000010:
4484 enumerated_value_() = std::move(x.m_enumerated_value);
4485 break;
4486
4487 case 0x00000011:
4488 string8_value_() = std::move(x.m_string8_value);
4489 break;
4490
4491 case 0x00000012:
4492 string16_value_() = std::move(x.m_string16_value);
4493 break;
4494
4495 case 0x00000013:
4496 extended_value_() = std::move(x.m_extended_value);
4497 break;
4498
4499 }
4500 }
4501
4506 eProsima_user_DllExport AnnotationParameterValue& operator =(
4507 const AnnotationParameterValue& x)
4508 {
4509 m__d = x.m__d;
4510
4511 switch (x.selected_member_)
4512 {
4513 case 0x00000001:
4514 boolean_value_() = x.m_boolean_value;
4515 break;
4516
4517 case 0x00000002:
4518 byte_value_() = x.m_byte_value;
4519 break;
4520
4521 case 0x00000003:
4522 int8_value_() = x.m_int8_value;
4523 break;
4524
4525 case 0x00000004:
4526 uint8_value_() = x.m_uint8_value;
4527 break;
4528
4529 case 0x00000005:
4530 int16_value_() = x.m_int16_value;
4531 break;
4532
4533 case 0x00000006:
4534 uint_16_value_() = x.m_uint_16_value;
4535 break;
4536
4537 case 0x00000007:
4538 int32_value_() = x.m_int32_value;
4539 break;
4540
4541 case 0x00000008:
4542 uint32_value_() = x.m_uint32_value;
4543 break;
4544
4545 case 0x00000009:
4546 int64_value_() = x.m_int64_value;
4547 break;
4548
4549 case 0x0000000a:
4550 uint64_value_() = x.m_uint64_value;
4551 break;
4552
4553 case 0x0000000b:
4554 float32_value_() = x.m_float32_value;
4555 break;
4556
4557 case 0x0000000c:
4558 float64_value_() = x.m_float64_value;
4559 break;
4560
4561 case 0x0000000d:
4562 float128_value_() = x.m_float128_value;
4563 break;
4564
4565 case 0x0000000e:
4566 char_value_() = x.m_char_value;
4567 break;
4568
4569 case 0x0000000f:
4570 wchar_value_() = x.m_wchar_value;
4571 break;
4572
4573 case 0x00000010:
4574 enumerated_value_() = x.m_enumerated_value;
4575 break;
4576
4577 case 0x00000011:
4578 string8_value_() = x.m_string8_value;
4579 break;
4580
4581 case 0x00000012:
4582 string16_value_() = x.m_string16_value;
4583 break;
4584
4585 case 0x00000013:
4586 extended_value_() = x.m_extended_value;
4587 break;
4588
4589 }
4590
4591 return *this;
4592 }
4593
4598 eProsima_user_DllExport AnnotationParameterValue& operator =(
4599 AnnotationParameterValue&& x) noexcept
4600 {
4601 m__d = x.m__d;
4602
4603 switch (x.selected_member_)
4604 {
4605 case 0x00000001:
4606 boolean_value_() = std::move(x.m_boolean_value);
4607 break;
4608
4609 case 0x00000002:
4610 byte_value_() = std::move(x.m_byte_value);
4611 break;
4612
4613 case 0x00000003:
4614 int8_value_() = std::move(x.m_int8_value);
4615 break;
4616
4617 case 0x00000004:
4618 uint8_value_() = std::move(x.m_uint8_value);
4619 break;
4620
4621 case 0x00000005:
4622 int16_value_() = std::move(x.m_int16_value);
4623 break;
4624
4625 case 0x00000006:
4626 uint_16_value_() = std::move(x.m_uint_16_value);
4627 break;
4628
4629 case 0x00000007:
4630 int32_value_() = std::move(x.m_int32_value);
4631 break;
4632
4633 case 0x00000008:
4634 uint32_value_() = std::move(x.m_uint32_value);
4635 break;
4636
4637 case 0x00000009:
4638 int64_value_() = std::move(x.m_int64_value);
4639 break;
4640
4641 case 0x0000000a:
4642 uint64_value_() = std::move(x.m_uint64_value);
4643 break;
4644
4645 case 0x0000000b:
4646 float32_value_() = std::move(x.m_float32_value);
4647 break;
4648
4649 case 0x0000000c:
4650 float64_value_() = std::move(x.m_float64_value);
4651 break;
4652
4653 case 0x0000000d:
4654 float128_value_() = std::move(x.m_float128_value);
4655 break;
4656
4657 case 0x0000000e:
4658 char_value_() = std::move(x.m_char_value);
4659 break;
4660
4661 case 0x0000000f:
4662 wchar_value_() = std::move(x.m_wchar_value);
4663 break;
4664
4665 case 0x00000010:
4666 enumerated_value_() = std::move(x.m_enumerated_value);
4667 break;
4668
4669 case 0x00000011:
4670 string8_value_() = std::move(x.m_string8_value);
4671 break;
4672
4673 case 0x00000012:
4674 string16_value_() = std::move(x.m_string16_value);
4675 break;
4676
4677 case 0x00000013:
4678 extended_value_() = std::move(x.m_extended_value);
4679 break;
4680
4681 }
4682
4683 return *this;
4684 }
4685
4690 eProsima_user_DllExport bool operator ==(
4691 const AnnotationParameterValue& x) const
4692 {
4693 bool ret_value {false};
4694
4695 if (x.selected_member_ == selected_member_)
4696 {
4697 if (0x0FFFFFFFu != selected_member_)
4698 {
4699 if (x.m__d == m__d)
4700 {
4701 switch (selected_member_)
4702 {
4703 case 0x00000001:
4704 ret_value = (x.m_boolean_value == m_boolean_value);
4705 break;
4706
4707 case 0x00000002:
4708 ret_value = (x.m_byte_value == m_byte_value);
4709 break;
4710
4711 case 0x00000003:
4712 ret_value = (x.m_int8_value == m_int8_value);
4713 break;
4714
4715 case 0x00000004:
4716 ret_value = (x.m_uint8_value == m_uint8_value);
4717 break;
4718
4719 case 0x00000005:
4720 ret_value = (x.m_int16_value == m_int16_value);
4721 break;
4722
4723 case 0x00000006:
4724 ret_value = (x.m_uint_16_value == m_uint_16_value);
4725 break;
4726
4727 case 0x00000007:
4728 ret_value = (x.m_int32_value == m_int32_value);
4729 break;
4730
4731 case 0x00000008:
4732 ret_value = (x.m_uint32_value == m_uint32_value);
4733 break;
4734
4735 case 0x00000009:
4736 ret_value = (x.m_int64_value == m_int64_value);
4737 break;
4738
4739 case 0x0000000a:
4740 ret_value = (x.m_uint64_value == m_uint64_value);
4741 break;
4742
4743 case 0x0000000b:
4744 ret_value = (x.m_float32_value == m_float32_value);
4745 break;
4746
4747 case 0x0000000c:
4748 ret_value = (x.m_float64_value == m_float64_value);
4749 break;
4750
4751 case 0x0000000d:
4752 ret_value = (x.m_float128_value == m_float128_value);
4753 break;
4754
4755 case 0x0000000e:
4756 ret_value = (x.m_char_value == m_char_value);
4757 break;
4758
4759 case 0x0000000f:
4760 ret_value = (x.m_wchar_value == m_wchar_value);
4761 break;
4762
4763 case 0x00000010:
4764 ret_value = (x.m_enumerated_value == m_enumerated_value);
4765 break;
4766
4767 case 0x00000011:
4768 ret_value = (x.m_string8_value == m_string8_value);
4769 break;
4770
4771 case 0x00000012:
4772 ret_value = (x.m_string16_value == m_string16_value);
4773 break;
4774
4775 case 0x00000013:
4776 ret_value = (x.m_extended_value == m_extended_value);
4777 break;
4778
4779 }
4780 }
4781 }
4782 else
4783 {
4784 ret_value = true;
4785 }
4786 }
4787
4788 return ret_value;
4789 }
4790
4795 eProsima_user_DllExport bool operator !=(
4796 const AnnotationParameterValue& x) const
4797 {
4798 return !(*this == x);
4799 }
4800
4806 eProsima_user_DllExport void _d(
4807 uint8_t __d)
4808 {
4809 bool valid_discriminator = false;
4810
4811 switch (__d)
4812 {
4813 case TK_BOOLEAN:
4814 if (0x00000001 == selected_member_)
4815 {
4816 valid_discriminator = true;
4817 }
4818 break;
4819
4820 case TK_BYTE:
4821 if (0x00000002 == selected_member_)
4822 {
4823 valid_discriminator = true;
4824 }
4825 break;
4826
4827 case TK_INT8:
4828 if (0x00000003 == selected_member_)
4829 {
4830 valid_discriminator = true;
4831 }
4832 break;
4833
4834 case TK_UINT8:
4835 if (0x00000004 == selected_member_)
4836 {
4837 valid_discriminator = true;
4838 }
4839 break;
4840
4841 case TK_INT16:
4842 if (0x00000005 == selected_member_)
4843 {
4844 valid_discriminator = true;
4845 }
4846 break;
4847
4848 case TK_UINT16:
4849 if (0x00000006 == selected_member_)
4850 {
4851 valid_discriminator = true;
4852 }
4853 break;
4854
4855 case TK_INT32:
4856 if (0x00000007 == selected_member_)
4857 {
4858 valid_discriminator = true;
4859 }
4860 break;
4861
4862 case TK_UINT32:
4863 if (0x00000008 == selected_member_)
4864 {
4865 valid_discriminator = true;
4866 }
4867 break;
4868
4869 case TK_INT64:
4870 if (0x00000009 == selected_member_)
4871 {
4872 valid_discriminator = true;
4873 }
4874 break;
4875
4876 case TK_UINT64:
4877 if (0x0000000a == selected_member_)
4878 {
4879 valid_discriminator = true;
4880 }
4881 break;
4882
4883 case TK_FLOAT32:
4884 if (0x0000000b == selected_member_)
4885 {
4886 valid_discriminator = true;
4887 }
4888 break;
4889
4890 case TK_FLOAT64:
4891 if (0x0000000c == selected_member_)
4892 {
4893 valid_discriminator = true;
4894 }
4895 break;
4896
4897 case TK_FLOAT128:
4898 if (0x0000000d == selected_member_)
4899 {
4900 valid_discriminator = true;
4901 }
4902 break;
4903
4904 case TK_CHAR8:
4905 if (0x0000000e == selected_member_)
4906 {
4907 valid_discriminator = true;
4908 }
4909 break;
4910
4911 case TK_CHAR16:
4912 if (0x0000000f == selected_member_)
4913 {
4914 valid_discriminator = true;
4915 }
4916 break;
4917
4918 case TK_ENUM:
4919 if (0x00000010 == selected_member_)
4920 {
4921 valid_discriminator = true;
4922 }
4923 break;
4924
4925 case TK_STRING8:
4926 if (0x00000011 == selected_member_)
4927 {
4928 valid_discriminator = true;
4929 }
4930 break;
4931
4932 case TK_STRING16:
4933 if (0x00000012 == selected_member_)
4934 {
4935 valid_discriminator = true;
4936 }
4937 break;
4938
4939 default:
4940 if (0x00000013 == selected_member_)
4941 {
4942 valid_discriminator = true;
4943 }
4944 break;
4945
4946 }
4947
4948 if (!valid_discriminator)
4949 {
4950 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
4951 }
4952
4953 m__d = __d;
4954 }
4955
4960 eProsima_user_DllExport uint8_t _d() const
4961 {
4962 return m__d;
4963 }
4964
4969 eProsima_user_DllExport void boolean_value(
4970 bool _boolean_value)
4971 {
4972 boolean_value_() = _boolean_value;
4973 m__d = TK_BOOLEAN;
4974 }
4975
4981 eProsima_user_DllExport bool boolean_value() const
4982 {
4983 if (0x00000001 != selected_member_)
4984 {
4985 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
4986 }
4987
4988 return m_boolean_value;
4989 }
4990
4996 eProsima_user_DllExport bool& boolean_value()
4997 {
4998 if (0x00000001 != selected_member_)
4999 {
5000 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5001 }
5002
5003 return m_boolean_value;
5004 }
5005
5006
5011 eProsima_user_DllExport void byte_value(
5012 uint8_t _byte_value)
5013 {
5014 byte_value_() = _byte_value;
5015 m__d = TK_BYTE;
5016 }
5017
5023 eProsima_user_DllExport uint8_t byte_value() const
5024 {
5025 if (0x00000002 != selected_member_)
5026 {
5027 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5028 }
5029
5030 return m_byte_value;
5031 }
5032
5038 eProsima_user_DllExport uint8_t& byte_value()
5039 {
5040 if (0x00000002 != selected_member_)
5041 {
5042 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5043 }
5044
5045 return m_byte_value;
5046 }
5047
5048
5053 eProsima_user_DllExport void int8_value(
5054 int8_t _int8_value)
5055 {
5056 int8_value_() = _int8_value;
5057 m__d = TK_INT8;
5058 }
5059
5065 eProsima_user_DllExport int8_t int8_value() const
5066 {
5067 if (0x00000003 != selected_member_)
5068 {
5069 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5070 }
5071
5072 return m_int8_value;
5073 }
5074
5080 eProsima_user_DllExport int8_t& int8_value()
5081 {
5082 if (0x00000003 != selected_member_)
5083 {
5084 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5085 }
5086
5087 return m_int8_value;
5088 }
5089
5090
5095 eProsima_user_DllExport void uint8_value(
5096 uint8_t _uint8_value)
5097 {
5098 uint8_value_() = _uint8_value;
5099 m__d = TK_UINT8;
5100 }
5101
5107 eProsima_user_DllExport uint8_t uint8_value() const
5108 {
5109 if (0x00000004 != selected_member_)
5110 {
5111 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5112 }
5113
5114 return m_uint8_value;
5115 }
5116
5122 eProsima_user_DllExport uint8_t& uint8_value()
5123 {
5124 if (0x00000004 != selected_member_)
5125 {
5126 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5127 }
5128
5129 return m_uint8_value;
5130 }
5131
5132
5137 eProsima_user_DllExport void int16_value(
5138 int16_t _int16_value)
5139 {
5140 int16_value_() = _int16_value;
5141 m__d = TK_INT16;
5142 }
5143
5149 eProsima_user_DllExport int16_t int16_value() const
5150 {
5151 if (0x00000005 != selected_member_)
5152 {
5153 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5154 }
5155
5156 return m_int16_value;
5157 }
5158
5164 eProsima_user_DllExport int16_t& int16_value()
5165 {
5166 if (0x00000005 != selected_member_)
5167 {
5168 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5169 }
5170
5171 return m_int16_value;
5172 }
5173
5174
5179 eProsima_user_DllExport void uint_16_value(
5180 uint16_t _uint_16_value)
5181 {
5182 uint_16_value_() = _uint_16_value;
5183 m__d = TK_UINT16;
5184 }
5185
5191 eProsima_user_DllExport uint16_t uint_16_value() const
5192 {
5193 if (0x00000006 != selected_member_)
5194 {
5195 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5196 }
5197
5198 return m_uint_16_value;
5199 }
5200
5206 eProsima_user_DllExport uint16_t& uint_16_value()
5207 {
5208 if (0x00000006 != selected_member_)
5209 {
5210 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5211 }
5212
5213 return m_uint_16_value;
5214 }
5215
5216
5221 eProsima_user_DllExport void int32_value(
5222 int32_t _int32_value)
5223 {
5224 int32_value_() = _int32_value;
5225 m__d = TK_INT32;
5226 }
5227
5233 eProsima_user_DllExport int32_t int32_value() const
5234 {
5235 if (0x00000007 != selected_member_)
5236 {
5237 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5238 }
5239
5240 return m_int32_value;
5241 }
5242
5248 eProsima_user_DllExport int32_t& int32_value()
5249 {
5250 if (0x00000007 != selected_member_)
5251 {
5252 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5253 }
5254
5255 return m_int32_value;
5256 }
5257
5258
5263 eProsima_user_DllExport void uint32_value(
5264 uint32_t _uint32_value)
5265 {
5266 uint32_value_() = _uint32_value;
5267 m__d = TK_UINT32;
5268 }
5269
5275 eProsima_user_DllExport uint32_t uint32_value() const
5276 {
5277 if (0x00000008 != selected_member_)
5278 {
5279 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5280 }
5281
5282 return m_uint32_value;
5283 }
5284
5290 eProsima_user_DllExport uint32_t& uint32_value()
5291 {
5292 if (0x00000008 != selected_member_)
5293 {
5294 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5295 }
5296
5297 return m_uint32_value;
5298 }
5299
5300
5305 eProsima_user_DllExport void int64_value(
5306 int64_t _int64_value)
5307 {
5308 int64_value_() = _int64_value;
5309 m__d = TK_INT64;
5310 }
5311
5317 eProsima_user_DllExport int64_t int64_value() const
5318 {
5319 if (0x00000009 != selected_member_)
5320 {
5321 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5322 }
5323
5324 return m_int64_value;
5325 }
5326
5332 eProsima_user_DllExport int64_t& int64_value()
5333 {
5334 if (0x00000009 != selected_member_)
5335 {
5336 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5337 }
5338
5339 return m_int64_value;
5340 }
5341
5342
5347 eProsima_user_DllExport void uint64_value(
5348 uint64_t _uint64_value)
5349 {
5350 uint64_value_() = _uint64_value;
5351 m__d = TK_UINT64;
5352 }
5353
5359 eProsima_user_DllExport uint64_t uint64_value() const
5360 {
5361 if (0x0000000a != selected_member_)
5362 {
5363 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5364 }
5365
5366 return m_uint64_value;
5367 }
5368
5374 eProsima_user_DllExport uint64_t& uint64_value()
5375 {
5376 if (0x0000000a != selected_member_)
5377 {
5378 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5379 }
5380
5381 return m_uint64_value;
5382 }
5383
5384
5389 eProsima_user_DllExport void float32_value(
5390 float _float32_value)
5391 {
5392 float32_value_() = _float32_value;
5393 m__d = TK_FLOAT32;
5394 }
5395
5401 eProsima_user_DllExport float float32_value() const
5402 {
5403 if (0x0000000b != selected_member_)
5404 {
5405 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5406 }
5407
5408 return m_float32_value;
5409 }
5410
5416 eProsima_user_DllExport float& float32_value()
5417 {
5418 if (0x0000000b != selected_member_)
5419 {
5420 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5421 }
5422
5423 return m_float32_value;
5424 }
5425
5426
5431 eProsima_user_DllExport void float64_value(
5432 double _float64_value)
5433 {
5434 float64_value_() = _float64_value;
5435 m__d = TK_FLOAT64;
5436 }
5437
5443 eProsima_user_DllExport double float64_value() const
5444 {
5445 if (0x0000000c != selected_member_)
5446 {
5447 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5448 }
5449
5450 return m_float64_value;
5451 }
5452
5458 eProsima_user_DllExport double& float64_value()
5459 {
5460 if (0x0000000c != selected_member_)
5461 {
5462 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5463 }
5464
5465 return m_float64_value;
5466 }
5467
5468
5473 eProsima_user_DllExport void float128_value(
5474 long double _float128_value)
5475 {
5476 float128_value_() = _float128_value;
5477 m__d = TK_FLOAT128;
5478 }
5479
5485 eProsima_user_DllExport long double float128_value() const
5486 {
5487 if (0x0000000d != selected_member_)
5488 {
5489 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5490 }
5491
5492 return m_float128_value;
5493 }
5494
5500 eProsima_user_DllExport long double& float128_value()
5501 {
5502 if (0x0000000d != selected_member_)
5503 {
5504 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5505 }
5506
5507 return m_float128_value;
5508 }
5509
5510
5515 eProsima_user_DllExport void char_value(
5516 char _char_value)
5517 {
5518 char_value_() = _char_value;
5519 m__d = TK_CHAR8;
5520 }
5521
5527 eProsima_user_DllExport char char_value() const
5528 {
5529 if (0x0000000e != selected_member_)
5530 {
5531 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5532 }
5533
5534 return m_char_value;
5535 }
5536
5542 eProsima_user_DllExport char& char_value()
5543 {
5544 if (0x0000000e != selected_member_)
5545 {
5546 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5547 }
5548
5549 return m_char_value;
5550 }
5551
5552
5557 eProsima_user_DllExport void wchar_value(
5558 wchar_t _wchar_value)
5559 {
5560 wchar_value_() = _wchar_value;
5561 m__d = TK_CHAR16;
5562 }
5563
5569 eProsima_user_DllExport wchar_t wchar_value() const
5570 {
5571 if (0x0000000f != selected_member_)
5572 {
5573 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5574 }
5575
5576 return m_wchar_value;
5577 }
5578
5584 eProsima_user_DllExport wchar_t& wchar_value()
5585 {
5586 if (0x0000000f != selected_member_)
5587 {
5588 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5589 }
5590
5591 return m_wchar_value;
5592 }
5593
5594
5599 eProsima_user_DllExport void enumerated_value(
5600 int32_t _enumerated_value)
5601 {
5602 enumerated_value_() = _enumerated_value;
5603 m__d = TK_ENUM;
5604 }
5605
5611 eProsima_user_DllExport int32_t enumerated_value() const
5612 {
5613 if (0x00000010 != selected_member_)
5614 {
5615 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5616 }
5617
5618 return m_enumerated_value;
5619 }
5620
5626 eProsima_user_DllExport int32_t& enumerated_value()
5627 {
5628 if (0x00000010 != selected_member_)
5629 {
5630 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5631 }
5632
5633 return m_enumerated_value;
5634 }
5635
5636
5641 eProsima_user_DllExport void string8_value(
5642 const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& _string8_value)
5643 {
5644 string8_value_() = _string8_value;
5645 m__d = TK_STRING8;
5646 }
5647
5652 eProsima_user_DllExport void string8_value(
5653 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>&& _string8_value)
5654 {
5655 string8_value_() = _string8_value;
5656 m__d = TK_STRING8;
5657 }
5658
5664 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value() const
5665 {
5666 if (0x00000011 != selected_member_)
5667 {
5668 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5669 }
5670
5671 return m_string8_value;
5672 }
5673
5679 eProsima_user_DllExport eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value()
5680 {
5681 if (0x00000011 != selected_member_)
5682 {
5683 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5684 }
5685
5686 return m_string8_value;
5687 }
5688
5689
5694 eProsima_user_DllExport void string16_value(
5695 const std::wstring& _string16_value)
5696 {
5697 string16_value_() = _string16_value;
5698 m__d = TK_STRING16;
5699 }
5700
5705 eProsima_user_DllExport void string16_value(
5706 std::wstring&& _string16_value)
5707 {
5708 string16_value_() = _string16_value;
5709 m__d = TK_STRING16;
5710 }
5711
5717 eProsima_user_DllExport const std::wstring& string16_value() const
5718 {
5719 if (0x00000012 != selected_member_)
5720 {
5721 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5722 }
5723
5724 return m_string16_value;
5725 }
5726
5732 eProsima_user_DllExport std::wstring& string16_value()
5733 {
5734 if (0x00000012 != selected_member_)
5735 {
5736 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5737 }
5738
5739 return m_string16_value;
5740 }
5741
5742
5747 eProsima_user_DllExport void extended_value(
5748 const ExtendedAnnotationParameterValue& _extended_value)
5749 {
5750 extended_value_() = _extended_value;
5751 m__d = 127;
5752 }
5753
5758 eProsima_user_DllExport void extended_value(
5759 ExtendedAnnotationParameterValue&& _extended_value)
5760 {
5761 extended_value_() = _extended_value;
5762 m__d = 127;
5763 }
5764
5770 eProsima_user_DllExport const ExtendedAnnotationParameterValue& extended_value() const
5771 {
5772 if (0x00000013 != selected_member_)
5773 {
5774 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5775 }
5776
5777 return m_extended_value;
5778 }
5779
5786 {
5787 if (0x00000013 != selected_member_)
5788 {
5789 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
5790 }
5791
5792 return m_extended_value;
5793 }
5794
5795
5796
5797private:
5798
5799 bool& boolean_value_()
5800 {
5801 if (0x00000001 != selected_member_)
5802 {
5803 if (member_destructor_)
5804 {
5805 member_destructor_();
5806 }
5807
5808 selected_member_ = 0x00000001;
5809 member_destructor_ = nullptr;
5810 m_boolean_value = {false};
5811
5812 }
5813
5814 return m_boolean_value;
5815 }
5816
5817 uint8_t& byte_value_()
5818 {
5819 if (0x00000002 != selected_member_)
5820 {
5821 if (member_destructor_)
5822 {
5823 member_destructor_();
5824 }
5825
5826 selected_member_ = 0x00000002;
5827 member_destructor_ = nullptr;
5828 m_byte_value = {0};
5829
5830 }
5831
5832 return m_byte_value;
5833 }
5834
5835 int8_t& int8_value_()
5836 {
5837 if (0x00000003 != selected_member_)
5838 {
5839 if (member_destructor_)
5840 {
5841 member_destructor_();
5842 }
5843
5844 selected_member_ = 0x00000003;
5845 member_destructor_ = nullptr;
5846 m_int8_value = {0};
5847
5848 }
5849
5850 return m_int8_value;
5851 }
5852
5853 uint8_t& uint8_value_()
5854 {
5855 if (0x00000004 != selected_member_)
5856 {
5857 if (member_destructor_)
5858 {
5859 member_destructor_();
5860 }
5861
5862 selected_member_ = 0x00000004;
5863 member_destructor_ = nullptr;
5864 m_uint8_value = {0};
5865
5866 }
5867
5868 return m_uint8_value;
5869 }
5870
5871 int16_t& int16_value_()
5872 {
5873 if (0x00000005 != selected_member_)
5874 {
5875 if (member_destructor_)
5876 {
5877 member_destructor_();
5878 }
5879
5880 selected_member_ = 0x00000005;
5881 member_destructor_ = nullptr;
5882 m_int16_value = {0};
5883
5884 }
5885
5886 return m_int16_value;
5887 }
5888
5889 uint16_t& uint_16_value_()
5890 {
5891 if (0x00000006 != selected_member_)
5892 {
5893 if (member_destructor_)
5894 {
5895 member_destructor_();
5896 }
5897
5898 selected_member_ = 0x00000006;
5899 member_destructor_ = nullptr;
5900 m_uint_16_value = {0};
5901
5902 }
5903
5904 return m_uint_16_value;
5905 }
5906
5907 int32_t& int32_value_()
5908 {
5909 if (0x00000007 != selected_member_)
5910 {
5911 if (member_destructor_)
5912 {
5913 member_destructor_();
5914 }
5915
5916 selected_member_ = 0x00000007;
5917 member_destructor_ = nullptr;
5918 m_int32_value = {0};
5919
5920 }
5921
5922 return m_int32_value;
5923 }
5924
5925 uint32_t& uint32_value_()
5926 {
5927 if (0x00000008 != selected_member_)
5928 {
5929 if (member_destructor_)
5930 {
5931 member_destructor_();
5932 }
5933
5934 selected_member_ = 0x00000008;
5935 member_destructor_ = nullptr;
5936 m_uint32_value = {0};
5937
5938 }
5939
5940 return m_uint32_value;
5941 }
5942
5943 int64_t& int64_value_()
5944 {
5945 if (0x00000009 != selected_member_)
5946 {
5947 if (member_destructor_)
5948 {
5949 member_destructor_();
5950 }
5951
5952 selected_member_ = 0x00000009;
5953 member_destructor_ = nullptr;
5954 m_int64_value = {0};
5955
5956 }
5957
5958 return m_int64_value;
5959 }
5960
5961 uint64_t& uint64_value_()
5962 {
5963 if (0x0000000a != selected_member_)
5964 {
5965 if (member_destructor_)
5966 {
5967 member_destructor_();
5968 }
5969
5970 selected_member_ = 0x0000000a;
5971 member_destructor_ = nullptr;
5972 m_uint64_value = {0};
5973
5974 }
5975
5976 return m_uint64_value;
5977 }
5978
5979 float& float32_value_()
5980 {
5981 if (0x0000000b != selected_member_)
5982 {
5983 if (member_destructor_)
5984 {
5985 member_destructor_();
5986 }
5987
5988 selected_member_ = 0x0000000b;
5989 member_destructor_ = nullptr;
5990 m_float32_value = {0.0};
5991
5992 }
5993
5994 return m_float32_value;
5995 }
5996
5997 double& float64_value_()
5998 {
5999 if (0x0000000c != selected_member_)
6000 {
6001 if (member_destructor_)
6002 {
6003 member_destructor_();
6004 }
6005
6006 selected_member_ = 0x0000000c;
6007 member_destructor_ = nullptr;
6008 m_float64_value = {0.0};
6009
6010 }
6011
6012 return m_float64_value;
6013 }
6014
6015 long double& float128_value_()
6016 {
6017 if (0x0000000d != selected_member_)
6018 {
6019 if (member_destructor_)
6020 {
6021 member_destructor_();
6022 }
6023
6024 selected_member_ = 0x0000000d;
6025 member_destructor_ = nullptr;
6026 m_float128_value = {0.0};
6027
6028 }
6029
6030 return m_float128_value;
6031 }
6032
6033 char& char_value_()
6034 {
6035 if (0x0000000e != selected_member_)
6036 {
6037 if (member_destructor_)
6038 {
6039 member_destructor_();
6040 }
6041
6042 selected_member_ = 0x0000000e;
6043 member_destructor_ = nullptr;
6044 m_char_value = {0};
6045
6046 }
6047
6048 return m_char_value;
6049 }
6050
6051 wchar_t& wchar_value_()
6052 {
6053 if (0x0000000f != selected_member_)
6054 {
6055 if (member_destructor_)
6056 {
6057 member_destructor_();
6058 }
6059
6060 selected_member_ = 0x0000000f;
6061 member_destructor_ = nullptr;
6062 m_wchar_value = {0};
6063
6064 }
6065
6066 return m_wchar_value;
6067 }
6068
6069 int32_t& enumerated_value_()
6070 {
6071 if (0x00000010 != selected_member_)
6072 {
6073 if (member_destructor_)
6074 {
6075 member_destructor_();
6076 }
6077
6078 selected_member_ = 0x00000010;
6079 member_destructor_ = nullptr;
6080 m_enumerated_value = {0};
6081
6082 }
6083
6084 return m_enumerated_value;
6085 }
6086
6087 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>& string8_value_()
6088 {
6089 if (0x00000011 != selected_member_)
6090 {
6091 if (member_destructor_)
6092 {
6093 member_destructor_();
6094 }
6095
6096 selected_member_ = 0x00000011;
6097 member_destructor_ = [&]() {m_string8_value.~fixed_string();};
6098 new(&m_string8_value) eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN>();
6099
6100 }
6101
6102 return m_string8_value;
6103 }
6104
6105 std::wstring& string16_value_()
6106 {
6107 if (0x00000012 != selected_member_)
6108 {
6109 if (member_destructor_)
6110 {
6111 member_destructor_();
6112 }
6113
6114 selected_member_ = 0x00000012;
6115 member_destructor_ = [&]() {m_string16_value.~basic_string();};
6116 new(&m_string16_value) std::wstring();
6117
6118 }
6119
6120 return m_string16_value;
6121 }
6122
6123 ExtendedAnnotationParameterValue& extended_value_()
6124 {
6125 if (0x00000013 != selected_member_)
6126 {
6127 if (member_destructor_)
6128 {
6129 member_destructor_();
6130 }
6131
6132 selected_member_ = 0x00000013;
6133 member_destructor_ = [&]() {m_extended_value.~ExtendedAnnotationParameterValue();};
6134 new(&m_extended_value) ExtendedAnnotationParameterValue();
6135
6136 }
6137
6138 return m_extended_value;
6139 }
6140
6141
6142 uint8_t m__d {127};
6143
6144 union
6145 {
6158 long double m_float128_value;
6162 eprosima::fastcdr::fixed_string<ANNOTATION_STR_VALUE_MAX_LEN> m_string8_value;
6163 std::wstring m_string16_value;
6165 };
6166
6167 uint32_t selected_member_ {0x0FFFFFFFu};
6168
6169 std::function<void()> member_destructor_;
6170};
6176{
6177public:
6178
6182 eProsima_user_DllExport AppliedAnnotationParameter()
6183 {
6184 }
6185
6189 eProsima_user_DllExport ~AppliedAnnotationParameter()
6190 {
6191 }
6192
6197 eProsima_user_DllExport AppliedAnnotationParameter(
6199 {
6200 m_paramname_hash = x.m_paramname_hash;
6201
6202 m_value = x.m_value;
6203
6204 }
6205
6210 eProsima_user_DllExport AppliedAnnotationParameter(
6211 AppliedAnnotationParameter&& x) noexcept
6212 {
6213 m_paramname_hash = std::move(x.m_paramname_hash);
6214 m_value = std::move(x.m_value);
6215 }
6216
6221 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6223 {
6224
6225 m_paramname_hash = x.m_paramname_hash;
6226
6227 m_value = x.m_value;
6228
6229 return *this;
6230 }
6231
6236 eProsima_user_DllExport AppliedAnnotationParameter& operator =(
6237 AppliedAnnotationParameter&& x) noexcept
6238 {
6239
6240 m_paramname_hash = std::move(x.m_paramname_hash);
6241 m_value = std::move(x.m_value);
6242 return *this;
6243 }
6244
6249 eProsima_user_DllExport bool operator ==(
6250 const AppliedAnnotationParameter& x) const
6251 {
6252 return (m_paramname_hash == x.m_paramname_hash &&
6253 m_value == x.m_value);
6254 }
6255
6260 eProsima_user_DllExport bool operator !=(
6261 const AppliedAnnotationParameter& x) const
6262 {
6263 return !(*this == x);
6264 }
6265
6270 eProsima_user_DllExport void paramname_hash(
6271 const NameHash& _paramname_hash)
6272 {
6273 m_paramname_hash = _paramname_hash;
6274 }
6275
6280 eProsima_user_DllExport void paramname_hash(
6281 NameHash&& _paramname_hash)
6282 {
6283 m_paramname_hash = std::move(_paramname_hash);
6284 }
6285
6290 eProsima_user_DllExport const NameHash& paramname_hash() const
6291 {
6292 return m_paramname_hash;
6293 }
6294
6299 eProsima_user_DllExport NameHash& paramname_hash()
6300 {
6301 return m_paramname_hash;
6302 }
6303
6304
6309 eProsima_user_DllExport void value(
6310 const AnnotationParameterValue& _value)
6311 {
6312 m_value = _value;
6313 }
6314
6319 eProsima_user_DllExport void value(
6320 AnnotationParameterValue&& _value)
6321 {
6322 m_value = std::move(_value);
6323 }
6324
6329 eProsima_user_DllExport const AnnotationParameterValue& value() const
6330 {
6331 return m_value;
6332 }
6333
6338 eProsima_user_DllExport AnnotationParameterValue& value()
6339 {
6340 return m_value;
6341 }
6342
6343
6344
6345private:
6346
6347 NameHash m_paramname_hash{0};
6348 AnnotationParameterValue m_value;
6349
6350};
6351typedef std::vector<AppliedAnnotationParameter> AppliedAnnotationParameterSeq;
6352
6358{
6359public:
6360
6364 eProsima_user_DllExport AppliedAnnotation()
6365 {
6366 }
6367
6371 eProsima_user_DllExport ~AppliedAnnotation()
6372 {
6373 }
6374
6379 eProsima_user_DllExport AppliedAnnotation(
6380 const AppliedAnnotation& x)
6381 {
6382 m_annotation_typeid = x.m_annotation_typeid;
6383
6384 m_param_seq = x.m_param_seq;
6385
6386 }
6387
6392 eProsima_user_DllExport AppliedAnnotation(
6393 AppliedAnnotation&& x) noexcept
6394 {
6395 m_annotation_typeid = std::move(x.m_annotation_typeid);
6396 m_param_seq = std::move(x.m_param_seq);
6397 }
6398
6403 eProsima_user_DllExport AppliedAnnotation& operator =(
6404 const AppliedAnnotation& x)
6405 {
6406
6407 m_annotation_typeid = x.m_annotation_typeid;
6408
6409 m_param_seq = x.m_param_seq;
6410
6411 return *this;
6412 }
6413
6418 eProsima_user_DllExport AppliedAnnotation& operator =(
6419 AppliedAnnotation&& x) noexcept
6420 {
6421
6422 m_annotation_typeid = std::move(x.m_annotation_typeid);
6423 m_param_seq = std::move(x.m_param_seq);
6424 return *this;
6425 }
6426
6431 eProsima_user_DllExport bool operator ==(
6432 const AppliedAnnotation& x) const
6433 {
6434 return (m_annotation_typeid == x.m_annotation_typeid &&
6435 m_param_seq == x.m_param_seq);
6436 }
6437
6442 eProsima_user_DllExport bool operator !=(
6443 const AppliedAnnotation& x) const
6444 {
6445 return !(*this == x);
6446 }
6447
6452 eProsima_user_DllExport void annotation_typeid(
6453 const TypeIdentifier& _annotation_typeid)
6454 {
6455 m_annotation_typeid = _annotation_typeid;
6456 }
6457
6462 eProsima_user_DllExport void annotation_typeid(
6463 TypeIdentifier&& _annotation_typeid)
6464 {
6465 m_annotation_typeid = std::move(_annotation_typeid);
6466 }
6467
6472 eProsima_user_DllExport const TypeIdentifier& annotation_typeid() const
6473 {
6474 return m_annotation_typeid;
6475 }
6476
6481 eProsima_user_DllExport TypeIdentifier& annotation_typeid()
6482 {
6483 return m_annotation_typeid;
6484 }
6485
6486
6491 eProsima_user_DllExport void param_seq(
6492 const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& _param_seq)
6493 {
6494 m_param_seq = _param_seq;
6495 }
6496
6501 eProsima_user_DllExport void param_seq(
6502 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>&& _param_seq)
6503 {
6504 m_param_seq = std::move(_param_seq);
6505 }
6506
6511 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq() const
6512 {
6513 return m_param_seq;
6514 }
6515
6520 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationParameterSeq>& param_seq()
6521 {
6522 return m_param_seq;
6523 }
6524
6525
6526
6527private:
6528
6529 TypeIdentifier m_annotation_typeid;
6530 eprosima::fastcdr::optional<AppliedAnnotationParameterSeq> m_param_seq;
6531
6532};
6533typedef std::vector<AppliedAnnotation> AppliedAnnotationSeq;
6534
6540{
6541public:
6542
6546 eProsima_user_DllExport AppliedVerbatimAnnotation()
6547 {
6548 }
6549
6553 eProsima_user_DllExport ~AppliedVerbatimAnnotation()
6554 {
6555 }
6556
6561 eProsima_user_DllExport AppliedVerbatimAnnotation(
6563 {
6564 m_placement = x.m_placement;
6565
6566 m_language = x.m_language;
6567
6568 m_text = x.m_text;
6569
6570 }
6571
6576 eProsima_user_DllExport AppliedVerbatimAnnotation(
6577 AppliedVerbatimAnnotation&& x) noexcept
6578 {
6579 m_placement = std::move(x.m_placement);
6580 m_language = std::move(x.m_language);
6581 m_text = std::move(x.m_text);
6582 }
6583
6588 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6590 {
6591
6592 m_placement = x.m_placement;
6593
6594 m_language = x.m_language;
6595
6596 m_text = x.m_text;
6597
6598 return *this;
6599 }
6600
6605 eProsima_user_DllExport AppliedVerbatimAnnotation& operator =(
6606 AppliedVerbatimAnnotation&& x) noexcept
6607 {
6608
6609 m_placement = std::move(x.m_placement);
6610 m_language = std::move(x.m_language);
6611 m_text = std::move(x.m_text);
6612 return *this;
6613 }
6614
6619 eProsima_user_DllExport bool operator ==(
6620 const AppliedVerbatimAnnotation& x) const
6621 {
6622 return (m_placement == x.m_placement &&
6623 m_language == x.m_language &&
6624 m_text == x.m_text);
6625 }
6626
6631 eProsima_user_DllExport bool operator !=(
6632 const AppliedVerbatimAnnotation& x) const
6633 {
6634 return !(*this == x);
6635 }
6636
6641 eProsima_user_DllExport void placement(
6642 const eprosima::fastcdr::fixed_string<32>& _placement)
6643 {
6644 m_placement = _placement;
6645 }
6646
6651 eProsima_user_DllExport void placement(
6652 eprosima::fastcdr::fixed_string<32>&& _placement)
6653 {
6654 m_placement = std::move(_placement);
6655 }
6656
6661 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& placement() const
6662 {
6663 return m_placement;
6664 }
6665
6670 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& placement()
6671 {
6672 return m_placement;
6673 }
6674
6675
6680 eProsima_user_DllExport void language(
6681 const eprosima::fastcdr::fixed_string<32>& _language)
6682 {
6683 m_language = _language;
6684 }
6685
6690 eProsima_user_DllExport void language(
6691 eprosima::fastcdr::fixed_string<32>&& _language)
6692 {
6693 m_language = std::move(_language);
6694 }
6695
6700 eProsima_user_DllExport const eprosima::fastcdr::fixed_string<32>& language() const
6701 {
6702 return m_language;
6703 }
6704
6709 eProsima_user_DllExport eprosima::fastcdr::fixed_string<32>& language()
6710 {
6711 return m_language;
6712 }
6713
6714
6719 eProsima_user_DllExport void text(
6720 const std::string& _text)
6721 {
6722 m_text = _text;
6723 }
6724
6729 eProsima_user_DllExport void text(
6730 std::string&& _text)
6731 {
6732 m_text = std::move(_text);
6733 }
6734
6739 eProsima_user_DllExport const std::string& text() const
6740 {
6741 return m_text;
6742 }
6743
6748 eProsima_user_DllExport std::string& text()
6749 {
6750 return m_text;
6751 }
6752
6753
6754
6755private:
6756
6757 eprosima::fastcdr::fixed_string<32> m_placement;
6758 eprosima::fastcdr::fixed_string<32> m_language;
6759 std::string m_text;
6760
6761};
6767{
6768public:
6769
6773 eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
6774 {
6775 }
6776
6780 eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
6781 {
6782 }
6783
6788 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
6790 {
6791 m_unit = x.m_unit;
6792
6793 m_min = x.m_min;
6794
6795 m_max = x.m_max;
6796
6797 m_hash_id = x.m_hash_id;
6798
6799 }
6800
6805 eProsima_user_DllExport AppliedBuiltinMemberAnnotations(
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 }
6813
6820 {
6821
6822 m_unit = x.m_unit;
6823
6824 m_min = x.m_min;
6825
6826 m_max = x.m_max;
6827
6828 m_hash_id = x.m_hash_id;
6829
6830 return *this;
6831 }
6832
6839 {
6840
6841 m_unit = std::move(x.m_unit);
6842 m_min = std::move(x.m_min);
6843 m_max = std::move(x.m_max);
6844 m_hash_id = std::move(x.m_hash_id);
6845 return *this;
6846 }
6847
6852 eProsima_user_DllExport bool operator ==(
6853 const AppliedBuiltinMemberAnnotations& x) const
6854 {
6855 return (m_unit == x.m_unit &&
6856 m_min == x.m_min &&
6857 m_max == x.m_max &&
6858 m_hash_id == x.m_hash_id);
6859 }
6860
6865 eProsima_user_DllExport bool operator !=(
6866 const AppliedBuiltinMemberAnnotations& x) const
6867 {
6868 return !(*this == x);
6869 }
6870
6875 eProsima_user_DllExport void unit(
6876 const eprosima::fastcdr::optional<std::string>& _unit)
6877 {
6878 m_unit = _unit;
6879 }
6880
6885 eProsima_user_DllExport void unit(
6886 eprosima::fastcdr::optional<std::string>&& _unit)
6887 {
6888 m_unit = std::move(_unit);
6889 }
6890
6895 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& unit() const
6896 {
6897 return m_unit;
6898 }
6899
6904 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& unit()
6905 {
6906 return m_unit;
6907 }
6908
6909
6914 eProsima_user_DllExport void min(
6915 const eprosima::fastcdr::optional<AnnotationParameterValue>& _min)
6916 {
6917 m_min = _min;
6918 }
6919
6924 eProsima_user_DllExport void min(
6925 eprosima::fastcdr::optional<AnnotationParameterValue>&& _min)
6926 {
6927 m_min = std::move(_min);
6928 }
6929
6934 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& min() const
6935 {
6936 return m_min;
6937 }
6938
6943 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& min()
6944 {
6945 return m_min;
6946 }
6947
6948
6953 eProsima_user_DllExport void max(
6954 const eprosima::fastcdr::optional<AnnotationParameterValue>& _max)
6955 {
6956 m_max = _max;
6957 }
6958
6963 eProsima_user_DllExport void max(
6964 eprosima::fastcdr::optional<AnnotationParameterValue>&& _max)
6965 {
6966 m_max = std::move(_max);
6967 }
6968
6973 eProsima_user_DllExport const eprosima::fastcdr::optional<AnnotationParameterValue>& max() const
6974 {
6975 return m_max;
6976 }
6977
6982 eProsima_user_DllExport eprosima::fastcdr::optional<AnnotationParameterValue>& max()
6983 {
6984 return m_max;
6985 }
6986
6987
6992 eProsima_user_DllExport void hash_id(
6993 const eprosima::fastcdr::optional<std::string>& _hash_id)
6994 {
6995 m_hash_id = _hash_id;
6996 }
6997
7002 eProsima_user_DllExport void hash_id(
7003 eprosima::fastcdr::optional<std::string>&& _hash_id)
7004 {
7005 m_hash_id = std::move(_hash_id);
7006 }
7007
7012 eProsima_user_DllExport const eprosima::fastcdr::optional<std::string>& hash_id() const
7013 {
7014 return m_hash_id;
7015 }
7016
7021 eProsima_user_DllExport eprosima::fastcdr::optional<std::string>& hash_id()
7022 {
7023 return m_hash_id;
7024 }
7025
7026
7027
7028private:
7029
7030 eprosima::fastcdr::optional<std::string> m_unit;
7031 eprosima::fastcdr::optional<AnnotationParameterValue> m_min;
7032 eprosima::fastcdr::optional<AnnotationParameterValue> m_max;
7033 eprosima::fastcdr::optional<std::string> m_hash_id;
7034
7035};
7041{
7042public:
7043
7047 eProsima_user_DllExport CommonStructMember()
7048 {
7049 }
7050
7054 eProsima_user_DllExport ~CommonStructMember()
7055 {
7056 }
7057
7062 eProsima_user_DllExport CommonStructMember(
7063 const CommonStructMember& x)
7064 {
7065 m_member_id = x.m_member_id;
7066
7067 m_member_flags = x.m_member_flags;
7068
7069 m_member_type_id = x.m_member_type_id;
7070
7071 }
7072
7077 eProsima_user_DllExport CommonStructMember(
7078 CommonStructMember&& x) noexcept
7079 {
7080 m_member_id = x.m_member_id;
7081 m_member_flags = std::move(x.m_member_flags);
7082 m_member_type_id = std::move(x.m_member_type_id);
7083 }
7084
7089 eProsima_user_DllExport CommonStructMember& operator =(
7090 const CommonStructMember& x)
7091 {
7092
7093 m_member_id = x.m_member_id;
7094
7095 m_member_flags = x.m_member_flags;
7096
7097 m_member_type_id = x.m_member_type_id;
7098
7099 return *this;
7100 }
7101
7106 eProsima_user_DllExport CommonStructMember& operator =(
7107 CommonStructMember&& x) noexcept
7108 {
7109
7110 m_member_id = x.m_member_id;
7111 m_member_flags = std::move(x.m_member_flags);
7112 m_member_type_id = std::move(x.m_member_type_id);
7113 return *this;
7114 }
7115
7120 eProsima_user_DllExport bool operator ==(
7121 const CommonStructMember& x) const
7122 {
7123 return (m_member_id == x.m_member_id &&
7124 m_member_flags == x.m_member_flags &&
7125 m_member_type_id == x.m_member_type_id);
7126 }
7127
7132 eProsima_user_DllExport bool operator !=(
7133 const CommonStructMember& x) const
7134 {
7135 return !(*this == x);
7136 }
7137
7142 eProsima_user_DllExport void member_id(
7143 MemberId _member_id)
7144 {
7145 m_member_id = _member_id;
7146 }
7147
7152 eProsima_user_DllExport MemberId member_id() const
7153 {
7154 return m_member_id;
7155 }
7156
7161 eProsima_user_DllExport MemberId& member_id()
7162 {
7163 return m_member_id;
7164 }
7165
7166
7171 eProsima_user_DllExport void member_flags(
7172 const StructMemberFlag& _member_flags)
7173 {
7174 m_member_flags = _member_flags;
7175 }
7176
7181 eProsima_user_DllExport void member_flags(
7182 StructMemberFlag&& _member_flags)
7183 {
7184 m_member_flags = std::move(_member_flags);
7185 }
7186
7191 eProsima_user_DllExport const StructMemberFlag& member_flags() const
7192 {
7193 return m_member_flags;
7194 }
7195
7200 eProsima_user_DllExport StructMemberFlag& member_flags()
7201 {
7202 return m_member_flags;
7203 }
7204
7205
7210 eProsima_user_DllExport void member_type_id(
7211 const TypeIdentifier& _member_type_id)
7212 {
7213 m_member_type_id = _member_type_id;
7214 }
7215
7220 eProsima_user_DllExport void member_type_id(
7221 TypeIdentifier&& _member_type_id)
7222 {
7223 m_member_type_id = std::move(_member_type_id);
7224 }
7225
7230 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
7231 {
7232 return m_member_type_id;
7233 }
7234
7239 eProsima_user_DllExport TypeIdentifier& member_type_id()
7240 {
7241 return m_member_type_id;
7242 }
7243
7244
7245
7246private:
7247
7248 MemberId m_member_id{0};
7249 StructMemberFlag m_member_flags{0};
7250 TypeIdentifier m_member_type_id;
7251
7252};
7258{
7259public:
7260
7264 eProsima_user_DllExport CompleteMemberDetail()
7265 {
7266 }
7267
7271 eProsima_user_DllExport ~CompleteMemberDetail()
7272 {
7273 }
7274
7279 eProsima_user_DllExport CompleteMemberDetail(
7280 const CompleteMemberDetail& x)
7281 {
7282 m_name = x.m_name;
7283
7284 m_ann_builtin = x.m_ann_builtin;
7285
7286 m_ann_custom = x.m_ann_custom;
7287
7288 }
7289
7294 eProsima_user_DllExport CompleteMemberDetail(
7295 CompleteMemberDetail&& x) noexcept
7296 {
7297 m_name = std::move(x.m_name);
7298 m_ann_builtin = std::move(x.m_ann_builtin);
7299 m_ann_custom = std::move(x.m_ann_custom);
7300 }
7301
7306 eProsima_user_DllExport CompleteMemberDetail& operator =(
7307 const CompleteMemberDetail& x)
7308 {
7309
7310 m_name = x.m_name;
7311
7312 m_ann_builtin = x.m_ann_builtin;
7313
7314 m_ann_custom = x.m_ann_custom;
7315
7316 return *this;
7317 }
7318
7323 eProsima_user_DllExport CompleteMemberDetail& operator =(
7324 CompleteMemberDetail&& x) noexcept
7325 {
7326
7327 m_name = std::move(x.m_name);
7328 m_ann_builtin = std::move(x.m_ann_builtin);
7329 m_ann_custom = std::move(x.m_ann_custom);
7330 return *this;
7331 }
7332
7337 eProsima_user_DllExport bool operator ==(
7338 const CompleteMemberDetail& x) const
7339 {
7340 return (m_name == x.m_name &&
7341 m_ann_builtin == x.m_ann_builtin &&
7342 m_ann_custom == x.m_ann_custom);
7343 }
7344
7349 eProsima_user_DllExport bool operator !=(
7350 const CompleteMemberDetail& x) const
7351 {
7352 return !(*this == x);
7353 }
7354
7359 eProsima_user_DllExport void name(
7360 const MemberName& _name)
7361 {
7362 m_name = _name;
7363 }
7364
7369 eProsima_user_DllExport void name(
7370 MemberName&& _name)
7371 {
7372 m_name = std::move(_name);
7373 }
7374
7379 eProsima_user_DllExport const MemberName& name() const
7380 {
7381 return m_name;
7382 }
7383
7388 eProsima_user_DllExport MemberName& name()
7389 {
7390 return m_name;
7391 }
7392
7393
7398 eProsima_user_DllExport void ann_builtin(
7399 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
7400 {
7401 m_ann_builtin = _ann_builtin;
7402 }
7403
7408 eProsima_user_DllExport void ann_builtin(
7409 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
7410 {
7411 m_ann_builtin = std::move(_ann_builtin);
7412 }
7413
7418 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
7419 {
7420 return m_ann_builtin;
7421 }
7422
7427 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
7428 {
7429 return m_ann_builtin;
7430 }
7431
7432
7437 eProsima_user_DllExport void ann_custom(
7438 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
7439 {
7440 m_ann_custom = _ann_custom;
7441 }
7442
7447 eProsima_user_DllExport void ann_custom(
7448 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
7449 {
7450 m_ann_custom = std::move(_ann_custom);
7451 }
7452
7457 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
7458 {
7459 return m_ann_custom;
7460 }
7461
7466 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
7467 {
7468 return m_ann_custom;
7469 }
7470
7471
7472
7473private:
7474
7475 MemberName m_name;
7476 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
7477 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
7478
7479};
7485{
7486public:
7487
7491 eProsima_user_DllExport MinimalMemberDetail()
7492 {
7493 }
7494
7498 eProsima_user_DllExport ~MinimalMemberDetail()
7499 {
7500 }
7501
7506 eProsima_user_DllExport MinimalMemberDetail(
7507 const MinimalMemberDetail& x)
7508 {
7509 m_name_hash = x.m_name_hash;
7510
7511 }
7512
7517 eProsima_user_DllExport MinimalMemberDetail(
7518 MinimalMemberDetail&& x) noexcept
7519 {
7520 m_name_hash = std::move(x.m_name_hash);
7521 }
7522
7527 eProsima_user_DllExport MinimalMemberDetail& operator =(
7528 const MinimalMemberDetail& x)
7529 {
7530
7531 m_name_hash = x.m_name_hash;
7532
7533 return *this;
7534 }
7535
7540 eProsima_user_DllExport MinimalMemberDetail& operator =(
7541 MinimalMemberDetail&& x) noexcept
7542 {
7543
7544 m_name_hash = std::move(x.m_name_hash);
7545 return *this;
7546 }
7547
7552 eProsima_user_DllExport bool operator ==(
7553 const MinimalMemberDetail& x) const
7554 {
7555 return (m_name_hash == x.m_name_hash);
7556 }
7557
7562 eProsima_user_DllExport bool operator !=(
7563 const MinimalMemberDetail& x) const
7564 {
7565 return !(*this == x);
7566 }
7567
7572 eProsima_user_DllExport void name_hash(
7573 const NameHash& _name_hash)
7574 {
7575 m_name_hash = _name_hash;
7576 }
7577
7582 eProsima_user_DllExport void name_hash(
7583 NameHash&& _name_hash)
7584 {
7585 m_name_hash = std::move(_name_hash);
7586 }
7587
7592 eProsima_user_DllExport const NameHash& name_hash() const
7593 {
7594 return m_name_hash;
7595 }
7596
7601 eProsima_user_DllExport NameHash& name_hash()
7602 {
7603 return m_name_hash;
7604 }
7605
7606
7607
7608private:
7609
7610 NameHash m_name_hash{0};
7611
7612};
7618{
7619public:
7620
7624 eProsima_user_DllExport CompleteStructMember()
7625 {
7626 }
7627
7631 eProsima_user_DllExport ~CompleteStructMember()
7632 {
7633 }
7634
7639 eProsima_user_DllExport CompleteStructMember(
7640 const CompleteStructMember& x)
7641 {
7642 m_common = x.m_common;
7643
7644 m_detail = x.m_detail;
7645
7646 }
7647
7652 eProsima_user_DllExport CompleteStructMember(
7653 CompleteStructMember&& x) noexcept
7654 {
7655 m_common = std::move(x.m_common);
7656 m_detail = std::move(x.m_detail);
7657 }
7658
7663 eProsima_user_DllExport CompleteStructMember& operator =(
7664 const CompleteStructMember& x)
7665 {
7666
7667 m_common = x.m_common;
7668
7669 m_detail = x.m_detail;
7670
7671 return *this;
7672 }
7673
7678 eProsima_user_DllExport CompleteStructMember& operator =(
7679 CompleteStructMember&& x) noexcept
7680 {
7681
7682 m_common = std::move(x.m_common);
7683 m_detail = std::move(x.m_detail);
7684 return *this;
7685 }
7686
7691 eProsima_user_DllExport bool operator ==(
7692 const CompleteStructMember& x) const
7693 {
7694 return (m_common == x.m_common &&
7695 m_detail == x.m_detail);
7696 }
7697
7702 eProsima_user_DllExport bool operator !=(
7703 const CompleteStructMember& x) const
7704 {
7705 return !(*this == x);
7706 }
7707
7712 eProsima_user_DllExport void common(
7713 const CommonStructMember& _common)
7714 {
7715 m_common = _common;
7716 }
7717
7722 eProsima_user_DllExport void common(
7723 CommonStructMember&& _common)
7724 {
7725 m_common = std::move(_common);
7726 }
7727
7732 eProsima_user_DllExport const CommonStructMember& common() const
7733 {
7734 return m_common;
7735 }
7736
7741 eProsima_user_DllExport CommonStructMember& common()
7742 {
7743 return m_common;
7744 }
7745
7746
7751 eProsima_user_DllExport void detail(
7752 const CompleteMemberDetail& _detail)
7753 {
7754 m_detail = _detail;
7755 }
7756
7761 eProsima_user_DllExport void detail(
7762 CompleteMemberDetail&& _detail)
7763 {
7764 m_detail = std::move(_detail);
7765 }
7766
7771 eProsima_user_DllExport const CompleteMemberDetail& detail() const
7772 {
7773 return m_detail;
7774 }
7775
7780 eProsima_user_DllExport CompleteMemberDetail& detail()
7781 {
7782 return m_detail;
7783 }
7784
7785
7786
7787private:
7788
7789 CommonStructMember m_common;
7790 CompleteMemberDetail m_detail;
7791
7792};
7793typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
7794
7800{
7801public:
7802
7806 eProsima_user_DllExport MinimalStructMember()
7807 {
7808 }
7809
7813 eProsima_user_DllExport ~MinimalStructMember()
7814 {
7815 }
7816
7821 eProsima_user_DllExport MinimalStructMember(
7822 const MinimalStructMember& x)
7823 {
7824 m_common = x.m_common;
7825
7826 m_detail = x.m_detail;
7827
7828 }
7829
7834 eProsima_user_DllExport MinimalStructMember(
7835 MinimalStructMember&& x) noexcept
7836 {
7837 m_common = std::move(x.m_common);
7838 m_detail = std::move(x.m_detail);
7839 }
7840
7845 eProsima_user_DllExport MinimalStructMember& operator =(
7846 const MinimalStructMember& x)
7847 {
7848
7849 m_common = x.m_common;
7850
7851 m_detail = x.m_detail;
7852
7853 return *this;
7854 }
7855
7860 eProsima_user_DllExport MinimalStructMember& operator =(
7861 MinimalStructMember&& x) noexcept
7862 {
7863
7864 m_common = std::move(x.m_common);
7865 m_detail = std::move(x.m_detail);
7866 return *this;
7867 }
7868
7873 eProsima_user_DllExport bool operator ==(
7874 const MinimalStructMember& x) const
7875 {
7876 return (m_common == x.m_common &&
7877 m_detail == x.m_detail);
7878 }
7879
7884 eProsima_user_DllExport bool operator !=(
7885 const MinimalStructMember& x) const
7886 {
7887 return !(*this == x);
7888 }
7889
7894 eProsima_user_DllExport void common(
7895 const CommonStructMember& _common)
7896 {
7897 m_common = _common;
7898 }
7899
7904 eProsima_user_DllExport void common(
7905 CommonStructMember&& _common)
7906 {
7907 m_common = std::move(_common);
7908 }
7909
7914 eProsima_user_DllExport const CommonStructMember& common() const
7915 {
7916 return m_common;
7917 }
7918
7923 eProsima_user_DllExport CommonStructMember& common()
7924 {
7925 return m_common;
7926 }
7927
7928
7933 eProsima_user_DllExport void detail(
7934 const MinimalMemberDetail& _detail)
7935 {
7936 m_detail = _detail;
7937 }
7938
7943 eProsima_user_DllExport void detail(
7944 MinimalMemberDetail&& _detail)
7945 {
7946 m_detail = std::move(_detail);
7947 }
7948
7953 eProsima_user_DllExport const MinimalMemberDetail& detail() const
7954 {
7955 return m_detail;
7956 }
7957
7962 eProsima_user_DllExport MinimalMemberDetail& detail()
7963 {
7964 return m_detail;
7965 }
7966
7967
7968
7969private:
7970
7971 CommonStructMember m_common;
7972 MinimalMemberDetail m_detail;
7973
7974};
7975typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
7976
7982{
7983public:
7984
7988 eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
7989 {
7990 }
7991
7995 eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
7996 {
7997 }
7998
8003 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
8005 {
8006 m_verbatim = x.m_verbatim;
8007
8008 }
8009
8014 eProsima_user_DllExport AppliedBuiltinTypeAnnotations(
8015 AppliedBuiltinTypeAnnotations&& x) noexcept
8016 {
8017 m_verbatim = std::move(x.m_verbatim);
8018 }
8019
8026 {
8027
8028 m_verbatim = x.m_verbatim;
8029
8030 return *this;
8031 }
8032
8038 AppliedBuiltinTypeAnnotations&& x) noexcept
8039 {
8040
8041 m_verbatim = std::move(x.m_verbatim);
8042 return *this;
8043 }
8044
8049 eProsima_user_DllExport bool operator ==(
8050 const AppliedBuiltinTypeAnnotations& x) const
8051 {
8052 return (m_verbatim == x.m_verbatim);
8053 }
8054
8059 eProsima_user_DllExport bool operator !=(
8060 const AppliedBuiltinTypeAnnotations& x) const
8061 {
8062 return !(*this == x);
8063 }
8064
8069 eProsima_user_DllExport void verbatim(
8070 const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& _verbatim)
8071 {
8072 m_verbatim = _verbatim;
8073 }
8074
8079 eProsima_user_DllExport void verbatim(
8080 eprosima::fastcdr::optional<AppliedVerbatimAnnotation>&& _verbatim)
8081 {
8082 m_verbatim = std::move(_verbatim);
8083 }
8084
8089 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim() const
8090 {
8091 return m_verbatim;
8092 }
8093
8098 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedVerbatimAnnotation>& verbatim()
8099 {
8100 return m_verbatim;
8101 }
8102
8103
8104
8105private:
8106
8107 eprosima::fastcdr::optional<AppliedVerbatimAnnotation> m_verbatim;
8108
8109};
8115{
8116public:
8117
8121 eProsima_user_DllExport MinimalTypeDetail()
8122 {
8123 }
8124
8128 eProsima_user_DllExport ~MinimalTypeDetail()
8129 {
8130 }
8131
8136 eProsima_user_DllExport MinimalTypeDetail(
8137 const MinimalTypeDetail& x)
8138 {
8139 static_cast<void>(x);
8140 }
8141
8146 eProsima_user_DllExport MinimalTypeDetail(
8147 MinimalTypeDetail&& x) noexcept
8148 {
8149 static_cast<void>(x);
8150 }
8151
8156 eProsima_user_DllExport MinimalTypeDetail& operator =(
8157 const MinimalTypeDetail& x)
8158 {
8159
8160 static_cast<void>(x);
8161
8162 return *this;
8163 }
8164
8169 eProsima_user_DllExport MinimalTypeDetail& operator =(
8170 MinimalTypeDetail&& x) noexcept
8171 {
8172
8173 static_cast<void>(x);
8174
8175 return *this;
8176 }
8177
8182 eProsima_user_DllExport bool operator ==(
8183 const MinimalTypeDetail& x) const
8184 {
8185 static_cast<void>(x);
8186 return true;
8187 }
8188
8193 eProsima_user_DllExport bool operator !=(
8194 const MinimalTypeDetail& x) const
8195 {
8196 return !(*this == x);
8197 }
8198
8199
8200
8201private:
8202
8203
8204};
8210{
8211public:
8212
8216 eProsima_user_DllExport CompleteTypeDetail()
8217 {
8218 }
8219
8223 eProsima_user_DllExport ~CompleteTypeDetail()
8224 {
8225 }
8226
8231 eProsima_user_DllExport CompleteTypeDetail(
8232 const CompleteTypeDetail& x)
8233 {
8234 m_ann_builtin = x.m_ann_builtin;
8235
8236 m_ann_custom = x.m_ann_custom;
8237
8238 m_type_name = x.m_type_name;
8239
8240 }
8241
8246 eProsima_user_DllExport CompleteTypeDetail(
8247 CompleteTypeDetail&& x) noexcept
8248 {
8249 m_ann_builtin = std::move(x.m_ann_builtin);
8250 m_ann_custom = std::move(x.m_ann_custom);
8251 m_type_name = std::move(x.m_type_name);
8252 }
8253
8258 eProsima_user_DllExport CompleteTypeDetail& operator =(
8259 const CompleteTypeDetail& x)
8260 {
8261
8262 m_ann_builtin = x.m_ann_builtin;
8263
8264 m_ann_custom = x.m_ann_custom;
8265
8266 m_type_name = x.m_type_name;
8267
8268 return *this;
8269 }
8270
8275 eProsima_user_DllExport CompleteTypeDetail& operator =(
8276 CompleteTypeDetail&& x) noexcept
8277 {
8278
8279 m_ann_builtin = std::move(x.m_ann_builtin);
8280 m_ann_custom = std::move(x.m_ann_custom);
8281 m_type_name = std::move(x.m_type_name);
8282 return *this;
8283 }
8284
8289 eProsima_user_DllExport bool operator ==(
8290 const CompleteTypeDetail& x) const
8291 {
8292 return (m_ann_builtin == x.m_ann_builtin &&
8293 m_ann_custom == x.m_ann_custom &&
8294 m_type_name == x.m_type_name);
8295 }
8296
8301 eProsima_user_DllExport bool operator !=(
8302 const CompleteTypeDetail& x) const
8303 {
8304 return !(*this == x);
8305 }
8306
8311 eProsima_user_DllExport void ann_builtin(
8312 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
8313 {
8314 m_ann_builtin = _ann_builtin;
8315 }
8316
8321 eProsima_user_DllExport void ann_builtin(
8322 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
8323 {
8324 m_ann_builtin = std::move(_ann_builtin);
8325 }
8326
8331 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
8332 {
8333 return m_ann_builtin;
8334 }
8335
8340 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
8341 {
8342 return m_ann_builtin;
8343 }
8344
8345
8350 eProsima_user_DllExport void ann_custom(
8351 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
8352 {
8353 m_ann_custom = _ann_custom;
8354 }
8355
8360 eProsima_user_DllExport void ann_custom(
8361 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
8362 {
8363 m_ann_custom = std::move(_ann_custom);
8364 }
8365
8370 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
8371 {
8372 return m_ann_custom;
8373 }
8374
8379 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
8380 {
8381 return m_ann_custom;
8382 }
8383
8384
8389 eProsima_user_DllExport void type_name(
8390 const QualifiedTypeName& _type_name)
8391 {
8392 m_type_name = _type_name;
8393 }
8394
8399 eProsima_user_DllExport void type_name(
8400 QualifiedTypeName&& _type_name)
8401 {
8402 m_type_name = std::move(_type_name);
8403 }
8404
8409 eProsima_user_DllExport const QualifiedTypeName& type_name() const
8410 {
8411 return m_type_name;
8412 }
8413
8418 eProsima_user_DllExport QualifiedTypeName& type_name()
8419 {
8420 return m_type_name;
8421 }
8422
8423
8424
8425private:
8426
8427 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
8428 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
8429 QualifiedTypeName m_type_name;
8430
8431};
8437{
8438public:
8439
8443 eProsima_user_DllExport CompleteStructHeader()
8444 {
8445 }
8446
8450 eProsima_user_DllExport ~CompleteStructHeader()
8451 {
8452 }
8453
8458 eProsima_user_DllExport CompleteStructHeader(
8459 const CompleteStructHeader& x)
8460 {
8461 m_base_type = x.m_base_type;
8462
8463 m_detail = x.m_detail;
8464
8465 }
8466
8471 eProsima_user_DllExport CompleteStructHeader(
8472 CompleteStructHeader&& x) noexcept
8473 {
8474 m_base_type = std::move(x.m_base_type);
8475 m_detail = std::move(x.m_detail);
8476 }
8477
8482 eProsima_user_DllExport CompleteStructHeader& operator =(
8483 const CompleteStructHeader& x)
8484 {
8485
8486 m_base_type = x.m_base_type;
8487
8488 m_detail = x.m_detail;
8489
8490 return *this;
8491 }
8492
8497 eProsima_user_DllExport CompleteStructHeader& operator =(
8498 CompleteStructHeader&& x) noexcept
8499 {
8500
8501 m_base_type = std::move(x.m_base_type);
8502 m_detail = std::move(x.m_detail);
8503 return *this;
8504 }
8505
8510 eProsima_user_DllExport bool operator ==(
8511 const CompleteStructHeader& x) const
8512 {
8513 return (m_base_type == x.m_base_type &&
8514 m_detail == x.m_detail);
8515 }
8516
8521 eProsima_user_DllExport bool operator !=(
8522 const CompleteStructHeader& x) const
8523 {
8524 return !(*this == x);
8525 }
8526
8531 eProsima_user_DllExport void base_type(
8532 const TypeIdentifier& _base_type)
8533 {
8534 m_base_type = _base_type;
8535 }
8536
8541 eProsima_user_DllExport void base_type(
8542 TypeIdentifier&& _base_type)
8543 {
8544 m_base_type = std::move(_base_type);
8545 }
8546
8551 eProsima_user_DllExport const TypeIdentifier& base_type() const
8552 {
8553 return m_base_type;
8554 }
8555
8560 eProsima_user_DllExport TypeIdentifier& base_type()
8561 {
8562 return m_base_type;
8563 }
8564
8565
8570 eProsima_user_DllExport void detail(
8571 const CompleteTypeDetail& _detail)
8572 {
8573 m_detail = _detail;
8574 }
8575
8580 eProsima_user_DllExport void detail(
8581 CompleteTypeDetail&& _detail)
8582 {
8583 m_detail = std::move(_detail);
8584 }
8585
8590 eProsima_user_DllExport const CompleteTypeDetail& detail() const
8591 {
8592 return m_detail;
8593 }
8594
8599 eProsima_user_DllExport CompleteTypeDetail& detail()
8600 {
8601 return m_detail;
8602 }
8603
8604
8605
8606private:
8607
8608 TypeIdentifier m_base_type;
8609 CompleteTypeDetail m_detail;
8610
8611};
8617{
8618public:
8619
8623 eProsima_user_DllExport MinimalStructHeader()
8624 {
8625 }
8626
8630 eProsima_user_DllExport ~MinimalStructHeader()
8631 {
8632 }
8633
8638 eProsima_user_DllExport MinimalStructHeader(
8639 const MinimalStructHeader& x)
8640 {
8641 m_base_type = x.m_base_type;
8642
8643 m_detail = x.m_detail;
8644
8645 }
8646
8651 eProsima_user_DllExport MinimalStructHeader(
8652 MinimalStructHeader&& x) noexcept
8653 {
8654 m_base_type = std::move(x.m_base_type);
8655 m_detail = std::move(x.m_detail);
8656 }
8657
8662 eProsima_user_DllExport MinimalStructHeader& operator =(
8663 const MinimalStructHeader& x)
8664 {
8665
8666 m_base_type = x.m_base_type;
8667
8668 m_detail = x.m_detail;
8669
8670 return *this;
8671 }
8672
8677 eProsima_user_DllExport MinimalStructHeader& operator =(
8678 MinimalStructHeader&& x) noexcept
8679 {
8680
8681 m_base_type = std::move(x.m_base_type);
8682 m_detail = std::move(x.m_detail);
8683 return *this;
8684 }
8685
8690 eProsima_user_DllExport bool operator ==(
8691 const MinimalStructHeader& x) const
8692 {
8693 return (m_base_type == x.m_base_type &&
8694 m_detail == x.m_detail);
8695 }
8696
8701 eProsima_user_DllExport bool operator !=(
8702 const MinimalStructHeader& x) const
8703 {
8704 return !(*this == x);
8705 }
8706
8711 eProsima_user_DllExport void base_type(
8712 const TypeIdentifier& _base_type)
8713 {
8714 m_base_type = _base_type;
8715 }
8716
8721 eProsima_user_DllExport void base_type(
8722 TypeIdentifier&& _base_type)
8723 {
8724 m_base_type = std::move(_base_type);
8725 }
8726
8731 eProsima_user_DllExport const TypeIdentifier& base_type() const
8732 {
8733 return m_base_type;
8734 }
8735
8740 eProsima_user_DllExport TypeIdentifier& base_type()
8741 {
8742 return m_base_type;
8743 }
8744
8745
8750 eProsima_user_DllExport void detail(
8751 const MinimalTypeDetail& _detail)
8752 {
8753 m_detail = _detail;
8754 }
8755
8760 eProsima_user_DllExport void detail(
8761 MinimalTypeDetail&& _detail)
8762 {
8763 m_detail = std::move(_detail);
8764 }
8765
8770 eProsima_user_DllExport const MinimalTypeDetail& detail() const
8771 {
8772 return m_detail;
8773 }
8774
8779 eProsima_user_DllExport MinimalTypeDetail& detail()
8780 {
8781 return m_detail;
8782 }
8783
8784
8785
8786private:
8787
8788 TypeIdentifier m_base_type;
8789 MinimalTypeDetail m_detail;
8790
8791};
8797{
8798public:
8799
8803 eProsima_user_DllExport CompleteStructType()
8804 {
8805 }
8806
8810 eProsima_user_DllExport ~CompleteStructType()
8811 {
8812 }
8813
8818 eProsima_user_DllExport CompleteStructType(
8819 const CompleteStructType& x)
8820 {
8821 m_struct_flags = x.m_struct_flags;
8822
8823 m_header = x.m_header;
8824
8825 m_member_seq = x.m_member_seq;
8826
8827 }
8828
8833 eProsima_user_DllExport CompleteStructType(
8834 CompleteStructType&& x) noexcept
8835 {
8836 m_struct_flags = std::move(x.m_struct_flags);
8837 m_header = std::move(x.m_header);
8838 m_member_seq = std::move(x.m_member_seq);
8839 }
8840
8845 eProsima_user_DllExport CompleteStructType& operator =(
8846 const CompleteStructType& x)
8847 {
8848
8849 m_struct_flags = x.m_struct_flags;
8850
8851 m_header = x.m_header;
8852
8853 m_member_seq = x.m_member_seq;
8854
8855 return *this;
8856 }
8857
8862 eProsima_user_DllExport CompleteStructType& operator =(
8863 CompleteStructType&& x) noexcept
8864 {
8865
8866 m_struct_flags = std::move(x.m_struct_flags);
8867 m_header = std::move(x.m_header);
8868 m_member_seq = std::move(x.m_member_seq);
8869 return *this;
8870 }
8871
8876 eProsima_user_DllExport bool operator ==(
8877 const CompleteStructType& x) const
8878 {
8879 return (m_struct_flags == x.m_struct_flags &&
8880 m_header == x.m_header &&
8881 m_member_seq == x.m_member_seq);
8882 }
8883
8888 eProsima_user_DllExport bool operator !=(
8889 const CompleteStructType& x) const
8890 {
8891 return !(*this == x);
8892 }
8893
8898 eProsima_user_DllExport void struct_flags(
8899 const StructTypeFlag& _struct_flags)
8900 {
8901 m_struct_flags = _struct_flags;
8902 }
8903
8908 eProsima_user_DllExport void struct_flags(
8909 StructTypeFlag&& _struct_flags)
8910 {
8911 m_struct_flags = std::move(_struct_flags);
8912 }
8913
8918 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
8919 {
8920 return m_struct_flags;
8921 }
8922
8927 eProsima_user_DllExport StructTypeFlag& struct_flags()
8928 {
8929 return m_struct_flags;
8930 }
8931
8932
8937 eProsima_user_DllExport void header(
8938 const CompleteStructHeader& _header)
8939 {
8940 m_header = _header;
8941 }
8942
8947 eProsima_user_DllExport void header(
8948 CompleteStructHeader&& _header)
8949 {
8950 m_header = std::move(_header);
8951 }
8952
8957 eProsima_user_DllExport const CompleteStructHeader& header() const
8958 {
8959 return m_header;
8960 }
8961
8966 eProsima_user_DllExport CompleteStructHeader& header()
8967 {
8968 return m_header;
8969 }
8970
8971
8976 eProsima_user_DllExport void member_seq(
8977 const CompleteStructMemberSeq& _member_seq)
8978 {
8979 m_member_seq = _member_seq;
8980 }
8981
8986 eProsima_user_DllExport void member_seq(
8987 CompleteStructMemberSeq&& _member_seq)
8988 {
8989 m_member_seq = std::move(_member_seq);
8990 }
8991
8996 eProsima_user_DllExport const CompleteStructMemberSeq& member_seq() const
8997 {
8998 return m_member_seq;
8999 }
9000
9005 eProsima_user_DllExport CompleteStructMemberSeq& member_seq()
9006 {
9007 return m_member_seq;
9008 }
9009
9010
9011
9012private:
9013
9014 StructTypeFlag m_struct_flags{0};
9015 CompleteStructHeader m_header;
9016 CompleteStructMemberSeq m_member_seq;
9017
9018};
9024{
9025public:
9026
9030 eProsima_user_DllExport MinimalStructType()
9031 {
9032 }
9033
9037 eProsima_user_DllExport ~MinimalStructType()
9038 {
9039 }
9040
9045 eProsima_user_DllExport MinimalStructType(
9046 const MinimalStructType& x)
9047 {
9048 m_struct_flags = x.m_struct_flags;
9049
9050 m_header = x.m_header;
9051
9052 m_member_seq = x.m_member_seq;
9053
9054 }
9055
9060 eProsima_user_DllExport MinimalStructType(
9061 MinimalStructType&& x) noexcept
9062 {
9063 m_struct_flags = std::move(x.m_struct_flags);
9064 m_header = std::move(x.m_header);
9065 m_member_seq = std::move(x.m_member_seq);
9066 }
9067
9072 eProsima_user_DllExport MinimalStructType& operator =(
9073 const MinimalStructType& x)
9074 {
9075
9076 m_struct_flags = x.m_struct_flags;
9077
9078 m_header = x.m_header;
9079
9080 m_member_seq = x.m_member_seq;
9081
9082 return *this;
9083 }
9084
9089 eProsima_user_DllExport MinimalStructType& operator =(
9090 MinimalStructType&& x) noexcept
9091 {
9092
9093 m_struct_flags = std::move(x.m_struct_flags);
9094 m_header = std::move(x.m_header);
9095 m_member_seq = std::move(x.m_member_seq);
9096 return *this;
9097 }
9098
9103 eProsima_user_DllExport bool operator ==(
9104 const MinimalStructType& x) const
9105 {
9106 return (m_struct_flags == x.m_struct_flags &&
9107 m_header == x.m_header &&
9108 m_member_seq == x.m_member_seq);
9109 }
9110
9115 eProsima_user_DllExport bool operator !=(
9116 const MinimalStructType& x) const
9117 {
9118 return !(*this == x);
9119 }
9120
9125 eProsima_user_DllExport void struct_flags(
9126 const StructTypeFlag& _struct_flags)
9127 {
9128 m_struct_flags = _struct_flags;
9129 }
9130
9135 eProsima_user_DllExport void struct_flags(
9136 StructTypeFlag&& _struct_flags)
9137 {
9138 m_struct_flags = std::move(_struct_flags);
9139 }
9140
9145 eProsima_user_DllExport const StructTypeFlag& struct_flags() const
9146 {
9147 return m_struct_flags;
9148 }
9149
9154 eProsima_user_DllExport StructTypeFlag& struct_flags()
9155 {
9156 return m_struct_flags;
9157 }
9158
9159
9164 eProsima_user_DllExport void header(
9165 const MinimalStructHeader& _header)
9166 {
9167 m_header = _header;
9168 }
9169
9174 eProsima_user_DllExport void header(
9175 MinimalStructHeader&& _header)
9176 {
9177 m_header = std::move(_header);
9178 }
9179
9184 eProsima_user_DllExport const MinimalStructHeader& header() const
9185 {
9186 return m_header;
9187 }
9188
9193 eProsima_user_DllExport MinimalStructHeader& header()
9194 {
9195 return m_header;
9196 }
9197
9198
9203 eProsima_user_DllExport void member_seq(
9204 const MinimalStructMemberSeq& _member_seq)
9205 {
9206 m_member_seq = _member_seq;
9207 }
9208
9213 eProsima_user_DllExport void member_seq(
9214 MinimalStructMemberSeq&& _member_seq)
9215 {
9216 m_member_seq = std::move(_member_seq);
9217 }
9218
9223 eProsima_user_DllExport const MinimalStructMemberSeq& member_seq() const
9224 {
9225 return m_member_seq;
9226 }
9227
9232 eProsima_user_DllExport MinimalStructMemberSeq& member_seq()
9233 {
9234 return m_member_seq;
9235 }
9236
9237
9238
9239private:
9240
9241 StructTypeFlag m_struct_flags{0};
9242 MinimalStructHeader m_header;
9243 MinimalStructMemberSeq m_member_seq;
9244
9245};
9246typedef std::vector<int32_t> UnionCaseLabelSeq;
9247
9253{
9254public:
9255
9259 eProsima_user_DllExport CommonUnionMember()
9260 {
9261 }
9262
9266 eProsima_user_DllExport ~CommonUnionMember()
9267 {
9268 }
9269
9274 eProsima_user_DllExport CommonUnionMember(
9275 const CommonUnionMember& x)
9276 {
9277 m_member_id = x.m_member_id;
9278
9279 m_member_flags = x.m_member_flags;
9280
9281 m_type_id = x.m_type_id;
9282
9283 m_label_seq = x.m_label_seq;
9284
9285 }
9286
9291 eProsima_user_DllExport CommonUnionMember(
9292 CommonUnionMember&& x) noexcept
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 }
9299
9304 eProsima_user_DllExport CommonUnionMember& operator =(
9305 const CommonUnionMember& x)
9306 {
9307
9308 m_member_id = x.m_member_id;
9309
9310 m_member_flags = x.m_member_flags;
9311
9312 m_type_id = x.m_type_id;
9313
9314 m_label_seq = x.m_label_seq;
9315
9316 return *this;
9317 }
9318
9323 eProsima_user_DllExport CommonUnionMember& operator =(
9324 CommonUnionMember&& x) noexcept
9325 {
9326
9327 m_member_id = x.m_member_id;
9328 m_member_flags = std::move(x.m_member_flags);
9329 m_type_id = std::move(x.m_type_id);
9330 m_label_seq = std::move(x.m_label_seq);
9331 return *this;
9332 }
9333
9338 eProsima_user_DllExport bool operator ==(
9339 const CommonUnionMember& x) const
9340 {
9341 return (m_member_id == x.m_member_id &&
9342 m_member_flags == x.m_member_flags &&
9343 m_type_id == x.m_type_id &&
9344 m_label_seq == x.m_label_seq);
9345 }
9346
9351 eProsima_user_DllExport bool operator !=(
9352 const CommonUnionMember& x) const
9353 {
9354 return !(*this == x);
9355 }
9356
9361 eProsima_user_DllExport void member_id(
9362 MemberId _member_id)
9363 {
9364 m_member_id = _member_id;
9365 }
9366
9371 eProsima_user_DllExport MemberId member_id() const
9372 {
9373 return m_member_id;
9374 }
9375
9380 eProsima_user_DllExport MemberId& member_id()
9381 {
9382 return m_member_id;
9383 }
9384
9385
9390 eProsima_user_DllExport void member_flags(
9391 const UnionMemberFlag& _member_flags)
9392 {
9393 m_member_flags = _member_flags;
9394 }
9395
9400 eProsima_user_DllExport void member_flags(
9401 UnionMemberFlag&& _member_flags)
9402 {
9403 m_member_flags = std::move(_member_flags);
9404 }
9405
9410 eProsima_user_DllExport const UnionMemberFlag& member_flags() const
9411 {
9412 return m_member_flags;
9413 }
9414
9419 eProsima_user_DllExport UnionMemberFlag& member_flags()
9420 {
9421 return m_member_flags;
9422 }
9423
9424
9429 eProsima_user_DllExport void type_id(
9430 const TypeIdentifier& _type_id)
9431 {
9432 m_type_id = _type_id;
9433 }
9434
9439 eProsima_user_DllExport void type_id(
9440 TypeIdentifier&& _type_id)
9441 {
9442 m_type_id = std::move(_type_id);
9443 }
9444
9449 eProsima_user_DllExport const TypeIdentifier& type_id() const
9450 {
9451 return m_type_id;
9452 }
9453
9458 eProsima_user_DllExport TypeIdentifier& type_id()
9459 {
9460 return m_type_id;
9461 }
9462
9463
9468 eProsima_user_DllExport void label_seq(
9469 const UnionCaseLabelSeq& _label_seq)
9470 {
9471 m_label_seq = _label_seq;
9472 }
9473
9478 eProsima_user_DllExport void label_seq(
9479 UnionCaseLabelSeq&& _label_seq)
9480 {
9481 m_label_seq = std::move(_label_seq);
9482 }
9483
9488 eProsima_user_DllExport const UnionCaseLabelSeq& label_seq() const
9489 {
9490 return m_label_seq;
9491 }
9492
9497 eProsima_user_DllExport UnionCaseLabelSeq& label_seq()
9498 {
9499 return m_label_seq;
9500 }
9501
9502
9503
9504private:
9505
9506 MemberId m_member_id{0};
9507 UnionMemberFlag m_member_flags{0};
9508 TypeIdentifier m_type_id;
9509 UnionCaseLabelSeq m_label_seq;
9510
9511};
9517{
9518public:
9519
9523 eProsima_user_DllExport CompleteUnionMember()
9524 {
9525 }
9526
9530 eProsima_user_DllExport ~CompleteUnionMember()
9531 {
9532 }
9533
9538 eProsima_user_DllExport CompleteUnionMember(
9539 const CompleteUnionMember& x)
9540 {
9541 m_common = x.m_common;
9542
9543 m_detail = x.m_detail;
9544
9545 }
9546
9551 eProsima_user_DllExport CompleteUnionMember(
9552 CompleteUnionMember&& x) noexcept
9553 {
9554 m_common = std::move(x.m_common);
9555 m_detail = std::move(x.m_detail);
9556 }
9557
9562 eProsima_user_DllExport CompleteUnionMember& operator =(
9563 const CompleteUnionMember& x)
9564 {
9565
9566 m_common = x.m_common;
9567
9568 m_detail = x.m_detail;
9569
9570 return *this;
9571 }
9572
9577 eProsima_user_DllExport CompleteUnionMember& operator =(
9578 CompleteUnionMember&& x) noexcept
9579 {
9580
9581 m_common = std::move(x.m_common);
9582 m_detail = std::move(x.m_detail);
9583 return *this;
9584 }
9585
9590 eProsima_user_DllExport bool operator ==(
9591 const CompleteUnionMember& x) const
9592 {
9593 return (m_common == x.m_common &&
9594 m_detail == x.m_detail);
9595 }
9596
9601 eProsima_user_DllExport bool operator !=(
9602 const CompleteUnionMember& x) const
9603 {
9604 return !(*this == x);
9605 }
9606
9611 eProsima_user_DllExport void common(
9612 const CommonUnionMember& _common)
9613 {
9614 m_common = _common;
9615 }
9616
9621 eProsima_user_DllExport void common(
9622 CommonUnionMember&& _common)
9623 {
9624 m_common = std::move(_common);
9625 }
9626
9631 eProsima_user_DllExport const CommonUnionMember& common() const
9632 {
9633 return m_common;
9634 }
9635
9640 eProsima_user_DllExport CommonUnionMember& common()
9641 {
9642 return m_common;
9643 }
9644
9645
9650 eProsima_user_DllExport void detail(
9651 const CompleteMemberDetail& _detail)
9652 {
9653 m_detail = _detail;
9654 }
9655
9660 eProsima_user_DllExport void detail(
9661 CompleteMemberDetail&& _detail)
9662 {
9663 m_detail = std::move(_detail);
9664 }
9665
9670 eProsima_user_DllExport const CompleteMemberDetail& detail() const
9671 {
9672 return m_detail;
9673 }
9674
9679 eProsima_user_DllExport CompleteMemberDetail& detail()
9680 {
9681 return m_detail;
9682 }
9683
9684
9685
9686private:
9687
9688 CommonUnionMember m_common;
9689 CompleteMemberDetail m_detail;
9690
9691};
9692typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
9693
9699{
9700public:
9701
9705 eProsima_user_DllExport MinimalUnionMember()
9706 {
9707 }
9708
9712 eProsima_user_DllExport ~MinimalUnionMember()
9713 {
9714 }
9715
9720 eProsima_user_DllExport MinimalUnionMember(
9721 const MinimalUnionMember& x)
9722 {
9723 m_common = x.m_common;
9724
9725 m_detail = x.m_detail;
9726
9727 }
9728
9733 eProsima_user_DllExport MinimalUnionMember(
9734 MinimalUnionMember&& x) noexcept
9735 {
9736 m_common = std::move(x.m_common);
9737 m_detail = std::move(x.m_detail);
9738 }
9739
9744 eProsima_user_DllExport MinimalUnionMember& operator =(
9745 const MinimalUnionMember& x)
9746 {
9747
9748 m_common = x.m_common;
9749
9750 m_detail = x.m_detail;
9751
9752 return *this;
9753 }
9754
9759 eProsima_user_DllExport MinimalUnionMember& operator =(
9760 MinimalUnionMember&& x) noexcept
9761 {
9762
9763 m_common = std::move(x.m_common);
9764 m_detail = std::move(x.m_detail);
9765 return *this;
9766 }
9767
9772 eProsima_user_DllExport bool operator ==(
9773 const MinimalUnionMember& x) const
9774 {
9775 return (m_common == x.m_common &&
9776 m_detail == x.m_detail);
9777 }
9778
9783 eProsima_user_DllExport bool operator !=(
9784 const MinimalUnionMember& x) const
9785 {
9786 return !(*this == x);
9787 }
9788
9793 eProsima_user_DllExport void common(
9794 const CommonUnionMember& _common)
9795 {
9796 m_common = _common;
9797 }
9798
9803 eProsima_user_DllExport void common(
9804 CommonUnionMember&& _common)
9805 {
9806 m_common = std::move(_common);
9807 }
9808
9813 eProsima_user_DllExport const CommonUnionMember& common() const
9814 {
9815 return m_common;
9816 }
9817
9822 eProsima_user_DllExport CommonUnionMember& common()
9823 {
9824 return m_common;
9825 }
9826
9827
9832 eProsima_user_DllExport void detail(
9833 const MinimalMemberDetail& _detail)
9834 {
9835 m_detail = _detail;
9836 }
9837
9842 eProsima_user_DllExport void detail(
9843 MinimalMemberDetail&& _detail)
9844 {
9845 m_detail = std::move(_detail);
9846 }
9847
9852 eProsima_user_DllExport const MinimalMemberDetail& detail() const
9853 {
9854 return m_detail;
9855 }
9856
9861 eProsima_user_DllExport MinimalMemberDetail& detail()
9862 {
9863 return m_detail;
9864 }
9865
9866
9867
9868private:
9869
9870 CommonUnionMember m_common;
9871 MinimalMemberDetail m_detail;
9872
9873};
9874typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
9875
9881{
9882public:
9883
9887 eProsima_user_DllExport CommonDiscriminatorMember()
9888 {
9889 }
9890
9894 eProsima_user_DllExport ~CommonDiscriminatorMember()
9895 {
9896 }
9897
9902 eProsima_user_DllExport CommonDiscriminatorMember(
9904 {
9905 m_member_flags = x.m_member_flags;
9906
9907 m_type_id = x.m_type_id;
9908
9909 }
9910
9915 eProsima_user_DllExport CommonDiscriminatorMember(
9916 CommonDiscriminatorMember&& x) noexcept
9917 {
9918 m_member_flags = std::move(x.m_member_flags);
9919 m_type_id = std::move(x.m_type_id);
9920 }
9921
9926 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9928 {
9929
9930 m_member_flags = x.m_member_flags;
9931
9932 m_type_id = x.m_type_id;
9933
9934 return *this;
9935 }
9936
9941 eProsima_user_DllExport CommonDiscriminatorMember& operator =(
9942 CommonDiscriminatorMember&& x) noexcept
9943 {
9944
9945 m_member_flags = std::move(x.m_member_flags);
9946 m_type_id = std::move(x.m_type_id);
9947 return *this;
9948 }
9949
9954 eProsima_user_DllExport bool operator ==(
9955 const CommonDiscriminatorMember& x) const
9956 {
9957 return (m_member_flags == x.m_member_flags &&
9958 m_type_id == x.m_type_id);
9959 }
9960
9965 eProsima_user_DllExport bool operator !=(
9966 const CommonDiscriminatorMember& x) const
9967 {
9968 return !(*this == x);
9969 }
9970
9975 eProsima_user_DllExport void member_flags(
9976 const UnionDiscriminatorFlag& _member_flags)
9977 {
9978 m_member_flags = _member_flags;
9979 }
9980
9985 eProsima_user_DllExport void member_flags(
9986 UnionDiscriminatorFlag&& _member_flags)
9987 {
9988 m_member_flags = std::move(_member_flags);
9989 }
9990
9995 eProsima_user_DllExport const UnionDiscriminatorFlag& member_flags() const
9996 {
9997 return m_member_flags;
9998 }
9999
10004 eProsima_user_DllExport UnionDiscriminatorFlag& member_flags()
10005 {
10006 return m_member_flags;
10007 }
10008
10009
10014 eProsima_user_DllExport void type_id(
10015 const TypeIdentifier& _type_id)
10016 {
10017 m_type_id = _type_id;
10018 }
10019
10024 eProsima_user_DllExport void type_id(
10025 TypeIdentifier&& _type_id)
10026 {
10027 m_type_id = std::move(_type_id);
10028 }
10029
10034 eProsima_user_DllExport const TypeIdentifier& type_id() const
10035 {
10036 return m_type_id;
10037 }
10038
10043 eProsima_user_DllExport TypeIdentifier& type_id()
10044 {
10045 return m_type_id;
10046 }
10047
10048
10049
10050private:
10051
10052 UnionDiscriminatorFlag m_member_flags{0};
10053 TypeIdentifier m_type_id;
10054
10055};
10061{
10062public:
10063
10067 eProsima_user_DllExport CompleteDiscriminatorMember()
10068 {
10069 }
10070
10074 eProsima_user_DllExport ~CompleteDiscriminatorMember()
10075 {
10076 }
10077
10082 eProsima_user_DllExport CompleteDiscriminatorMember(
10084 {
10085 m_common = x.m_common;
10086
10087 m_ann_builtin = x.m_ann_builtin;
10088
10089 m_ann_custom = x.m_ann_custom;
10090
10091 }
10092
10097 eProsima_user_DllExport CompleteDiscriminatorMember(
10098 CompleteDiscriminatorMember&& x) noexcept
10099 {
10100 m_common = std::move(x.m_common);
10101 m_ann_builtin = std::move(x.m_ann_builtin);
10102 m_ann_custom = std::move(x.m_ann_custom);
10103 }
10104
10109 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10111 {
10112
10113 m_common = x.m_common;
10114
10115 m_ann_builtin = x.m_ann_builtin;
10116
10117 m_ann_custom = x.m_ann_custom;
10118
10119 return *this;
10120 }
10121
10126 eProsima_user_DllExport CompleteDiscriminatorMember& operator =(
10127 CompleteDiscriminatorMember&& x) noexcept
10128 {
10129
10130 m_common = std::move(x.m_common);
10131 m_ann_builtin = std::move(x.m_ann_builtin);
10132 m_ann_custom = std::move(x.m_ann_custom);
10133 return *this;
10134 }
10135
10140 eProsima_user_DllExport bool operator ==(
10141 const CompleteDiscriminatorMember& x) const
10142 {
10143 return (m_common == x.m_common &&
10144 m_ann_builtin == x.m_ann_builtin &&
10145 m_ann_custom == x.m_ann_custom);
10146 }
10147
10152 eProsima_user_DllExport bool operator !=(
10153 const CompleteDiscriminatorMember& x) const
10154 {
10155 return !(*this == x);
10156 }
10157
10162 eProsima_user_DllExport void common(
10163 const CommonDiscriminatorMember& _common)
10164 {
10165 m_common = _common;
10166 }
10167
10172 eProsima_user_DllExport void common(
10173 CommonDiscriminatorMember&& _common)
10174 {
10175 m_common = std::move(_common);
10176 }
10177
10182 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10183 {
10184 return m_common;
10185 }
10186
10191 eProsima_user_DllExport CommonDiscriminatorMember& common()
10192 {
10193 return m_common;
10194 }
10195
10196
10201 eProsima_user_DllExport void ann_builtin(
10202 const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& _ann_builtin)
10203 {
10204 m_ann_builtin = _ann_builtin;
10205 }
10206
10211 eProsima_user_DllExport void ann_builtin(
10212 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>&& _ann_builtin)
10213 {
10214 m_ann_builtin = std::move(_ann_builtin);
10215 }
10216
10221 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin() const
10222 {
10223 return m_ann_builtin;
10224 }
10225
10230 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations>& ann_builtin()
10231 {
10232 return m_ann_builtin;
10233 }
10234
10235
10240 eProsima_user_DllExport void ann_custom(
10241 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
10242 {
10243 m_ann_custom = _ann_custom;
10244 }
10245
10250 eProsima_user_DllExport void ann_custom(
10251 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
10252 {
10253 m_ann_custom = std::move(_ann_custom);
10254 }
10255
10260 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
10261 {
10262 return m_ann_custom;
10263 }
10264
10269 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
10270 {
10271 return m_ann_custom;
10272 }
10273
10274
10275
10276private:
10277
10279 eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> m_ann_builtin;
10280 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
10281
10282};
10288{
10289public:
10290
10294 eProsima_user_DllExport MinimalDiscriminatorMember()
10295 {
10296 }
10297
10301 eProsima_user_DllExport ~MinimalDiscriminatorMember()
10302 {
10303 }
10304
10309 eProsima_user_DllExport MinimalDiscriminatorMember(
10311 {
10312 m_common = x.m_common;
10313
10314 }
10315
10320 eProsima_user_DllExport MinimalDiscriminatorMember(
10321 MinimalDiscriminatorMember&& x) noexcept
10322 {
10323 m_common = std::move(x.m_common);
10324 }
10325
10330 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10332 {
10333
10334 m_common = x.m_common;
10335
10336 return *this;
10337 }
10338
10343 eProsima_user_DllExport MinimalDiscriminatorMember& operator =(
10344 MinimalDiscriminatorMember&& x) noexcept
10345 {
10346
10347 m_common = std::move(x.m_common);
10348 return *this;
10349 }
10350
10355 eProsima_user_DllExport bool operator ==(
10356 const MinimalDiscriminatorMember& x) const
10357 {
10358 return (m_common == x.m_common);
10359 }
10360
10365 eProsima_user_DllExport bool operator !=(
10366 const MinimalDiscriminatorMember& x) const
10367 {
10368 return !(*this == x);
10369 }
10370
10375 eProsima_user_DllExport void common(
10376 const CommonDiscriminatorMember& _common)
10377 {
10378 m_common = _common;
10379 }
10380
10385 eProsima_user_DllExport void common(
10386 CommonDiscriminatorMember&& _common)
10387 {
10388 m_common = std::move(_common);
10389 }
10390
10395 eProsima_user_DllExport const CommonDiscriminatorMember& common() const
10396 {
10397 return m_common;
10398 }
10399
10404 eProsima_user_DllExport CommonDiscriminatorMember& common()
10405 {
10406 return m_common;
10407 }
10408
10409
10410
10411private:
10412
10414
10415};
10421{
10422public:
10423
10427 eProsima_user_DllExport CompleteUnionHeader()
10428 {
10429 }
10430
10434 eProsima_user_DllExport ~CompleteUnionHeader()
10435 {
10436 }
10437
10442 eProsima_user_DllExport CompleteUnionHeader(
10443 const CompleteUnionHeader& x)
10444 {
10445 m_detail = x.m_detail;
10446
10447 }
10448
10453 eProsima_user_DllExport CompleteUnionHeader(
10454 CompleteUnionHeader&& x) noexcept
10455 {
10456 m_detail = std::move(x.m_detail);
10457 }
10458
10463 eProsima_user_DllExport CompleteUnionHeader& operator =(
10464 const CompleteUnionHeader& x)
10465 {
10466
10467 m_detail = x.m_detail;
10468
10469 return *this;
10470 }
10471
10476 eProsima_user_DllExport CompleteUnionHeader& operator =(
10477 CompleteUnionHeader&& x) noexcept
10478 {
10479
10480 m_detail = std::move(x.m_detail);
10481 return *this;
10482 }
10483
10488 eProsima_user_DllExport bool operator ==(
10489 const CompleteUnionHeader& x) const
10490 {
10491 return (m_detail == x.m_detail);
10492 }
10493
10498 eProsima_user_DllExport bool operator !=(
10499 const CompleteUnionHeader& x) const
10500 {
10501 return !(*this == x);
10502 }
10503
10508 eProsima_user_DllExport void detail(
10509 const CompleteTypeDetail& _detail)
10510 {
10511 m_detail = _detail;
10512 }
10513
10518 eProsima_user_DllExport void detail(
10519 CompleteTypeDetail&& _detail)
10520 {
10521 m_detail = std::move(_detail);
10522 }
10523
10528 eProsima_user_DllExport const CompleteTypeDetail& detail() const
10529 {
10530 return m_detail;
10531 }
10532
10537 eProsima_user_DllExport CompleteTypeDetail& detail()
10538 {
10539 return m_detail;
10540 }
10541
10542
10543
10544private:
10545
10546 CompleteTypeDetail m_detail;
10547
10548};
10554{
10555public:
10556
10560 eProsima_user_DllExport MinimalUnionHeader()
10561 {
10562 }
10563
10567 eProsima_user_DllExport ~MinimalUnionHeader()
10568 {
10569 }
10570
10575 eProsima_user_DllExport MinimalUnionHeader(
10576 const MinimalUnionHeader& x)
10577 {
10578 m_detail = x.m_detail;
10579
10580 }
10581
10586 eProsima_user_DllExport MinimalUnionHeader(
10587 MinimalUnionHeader&& x) noexcept
10588 {
10589 m_detail = std::move(x.m_detail);
10590 }
10591
10596 eProsima_user_DllExport MinimalUnionHeader& operator =(
10597 const MinimalUnionHeader& x)
10598 {
10599
10600 m_detail = x.m_detail;
10601
10602 return *this;
10603 }
10604
10609 eProsima_user_DllExport MinimalUnionHeader& operator =(
10610 MinimalUnionHeader&& x) noexcept
10611 {
10612
10613 m_detail = std::move(x.m_detail);
10614 return *this;
10615 }
10616
10621 eProsima_user_DllExport bool operator ==(
10622 const MinimalUnionHeader& x) const
10623 {
10624 return (m_detail == x.m_detail);
10625 }
10626
10631 eProsima_user_DllExport bool operator !=(
10632 const MinimalUnionHeader& x) const
10633 {
10634 return !(*this == x);
10635 }
10636
10641 eProsima_user_DllExport void detail(
10642 const MinimalTypeDetail& _detail)
10643 {
10644 m_detail = _detail;
10645 }
10646
10651 eProsima_user_DllExport void detail(
10652 MinimalTypeDetail&& _detail)
10653 {
10654 m_detail = std::move(_detail);
10655 }
10656
10661 eProsima_user_DllExport const MinimalTypeDetail& detail() const
10662 {
10663 return m_detail;
10664 }
10665
10670 eProsima_user_DllExport MinimalTypeDetail& detail()
10671 {
10672 return m_detail;
10673 }
10674
10675
10676
10677private:
10678
10679 MinimalTypeDetail m_detail;
10680
10681};
10687{
10688public:
10689
10693 eProsima_user_DllExport CompleteUnionType()
10694 {
10695 }
10696
10700 eProsima_user_DllExport ~CompleteUnionType()
10701 {
10702 }
10703
10708 eProsima_user_DllExport CompleteUnionType(
10709 const CompleteUnionType& x)
10710 {
10711 m_union_flags = x.m_union_flags;
10712
10713 m_header = x.m_header;
10714
10715 m_discriminator = x.m_discriminator;
10716
10717 m_member_seq = x.m_member_seq;
10718
10719 }
10720
10725 eProsima_user_DllExport CompleteUnionType(
10726 CompleteUnionType&& x) noexcept
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 }
10733
10738 eProsima_user_DllExport CompleteUnionType& operator =(
10739 const CompleteUnionType& x)
10740 {
10741
10742 m_union_flags = x.m_union_flags;
10743
10744 m_header = x.m_header;
10745
10746 m_discriminator = x.m_discriminator;
10747
10748 m_member_seq = x.m_member_seq;
10749
10750 return *this;
10751 }
10752
10757 eProsima_user_DllExport CompleteUnionType& operator =(
10758 CompleteUnionType&& x) noexcept
10759 {
10760
10761 m_union_flags = std::move(x.m_union_flags);
10762 m_header = std::move(x.m_header);
10763 m_discriminator = std::move(x.m_discriminator);
10764 m_member_seq = std::move(x.m_member_seq);
10765 return *this;
10766 }
10767
10772 eProsima_user_DllExport bool operator ==(
10773 const CompleteUnionType& x) const
10774 {
10775 return (m_union_flags == x.m_union_flags &&
10776 m_header == x.m_header &&
10777 m_discriminator == x.m_discriminator &&
10778 m_member_seq == x.m_member_seq);
10779 }
10780
10785 eProsima_user_DllExport bool operator !=(
10786 const CompleteUnionType& x) const
10787 {
10788 return !(*this == x);
10789 }
10790
10795 eProsima_user_DllExport void union_flags(
10796 const UnionTypeFlag& _union_flags)
10797 {
10798 m_union_flags = _union_flags;
10799 }
10800
10805 eProsima_user_DllExport void union_flags(
10806 UnionTypeFlag&& _union_flags)
10807 {
10808 m_union_flags = std::move(_union_flags);
10809 }
10810
10815 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
10816 {
10817 return m_union_flags;
10818 }
10819
10824 eProsima_user_DllExport UnionTypeFlag& union_flags()
10825 {
10826 return m_union_flags;
10827 }
10828
10829
10834 eProsima_user_DllExport void header(
10835 const CompleteUnionHeader& _header)
10836 {
10837 m_header = _header;
10838 }
10839
10844 eProsima_user_DllExport void header(
10845 CompleteUnionHeader&& _header)
10846 {
10847 m_header = std::move(_header);
10848 }
10849
10854 eProsima_user_DllExport const CompleteUnionHeader& header() const
10855 {
10856 return m_header;
10857 }
10858
10863 eProsima_user_DllExport CompleteUnionHeader& header()
10864 {
10865 return m_header;
10866 }
10867
10868
10873 eProsima_user_DllExport void discriminator(
10874 const CompleteDiscriminatorMember& _discriminator)
10875 {
10876 m_discriminator = _discriminator;
10877 }
10878
10883 eProsima_user_DllExport void discriminator(
10884 CompleteDiscriminatorMember&& _discriminator)
10885 {
10886 m_discriminator = std::move(_discriminator);
10887 }
10888
10893 eProsima_user_DllExport const CompleteDiscriminatorMember& discriminator() const
10894 {
10895 return m_discriminator;
10896 }
10897
10903 {
10904 return m_discriminator;
10905 }
10906
10907
10912 eProsima_user_DllExport void member_seq(
10913 const CompleteUnionMemberSeq& _member_seq)
10914 {
10915 m_member_seq = _member_seq;
10916 }
10917
10922 eProsima_user_DllExport void member_seq(
10923 CompleteUnionMemberSeq&& _member_seq)
10924 {
10925 m_member_seq = std::move(_member_seq);
10926 }
10927
10932 eProsima_user_DllExport const CompleteUnionMemberSeq& member_seq() const
10933 {
10934 return m_member_seq;
10935 }
10936
10941 eProsima_user_DllExport CompleteUnionMemberSeq& member_seq()
10942 {
10943 return m_member_seq;
10944 }
10945
10946
10947
10948private:
10949
10950 UnionTypeFlag m_union_flags{0};
10951 CompleteUnionHeader m_header;
10952 CompleteDiscriminatorMember m_discriminator;
10953 CompleteUnionMemberSeq m_member_seq;
10954
10955};
10961{
10962public:
10963
10967 eProsima_user_DllExport MinimalUnionType()
10968 {
10969 }
10970
10974 eProsima_user_DllExport ~MinimalUnionType()
10975 {
10976 }
10977
10982 eProsima_user_DllExport MinimalUnionType(
10983 const MinimalUnionType& x)
10984 {
10985 m_union_flags = x.m_union_flags;
10986
10987 m_header = x.m_header;
10988
10989 m_discriminator = x.m_discriminator;
10990
10991 m_member_seq = x.m_member_seq;
10992
10993 }
10994
10999 eProsima_user_DllExport MinimalUnionType(
11000 MinimalUnionType&& x) noexcept
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 }
11007
11012 eProsima_user_DllExport MinimalUnionType& operator =(
11013 const MinimalUnionType& x)
11014 {
11015
11016 m_union_flags = x.m_union_flags;
11017
11018 m_header = x.m_header;
11019
11020 m_discriminator = x.m_discriminator;
11021
11022 m_member_seq = x.m_member_seq;
11023
11024 return *this;
11025 }
11026
11031 eProsima_user_DllExport MinimalUnionType& operator =(
11032 MinimalUnionType&& x) noexcept
11033 {
11034
11035 m_union_flags = std::move(x.m_union_flags);
11036 m_header = std::move(x.m_header);
11037 m_discriminator = std::move(x.m_discriminator);
11038 m_member_seq = std::move(x.m_member_seq);
11039 return *this;
11040 }
11041
11046 eProsima_user_DllExport bool operator ==(
11047 const MinimalUnionType& x) const
11048 {
11049 return (m_union_flags == x.m_union_flags &&
11050 m_header == x.m_header &&
11051 m_discriminator == x.m_discriminator &&
11052 m_member_seq == x.m_member_seq);
11053 }
11054
11059 eProsima_user_DllExport bool operator !=(
11060 const MinimalUnionType& x) const
11061 {
11062 return !(*this == x);
11063 }
11064
11069 eProsima_user_DllExport void union_flags(
11070 const UnionTypeFlag& _union_flags)
11071 {
11072 m_union_flags = _union_flags;
11073 }
11074
11079 eProsima_user_DllExport void union_flags(
11080 UnionTypeFlag&& _union_flags)
11081 {
11082 m_union_flags = std::move(_union_flags);
11083 }
11084
11089 eProsima_user_DllExport const UnionTypeFlag& union_flags() const
11090 {
11091 return m_union_flags;
11092 }
11093
11098 eProsima_user_DllExport UnionTypeFlag& union_flags()
11099 {
11100 return m_union_flags;
11101 }
11102
11103
11108 eProsima_user_DllExport void header(
11109 const MinimalUnionHeader& _header)
11110 {
11111 m_header = _header;
11112 }
11113
11118 eProsima_user_DllExport void header(
11119 MinimalUnionHeader&& _header)
11120 {
11121 m_header = std::move(_header);
11122 }
11123
11128 eProsima_user_DllExport const MinimalUnionHeader& header() const
11129 {
11130 return m_header;
11131 }
11132
11137 eProsima_user_DllExport MinimalUnionHeader& header()
11138 {
11139 return m_header;
11140 }
11141
11142
11147 eProsima_user_DllExport void discriminator(
11148 const MinimalDiscriminatorMember& _discriminator)
11149 {
11150 m_discriminator = _discriminator;
11151 }
11152
11157 eProsima_user_DllExport void discriminator(
11158 MinimalDiscriminatorMember&& _discriminator)
11159 {
11160 m_discriminator = std::move(_discriminator);
11161 }
11162
11167 eProsima_user_DllExport const MinimalDiscriminatorMember& discriminator() const
11168 {
11169 return m_discriminator;
11170 }
11171
11177 {
11178 return m_discriminator;
11179 }
11180
11181
11186 eProsima_user_DllExport void member_seq(
11187 const MinimalUnionMemberSeq& _member_seq)
11188 {
11189 m_member_seq = _member_seq;
11190 }
11191
11196 eProsima_user_DllExport void member_seq(
11197 MinimalUnionMemberSeq&& _member_seq)
11198 {
11199 m_member_seq = std::move(_member_seq);
11200 }
11201
11206 eProsima_user_DllExport const MinimalUnionMemberSeq& member_seq() const
11207 {
11208 return m_member_seq;
11209 }
11210
11215 eProsima_user_DllExport MinimalUnionMemberSeq& member_seq()
11216 {
11217 return m_member_seq;
11218 }
11219
11220
11221
11222private:
11223
11224 UnionTypeFlag m_union_flags{0};
11225 MinimalUnionHeader m_header;
11226 MinimalDiscriminatorMember m_discriminator;
11227 MinimalUnionMemberSeq m_member_seq;
11228
11229};
11235{
11236public:
11237
11241 eProsima_user_DllExport CommonAnnotationParameter()
11242 {
11243 }
11244
11248 eProsima_user_DllExport ~CommonAnnotationParameter()
11249 {
11250 }
11251
11256 eProsima_user_DllExport CommonAnnotationParameter(
11258 {
11259 m_member_flags = x.m_member_flags;
11260
11261 m_member_type_id = x.m_member_type_id;
11262
11263 }
11264
11269 eProsima_user_DllExport CommonAnnotationParameter(
11270 CommonAnnotationParameter&& x) noexcept
11271 {
11272 m_member_flags = std::move(x.m_member_flags);
11273 m_member_type_id = std::move(x.m_member_type_id);
11274 }
11275
11280 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11282 {
11283
11284 m_member_flags = x.m_member_flags;
11285
11286 m_member_type_id = x.m_member_type_id;
11287
11288 return *this;
11289 }
11290
11295 eProsima_user_DllExport CommonAnnotationParameter& operator =(
11296 CommonAnnotationParameter&& x) noexcept
11297 {
11298
11299 m_member_flags = std::move(x.m_member_flags);
11300 m_member_type_id = std::move(x.m_member_type_id);
11301 return *this;
11302 }
11303
11308 eProsima_user_DllExport bool operator ==(
11309 const CommonAnnotationParameter& x) const
11310 {
11311 return (m_member_flags == x.m_member_flags &&
11312 m_member_type_id == x.m_member_type_id);
11313 }
11314
11319 eProsima_user_DllExport bool operator !=(
11320 const CommonAnnotationParameter& x) const
11321 {
11322 return !(*this == x);
11323 }
11324
11329 eProsima_user_DllExport void member_flags(
11330 const AnnotationParameterFlag& _member_flags)
11331 {
11332 m_member_flags = _member_flags;
11333 }
11334
11339 eProsima_user_DllExport void member_flags(
11340 AnnotationParameterFlag&& _member_flags)
11341 {
11342 m_member_flags = std::move(_member_flags);
11343 }
11344
11349 eProsima_user_DllExport const AnnotationParameterFlag& member_flags() const
11350 {
11351 return m_member_flags;
11352 }
11353
11358 eProsima_user_DllExport AnnotationParameterFlag& member_flags()
11359 {
11360 return m_member_flags;
11361 }
11362
11363
11368 eProsima_user_DllExport void member_type_id(
11369 const TypeIdentifier& _member_type_id)
11370 {
11371 m_member_type_id = _member_type_id;
11372 }
11373
11378 eProsima_user_DllExport void member_type_id(
11379 TypeIdentifier&& _member_type_id)
11380 {
11381 m_member_type_id = std::move(_member_type_id);
11382 }
11383
11388 eProsima_user_DllExport const TypeIdentifier& member_type_id() const
11389 {
11390 return m_member_type_id;
11391 }
11392
11397 eProsima_user_DllExport TypeIdentifier& member_type_id()
11398 {
11399 return m_member_type_id;
11400 }
11401
11402
11403
11404private:
11405
11406 AnnotationParameterFlag m_member_flags{0};
11407 TypeIdentifier m_member_type_id;
11408
11409};
11415{
11416public:
11417
11421 eProsima_user_DllExport CompleteAnnotationParameter()
11422 {
11423 }
11424
11428 eProsima_user_DllExport ~CompleteAnnotationParameter()
11429 {
11430 }
11431
11436 eProsima_user_DllExport CompleteAnnotationParameter(
11438 {
11439 m_common = x.m_common;
11440
11441 m_name = x.m_name;
11442
11443 m_default_value = x.m_default_value;
11444
11445 }
11446
11451 eProsima_user_DllExport CompleteAnnotationParameter(
11452 CompleteAnnotationParameter&& x) noexcept
11453 {
11454 m_common = std::move(x.m_common);
11455 m_name = std::move(x.m_name);
11456 m_default_value = std::move(x.m_default_value);
11457 }
11458
11463 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11465 {
11466
11467 m_common = x.m_common;
11468
11469 m_name = x.m_name;
11470
11471 m_default_value = x.m_default_value;
11472
11473 return *this;
11474 }
11475
11480 eProsima_user_DllExport CompleteAnnotationParameter& operator =(
11481 CompleteAnnotationParameter&& x) noexcept
11482 {
11483
11484 m_common = std::move(x.m_common);
11485 m_name = std::move(x.m_name);
11486 m_default_value = std::move(x.m_default_value);
11487 return *this;
11488 }
11489
11494 eProsima_user_DllExport bool operator ==(
11495 const CompleteAnnotationParameter& x) const
11496 {
11497 return (m_common == x.m_common &&
11498 m_name == x.m_name &&
11499 m_default_value == x.m_default_value);
11500 }
11501
11506 eProsima_user_DllExport bool operator !=(
11507 const CompleteAnnotationParameter& x) const
11508 {
11509 return !(*this == x);
11510 }
11511
11516 eProsima_user_DllExport void common(
11517 const CommonAnnotationParameter& _common)
11518 {
11519 m_common = _common;
11520 }
11521
11526 eProsima_user_DllExport void common(
11527 CommonAnnotationParameter&& _common)
11528 {
11529 m_common = std::move(_common);
11530 }
11531
11536 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11537 {
11538 return m_common;
11539 }
11540
11545 eProsima_user_DllExport CommonAnnotationParameter& common()
11546 {
11547 return m_common;
11548 }
11549
11550
11555 eProsima_user_DllExport void name(
11556 const MemberName& _name)
11557 {
11558 m_name = _name;
11559 }
11560
11565 eProsima_user_DllExport void name(
11566 MemberName&& _name)
11567 {
11568 m_name = std::move(_name);
11569 }
11570
11575 eProsima_user_DllExport const MemberName& name() const
11576 {
11577 return m_name;
11578 }
11579
11584 eProsima_user_DllExport MemberName& name()
11585 {
11586 return m_name;
11587 }
11588
11589
11594 eProsima_user_DllExport void default_value(
11595 const AnnotationParameterValue& _default_value)
11596 {
11597 m_default_value = _default_value;
11598 }
11599
11604 eProsima_user_DllExport void default_value(
11605 AnnotationParameterValue&& _default_value)
11606 {
11607 m_default_value = std::move(_default_value);
11608 }
11609
11614 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11615 {
11616 return m_default_value;
11617 }
11618
11623 eProsima_user_DllExport AnnotationParameterValue& default_value()
11624 {
11625 return m_default_value;
11626 }
11627
11628
11629
11630private:
11631
11633 MemberName m_name;
11634 AnnotationParameterValue m_default_value;
11635
11636};
11637typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
11638
11644{
11645public:
11646
11650 eProsima_user_DllExport MinimalAnnotationParameter()
11651 {
11652 }
11653
11657 eProsima_user_DllExport ~MinimalAnnotationParameter()
11658 {
11659 }
11660
11665 eProsima_user_DllExport MinimalAnnotationParameter(
11667 {
11668 m_common = x.m_common;
11669
11670 m_name_hash = x.m_name_hash;
11671
11672 m_default_value = x.m_default_value;
11673
11674 }
11675
11680 eProsima_user_DllExport MinimalAnnotationParameter(
11681 MinimalAnnotationParameter&& x) noexcept
11682 {
11683 m_common = std::move(x.m_common);
11684 m_name_hash = std::move(x.m_name_hash);
11685 m_default_value = std::move(x.m_default_value);
11686 }
11687
11692 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11694 {
11695
11696 m_common = x.m_common;
11697
11698 m_name_hash = x.m_name_hash;
11699
11700 m_default_value = x.m_default_value;
11701
11702 return *this;
11703 }
11704
11709 eProsima_user_DllExport MinimalAnnotationParameter& operator =(
11710 MinimalAnnotationParameter&& x) noexcept
11711 {
11712
11713 m_common = std::move(x.m_common);
11714 m_name_hash = std::move(x.m_name_hash);
11715 m_default_value = std::move(x.m_default_value);
11716 return *this;
11717 }
11718
11723 eProsima_user_DllExport bool operator ==(
11724 const MinimalAnnotationParameter& x) const
11725 {
11726 return (m_common == x.m_common &&
11727 m_name_hash == x.m_name_hash &&
11728 m_default_value == x.m_default_value);
11729 }
11730
11735 eProsima_user_DllExport bool operator !=(
11736 const MinimalAnnotationParameter& x) const
11737 {
11738 return !(*this == x);
11739 }
11740
11745 eProsima_user_DllExport void common(
11746 const CommonAnnotationParameter& _common)
11747 {
11748 m_common = _common;
11749 }
11750
11755 eProsima_user_DllExport void common(
11756 CommonAnnotationParameter&& _common)
11757 {
11758 m_common = std::move(_common);
11759 }
11760
11765 eProsima_user_DllExport const CommonAnnotationParameter& common() const
11766 {
11767 return m_common;
11768 }
11769
11774 eProsima_user_DllExport CommonAnnotationParameter& common()
11775 {
11776 return m_common;
11777 }
11778
11779
11784 eProsima_user_DllExport void name_hash(
11785 const NameHash& _name_hash)
11786 {
11787 m_name_hash = _name_hash;
11788 }
11789
11794 eProsima_user_DllExport void name_hash(
11795 NameHash&& _name_hash)
11796 {
11797 m_name_hash = std::move(_name_hash);
11798 }
11799
11804 eProsima_user_DllExport const NameHash& name_hash() const
11805 {
11806 return m_name_hash;
11807 }
11808
11813 eProsima_user_DllExport NameHash& name_hash()
11814 {
11815 return m_name_hash;
11816 }
11817
11818
11823 eProsima_user_DllExport void default_value(
11824 const AnnotationParameterValue& _default_value)
11825 {
11826 m_default_value = _default_value;
11827 }
11828
11833 eProsima_user_DllExport void default_value(
11834 AnnotationParameterValue&& _default_value)
11835 {
11836 m_default_value = std::move(_default_value);
11837 }
11838
11843 eProsima_user_DllExport const AnnotationParameterValue& default_value() const
11844 {
11845 return m_default_value;
11846 }
11847
11852 eProsima_user_DllExport AnnotationParameterValue& default_value()
11853 {
11854 return m_default_value;
11855 }
11856
11857
11858
11859private:
11860
11862 NameHash m_name_hash{0};
11863 AnnotationParameterValue m_default_value;
11864
11865};
11866typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
11867
11873{
11874public:
11875
11879 eProsima_user_DllExport CompleteAnnotationHeader()
11880 {
11881 }
11882
11886 eProsima_user_DllExport ~CompleteAnnotationHeader()
11887 {
11888 }
11889
11894 eProsima_user_DllExport CompleteAnnotationHeader(
11895 const CompleteAnnotationHeader& x)
11896 {
11897 m_annotation_name = x.m_annotation_name;
11898
11899 }
11900
11905 eProsima_user_DllExport CompleteAnnotationHeader(
11906 CompleteAnnotationHeader&& x) noexcept
11907 {
11908 m_annotation_name = std::move(x.m_annotation_name);
11909 }
11910
11915 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11916 const CompleteAnnotationHeader& x)
11917 {
11918
11919 m_annotation_name = x.m_annotation_name;
11920
11921 return *this;
11922 }
11923
11928 eProsima_user_DllExport CompleteAnnotationHeader& operator =(
11929 CompleteAnnotationHeader&& x) noexcept
11930 {
11931
11932 m_annotation_name = std::move(x.m_annotation_name);
11933 return *this;
11934 }
11935
11940 eProsima_user_DllExport bool operator ==(
11941 const CompleteAnnotationHeader& x) const
11942 {
11943 return (m_annotation_name == x.m_annotation_name);
11944 }
11945
11950 eProsima_user_DllExport bool operator !=(
11951 const CompleteAnnotationHeader& x) const
11952 {
11953 return !(*this == x);
11954 }
11955
11960 eProsima_user_DllExport void annotation_name(
11961 const QualifiedTypeName& _annotation_name)
11962 {
11963 m_annotation_name = _annotation_name;
11964 }
11965
11970 eProsima_user_DllExport void annotation_name(
11971 QualifiedTypeName&& _annotation_name)
11972 {
11973 m_annotation_name = std::move(_annotation_name);
11974 }
11975
11980 eProsima_user_DllExport const QualifiedTypeName& annotation_name() const
11981 {
11982 return m_annotation_name;
11983 }
11984
11989 eProsima_user_DllExport QualifiedTypeName& annotation_name()
11990 {
11991 return m_annotation_name;
11992 }
11993
11994
11995
11996private:
11997
11998 QualifiedTypeName m_annotation_name;
11999
12000};
12006{
12007public:
12008
12012 eProsima_user_DllExport MinimalAnnotationHeader()
12013 {
12014 }
12015
12019 eProsima_user_DllExport ~MinimalAnnotationHeader()
12020 {
12021 }
12022
12027 eProsima_user_DllExport MinimalAnnotationHeader(
12028 const MinimalAnnotationHeader& x)
12029 {
12030 static_cast<void>(x);
12031 }
12032
12037 eProsima_user_DllExport MinimalAnnotationHeader(
12038 MinimalAnnotationHeader&& x) noexcept
12039 {
12040 static_cast<void>(x);
12041 }
12042
12047 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12048 const MinimalAnnotationHeader& x)
12049 {
12050
12051 static_cast<void>(x);
12052
12053 return *this;
12054 }
12055
12060 eProsima_user_DllExport MinimalAnnotationHeader& operator =(
12061 MinimalAnnotationHeader&& x) noexcept
12062 {
12063
12064 static_cast<void>(x);
12065
12066 return *this;
12067 }
12068
12073 eProsima_user_DllExport bool operator ==(
12074 const MinimalAnnotationHeader& x) const
12075 {
12076 static_cast<void>(x);
12077 return true;
12078 }
12079
12084 eProsima_user_DllExport bool operator !=(
12085 const MinimalAnnotationHeader& x) const
12086 {
12087 return !(*this == x);
12088 }
12089
12090
12091
12092private:
12093
12094
12095};
12101{
12102public:
12103
12107 eProsima_user_DllExport CompleteAnnotationType()
12108 {
12109 }
12110
12114 eProsima_user_DllExport ~CompleteAnnotationType()
12115 {
12116 }
12117
12122 eProsima_user_DllExport CompleteAnnotationType(
12123 const CompleteAnnotationType& x)
12124 {
12125 m_annotation_flag = x.m_annotation_flag;
12126
12127 m_header = x.m_header;
12128
12129 m_member_seq = x.m_member_seq;
12130
12131 }
12132
12137 eProsima_user_DllExport CompleteAnnotationType(
12138 CompleteAnnotationType&& x) noexcept
12139 {
12140 m_annotation_flag = std::move(x.m_annotation_flag);
12141 m_header = std::move(x.m_header);
12142 m_member_seq = std::move(x.m_member_seq);
12143 }
12144
12149 eProsima_user_DllExport CompleteAnnotationType& operator =(
12150 const CompleteAnnotationType& x)
12151 {
12152
12153 m_annotation_flag = x.m_annotation_flag;
12154
12155 m_header = x.m_header;
12156
12157 m_member_seq = x.m_member_seq;
12158
12159 return *this;
12160 }
12161
12166 eProsima_user_DllExport CompleteAnnotationType& operator =(
12167 CompleteAnnotationType&& x) noexcept
12168 {
12169
12170 m_annotation_flag = std::move(x.m_annotation_flag);
12171 m_header = std::move(x.m_header);
12172 m_member_seq = std::move(x.m_member_seq);
12173 return *this;
12174 }
12175
12180 eProsima_user_DllExport bool operator ==(
12181 const CompleteAnnotationType& x) const
12182 {
12183 return (m_annotation_flag == x.m_annotation_flag &&
12184 m_header == x.m_header &&
12185 m_member_seq == x.m_member_seq);
12186 }
12187
12192 eProsima_user_DllExport bool operator !=(
12193 const CompleteAnnotationType& x) const
12194 {
12195 return !(*this == x);
12196 }
12197
12202 eProsima_user_DllExport void annotation_flag(
12203 const AnnotationTypeFlag& _annotation_flag)
12204 {
12205 m_annotation_flag = _annotation_flag;
12206 }
12207
12212 eProsima_user_DllExport void annotation_flag(
12213 AnnotationTypeFlag&& _annotation_flag)
12214 {
12215 m_annotation_flag = std::move(_annotation_flag);
12216 }
12217
12222 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12223 {
12224 return m_annotation_flag;
12225 }
12226
12231 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12232 {
12233 return m_annotation_flag;
12234 }
12235
12236
12241 eProsima_user_DllExport void header(
12242 const CompleteAnnotationHeader& _header)
12243 {
12244 m_header = _header;
12245 }
12246
12251 eProsima_user_DllExport void header(
12252 CompleteAnnotationHeader&& _header)
12253 {
12254 m_header = std::move(_header);
12255 }
12256
12261 eProsima_user_DllExport const CompleteAnnotationHeader& header() const
12262 {
12263 return m_header;
12264 }
12265
12270 eProsima_user_DllExport CompleteAnnotationHeader& header()
12271 {
12272 return m_header;
12273 }
12274
12275
12280 eProsima_user_DllExport void member_seq(
12281 const CompleteAnnotationParameterSeq& _member_seq)
12282 {
12283 m_member_seq = _member_seq;
12284 }
12285
12290 eProsima_user_DllExport void member_seq(
12291 CompleteAnnotationParameterSeq&& _member_seq)
12292 {
12293 m_member_seq = std::move(_member_seq);
12294 }
12295
12300 eProsima_user_DllExport const CompleteAnnotationParameterSeq& member_seq() const
12301 {
12302 return m_member_seq;
12303 }
12304
12310 {
12311 return m_member_seq;
12312 }
12313
12314
12315
12316private:
12317
12318 AnnotationTypeFlag m_annotation_flag{0};
12319 CompleteAnnotationHeader m_header;
12320 CompleteAnnotationParameterSeq m_member_seq;
12321
12322};
12328{
12329public:
12330
12334 eProsima_user_DllExport MinimalAnnotationType()
12335 {
12336 }
12337
12341 eProsima_user_DllExport ~MinimalAnnotationType()
12342 {
12343 }
12344
12349 eProsima_user_DllExport MinimalAnnotationType(
12350 const MinimalAnnotationType& x)
12351 {
12352 m_annotation_flag = x.m_annotation_flag;
12353
12354 m_header = x.m_header;
12355
12356 m_member_seq = x.m_member_seq;
12357
12358 }
12359
12364 eProsima_user_DllExport MinimalAnnotationType(
12365 MinimalAnnotationType&& x) noexcept
12366 {
12367 m_annotation_flag = std::move(x.m_annotation_flag);
12368 m_header = std::move(x.m_header);
12369 m_member_seq = std::move(x.m_member_seq);
12370 }
12371
12376 eProsima_user_DllExport MinimalAnnotationType& operator =(
12377 const MinimalAnnotationType& x)
12378 {
12379
12380 m_annotation_flag = x.m_annotation_flag;
12381
12382 m_header = x.m_header;
12383
12384 m_member_seq = x.m_member_seq;
12385
12386 return *this;
12387 }
12388
12393 eProsima_user_DllExport MinimalAnnotationType& operator =(
12394 MinimalAnnotationType&& x) noexcept
12395 {
12396
12397 m_annotation_flag = std::move(x.m_annotation_flag);
12398 m_header = std::move(x.m_header);
12399 m_member_seq = std::move(x.m_member_seq);
12400 return *this;
12401 }
12402
12407 eProsima_user_DllExport bool operator ==(
12408 const MinimalAnnotationType& x) const
12409 {
12410 return (m_annotation_flag == x.m_annotation_flag &&
12411 m_header == x.m_header &&
12412 m_member_seq == x.m_member_seq);
12413 }
12414
12419 eProsima_user_DllExport bool operator !=(
12420 const MinimalAnnotationType& x) const
12421 {
12422 return !(*this == x);
12423 }
12424
12429 eProsima_user_DllExport void annotation_flag(
12430 const AnnotationTypeFlag& _annotation_flag)
12431 {
12432 m_annotation_flag = _annotation_flag;
12433 }
12434
12439 eProsima_user_DllExport void annotation_flag(
12440 AnnotationTypeFlag&& _annotation_flag)
12441 {
12442 m_annotation_flag = std::move(_annotation_flag);
12443 }
12444
12449 eProsima_user_DllExport const AnnotationTypeFlag& annotation_flag() const
12450 {
12451 return m_annotation_flag;
12452 }
12453
12458 eProsima_user_DllExport AnnotationTypeFlag& annotation_flag()
12459 {
12460 return m_annotation_flag;
12461 }
12462
12463
12468 eProsima_user_DllExport void header(
12469 const MinimalAnnotationHeader& _header)
12470 {
12471 m_header = _header;
12472 }
12473
12478 eProsima_user_DllExport void header(
12479 MinimalAnnotationHeader&& _header)
12480 {
12481 m_header = std::move(_header);
12482 }
12483
12488 eProsima_user_DllExport const MinimalAnnotationHeader& header() const
12489 {
12490 return m_header;
12491 }
12492
12497 eProsima_user_DllExport MinimalAnnotationHeader& header()
12498 {
12499 return m_header;
12500 }
12501
12502
12507 eProsima_user_DllExport void member_seq(
12508 const MinimalAnnotationParameterSeq& _member_seq)
12509 {
12510 m_member_seq = _member_seq;
12511 }
12512
12517 eProsima_user_DllExport void member_seq(
12518 MinimalAnnotationParameterSeq&& _member_seq)
12519 {
12520 m_member_seq = std::move(_member_seq);
12521 }
12522
12527 eProsima_user_DllExport const MinimalAnnotationParameterSeq& member_seq() const
12528 {
12529 return m_member_seq;
12530 }
12531
12537 {
12538 return m_member_seq;
12539 }
12540
12541
12542
12543private:
12544
12545 AnnotationTypeFlag m_annotation_flag{0};
12546 MinimalAnnotationHeader m_header;
12547 MinimalAnnotationParameterSeq m_member_seq;
12548
12549};
12555{
12556public:
12557
12561 eProsima_user_DllExport CommonAliasBody()
12562 {
12563 }
12564
12568 eProsima_user_DllExport ~CommonAliasBody()
12569 {
12570 }
12571
12576 eProsima_user_DllExport CommonAliasBody(
12577 const CommonAliasBody& x)
12578 {
12579 m_related_flags = x.m_related_flags;
12580
12581 m_related_type = x.m_related_type;
12582
12583 }
12584
12589 eProsima_user_DllExport CommonAliasBody(
12590 CommonAliasBody&& x) noexcept
12591 {
12592 m_related_flags = std::move(x.m_related_flags);
12593 m_related_type = std::move(x.m_related_type);
12594 }
12595
12600 eProsima_user_DllExport CommonAliasBody& operator =(
12601 const CommonAliasBody& x)
12602 {
12603
12604 m_related_flags = x.m_related_flags;
12605
12606 m_related_type = x.m_related_type;
12607
12608 return *this;
12609 }
12610
12615 eProsima_user_DllExport CommonAliasBody& operator =(
12616 CommonAliasBody&& x) noexcept
12617 {
12618
12619 m_related_flags = std::move(x.m_related_flags);
12620 m_related_type = std::move(x.m_related_type);
12621 return *this;
12622 }
12623
12628 eProsima_user_DllExport bool operator ==(
12629 const CommonAliasBody& x) const
12630 {
12631 return (m_related_flags == x.m_related_flags &&
12632 m_related_type == x.m_related_type);
12633 }
12634
12639 eProsima_user_DllExport bool operator !=(
12640 const CommonAliasBody& x) const
12641 {
12642 return !(*this == x);
12643 }
12644
12649 eProsima_user_DllExport void related_flags(
12650 const AliasMemberFlag& _related_flags)
12651 {
12652 m_related_flags = _related_flags;
12653 }
12654
12659 eProsima_user_DllExport void related_flags(
12660 AliasMemberFlag&& _related_flags)
12661 {
12662 m_related_flags = std::move(_related_flags);
12663 }
12664
12669 eProsima_user_DllExport const AliasMemberFlag& related_flags() const
12670 {
12671 return m_related_flags;
12672 }
12673
12678 eProsima_user_DllExport AliasMemberFlag& related_flags()
12679 {
12680 return m_related_flags;
12681 }
12682
12683
12688 eProsima_user_DllExport void related_type(
12689 const TypeIdentifier& _related_type)
12690 {
12691 m_related_type = _related_type;
12692 }
12693
12698 eProsima_user_DllExport void related_type(
12699 TypeIdentifier&& _related_type)
12700 {
12701 m_related_type = std::move(_related_type);
12702 }
12703
12708 eProsima_user_DllExport const TypeIdentifier& related_type() const
12709 {
12710 return m_related_type;
12711 }
12712
12717 eProsima_user_DllExport TypeIdentifier& related_type()
12718 {
12719 return m_related_type;
12720 }
12721
12722
12723
12724private:
12725
12726 AliasMemberFlag m_related_flags{0};
12727 TypeIdentifier m_related_type;
12728
12729};
12735{
12736public:
12737
12741 eProsima_user_DllExport CompleteAliasBody()
12742 {
12743 }
12744
12748 eProsima_user_DllExport ~CompleteAliasBody()
12749 {
12750 }
12751
12756 eProsima_user_DllExport CompleteAliasBody(
12757 const CompleteAliasBody& x)
12758 {
12759 m_common = x.m_common;
12760
12761 m_ann_builtin = x.m_ann_builtin;
12762
12763 m_ann_custom = x.m_ann_custom;
12764
12765 }
12766
12771 eProsima_user_DllExport CompleteAliasBody(
12772 CompleteAliasBody&& x) noexcept
12773 {
12774 m_common = std::move(x.m_common);
12775 m_ann_builtin = std::move(x.m_ann_builtin);
12776 m_ann_custom = std::move(x.m_ann_custom);
12777 }
12778
12783 eProsima_user_DllExport CompleteAliasBody& operator =(
12784 const CompleteAliasBody& x)
12785 {
12786
12787 m_common = x.m_common;
12788
12789 m_ann_builtin = x.m_ann_builtin;
12790
12791 m_ann_custom = x.m_ann_custom;
12792
12793 return *this;
12794 }
12795
12800 eProsima_user_DllExport CompleteAliasBody& operator =(
12801 CompleteAliasBody&& x) noexcept
12802 {
12803
12804 m_common = std::move(x.m_common);
12805 m_ann_builtin = std::move(x.m_ann_builtin);
12806 m_ann_custom = std::move(x.m_ann_custom);
12807 return *this;
12808 }
12809
12814 eProsima_user_DllExport bool operator ==(
12815 const CompleteAliasBody& x) const
12816 {
12817 return (m_common == x.m_common &&
12818 m_ann_builtin == x.m_ann_builtin &&
12819 m_ann_custom == x.m_ann_custom);
12820 }
12821
12826 eProsima_user_DllExport bool operator !=(
12827 const CompleteAliasBody& x) const
12828 {
12829 return !(*this == x);
12830 }
12831
12836 eProsima_user_DllExport void common(
12837 const CommonAliasBody& _common)
12838 {
12839 m_common = _common;
12840 }
12841
12846 eProsima_user_DllExport void common(
12847 CommonAliasBody&& _common)
12848 {
12849 m_common = std::move(_common);
12850 }
12851
12856 eProsima_user_DllExport const CommonAliasBody& common() const
12857 {
12858 return m_common;
12859 }
12860
12865 eProsima_user_DllExport CommonAliasBody& common()
12866 {
12867 return m_common;
12868 }
12869
12870
12875 eProsima_user_DllExport void ann_builtin(
12876 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
12877 {
12878 m_ann_builtin = _ann_builtin;
12879 }
12880
12885 eProsima_user_DllExport void ann_builtin(
12886 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
12887 {
12888 m_ann_builtin = std::move(_ann_builtin);
12889 }
12890
12895 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
12896 {
12897 return m_ann_builtin;
12898 }
12899
12904 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
12905 {
12906 return m_ann_builtin;
12907 }
12908
12909
12914 eProsima_user_DllExport void ann_custom(
12915 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
12916 {
12917 m_ann_custom = _ann_custom;
12918 }
12919
12924 eProsima_user_DllExport void ann_custom(
12925 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
12926 {
12927 m_ann_custom = std::move(_ann_custom);
12928 }
12929
12934 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
12935 {
12936 return m_ann_custom;
12937 }
12938
12943 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
12944 {
12945 return m_ann_custom;
12946 }
12947
12948
12949
12950private:
12951
12952 CommonAliasBody m_common;
12953 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
12954 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
12955
12956};
12962{
12963public:
12964
12968 eProsima_user_DllExport MinimalAliasBody()
12969 {
12970 }
12971
12975 eProsima_user_DllExport ~MinimalAliasBody()
12976 {
12977 }
12978
12983 eProsima_user_DllExport MinimalAliasBody(
12984 const MinimalAliasBody& x)
12985 {
12986 m_common = x.m_common;
12987
12988 }
12989
12994 eProsima_user_DllExport MinimalAliasBody(
12995 MinimalAliasBody&& x) noexcept
12996 {
12997 m_common = std::move(x.m_common);
12998 }
12999
13004 eProsima_user_DllExport MinimalAliasBody& operator =(
13005 const MinimalAliasBody& x)
13006 {
13007
13008 m_common = x.m_common;
13009
13010 return *this;
13011 }
13012
13017 eProsima_user_DllExport MinimalAliasBody& operator =(
13018 MinimalAliasBody&& x) noexcept
13019 {
13020
13021 m_common = std::move(x.m_common);
13022 return *this;
13023 }
13024
13029 eProsima_user_DllExport bool operator ==(
13030 const MinimalAliasBody& x) const
13031 {
13032 return (m_common == x.m_common);
13033 }
13034
13039 eProsima_user_DllExport bool operator !=(
13040 const MinimalAliasBody& x) const
13041 {
13042 return !(*this == x);
13043 }
13044
13049 eProsima_user_DllExport void common(
13050 const CommonAliasBody& _common)
13051 {
13052 m_common = _common;
13053 }
13054
13059 eProsima_user_DllExport void common(
13060 CommonAliasBody&& _common)
13061 {
13062 m_common = std::move(_common);
13063 }
13064
13069 eProsima_user_DllExport const CommonAliasBody& common() const
13070 {
13071 return m_common;
13072 }
13073
13078 eProsima_user_DllExport CommonAliasBody& common()
13079 {
13080 return m_common;
13081 }
13082
13083
13084
13085private:
13086
13087 CommonAliasBody m_common;
13088
13089};
13095{
13096public:
13097
13101 eProsima_user_DllExport CompleteAliasHeader()
13102 {
13103 }
13104
13108 eProsima_user_DllExport ~CompleteAliasHeader()
13109 {
13110 }
13111
13116 eProsima_user_DllExport CompleteAliasHeader(
13117 const CompleteAliasHeader& x)
13118 {
13119 m_detail = x.m_detail;
13120
13121 }
13122
13127 eProsima_user_DllExport CompleteAliasHeader(
13128 CompleteAliasHeader&& x) noexcept
13129 {
13130 m_detail = std::move(x.m_detail);
13131 }
13132
13137 eProsima_user_DllExport CompleteAliasHeader& operator =(
13138 const CompleteAliasHeader& x)
13139 {
13140
13141 m_detail = x.m_detail;
13142
13143 return *this;
13144 }
13145
13150 eProsima_user_DllExport CompleteAliasHeader& operator =(
13151 CompleteAliasHeader&& x) noexcept
13152 {
13153
13154 m_detail = std::move(x.m_detail);
13155 return *this;
13156 }
13157
13162 eProsima_user_DllExport bool operator ==(
13163 const CompleteAliasHeader& x) const
13164 {
13165 return (m_detail == x.m_detail);
13166 }
13167
13172 eProsima_user_DllExport bool operator !=(
13173 const CompleteAliasHeader& x) const
13174 {
13175 return !(*this == x);
13176 }
13177
13182 eProsima_user_DllExport void detail(
13183 const CompleteTypeDetail& _detail)
13184 {
13185 m_detail = _detail;
13186 }
13187
13192 eProsima_user_DllExport void detail(
13193 CompleteTypeDetail&& _detail)
13194 {
13195 m_detail = std::move(_detail);
13196 }
13197
13202 eProsima_user_DllExport const CompleteTypeDetail& detail() const
13203 {
13204 return m_detail;
13205 }
13206
13211 eProsima_user_DllExport CompleteTypeDetail& detail()
13212 {
13213 return m_detail;
13214 }
13215
13216
13217
13218private:
13219
13220 CompleteTypeDetail m_detail;
13221
13222};
13228{
13229public:
13230
13234 eProsima_user_DllExport MinimalAliasHeader()
13235 {
13236 }
13237
13241 eProsima_user_DllExport ~MinimalAliasHeader()
13242 {
13243 }
13244
13249 eProsima_user_DllExport MinimalAliasHeader(
13250 const MinimalAliasHeader& x)
13251 {
13252 static_cast<void>(x);
13253 }
13254
13259 eProsima_user_DllExport MinimalAliasHeader(
13260 MinimalAliasHeader&& x) noexcept
13261 {
13262 static_cast<void>(x);
13263 }
13264
13269 eProsima_user_DllExport MinimalAliasHeader& operator =(
13270 const MinimalAliasHeader& x)
13271 {
13272
13273 static_cast<void>(x);
13274
13275 return *this;
13276 }
13277
13282 eProsima_user_DllExport MinimalAliasHeader& operator =(
13283 MinimalAliasHeader&& x) noexcept
13284 {
13285
13286 static_cast<void>(x);
13287
13288 return *this;
13289 }
13290
13295 eProsima_user_DllExport bool operator ==(
13296 const MinimalAliasHeader& x) const
13297 {
13298 static_cast<void>(x);
13299 return true;
13300 }
13301
13306 eProsima_user_DllExport bool operator !=(
13307 const MinimalAliasHeader& x) const
13308 {
13309 return !(*this == x);
13310 }
13311
13312
13313
13314private:
13315
13316
13317};
13323{
13324public:
13325
13329 eProsima_user_DllExport CompleteAliasType()
13330 {
13331 }
13332
13336 eProsima_user_DllExport ~CompleteAliasType()
13337 {
13338 }
13339
13344 eProsima_user_DllExport CompleteAliasType(
13345 const CompleteAliasType& x)
13346 {
13347 m_alias_flags = x.m_alias_flags;
13348
13349 m_header = x.m_header;
13350
13351 m_body = x.m_body;
13352
13353 }
13354
13359 eProsima_user_DllExport CompleteAliasType(
13360 CompleteAliasType&& x) noexcept
13361 {
13362 m_alias_flags = std::move(x.m_alias_flags);
13363 m_header = std::move(x.m_header);
13364 m_body = std::move(x.m_body);
13365 }
13366
13371 eProsima_user_DllExport CompleteAliasType& operator =(
13372 const CompleteAliasType& x)
13373 {
13374
13375 m_alias_flags = x.m_alias_flags;
13376
13377 m_header = x.m_header;
13378
13379 m_body = x.m_body;
13380
13381 return *this;
13382 }
13383
13388 eProsima_user_DllExport CompleteAliasType& operator =(
13389 CompleteAliasType&& x) noexcept
13390 {
13391
13392 m_alias_flags = std::move(x.m_alias_flags);
13393 m_header = std::move(x.m_header);
13394 m_body = std::move(x.m_body);
13395 return *this;
13396 }
13397
13402 eProsima_user_DllExport bool operator ==(
13403 const CompleteAliasType& x) const
13404 {
13405 return (m_alias_flags == x.m_alias_flags &&
13406 m_header == x.m_header &&
13407 m_body == x.m_body);
13408 }
13409
13414 eProsima_user_DllExport bool operator !=(
13415 const CompleteAliasType& x) const
13416 {
13417 return !(*this == x);
13418 }
13419
13424 eProsima_user_DllExport void alias_flags(
13425 const AliasTypeFlag& _alias_flags)
13426 {
13427 m_alias_flags = _alias_flags;
13428 }
13429
13434 eProsima_user_DllExport void alias_flags(
13435 AliasTypeFlag&& _alias_flags)
13436 {
13437 m_alias_flags = std::move(_alias_flags);
13438 }
13439
13444 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13445 {
13446 return m_alias_flags;
13447 }
13448
13453 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13454 {
13455 return m_alias_flags;
13456 }
13457
13458
13463 eProsima_user_DllExport void header(
13464 const CompleteAliasHeader& _header)
13465 {
13466 m_header = _header;
13467 }
13468
13473 eProsima_user_DllExport void header(
13474 CompleteAliasHeader&& _header)
13475 {
13476 m_header = std::move(_header);
13477 }
13478
13483 eProsima_user_DllExport const CompleteAliasHeader& header() const
13484 {
13485 return m_header;
13486 }
13487
13492 eProsima_user_DllExport CompleteAliasHeader& header()
13493 {
13494 return m_header;
13495 }
13496
13497
13502 eProsima_user_DllExport void body(
13503 const CompleteAliasBody& _body)
13504 {
13505 m_body = _body;
13506 }
13507
13512 eProsima_user_DllExport void body(
13513 CompleteAliasBody&& _body)
13514 {
13515 m_body = std::move(_body);
13516 }
13517
13522 eProsima_user_DllExport const CompleteAliasBody& body() const
13523 {
13524 return m_body;
13525 }
13526
13531 eProsima_user_DllExport CompleteAliasBody& body()
13532 {
13533 return m_body;
13534 }
13535
13536
13537
13538private:
13539
13540 AliasTypeFlag m_alias_flags{0};
13541 CompleteAliasHeader m_header;
13542 CompleteAliasBody m_body;
13543
13544};
13550{
13551public:
13552
13556 eProsima_user_DllExport MinimalAliasType()
13557 {
13558 }
13559
13563 eProsima_user_DllExport ~MinimalAliasType()
13564 {
13565 }
13566
13571 eProsima_user_DllExport MinimalAliasType(
13572 const MinimalAliasType& x)
13573 {
13574 m_alias_flags = x.m_alias_flags;
13575
13576 m_header = x.m_header;
13577
13578 m_body = x.m_body;
13579
13580 }
13581
13586 eProsima_user_DllExport MinimalAliasType(
13587 MinimalAliasType&& x) noexcept
13588 {
13589 m_alias_flags = std::move(x.m_alias_flags);
13590 m_header = std::move(x.m_header);
13591 m_body = std::move(x.m_body);
13592 }
13593
13598 eProsima_user_DllExport MinimalAliasType& operator =(
13599 const MinimalAliasType& x)
13600 {
13601
13602 m_alias_flags = x.m_alias_flags;
13603
13604 m_header = x.m_header;
13605
13606 m_body = x.m_body;
13607
13608 return *this;
13609 }
13610
13615 eProsima_user_DllExport MinimalAliasType& operator =(
13616 MinimalAliasType&& x) noexcept
13617 {
13618
13619 m_alias_flags = std::move(x.m_alias_flags);
13620 m_header = std::move(x.m_header);
13621 m_body = std::move(x.m_body);
13622 return *this;
13623 }
13624
13629 eProsima_user_DllExport bool operator ==(
13630 const MinimalAliasType& x) const
13631 {
13632 return (m_alias_flags == x.m_alias_flags &&
13633 m_header == x.m_header &&
13634 m_body == x.m_body);
13635 }
13636
13641 eProsima_user_DllExport bool operator !=(
13642 const MinimalAliasType& x) const
13643 {
13644 return !(*this == x);
13645 }
13646
13651 eProsima_user_DllExport void alias_flags(
13652 const AliasTypeFlag& _alias_flags)
13653 {
13654 m_alias_flags = _alias_flags;
13655 }
13656
13661 eProsima_user_DllExport void alias_flags(
13662 AliasTypeFlag&& _alias_flags)
13663 {
13664 m_alias_flags = std::move(_alias_flags);
13665 }
13666
13671 eProsima_user_DllExport const AliasTypeFlag& alias_flags() const
13672 {
13673 return m_alias_flags;
13674 }
13675
13680 eProsima_user_DllExport AliasTypeFlag& alias_flags()
13681 {
13682 return m_alias_flags;
13683 }
13684
13685
13690 eProsima_user_DllExport void header(
13691 const MinimalAliasHeader& _header)
13692 {
13693 m_header = _header;
13694 }
13695
13700 eProsima_user_DllExport void header(
13701 MinimalAliasHeader&& _header)
13702 {
13703 m_header = std::move(_header);
13704 }
13705
13710 eProsima_user_DllExport const MinimalAliasHeader& header() const
13711 {
13712 return m_header;
13713 }
13714
13719 eProsima_user_DllExport MinimalAliasHeader& header()
13720 {
13721 return m_header;
13722 }
13723
13724
13729 eProsima_user_DllExport void body(
13730 const MinimalAliasBody& _body)
13731 {
13732 m_body = _body;
13733 }
13734
13739 eProsima_user_DllExport void body(
13740 MinimalAliasBody&& _body)
13741 {
13742 m_body = std::move(_body);
13743 }
13744
13749 eProsima_user_DllExport const MinimalAliasBody& body() const
13750 {
13751 return m_body;
13752 }
13753
13758 eProsima_user_DllExport MinimalAliasBody& body()
13759 {
13760 return m_body;
13761 }
13762
13763
13764
13765private:
13766
13767 AliasTypeFlag m_alias_flags{0};
13768 MinimalAliasHeader m_header;
13769 MinimalAliasBody m_body;
13770
13771};
13777{
13778public:
13779
13783 eProsima_user_DllExport CompleteElementDetail()
13784 {
13785 }
13786
13790 eProsima_user_DllExport ~CompleteElementDetail()
13791 {
13792 }
13793
13798 eProsima_user_DllExport CompleteElementDetail(
13799 const CompleteElementDetail& x)
13800 {
13801 m_ann_builtin = x.m_ann_builtin;
13802
13803 m_ann_custom = x.m_ann_custom;
13804
13805 }
13806
13811 eProsima_user_DllExport CompleteElementDetail(
13812 CompleteElementDetail&& x) noexcept
13813 {
13814 m_ann_builtin = std::move(x.m_ann_builtin);
13815 m_ann_custom = std::move(x.m_ann_custom);
13816 }
13817
13822 eProsima_user_DllExport CompleteElementDetail& operator =(
13823 const CompleteElementDetail& x)
13824 {
13825
13826 m_ann_builtin = x.m_ann_builtin;
13827
13828 m_ann_custom = x.m_ann_custom;
13829
13830 return *this;
13831 }
13832
13837 eProsima_user_DllExport CompleteElementDetail& operator =(
13838 CompleteElementDetail&& x) noexcept
13839 {
13840
13841 m_ann_builtin = std::move(x.m_ann_builtin);
13842 m_ann_custom = std::move(x.m_ann_custom);
13843 return *this;
13844 }
13845
13850 eProsima_user_DllExport bool operator ==(
13851 const CompleteElementDetail& x) const
13852 {
13853 return (m_ann_builtin == x.m_ann_builtin &&
13854 m_ann_custom == x.m_ann_custom);
13855 }
13856
13861 eProsima_user_DllExport bool operator !=(
13862 const CompleteElementDetail& x) const
13863 {
13864 return !(*this == x);
13865 }
13866
13871 eProsima_user_DllExport void ann_builtin(
13872 const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& _ann_builtin)
13873 {
13874 m_ann_builtin = _ann_builtin;
13875 }
13876
13881 eProsima_user_DllExport void ann_builtin(
13882 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>&& _ann_builtin)
13883 {
13884 m_ann_builtin = std::move(_ann_builtin);
13885 }
13886
13891 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin() const
13892 {
13893 return m_ann_builtin;
13894 }
13895
13900 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations>& ann_builtin()
13901 {
13902 return m_ann_builtin;
13903 }
13904
13905
13910 eProsima_user_DllExport void ann_custom(
13911 const eprosima::fastcdr::optional<AppliedAnnotationSeq>& _ann_custom)
13912 {
13913 m_ann_custom = _ann_custom;
13914 }
13915
13920 eProsima_user_DllExport void ann_custom(
13921 eprosima::fastcdr::optional<AppliedAnnotationSeq>&& _ann_custom)
13922 {
13923 m_ann_custom = std::move(_ann_custom);
13924 }
13925
13930 eProsima_user_DllExport const eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom() const
13931 {
13932 return m_ann_custom;
13933 }
13934
13939 eProsima_user_DllExport eprosima::fastcdr::optional<AppliedAnnotationSeq>& ann_custom()
13940 {
13941 return m_ann_custom;
13942 }
13943
13944
13945
13946private:
13947
13948 eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> m_ann_builtin;
13949 eprosima::fastcdr::optional<AppliedAnnotationSeq> m_ann_custom;
13950
13951};
13957{
13958public:
13959
13963 eProsima_user_DllExport CommonCollectionElement()
13964 {
13965 }
13966
13970 eProsima_user_DllExport ~CommonCollectionElement()
13971 {
13972 }
13973
13978 eProsima_user_DllExport CommonCollectionElement(
13979 const CommonCollectionElement& x)
13980 {
13981 m_element_flags = x.m_element_flags;
13982
13983 m_type = x.m_type;
13984
13985 }
13986
13991 eProsima_user_DllExport CommonCollectionElement(
13992 CommonCollectionElement&& x) noexcept
13993 {
13994 m_element_flags = std::move(x.m_element_flags);
13995 m_type = std::move(x.m_type);
13996 }
13997
14002 eProsima_user_DllExport CommonCollectionElement& operator =(
14003 const CommonCollectionElement& x)
14004 {
14005
14006 m_element_flags = x.m_element_flags;
14007
14008 m_type = x.m_type;
14009
14010 return *this;
14011 }
14012
14017 eProsima_user_DllExport CommonCollectionElement& operator =(
14018 CommonCollectionElement&& x) noexcept
14019 {
14020
14021 m_element_flags = std::move(x.m_element_flags);
14022 m_type = std::move(x.m_type);
14023 return *this;
14024 }
14025
14030 eProsima_user_DllExport bool operator ==(
14031 const CommonCollectionElement& x) const
14032 {
14033 return (m_element_flags == x.m_element_flags &&
14034 m_type == x.m_type);
14035 }
14036
14041 eProsima_user_DllExport bool operator !=(
14042 const CommonCollectionElement& x) const
14043 {
14044 return !(*this == x);
14045 }
14046
14051 eProsima_user_DllExport void element_flags(
14052 const CollectionElementFlag& _element_flags)
14053 {
14054 m_element_flags = _element_flags;
14055 }
14056
14061 eProsima_user_DllExport void element_flags(
14062 CollectionElementFlag&& _element_flags)
14063 {
14064 m_element_flags = std::move(_element_flags);
14065 }
14066
14071 eProsima_user_DllExport const CollectionElementFlag& element_flags() const
14072 {
14073 return m_element_flags;
14074 }
14075
14080 eProsima_user_DllExport CollectionElementFlag& element_flags()
14081 {
14082 return m_element_flags;
14083 }
14084
14085
14090 eProsima_user_DllExport void type(
14091 const TypeIdentifier& _type)
14092 {
14093 m_type = _type;
14094 }
14095
14100 eProsima_user_DllExport void type(
14101 TypeIdentifier&& _type)
14102 {
14103 m_type = std::move(_type);
14104 }
14105
14110 eProsima_user_DllExport const TypeIdentifier& type() const
14111 {
14112 return m_type;
14113 }
14114
14119 eProsima_user_DllExport TypeIdentifier& type()
14120 {
14121 return m_type;
14122 }
14123
14124
14125
14126private:
14127
14128 CollectionElementFlag m_element_flags{0};
14129 TypeIdentifier m_type;
14130
14131};
14137{
14138public:
14139
14143 eProsima_user_DllExport CompleteCollectionElement()
14144 {
14145 }
14146
14150 eProsima_user_DllExport ~CompleteCollectionElement()
14151 {
14152 }
14153
14158 eProsima_user_DllExport CompleteCollectionElement(
14160 {
14161 m_common = x.m_common;
14162
14163 m_detail = x.m_detail;
14164
14165 }
14166
14171 eProsima_user_DllExport CompleteCollectionElement(
14172 CompleteCollectionElement&& x) noexcept
14173 {
14174 m_common = std::move(x.m_common);
14175 m_detail = std::move(x.m_detail);
14176 }
14177
14182 eProsima_user_DllExport CompleteCollectionElement& operator =(
14184 {
14185
14186 m_common = x.m_common;
14187
14188 m_detail = x.m_detail;
14189
14190 return *this;
14191 }
14192
14197 eProsima_user_DllExport CompleteCollectionElement& operator =(
14198 CompleteCollectionElement&& x) noexcept
14199 {
14200
14201 m_common = std::move(x.m_common);
14202 m_detail = std::move(x.m_detail);
14203 return *this;
14204 }
14205
14210 eProsima_user_DllExport bool operator ==(
14211 const CompleteCollectionElement& x) const
14212 {
14213 return (m_common == x.m_common &&
14214 m_detail == x.m_detail);
14215 }
14216
14221 eProsima_user_DllExport bool operator !=(
14222 const CompleteCollectionElement& x) const
14223 {
14224 return !(*this == x);
14225 }
14226
14231 eProsima_user_DllExport void common(
14232 const CommonCollectionElement& _common)
14233 {
14234 m_common = _common;
14235 }
14236
14241 eProsima_user_DllExport void common(
14242 CommonCollectionElement&& _common)
14243 {
14244 m_common = std::move(_common);
14245 }
14246
14251 eProsima_user_DllExport const CommonCollectionElement& common() const
14252 {
14253 return m_common;
14254 }
14255
14260 eProsima_user_DllExport CommonCollectionElement& common()
14261 {
14262 return m_common;
14263 }
14264
14265
14270 eProsima_user_DllExport void detail(
14271 const CompleteElementDetail& _detail)
14272 {
14273 m_detail = _detail;
14274 }
14275
14280 eProsima_user_DllExport void detail(
14281 CompleteElementDetail&& _detail)
14282 {
14283 m_detail = std::move(_detail);
14284 }
14285
14290 eProsima_user_DllExport const CompleteElementDetail& detail() const
14291 {
14292 return m_detail;
14293 }
14294
14299 eProsima_user_DllExport CompleteElementDetail& detail()
14300 {
14301 return m_detail;
14302 }
14303
14304
14305
14306private:
14307
14308 CommonCollectionElement m_common;
14309 CompleteElementDetail m_detail;
14310
14311};
14317{
14318public:
14319
14323 eProsima_user_DllExport MinimalCollectionElement()
14324 {
14325 }
14326
14330 eProsima_user_DllExport ~MinimalCollectionElement()
14331 {
14332 }
14333
14338 eProsima_user_DllExport MinimalCollectionElement(
14339 const MinimalCollectionElement& x)
14340 {
14341 m_common = x.m_common;
14342
14343 }
14344
14349 eProsima_user_DllExport MinimalCollectionElement(
14350 MinimalCollectionElement&& x) noexcept
14351 {
14352 m_common = std::move(x.m_common);
14353 }
14354
14359 eProsima_user_DllExport MinimalCollectionElement& operator =(
14360 const MinimalCollectionElement& x)
14361 {
14362
14363 m_common = x.m_common;
14364
14365 return *this;
14366 }
14367
14372 eProsima_user_DllExport MinimalCollectionElement& operator =(
14373 MinimalCollectionElement&& x) noexcept
14374 {
14375
14376 m_common = std::move(x.m_common);
14377 return *this;
14378 }
14379
14384 eProsima_user_DllExport bool operator ==(
14385 const MinimalCollectionElement& x) const
14386 {
14387 return (m_common == x.m_common);
14388 }
14389
14394 eProsima_user_DllExport bool operator !=(
14395 const MinimalCollectionElement& x) const
14396 {
14397 return !(*this == x);
14398 }
14399
14404 eProsima_user_DllExport void common(
14405 const CommonCollectionElement& _common)
14406 {
14407 m_common = _common;
14408 }
14409
14414 eProsima_user_DllExport void common(
14415 CommonCollectionElement&& _common)
14416 {
14417 m_common = std::move(_common);
14418 }
14419
14424 eProsima_user_DllExport const CommonCollectionElement& common() const
14425 {
14426 return m_common;
14427 }
14428
14433 eProsima_user_DllExport CommonCollectionElement& common()
14434 {
14435 return m_common;
14436 }
14437
14438
14439
14440private:
14441
14442 CommonCollectionElement m_common;
14443
14444};
14450{
14451public:
14452
14456 eProsima_user_DllExport CommonCollectionHeader()
14457 {
14458 }
14459
14463 eProsima_user_DllExport ~CommonCollectionHeader()
14464 {
14465 }
14466
14471 eProsima_user_DllExport CommonCollectionHeader(
14472 const CommonCollectionHeader& x)
14473 {
14474 m_bound = x.m_bound;
14475
14476 }
14477
14482 eProsima_user_DllExport CommonCollectionHeader(
14483 CommonCollectionHeader&& x) noexcept
14484 {
14485 m_bound = x.m_bound;
14486 }
14487
14492 eProsima_user_DllExport CommonCollectionHeader& operator =(
14493 const CommonCollectionHeader& x)
14494 {
14495
14496 m_bound = x.m_bound;
14497
14498 return *this;
14499 }
14500
14505 eProsima_user_DllExport CommonCollectionHeader& operator =(
14506 CommonCollectionHeader&& x) noexcept
14507 {
14508
14509 m_bound = x.m_bound;
14510 return *this;
14511 }
14512
14517 eProsima_user_DllExport bool operator ==(
14518 const CommonCollectionHeader& x) const
14519 {
14520 return (m_bound == x.m_bound);
14521 }
14522
14527 eProsima_user_DllExport bool operator !=(
14528 const CommonCollectionHeader& x) const
14529 {
14530 return !(*this == x);
14531 }
14532
14537 eProsima_user_DllExport void bound(
14538 LBound _bound)
14539 {
14540 m_bound = _bound;
14541 }
14542
14547 eProsima_user_DllExport LBound bound() const
14548 {
14549 return m_bound;
14550 }
14551
14556 eProsima_user_DllExport LBound& bound()
14557 {
14558 return m_bound;
14559 }
14560
14561
14562
14563private:
14564
14565 LBound m_bound{0};
14566
14567};
14573{
14574public:
14575
14579 eProsima_user_DllExport CompleteCollectionHeader()
14580 {
14581 }
14582
14586 eProsima_user_DllExport ~CompleteCollectionHeader()
14587 {
14588 }
14589
14594 eProsima_user_DllExport CompleteCollectionHeader(
14595 const CompleteCollectionHeader& x)
14596 {
14597 m_common = x.m_common;
14598
14599 m_detail = x.m_detail;
14600
14601 }
14602
14607 eProsima_user_DllExport CompleteCollectionHeader(
14608 CompleteCollectionHeader&& x) noexcept
14609 {
14610 m_common = std::move(x.m_common);
14611 m_detail = std::move(x.m_detail);
14612 }
14613
14618 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14619 const CompleteCollectionHeader& x)
14620 {
14621
14622 m_common = x.m_common;
14623
14624 m_detail = x.m_detail;
14625
14626 return *this;
14627 }
14628
14633 eProsima_user_DllExport CompleteCollectionHeader& operator =(
14634 CompleteCollectionHeader&& x) noexcept
14635 {
14636
14637 m_common = std::move(x.m_common);
14638 m_detail = std::move(x.m_detail);
14639 return *this;
14640 }
14641
14646 eProsima_user_DllExport bool operator ==(
14647 const CompleteCollectionHeader& x) const
14648 {
14649 return (m_common == x.m_common &&
14650 m_detail == x.m_detail);
14651 }
14652
14657 eProsima_user_DllExport bool operator !=(
14658 const CompleteCollectionHeader& x) const
14659 {
14660 return !(*this == x);
14661 }
14662
14667 eProsima_user_DllExport void common(
14668 const CommonCollectionHeader& _common)
14669 {
14670 m_common = _common;
14671 }
14672
14677 eProsima_user_DllExport void common(
14678 CommonCollectionHeader&& _common)
14679 {
14680 m_common = std::move(_common);
14681 }
14682
14687 eProsima_user_DllExport const CommonCollectionHeader& common() const
14688 {
14689 return m_common;
14690 }
14691
14696 eProsima_user_DllExport CommonCollectionHeader& common()
14697 {
14698 return m_common;
14699 }
14700
14701
14706 eProsima_user_DllExport void detail(
14707 const eprosima::fastcdr::optional<CompleteTypeDetail>& _detail)
14708 {
14709 m_detail = _detail;
14710 }
14711
14716 eProsima_user_DllExport void detail(
14717 eprosima::fastcdr::optional<CompleteTypeDetail>&& _detail)
14718 {
14719 m_detail = std::move(_detail);
14720 }
14721
14726 eProsima_user_DllExport const eprosima::fastcdr::optional<CompleteTypeDetail>& detail() const
14727 {
14728 return m_detail;
14729 }
14730
14735 eProsima_user_DllExport eprosima::fastcdr::optional<CompleteTypeDetail>& detail()
14736 {
14737 return m_detail;
14738 }
14739
14740
14741
14742private:
14743
14744 CommonCollectionHeader m_common;
14745 eprosima::fastcdr::optional<CompleteTypeDetail> m_detail;
14746
14747};
14753{
14754public:
14755
14759 eProsima_user_DllExport MinimalCollectionHeader()
14760 {
14761 }
14762
14766 eProsima_user_DllExport ~MinimalCollectionHeader()
14767 {
14768 }
14769
14774 eProsima_user_DllExport MinimalCollectionHeader(
14775 const MinimalCollectionHeader& x)
14776 {
14777 m_common = x.m_common;
14778
14779 }
14780
14785 eProsima_user_DllExport MinimalCollectionHeader(
14786 MinimalCollectionHeader&& x) noexcept
14787 {
14788 m_common = std::move(x.m_common);
14789 }
14790
14795 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14796 const MinimalCollectionHeader& x)
14797 {
14798
14799 m_common = x.m_common;
14800
14801 return *this;
14802 }
14803
14808 eProsima_user_DllExport MinimalCollectionHeader& operator =(
14809 MinimalCollectionHeader&& x) noexcept
14810 {
14811
14812 m_common = std::move(x.m_common);
14813 return *this;
14814 }
14815
14820 eProsima_user_DllExport bool operator ==(
14821 const MinimalCollectionHeader& x) const
14822 {
14823 return (m_common == x.m_common);
14824 }
14825
14830 eProsima_user_DllExport bool operator !=(
14831 const MinimalCollectionHeader& x) const
14832 {
14833 return !(*this == x);
14834 }
14835
14840 eProsima_user_DllExport void common(
14841 const CommonCollectionHeader& _common)
14842 {
14843 m_common = _common;
14844 }
14845
14850 eProsima_user_DllExport void common(
14851 CommonCollectionHeader&& _common)
14852 {
14853 m_common = std::move(_common);
14854 }
14855
14860 eProsima_user_DllExport const CommonCollectionHeader& common() const
14861 {
14862 return m_common;
14863 }
14864
14869 eProsima_user_DllExport CommonCollectionHeader& common()
14870 {
14871 return m_common;
14872 }
14873
14874
14875
14876private:
14877
14878 CommonCollectionHeader m_common;
14879
14880};
14886{
14887public:
14888
14892 eProsima_user_DllExport CompleteSequenceType()
14893 {
14894 }
14895
14899 eProsima_user_DllExport ~CompleteSequenceType()
14900 {
14901 }
14902
14907 eProsima_user_DllExport CompleteSequenceType(
14908 const CompleteSequenceType& x)
14909 {
14910 m_collection_flag = x.m_collection_flag;
14911
14912 m_header = x.m_header;
14913
14914 m_element = x.m_element;
14915
14916 }
14917
14922 eProsima_user_DllExport CompleteSequenceType(
14923 CompleteSequenceType&& x) noexcept
14924 {
14925 m_collection_flag = std::move(x.m_collection_flag);
14926 m_header = std::move(x.m_header);
14927 m_element = std::move(x.m_element);
14928 }
14929
14934 eProsima_user_DllExport CompleteSequenceType& operator =(
14935 const CompleteSequenceType& x)
14936 {
14937
14938 m_collection_flag = x.m_collection_flag;
14939
14940 m_header = x.m_header;
14941
14942 m_element = x.m_element;
14943
14944 return *this;
14945 }
14946
14951 eProsima_user_DllExport CompleteSequenceType& operator =(
14952 CompleteSequenceType&& x) noexcept
14953 {
14954
14955 m_collection_flag = std::move(x.m_collection_flag);
14956 m_header = std::move(x.m_header);
14957 m_element = std::move(x.m_element);
14958 return *this;
14959 }
14960
14965 eProsima_user_DllExport bool operator ==(
14966 const CompleteSequenceType& x) const
14967 {
14968 return (m_collection_flag == x.m_collection_flag &&
14969 m_header == x.m_header &&
14970 m_element == x.m_element);
14971 }
14972
14977 eProsima_user_DllExport bool operator !=(
14978 const CompleteSequenceType& x) const
14979 {
14980 return !(*this == x);
14981 }
14982
14987 eProsima_user_DllExport void collection_flag(
14988 const CollectionTypeFlag& _collection_flag)
14989 {
14990 m_collection_flag = _collection_flag;
14991 }
14992
14997 eProsima_user_DllExport void collection_flag(
14998 CollectionTypeFlag&& _collection_flag)
14999 {
15000 m_collection_flag = std::move(_collection_flag);
15001 }
15002
15007 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15008 {
15009 return m_collection_flag;
15010 }
15011
15016 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15017 {
15018 return m_collection_flag;
15019 }
15020
15021
15026 eProsima_user_DllExport void header(
15027 const CompleteCollectionHeader& _header)
15028 {
15029 m_header = _header;
15030 }
15031
15036 eProsima_user_DllExport void header(
15037 CompleteCollectionHeader&& _header)
15038 {
15039 m_header = std::move(_header);
15040 }
15041
15046 eProsima_user_DllExport const CompleteCollectionHeader& header() const
15047 {
15048 return m_header;
15049 }
15050
15055 eProsima_user_DllExport CompleteCollectionHeader& header()
15056 {
15057 return m_header;
15058 }
15059
15060
15065 eProsima_user_DllExport void element(
15066 const CompleteCollectionElement& _element)
15067 {
15068 m_element = _element;
15069 }
15070
15075 eProsima_user_DllExport void element(
15076 CompleteCollectionElement&& _element)
15077 {
15078 m_element = std::move(_element);
15079 }
15080
15085 eProsima_user_DllExport const CompleteCollectionElement& element() const
15086 {
15087 return m_element;
15088 }
15089
15094 eProsima_user_DllExport CompleteCollectionElement& element()
15095 {
15096 return m_element;
15097 }
15098
15099
15100
15101private:
15102
15103 CollectionTypeFlag m_collection_flag{0};
15104 CompleteCollectionHeader m_header;
15105 CompleteCollectionElement m_element;
15106
15107};
15113{
15114public:
15115
15119 eProsima_user_DllExport MinimalSequenceType()
15120 {
15121 }
15122
15126 eProsima_user_DllExport ~MinimalSequenceType()
15127 {
15128 }
15129
15134 eProsima_user_DllExport MinimalSequenceType(
15135 const MinimalSequenceType& x)
15136 {
15137 m_collection_flag = x.m_collection_flag;
15138
15139 m_header = x.m_header;
15140
15141 m_element = x.m_element;
15142
15143 }
15144
15149 eProsima_user_DllExport MinimalSequenceType(
15150 MinimalSequenceType&& x) noexcept
15151 {
15152 m_collection_flag = std::move(x.m_collection_flag);
15153 m_header = std::move(x.m_header);
15154 m_element = std::move(x.m_element);
15155 }
15156
15161 eProsima_user_DllExport MinimalSequenceType& operator =(
15162 const MinimalSequenceType& x)
15163 {
15164
15165 m_collection_flag = x.m_collection_flag;
15166
15167 m_header = x.m_header;
15168
15169 m_element = x.m_element;
15170
15171 return *this;
15172 }
15173
15178 eProsima_user_DllExport MinimalSequenceType& operator =(
15179 MinimalSequenceType&& x) noexcept
15180 {
15181
15182 m_collection_flag = std::move(x.m_collection_flag);
15183 m_header = std::move(x.m_header);
15184 m_element = std::move(x.m_element);
15185 return *this;
15186 }
15187
15192 eProsima_user_DllExport bool operator ==(
15193 const MinimalSequenceType& x) const
15194 {
15195 return (m_collection_flag == x.m_collection_flag &&
15196 m_header == x.m_header &&
15197 m_element == x.m_element);
15198 }
15199
15204 eProsima_user_DllExport bool operator !=(
15205 const MinimalSequenceType& x) const
15206 {
15207 return !(*this == x);
15208 }
15209
15214 eProsima_user_DllExport void collection_flag(
15215 const CollectionTypeFlag& _collection_flag)
15216 {
15217 m_collection_flag = _collection_flag;
15218 }
15219
15224 eProsima_user_DllExport void collection_flag(
15225 CollectionTypeFlag&& _collection_flag)
15226 {
15227 m_collection_flag = std::move(_collection_flag);
15228 }
15229
15234 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15235 {
15236 return m_collection_flag;
15237 }
15238
15243 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15244 {
15245 return m_collection_flag;
15246 }
15247
15248
15253 eProsima_user_DllExport void header(
15254 const MinimalCollectionHeader& _header)
15255 {
15256 m_header = _header;
15257 }
15258
15263 eProsima_user_DllExport void header(
15264 MinimalCollectionHeader&& _header)
15265 {
15266 m_header = std::move(_header);
15267 }
15268
15273 eProsima_user_DllExport const MinimalCollectionHeader& header() const
15274 {
15275 return m_header;
15276 }
15277
15282 eProsima_user_DllExport MinimalCollectionHeader& header()
15283 {
15284 return m_header;
15285 }
15286
15287
15292 eProsima_user_DllExport void element(
15293 const MinimalCollectionElement& _element)
15294 {
15295 m_element = _element;
15296 }
15297
15302 eProsima_user_DllExport void element(
15303 MinimalCollectionElement&& _element)
15304 {
15305 m_element = std::move(_element);
15306 }
15307
15312 eProsima_user_DllExport const MinimalCollectionElement& element() const
15313 {
15314 return m_element;
15315 }
15316
15321 eProsima_user_DllExport MinimalCollectionElement& element()
15322 {
15323 return m_element;
15324 }
15325
15326
15327
15328private:
15329
15330 CollectionTypeFlag m_collection_flag{0};
15331 MinimalCollectionHeader m_header;
15332 MinimalCollectionElement m_element;
15333
15334};
15340{
15341public:
15342
15346 eProsima_user_DllExport CommonArrayHeader()
15347 {
15348 }
15349
15353 eProsima_user_DllExport ~CommonArrayHeader()
15354 {
15355 }
15356
15361 eProsima_user_DllExport CommonArrayHeader(
15362 const CommonArrayHeader& x)
15363 {
15364 m_bound_seq = x.m_bound_seq;
15365
15366 }
15367
15372 eProsima_user_DllExport CommonArrayHeader(
15373 CommonArrayHeader&& x) noexcept
15374 {
15375 m_bound_seq = std::move(x.m_bound_seq);
15376 }
15377
15382 eProsima_user_DllExport CommonArrayHeader& operator =(
15383 const CommonArrayHeader& x)
15384 {
15385
15386 m_bound_seq = x.m_bound_seq;
15387
15388 return *this;
15389 }
15390
15395 eProsima_user_DllExport CommonArrayHeader& operator =(
15396 CommonArrayHeader&& x) noexcept
15397 {
15398
15399 m_bound_seq = std::move(x.m_bound_seq);
15400 return *this;
15401 }
15402
15407 eProsima_user_DllExport bool operator ==(
15408 const CommonArrayHeader& x) const
15409 {
15410 return (m_bound_seq == x.m_bound_seq);
15411 }
15412
15417 eProsima_user_DllExport bool operator !=(
15418 const CommonArrayHeader& x) const
15419 {
15420 return !(*this == x);
15421 }
15422
15427 eProsima_user_DllExport void bound_seq(
15428 const LBoundSeq& _bound_seq)
15429 {
15430 m_bound_seq = _bound_seq;
15431 }
15432
15437 eProsima_user_DllExport void bound_seq(
15438 LBoundSeq&& _bound_seq)
15439 {
15440 m_bound_seq = std::move(_bound_seq);
15441 }
15442
15447 eProsima_user_DllExport const LBoundSeq& bound_seq() const
15448 {
15449 return m_bound_seq;
15450 }
15451
15456 eProsima_user_DllExport LBoundSeq& bound_seq()
15457 {
15458 return m_bound_seq;
15459 }
15460
15461
15462
15463private:
15464
15465 LBoundSeq m_bound_seq;
15466
15467};
15473{
15474public:
15475
15479 eProsima_user_DllExport CompleteArrayHeader()
15480 {
15481 }
15482
15486 eProsima_user_DllExport ~CompleteArrayHeader()
15487 {
15488 }
15489
15494 eProsima_user_DllExport CompleteArrayHeader(
15495 const CompleteArrayHeader& x)
15496 {
15497 m_common = x.m_common;
15498
15499 m_detail = x.m_detail;
15500
15501 }
15502
15507 eProsima_user_DllExport CompleteArrayHeader(
15508 CompleteArrayHeader&& x) noexcept
15509 {
15510 m_common = std::move(x.m_common);
15511 m_detail = std::move(x.m_detail);
15512 }
15513
15518 eProsima_user_DllExport CompleteArrayHeader& operator =(
15519 const CompleteArrayHeader& x)
15520 {
15521
15522 m_common = x.m_common;
15523
15524 m_detail = x.m_detail;
15525
15526 return *this;
15527 }
15528
15533 eProsima_user_DllExport CompleteArrayHeader& operator =(
15534 CompleteArrayHeader&& x) noexcept
15535 {
15536
15537 m_common = std::move(x.m_common);
15538 m_detail = std::move(x.m_detail);
15539 return *this;
15540 }
15541
15546 eProsima_user_DllExport bool operator ==(
15547 const CompleteArrayHeader& x) const
15548 {
15549 return (m_common == x.m_common &&
15550 m_detail == x.m_detail);
15551 }
15552
15557 eProsima_user_DllExport bool operator !=(
15558 const CompleteArrayHeader& x) const
15559 {
15560 return !(*this == x);
15561 }
15562
15567 eProsima_user_DllExport void common(
15568 const CommonArrayHeader& _common)
15569 {
15570 m_common = _common;
15571 }
15572
15577 eProsima_user_DllExport void common(
15578 CommonArrayHeader&& _common)
15579 {
15580 m_common = std::move(_common);
15581 }
15582
15587 eProsima_user_DllExport const CommonArrayHeader& common() const
15588 {
15589 return m_common;
15590 }
15591
15596 eProsima_user_DllExport CommonArrayHeader& common()
15597 {
15598 return m_common;
15599 }
15600
15601
15606 eProsima_user_DllExport void detail(
15607 const CompleteTypeDetail& _detail)
15608 {
15609 m_detail = _detail;
15610 }
15611
15616 eProsima_user_DllExport void detail(
15617 CompleteTypeDetail&& _detail)
15618 {
15619 m_detail = std::move(_detail);
15620 }
15621
15626 eProsima_user_DllExport const CompleteTypeDetail& detail() const
15627 {
15628 return m_detail;
15629 }
15630
15635 eProsima_user_DllExport CompleteTypeDetail& detail()
15636 {
15637 return m_detail;
15638 }
15639
15640
15641
15642private:
15643
15644 CommonArrayHeader m_common;
15645 CompleteTypeDetail m_detail;
15646
15647};
15653{
15654public:
15655
15659 eProsima_user_DllExport MinimalArrayHeader()
15660 {
15661 }
15662
15666 eProsima_user_DllExport ~MinimalArrayHeader()
15667 {
15668 }
15669
15674 eProsima_user_DllExport MinimalArrayHeader(
15675 const MinimalArrayHeader& x)
15676 {
15677 m_common = x.m_common;
15678
15679 }
15680
15685 eProsima_user_DllExport MinimalArrayHeader(
15686 MinimalArrayHeader&& x) noexcept
15687 {
15688 m_common = std::move(x.m_common);
15689 }
15690
15695 eProsima_user_DllExport MinimalArrayHeader& operator =(
15696 const MinimalArrayHeader& x)
15697 {
15698
15699 m_common = x.m_common;
15700
15701 return *this;
15702 }
15703
15708 eProsima_user_DllExport MinimalArrayHeader& operator =(
15709 MinimalArrayHeader&& x) noexcept
15710 {
15711
15712 m_common = std::move(x.m_common);
15713 return *this;
15714 }
15715
15720 eProsima_user_DllExport bool operator ==(
15721 const MinimalArrayHeader& x) const
15722 {
15723 return (m_common == x.m_common);
15724 }
15725
15730 eProsima_user_DllExport bool operator !=(
15731 const MinimalArrayHeader& x) const
15732 {
15733 return !(*this == x);
15734 }
15735
15740 eProsima_user_DllExport void common(
15741 const CommonArrayHeader& _common)
15742 {
15743 m_common = _common;
15744 }
15745
15750 eProsima_user_DllExport void common(
15751 CommonArrayHeader&& _common)
15752 {
15753 m_common = std::move(_common);
15754 }
15755
15760 eProsima_user_DllExport const CommonArrayHeader& common() const
15761 {
15762 return m_common;
15763 }
15764
15769 eProsima_user_DllExport CommonArrayHeader& common()
15770 {
15771 return m_common;
15772 }
15773
15774
15775
15776private:
15777
15778 CommonArrayHeader m_common;
15779
15780};
15786{
15787public:
15788
15792 eProsima_user_DllExport CompleteArrayType()
15793 {
15794 }
15795
15799 eProsima_user_DllExport ~CompleteArrayType()
15800 {
15801 }
15802
15807 eProsima_user_DllExport CompleteArrayType(
15808 const CompleteArrayType& x)
15809 {
15810 m_collection_flag = x.m_collection_flag;
15811
15812 m_header = x.m_header;
15813
15814 m_element = x.m_element;
15815
15816 }
15817
15822 eProsima_user_DllExport CompleteArrayType(
15823 CompleteArrayType&& x) noexcept
15824 {
15825 m_collection_flag = std::move(x.m_collection_flag);
15826 m_header = std::move(x.m_header);
15827 m_element = std::move(x.m_element);
15828 }
15829
15834 eProsima_user_DllExport CompleteArrayType& operator =(
15835 const CompleteArrayType& x)
15836 {
15837
15838 m_collection_flag = x.m_collection_flag;
15839
15840 m_header = x.m_header;
15841
15842 m_element = x.m_element;
15843
15844 return *this;
15845 }
15846
15851 eProsima_user_DllExport CompleteArrayType& operator =(
15852 CompleteArrayType&& x) noexcept
15853 {
15854
15855 m_collection_flag = std::move(x.m_collection_flag);
15856 m_header = std::move(x.m_header);
15857 m_element = std::move(x.m_element);
15858 return *this;
15859 }
15860
15865 eProsima_user_DllExport bool operator ==(
15866 const CompleteArrayType& x) const
15867 {
15868 return (m_collection_flag == x.m_collection_flag &&
15869 m_header == x.m_header &&
15870 m_element == x.m_element);
15871 }
15872
15877 eProsima_user_DllExport bool operator !=(
15878 const CompleteArrayType& x) const
15879 {
15880 return !(*this == x);
15881 }
15882
15887 eProsima_user_DllExport void collection_flag(
15888 const CollectionTypeFlag& _collection_flag)
15889 {
15890 m_collection_flag = _collection_flag;
15891 }
15892
15897 eProsima_user_DllExport void collection_flag(
15898 CollectionTypeFlag&& _collection_flag)
15899 {
15900 m_collection_flag = std::move(_collection_flag);
15901 }
15902
15907 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
15908 {
15909 return m_collection_flag;
15910 }
15911
15916 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
15917 {
15918 return m_collection_flag;
15919 }
15920
15921
15926 eProsima_user_DllExport void header(
15927 const CompleteArrayHeader& _header)
15928 {
15929 m_header = _header;
15930 }
15931
15936 eProsima_user_DllExport void header(
15937 CompleteArrayHeader&& _header)
15938 {
15939 m_header = std::move(_header);
15940 }
15941
15946 eProsima_user_DllExport const CompleteArrayHeader& header() const
15947 {
15948 return m_header;
15949 }
15950
15955 eProsima_user_DllExport CompleteArrayHeader& header()
15956 {
15957 return m_header;
15958 }
15959
15960
15965 eProsima_user_DllExport void element(
15966 const CompleteCollectionElement& _element)
15967 {
15968 m_element = _element;
15969 }
15970
15975 eProsima_user_DllExport void element(
15976 CompleteCollectionElement&& _element)
15977 {
15978 m_element = std::move(_element);
15979 }
15980
15985 eProsima_user_DllExport const CompleteCollectionElement& element() const
15986 {
15987 return m_element;
15988 }
15989
15994 eProsima_user_DllExport CompleteCollectionElement& element()
15995 {
15996 return m_element;
15997 }
15998
15999
16000
16001private:
16002
16003 CollectionTypeFlag m_collection_flag{0};
16004 CompleteArrayHeader m_header;
16005 CompleteCollectionElement m_element;
16006
16007};
16013{
16014public:
16015
16019 eProsima_user_DllExport MinimalArrayType()
16020 {
16021 }
16022
16026 eProsima_user_DllExport ~MinimalArrayType()
16027 {
16028 }
16029
16034 eProsima_user_DllExport MinimalArrayType(
16035 const MinimalArrayType& x)
16036 {
16037 m_collection_flag = x.m_collection_flag;
16038
16039 m_header = x.m_header;
16040
16041 m_element = x.m_element;
16042
16043 }
16044
16049 eProsima_user_DllExport MinimalArrayType(
16050 MinimalArrayType&& x) noexcept
16051 {
16052 m_collection_flag = std::move(x.m_collection_flag);
16053 m_header = std::move(x.m_header);
16054 m_element = std::move(x.m_element);
16055 }
16056
16061 eProsima_user_DllExport MinimalArrayType& operator =(
16062 const MinimalArrayType& x)
16063 {
16064
16065 m_collection_flag = x.m_collection_flag;
16066
16067 m_header = x.m_header;
16068
16069 m_element = x.m_element;
16070
16071 return *this;
16072 }
16073
16078 eProsima_user_DllExport MinimalArrayType& operator =(
16079 MinimalArrayType&& x) noexcept
16080 {
16081
16082 m_collection_flag = std::move(x.m_collection_flag);
16083 m_header = std::move(x.m_header);
16084 m_element = std::move(x.m_element);
16085 return *this;
16086 }
16087
16092 eProsima_user_DllExport bool operator ==(
16093 const MinimalArrayType& x) const
16094 {
16095 return (m_collection_flag == x.m_collection_flag &&
16096 m_header == x.m_header &&
16097 m_element == x.m_element);
16098 }
16099
16104 eProsima_user_DllExport bool operator !=(
16105 const MinimalArrayType& x) const
16106 {
16107 return !(*this == x);
16108 }
16109
16114 eProsima_user_DllExport void collection_flag(
16115 const CollectionTypeFlag& _collection_flag)
16116 {
16117 m_collection_flag = _collection_flag;
16118 }
16119
16124 eProsima_user_DllExport void collection_flag(
16125 CollectionTypeFlag&& _collection_flag)
16126 {
16127 m_collection_flag = std::move(_collection_flag);
16128 }
16129
16134 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16135 {
16136 return m_collection_flag;
16137 }
16138
16143 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16144 {
16145 return m_collection_flag;
16146 }
16147
16148
16153 eProsima_user_DllExport void header(
16154 const MinimalArrayHeader& _header)
16155 {
16156 m_header = _header;
16157 }
16158
16163 eProsima_user_DllExport void header(
16164 MinimalArrayHeader&& _header)
16165 {
16166 m_header = std::move(_header);
16167 }
16168
16173 eProsima_user_DllExport const MinimalArrayHeader& header() const
16174 {
16175 return m_header;
16176 }
16177
16182 eProsima_user_DllExport MinimalArrayHeader& header()
16183 {
16184 return m_header;
16185 }
16186
16187
16192 eProsima_user_DllExport void element(
16193 const MinimalCollectionElement& _element)
16194 {
16195 m_element = _element;
16196 }
16197
16202 eProsima_user_DllExport void element(
16203 MinimalCollectionElement&& _element)
16204 {
16205 m_element = std::move(_element);
16206 }
16207
16212 eProsima_user_DllExport const MinimalCollectionElement& element() const
16213 {
16214 return m_element;
16215 }
16216
16221 eProsima_user_DllExport MinimalCollectionElement& element()
16222 {
16223 return m_element;
16224 }
16225
16226
16227
16228private:
16229
16230 CollectionTypeFlag m_collection_flag{0};
16231 MinimalArrayHeader m_header;
16232 MinimalCollectionElement m_element;
16233
16234};
16240{
16241public:
16242
16246 eProsima_user_DllExport CompleteMapType()
16247 {
16248 }
16249
16253 eProsima_user_DllExport ~CompleteMapType()
16254 {
16255 }
16256
16261 eProsima_user_DllExport CompleteMapType(
16262 const CompleteMapType& x)
16263 {
16264 m_collection_flag = x.m_collection_flag;
16265
16266 m_header = x.m_header;
16267
16268 m_key = x.m_key;
16269
16270 m_element = x.m_element;
16271
16272 }
16273
16278 eProsima_user_DllExport CompleteMapType(
16279 CompleteMapType&& x) noexcept
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 }
16286
16291 eProsima_user_DllExport CompleteMapType& operator =(
16292 const CompleteMapType& x)
16293 {
16294
16295 m_collection_flag = x.m_collection_flag;
16296
16297 m_header = x.m_header;
16298
16299 m_key = x.m_key;
16300
16301 m_element = x.m_element;
16302
16303 return *this;
16304 }
16305
16310 eProsima_user_DllExport CompleteMapType& operator =(
16311 CompleteMapType&& x) noexcept
16312 {
16313
16314 m_collection_flag = std::move(x.m_collection_flag);
16315 m_header = std::move(x.m_header);
16316 m_key = std::move(x.m_key);
16317 m_element = std::move(x.m_element);
16318 return *this;
16319 }
16320
16325 eProsima_user_DllExport bool operator ==(
16326 const CompleteMapType& x) const
16327 {
16328 return (m_collection_flag == x.m_collection_flag &&
16329 m_header == x.m_header &&
16330 m_key == x.m_key &&
16331 m_element == x.m_element);
16332 }
16333
16338 eProsima_user_DllExport bool operator !=(
16339 const CompleteMapType& x) const
16340 {
16341 return !(*this == x);
16342 }
16343
16348 eProsima_user_DllExport void collection_flag(
16349 const CollectionTypeFlag& _collection_flag)
16350 {
16351 m_collection_flag = _collection_flag;
16352 }
16353
16358 eProsima_user_DllExport void collection_flag(
16359 CollectionTypeFlag&& _collection_flag)
16360 {
16361 m_collection_flag = std::move(_collection_flag);
16362 }
16363
16368 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16369 {
16370 return m_collection_flag;
16371 }
16372
16377 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16378 {
16379 return m_collection_flag;
16380 }
16381
16382
16387 eProsima_user_DllExport void header(
16388 const CompleteCollectionHeader& _header)
16389 {
16390 m_header = _header;
16391 }
16392
16397 eProsima_user_DllExport void header(
16398 CompleteCollectionHeader&& _header)
16399 {
16400 m_header = std::move(_header);
16401 }
16402
16407 eProsima_user_DllExport const CompleteCollectionHeader& header() const
16408 {
16409 return m_header;
16410 }
16411
16416 eProsima_user_DllExport CompleteCollectionHeader& header()
16417 {
16418 return m_header;
16419 }
16420
16421
16426 eProsima_user_DllExport void key(
16427 const CompleteCollectionElement& _key)
16428 {
16429 m_key = _key;
16430 }
16431
16436 eProsima_user_DllExport void key(
16438 {
16439 m_key = std::move(_key);
16440 }
16441
16446 eProsima_user_DllExport const CompleteCollectionElement& key() const
16447 {
16448 return m_key;
16449 }
16450
16455 eProsima_user_DllExport CompleteCollectionElement& key()
16456 {
16457 return m_key;
16458 }
16459
16460
16465 eProsima_user_DllExport void element(
16466 const CompleteCollectionElement& _element)
16467 {
16468 m_element = _element;
16469 }
16470
16475 eProsima_user_DllExport void element(
16476 CompleteCollectionElement&& _element)
16477 {
16478 m_element = std::move(_element);
16479 }
16480
16485 eProsima_user_DllExport const CompleteCollectionElement& element() const
16486 {
16487 return m_element;
16488 }
16489
16494 eProsima_user_DllExport CompleteCollectionElement& element()
16495 {
16496 return m_element;
16497 }
16498
16499
16500
16501private:
16502
16503 CollectionTypeFlag m_collection_flag{0};
16504 CompleteCollectionHeader m_header;
16505 CompleteCollectionElement m_key;
16506 CompleteCollectionElement m_element;
16507
16508};
16514{
16515public:
16516
16520 eProsima_user_DllExport MinimalMapType()
16521 {
16522 }
16523
16527 eProsima_user_DllExport ~MinimalMapType()
16528 {
16529 }
16530
16535 eProsima_user_DllExport MinimalMapType(
16536 const MinimalMapType& x)
16537 {
16538 m_collection_flag = x.m_collection_flag;
16539
16540 m_header = x.m_header;
16541
16542 m_key = x.m_key;
16543
16544 m_element = x.m_element;
16545
16546 }
16547
16552 eProsima_user_DllExport MinimalMapType(
16553 MinimalMapType&& x) noexcept
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 }
16560
16565 eProsima_user_DllExport MinimalMapType& operator =(
16566 const MinimalMapType& x)
16567 {
16568
16569 m_collection_flag = x.m_collection_flag;
16570
16571 m_header = x.m_header;
16572
16573 m_key = x.m_key;
16574
16575 m_element = x.m_element;
16576
16577 return *this;
16578 }
16579
16584 eProsima_user_DllExport MinimalMapType& operator =(
16585 MinimalMapType&& x) noexcept
16586 {
16587
16588 m_collection_flag = std::move(x.m_collection_flag);
16589 m_header = std::move(x.m_header);
16590 m_key = std::move(x.m_key);
16591 m_element = std::move(x.m_element);
16592 return *this;
16593 }
16594
16599 eProsima_user_DllExport bool operator ==(
16600 const MinimalMapType& x) const
16601 {
16602 return (m_collection_flag == x.m_collection_flag &&
16603 m_header == x.m_header &&
16604 m_key == x.m_key &&
16605 m_element == x.m_element);
16606 }
16607
16612 eProsima_user_DllExport bool operator !=(
16613 const MinimalMapType& x) const
16614 {
16615 return !(*this == x);
16616 }
16617
16622 eProsima_user_DllExport void collection_flag(
16623 const CollectionTypeFlag& _collection_flag)
16624 {
16625 m_collection_flag = _collection_flag;
16626 }
16627
16632 eProsima_user_DllExport void collection_flag(
16633 CollectionTypeFlag&& _collection_flag)
16634 {
16635 m_collection_flag = std::move(_collection_flag);
16636 }
16637
16642 eProsima_user_DllExport const CollectionTypeFlag& collection_flag() const
16643 {
16644 return m_collection_flag;
16645 }
16646
16651 eProsima_user_DllExport CollectionTypeFlag& collection_flag()
16652 {
16653 return m_collection_flag;
16654 }
16655
16656
16661 eProsima_user_DllExport void header(
16662 const MinimalCollectionHeader& _header)
16663 {
16664 m_header = _header;
16665 }
16666
16671 eProsima_user_DllExport void header(
16672 MinimalCollectionHeader&& _header)
16673 {
16674 m_header = std::move(_header);
16675 }
16676
16681 eProsima_user_DllExport const MinimalCollectionHeader& header() const
16682 {
16683 return m_header;
16684 }
16685
16690 eProsima_user_DllExport MinimalCollectionHeader& header()
16691 {
16692 return m_header;
16693 }
16694
16695
16700 eProsima_user_DllExport void key(
16701 const MinimalCollectionElement& _key)
16702 {
16703 m_key = _key;
16704 }
16705
16710 eProsima_user_DllExport void key(
16712 {
16713 m_key = std::move(_key);
16714 }
16715
16720 eProsima_user_DllExport const MinimalCollectionElement& key() const
16721 {
16722 return m_key;
16723 }
16724
16729 eProsima_user_DllExport MinimalCollectionElement& key()
16730 {
16731 return m_key;
16732 }
16733
16734
16739 eProsima_user_DllExport void element(
16740 const MinimalCollectionElement& _element)
16741 {
16742 m_element = _element;
16743 }
16744
16749 eProsima_user_DllExport void element(
16750 MinimalCollectionElement&& _element)
16751 {
16752 m_element = std::move(_element);
16753 }
16754
16759 eProsima_user_DllExport const MinimalCollectionElement& element() const
16760 {
16761 return m_element;
16762 }
16763
16768 eProsima_user_DllExport MinimalCollectionElement& element()
16769 {
16770 return m_element;
16771 }
16772
16773
16774
16775private:
16776
16777 CollectionTypeFlag m_collection_flag{0};
16778 MinimalCollectionHeader m_header;
16779 MinimalCollectionElement m_key;
16780 MinimalCollectionElement m_element;
16781
16782};
16783typedef uint16_t BitBound;
16784
16790{
16791public:
16792
16796 eProsima_user_DllExport CommonEnumeratedLiteral()
16797 {
16798 }
16799
16803 eProsima_user_DllExport ~CommonEnumeratedLiteral()
16804 {
16805 }
16806
16811 eProsima_user_DllExport CommonEnumeratedLiteral(
16812 const CommonEnumeratedLiteral& x)
16813 {
16814 m_value = x.m_value;
16815
16816 m_flags = x.m_flags;
16817
16818 }
16819
16824 eProsima_user_DllExport CommonEnumeratedLiteral(
16825 CommonEnumeratedLiteral&& x) noexcept
16826 {
16827 m_value = x.m_value;
16828 m_flags = std::move(x.m_flags);
16829 }
16830
16835 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16836 const CommonEnumeratedLiteral& x)
16837 {
16838
16839 m_value = x.m_value;
16840
16841 m_flags = x.m_flags;
16842
16843 return *this;
16844 }
16845
16850 eProsima_user_DllExport CommonEnumeratedLiteral& operator =(
16851 CommonEnumeratedLiteral&& x) noexcept
16852 {
16853
16854 m_value = x.m_value;
16855 m_flags = std::move(x.m_flags);
16856 return *this;
16857 }
16858
16863 eProsima_user_DllExport bool operator ==(
16864 const CommonEnumeratedLiteral& x) const
16865 {
16866 return (m_value == x.m_value &&
16867 m_flags == x.m_flags);
16868 }
16869
16874 eProsima_user_DllExport bool operator !=(
16875 const CommonEnumeratedLiteral& x) const
16876 {
16877 return !(*this == x);
16878 }
16879
16884 eProsima_user_DllExport void value(
16885 int32_t _value)
16886 {
16887 m_value = _value;
16888 }
16889
16894 eProsima_user_DllExport int32_t value() const
16895 {
16896 return m_value;
16897 }
16898
16903 eProsima_user_DllExport int32_t& value()
16904 {
16905 return m_value;
16906 }
16907
16908
16913 eProsima_user_DllExport void flags(
16914 const EnumeratedLiteralFlag& _flags)
16915 {
16916 m_flags = _flags;
16917 }
16918
16923 eProsima_user_DllExport void flags(
16924 EnumeratedLiteralFlag&& _flags)
16925 {
16926 m_flags = std::move(_flags);
16927 }
16928
16933 eProsima_user_DllExport const EnumeratedLiteralFlag& flags() const
16934 {
16935 return m_flags;
16936 }
16937
16942 eProsima_user_DllExport EnumeratedLiteralFlag& flags()
16943 {
16944 return m_flags;
16945 }
16946
16947
16948
16949private:
16950
16951 int32_t m_value{0};
16952 EnumeratedLiteralFlag m_flags{0};
16953
16954};
16960{
16961public:
16962
16966 eProsima_user_DllExport CompleteEnumeratedLiteral()
16967 {
16968 }
16969
16973 eProsima_user_DllExport ~CompleteEnumeratedLiteral()
16974 {
16975 }
16976
16981 eProsima_user_DllExport CompleteEnumeratedLiteral(
16983 {
16984 m_common = x.m_common;
16985
16986 m_detail = x.m_detail;
16987
16988 }
16989
16994 eProsima_user_DllExport CompleteEnumeratedLiteral(
16995 CompleteEnumeratedLiteral&& x) noexcept
16996 {
16997 m_common = std::move(x.m_common);
16998 m_detail = std::move(x.m_detail);
16999 }
17000
17005 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
17007 {
17008
17009 m_common = x.m_common;
17010
17011 m_detail = x.m_detail;
17012
17013 return *this;
17014 }
17015
17020 eProsima_user_DllExport CompleteEnumeratedLiteral& operator =(
17021 CompleteEnumeratedLiteral&& x) noexcept
17022 {
17023
17024 m_common = std::move(x.m_common);
17025 m_detail = std::move(x.m_detail);
17026 return *this;
17027 }
17028
17033 eProsima_user_DllExport bool operator ==(
17034 const CompleteEnumeratedLiteral& x) const
17035 {
17036 return (m_common == x.m_common &&
17037 m_detail == x.m_detail);
17038 }
17039
17044 eProsima_user_DllExport bool operator !=(
17045 const CompleteEnumeratedLiteral& x) const
17046 {
17047 return !(*this == x);
17048 }
17049
17054 eProsima_user_DllExport void common(
17055 const CommonEnumeratedLiteral& _common)
17056 {
17057 m_common = _common;
17058 }
17059
17064 eProsima_user_DllExport void common(
17065 CommonEnumeratedLiteral&& _common)
17066 {
17067 m_common = std::move(_common);
17068 }
17069
17074 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17075 {
17076 return m_common;
17077 }
17078
17083 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17084 {
17085 return m_common;
17086 }
17087
17088
17093 eProsima_user_DllExport void detail(
17094 const CompleteMemberDetail& _detail)
17095 {
17096 m_detail = _detail;
17097 }
17098
17103 eProsima_user_DllExport void detail(
17104 CompleteMemberDetail&& _detail)
17105 {
17106 m_detail = std::move(_detail);
17107 }
17108
17113 eProsima_user_DllExport const CompleteMemberDetail& detail() const
17114 {
17115 return m_detail;
17116 }
17117
17122 eProsima_user_DllExport CompleteMemberDetail& detail()
17123 {
17124 return m_detail;
17125 }
17126
17127
17128
17129private:
17130
17131 CommonEnumeratedLiteral m_common;
17132 CompleteMemberDetail m_detail;
17133
17134};
17135typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
17136
17142{
17143public:
17144
17148 eProsima_user_DllExport MinimalEnumeratedLiteral()
17149 {
17150 }
17151
17155 eProsima_user_DllExport ~MinimalEnumeratedLiteral()
17156 {
17157 }
17158
17163 eProsima_user_DllExport MinimalEnumeratedLiteral(
17164 const MinimalEnumeratedLiteral& x)
17165 {
17166 m_common = x.m_common;
17167
17168 m_detail = x.m_detail;
17169
17170 }
17171
17176 eProsima_user_DllExport MinimalEnumeratedLiteral(
17177 MinimalEnumeratedLiteral&& x) noexcept
17178 {
17179 m_common = std::move(x.m_common);
17180 m_detail = std::move(x.m_detail);
17181 }
17182
17187 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17188 const MinimalEnumeratedLiteral& x)
17189 {
17190
17191 m_common = x.m_common;
17192
17193 m_detail = x.m_detail;
17194
17195 return *this;
17196 }
17197
17202 eProsima_user_DllExport MinimalEnumeratedLiteral& operator =(
17203 MinimalEnumeratedLiteral&& x) noexcept
17204 {
17205
17206 m_common = std::move(x.m_common);
17207 m_detail = std::move(x.m_detail);
17208 return *this;
17209 }
17210
17215 eProsima_user_DllExport bool operator ==(
17216 const MinimalEnumeratedLiteral& x) const
17217 {
17218 return (m_common == x.m_common &&
17219 m_detail == x.m_detail);
17220 }
17221
17226 eProsima_user_DllExport bool operator !=(
17227 const MinimalEnumeratedLiteral& x) const
17228 {
17229 return !(*this == x);
17230 }
17231
17236 eProsima_user_DllExport void common(
17237 const CommonEnumeratedLiteral& _common)
17238 {
17239 m_common = _common;
17240 }
17241
17246 eProsima_user_DllExport void common(
17247 CommonEnumeratedLiteral&& _common)
17248 {
17249 m_common = std::move(_common);
17250 }
17251
17256 eProsima_user_DllExport const CommonEnumeratedLiteral& common() const
17257 {
17258 return m_common;
17259 }
17260
17265 eProsima_user_DllExport CommonEnumeratedLiteral& common()
17266 {
17267 return m_common;
17268 }
17269
17270
17275 eProsima_user_DllExport void detail(
17276 const MinimalMemberDetail& _detail)
17277 {
17278 m_detail = _detail;
17279 }
17280
17285 eProsima_user_DllExport void detail(
17286 MinimalMemberDetail&& _detail)
17287 {
17288 m_detail = std::move(_detail);
17289 }
17290
17295 eProsima_user_DllExport const MinimalMemberDetail& detail() const
17296 {
17297 return m_detail;
17298 }
17299
17304 eProsima_user_DllExport MinimalMemberDetail& detail()
17305 {
17306 return m_detail;
17307 }
17308
17309
17310
17311private:
17312
17313 CommonEnumeratedLiteral m_common;
17314 MinimalMemberDetail m_detail;
17315
17316};
17317typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
17318
17324{
17325public:
17326
17330 eProsima_user_DllExport CommonEnumeratedHeader()
17331 {
17332 }
17333
17337 eProsima_user_DllExport ~CommonEnumeratedHeader()
17338 {
17339 }
17340
17345 eProsima_user_DllExport CommonEnumeratedHeader(
17346 const CommonEnumeratedHeader& x)
17347 {
17348 m_bit_bound = x.m_bit_bound;
17349
17350 }
17351
17356 eProsima_user_DllExport CommonEnumeratedHeader(
17357 CommonEnumeratedHeader&& x) noexcept
17358 {
17359 m_bit_bound = x.m_bit_bound;
17360 }
17361
17366 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17367 const CommonEnumeratedHeader& x)
17368 {
17369
17370 m_bit_bound = x.m_bit_bound;
17371
17372 return *this;
17373 }
17374
17379 eProsima_user_DllExport CommonEnumeratedHeader& operator =(
17380 CommonEnumeratedHeader&& x) noexcept
17381 {
17382
17383 m_bit_bound = x.m_bit_bound;
17384 return *this;
17385 }
17386
17391 eProsima_user_DllExport bool operator ==(
17392 const CommonEnumeratedHeader& x) const
17393 {
17394 return (m_bit_bound == x.m_bit_bound);
17395 }
17396
17401 eProsima_user_DllExport bool operator !=(
17402 const CommonEnumeratedHeader& x) const
17403 {
17404 return !(*this == x);
17405 }
17406
17411 eProsima_user_DllExport void bit_bound(
17412 BitBound _bit_bound)
17413 {
17414 m_bit_bound = _bit_bound;
17415 }
17416
17421 eProsima_user_DllExport BitBound bit_bound() const
17422 {
17423 return m_bit_bound;
17424 }
17425
17430 eProsima_user_DllExport BitBound& bit_bound()
17431 {
17432 return m_bit_bound;
17433 }
17434
17435
17436
17437private:
17438
17439 BitBound m_bit_bound{0};
17440
17441};
17447{
17448public:
17449
17453 eProsima_user_DllExport CompleteEnumeratedHeader()
17454 {
17455 }
17456
17460 eProsima_user_DllExport ~CompleteEnumeratedHeader()
17461 {
17462 }
17463
17468 eProsima_user_DllExport CompleteEnumeratedHeader(
17469 const CompleteEnumeratedHeader& x)
17470 {
17471 m_common = x.m_common;
17472
17473 m_detail = x.m_detail;
17474
17475 }
17476
17481 eProsima_user_DllExport CompleteEnumeratedHeader(
17482 CompleteEnumeratedHeader&& x) noexcept
17483 {
17484 m_common = std::move(x.m_common);
17485 m_detail = std::move(x.m_detail);
17486 }
17487
17492 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17493 const CompleteEnumeratedHeader& x)
17494 {
17495
17496 m_common = x.m_common;
17497
17498 m_detail = x.m_detail;
17499
17500 return *this;
17501 }
17502
17507 eProsima_user_DllExport CompleteEnumeratedHeader& operator =(
17508 CompleteEnumeratedHeader&& x) noexcept
17509 {
17510
17511 m_common = std::move(x.m_common);
17512 m_detail = std::move(x.m_detail);
17513 return *this;
17514 }
17515
17520 eProsima_user_DllExport bool operator ==(
17521 const CompleteEnumeratedHeader& x) const
17522 {
17523 return (m_common == x.m_common &&
17524 m_detail == x.m_detail);
17525 }
17526
17531 eProsima_user_DllExport bool operator !=(
17532 const CompleteEnumeratedHeader& x) const
17533 {
17534 return !(*this == x);
17535 }
17536
17541 eProsima_user_DllExport void common(
17542 const CommonEnumeratedHeader& _common)
17543 {
17544 m_common = _common;
17545 }
17546
17551 eProsima_user_DllExport void common(
17552 CommonEnumeratedHeader&& _common)
17553 {
17554 m_common = std::move(_common);
17555 }
17556
17561 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17562 {
17563 return m_common;
17564 }
17565
17570 eProsima_user_DllExport CommonEnumeratedHeader& common()
17571 {
17572 return m_common;
17573 }
17574
17575
17580 eProsima_user_DllExport void detail(
17581 const CompleteTypeDetail& _detail)
17582 {
17583 m_detail = _detail;
17584 }
17585
17590 eProsima_user_DllExport void detail(
17591 CompleteTypeDetail&& _detail)
17592 {
17593 m_detail = std::move(_detail);
17594 }
17595
17600 eProsima_user_DllExport const CompleteTypeDetail& detail() const
17601 {
17602 return m_detail;
17603 }
17604
17609 eProsima_user_DllExport CompleteTypeDetail& detail()
17610 {
17611 return m_detail;
17612 }
17613
17614
17615
17616private:
17617
17618 CommonEnumeratedHeader m_common;
17619 CompleteTypeDetail m_detail;
17620
17621};
17627{
17628public:
17629
17633 eProsima_user_DllExport MinimalEnumeratedHeader()
17634 {
17635 }
17636
17640 eProsima_user_DllExport ~MinimalEnumeratedHeader()
17641 {
17642 }
17643
17648 eProsima_user_DllExport MinimalEnumeratedHeader(
17649 const MinimalEnumeratedHeader& x)
17650 {
17651 m_common = x.m_common;
17652
17653 }
17654
17659 eProsima_user_DllExport MinimalEnumeratedHeader(
17660 MinimalEnumeratedHeader&& x) noexcept
17661 {
17662 m_common = std::move(x.m_common);
17663 }
17664
17669 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17670 const MinimalEnumeratedHeader& x)
17671 {
17672
17673 m_common = x.m_common;
17674
17675 return *this;
17676 }
17677
17682 eProsima_user_DllExport MinimalEnumeratedHeader& operator =(
17683 MinimalEnumeratedHeader&& x) noexcept
17684 {
17685
17686 m_common = std::move(x.m_common);
17687 return *this;
17688 }
17689
17694 eProsima_user_DllExport bool operator ==(
17695 const MinimalEnumeratedHeader& x) const
17696 {
17697 return (m_common == x.m_common);
17698 }
17699
17704 eProsima_user_DllExport bool operator !=(
17705 const MinimalEnumeratedHeader& x) const
17706 {
17707 return !(*this == x);
17708 }
17709
17714 eProsima_user_DllExport void common(
17715 const CommonEnumeratedHeader& _common)
17716 {
17717 m_common = _common;
17718 }
17719
17724 eProsima_user_DllExport void common(
17725 CommonEnumeratedHeader&& _common)
17726 {
17727 m_common = std::move(_common);
17728 }
17729
17734 eProsima_user_DllExport const CommonEnumeratedHeader& common() const
17735 {
17736 return m_common;
17737 }
17738
17743 eProsima_user_DllExport CommonEnumeratedHeader& common()
17744 {
17745 return m_common;
17746 }
17747
17748
17749
17750private:
17751
17752 CommonEnumeratedHeader m_common;
17753
17754};
17760{
17761public:
17762
17766 eProsima_user_DllExport CompleteEnumeratedType()
17767 {
17768 }
17769
17773 eProsima_user_DllExport ~CompleteEnumeratedType()
17774 {
17775 }
17776
17781 eProsima_user_DllExport CompleteEnumeratedType(
17782 const CompleteEnumeratedType& x)
17783 {
17784 m_enum_flags = x.m_enum_flags;
17785
17786 m_header = x.m_header;
17787
17788 m_literal_seq = x.m_literal_seq;
17789
17790 }
17791
17796 eProsima_user_DllExport CompleteEnumeratedType(
17797 CompleteEnumeratedType&& x) noexcept
17798 {
17799 m_enum_flags = std::move(x.m_enum_flags);
17800 m_header = std::move(x.m_header);
17801 m_literal_seq = std::move(x.m_literal_seq);
17802 }
17803
17808 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17809 const CompleteEnumeratedType& x)
17810 {
17811
17812 m_enum_flags = x.m_enum_flags;
17813
17814 m_header = x.m_header;
17815
17816 m_literal_seq = x.m_literal_seq;
17817
17818 return *this;
17819 }
17820
17825 eProsima_user_DllExport CompleteEnumeratedType& operator =(
17826 CompleteEnumeratedType&& x) noexcept
17827 {
17828
17829 m_enum_flags = std::move(x.m_enum_flags);
17830 m_header = std::move(x.m_header);
17831 m_literal_seq = std::move(x.m_literal_seq);
17832 return *this;
17833 }
17834
17839 eProsima_user_DllExport bool operator ==(
17840 const CompleteEnumeratedType& x) const
17841 {
17842 return (m_enum_flags == x.m_enum_flags &&
17843 m_header == x.m_header &&
17844 m_literal_seq == x.m_literal_seq);
17845 }
17846
17851 eProsima_user_DllExport bool operator !=(
17852 const CompleteEnumeratedType& x) const
17853 {
17854 return !(*this == x);
17855 }
17856
17861 eProsima_user_DllExport void enum_flags(
17862 const EnumTypeFlag& _enum_flags)
17863 {
17864 m_enum_flags = _enum_flags;
17865 }
17866
17871 eProsima_user_DllExport void enum_flags(
17872 EnumTypeFlag&& _enum_flags)
17873 {
17874 m_enum_flags = std::move(_enum_flags);
17875 }
17876
17881 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
17882 {
17883 return m_enum_flags;
17884 }
17885
17890 eProsima_user_DllExport EnumTypeFlag& enum_flags()
17891 {
17892 return m_enum_flags;
17893 }
17894
17895
17900 eProsima_user_DllExport void header(
17901 const CompleteEnumeratedHeader& _header)
17902 {
17903 m_header = _header;
17904 }
17905
17910 eProsima_user_DllExport void header(
17911 CompleteEnumeratedHeader&& _header)
17912 {
17913 m_header = std::move(_header);
17914 }
17915
17920 eProsima_user_DllExport const CompleteEnumeratedHeader& header() const
17921 {
17922 return m_header;
17923 }
17924
17929 eProsima_user_DllExport CompleteEnumeratedHeader& header()
17930 {
17931 return m_header;
17932 }
17933
17934
17939 eProsima_user_DllExport void literal_seq(
17940 const CompleteEnumeratedLiteralSeq& _literal_seq)
17941 {
17942 m_literal_seq = _literal_seq;
17943 }
17944
17949 eProsima_user_DllExport void literal_seq(
17950 CompleteEnumeratedLiteralSeq&& _literal_seq)
17951 {
17952 m_literal_seq = std::move(_literal_seq);
17953 }
17954
17959 eProsima_user_DllExport const CompleteEnumeratedLiteralSeq& literal_seq() const
17960 {
17961 return m_literal_seq;
17962 }
17963
17969 {
17970 return m_literal_seq;
17971 }
17972
17973
17974
17975private:
17976
17977 EnumTypeFlag m_enum_flags{0};
17978 CompleteEnumeratedHeader m_header;
17979 CompleteEnumeratedLiteralSeq m_literal_seq;
17980
17981};
17987{
17988public:
17989
17993 eProsima_user_DllExport MinimalEnumeratedType()
17994 {
17995 }
17996
18000 eProsima_user_DllExport ~MinimalEnumeratedType()
18001 {
18002 }
18003
18008 eProsima_user_DllExport MinimalEnumeratedType(
18009 const MinimalEnumeratedType& x)
18010 {
18011 m_enum_flags = x.m_enum_flags;
18012
18013 m_header = x.m_header;
18014
18015 m_literal_seq = x.m_literal_seq;
18016
18017 }
18018
18023 eProsima_user_DllExport MinimalEnumeratedType(
18024 MinimalEnumeratedType&& x) noexcept
18025 {
18026 m_enum_flags = std::move(x.m_enum_flags);
18027 m_header = std::move(x.m_header);
18028 m_literal_seq = std::move(x.m_literal_seq);
18029 }
18030
18035 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18036 const MinimalEnumeratedType& x)
18037 {
18038
18039 m_enum_flags = x.m_enum_flags;
18040
18041 m_header = x.m_header;
18042
18043 m_literal_seq = x.m_literal_seq;
18044
18045 return *this;
18046 }
18047
18052 eProsima_user_DllExport MinimalEnumeratedType& operator =(
18053 MinimalEnumeratedType&& x) noexcept
18054 {
18055
18056 m_enum_flags = std::move(x.m_enum_flags);
18057 m_header = std::move(x.m_header);
18058 m_literal_seq = std::move(x.m_literal_seq);
18059 return *this;
18060 }
18061
18066 eProsima_user_DllExport bool operator ==(
18067 const MinimalEnumeratedType& x) const
18068 {
18069 return (m_enum_flags == x.m_enum_flags &&
18070 m_header == x.m_header &&
18071 m_literal_seq == x.m_literal_seq);
18072 }
18073
18078 eProsima_user_DllExport bool operator !=(
18079 const MinimalEnumeratedType& x) const
18080 {
18081 return !(*this == x);
18082 }
18083
18088 eProsima_user_DllExport void enum_flags(
18089 const EnumTypeFlag& _enum_flags)
18090 {
18091 m_enum_flags = _enum_flags;
18092 }
18093
18098 eProsima_user_DllExport void enum_flags(
18099 EnumTypeFlag&& _enum_flags)
18100 {
18101 m_enum_flags = std::move(_enum_flags);
18102 }
18103
18108 eProsima_user_DllExport const EnumTypeFlag& enum_flags() const
18109 {
18110 return m_enum_flags;
18111 }
18112
18117 eProsima_user_DllExport EnumTypeFlag& enum_flags()
18118 {
18119 return m_enum_flags;
18120 }
18121
18122
18127 eProsima_user_DllExport void header(
18128 const MinimalEnumeratedHeader& _header)
18129 {
18130 m_header = _header;
18131 }
18132
18137 eProsima_user_DllExport void header(
18138 MinimalEnumeratedHeader&& _header)
18139 {
18140 m_header = std::move(_header);
18141 }
18142
18147 eProsima_user_DllExport const MinimalEnumeratedHeader& header() const
18148 {
18149 return m_header;
18150 }
18151
18156 eProsima_user_DllExport MinimalEnumeratedHeader& header()
18157 {
18158 return m_header;
18159 }
18160
18161
18166 eProsima_user_DllExport void literal_seq(
18167 const MinimalEnumeratedLiteralSeq& _literal_seq)
18168 {
18169 m_literal_seq = _literal_seq;
18170 }
18171
18176 eProsima_user_DllExport void literal_seq(
18177 MinimalEnumeratedLiteralSeq&& _literal_seq)
18178 {
18179 m_literal_seq = std::move(_literal_seq);
18180 }
18181
18186 eProsima_user_DllExport const MinimalEnumeratedLiteralSeq& literal_seq() const
18187 {
18188 return m_literal_seq;
18189 }
18190
18195 eProsima_user_DllExport MinimalEnumeratedLiteralSeq& literal_seq()
18196 {
18197 return m_literal_seq;
18198 }
18199
18200
18201
18202private:
18203
18204 EnumTypeFlag m_enum_flags{0};
18205 MinimalEnumeratedHeader m_header;
18206 MinimalEnumeratedLiteralSeq m_literal_seq;
18207
18208};
18214{
18215public:
18216
18220 eProsima_user_DllExport CommonBitflag()
18221 {
18222 }
18223
18227 eProsima_user_DllExport ~CommonBitflag()
18228 {
18229 }
18230
18235 eProsima_user_DllExport CommonBitflag(
18236 const CommonBitflag& x)
18237 {
18238 m_position = x.m_position;
18239
18240 m_flags = x.m_flags;
18241
18242 }
18243
18248 eProsima_user_DllExport CommonBitflag(
18249 CommonBitflag&& x) noexcept
18250 {
18251 m_position = x.m_position;
18252 m_flags = std::move(x.m_flags);
18253 }
18254
18259 eProsima_user_DllExport CommonBitflag& operator =(
18260 const CommonBitflag& x)
18261 {
18262
18263 m_position = x.m_position;
18264
18265 m_flags = x.m_flags;
18266
18267 return *this;
18268 }
18269
18274 eProsima_user_DllExport CommonBitflag& operator =(
18275 CommonBitflag&& x) noexcept
18276 {
18277
18278 m_position = x.m_position;
18279 m_flags = std::move(x.m_flags);
18280 return *this;
18281 }
18282
18287 eProsima_user_DllExport bool operator ==(
18288 const CommonBitflag& x) const
18289 {
18290 return (m_position == x.m_position &&
18291 m_flags == x.m_flags);
18292 }
18293
18298 eProsima_user_DllExport bool operator !=(
18299 const CommonBitflag& x) const
18300 {
18301 return !(*this == x);
18302 }
18303
18308 eProsima_user_DllExport void position(
18309 uint16_t _position)
18310 {
18311 m_position = _position;
18312 }
18313
18318 eProsima_user_DllExport uint16_t position() const
18319 {
18320 return m_position;
18321 }
18322
18327 eProsima_user_DllExport uint16_t& position()
18328 {
18329 return m_position;
18330 }
18331
18332
18337 eProsima_user_DllExport void flags(
18338 const BitflagFlag& _flags)
18339 {
18340 m_flags = _flags;
18341 }
18342
18347 eProsima_user_DllExport void flags(
18348 BitflagFlag&& _flags)
18349 {
18350 m_flags = std::move(_flags);
18351 }
18352
18357 eProsima_user_DllExport const BitflagFlag& flags() const
18358 {
18359 return m_flags;
18360 }
18361
18366 eProsima_user_DllExport BitflagFlag& flags()
18367 {
18368 return m_flags;
18369 }
18370
18371
18372
18373private:
18374
18375 uint16_t m_position{0};
18376 BitflagFlag m_flags{0};
18377
18378};
18384{
18385public:
18386
18390 eProsima_user_DllExport CompleteBitflag()
18391 {
18392 }
18393
18397 eProsima_user_DllExport ~CompleteBitflag()
18398 {
18399 }
18400
18405 eProsima_user_DllExport CompleteBitflag(
18406 const CompleteBitflag& x)
18407 {
18408 m_common = x.m_common;
18409
18410 m_detail = x.m_detail;
18411
18412 }
18413
18418 eProsima_user_DllExport CompleteBitflag(
18419 CompleteBitflag&& x) noexcept
18420 {
18421 m_common = std::move(x.m_common);
18422 m_detail = std::move(x.m_detail);
18423 }
18424
18429 eProsima_user_DllExport CompleteBitflag& operator =(
18430 const CompleteBitflag& x)
18431 {
18432
18433 m_common = x.m_common;
18434
18435 m_detail = x.m_detail;
18436
18437 return *this;
18438 }
18439
18444 eProsima_user_DllExport CompleteBitflag& operator =(
18445 CompleteBitflag&& x) noexcept
18446 {
18447
18448 m_common = std::move(x.m_common);
18449 m_detail = std::move(x.m_detail);
18450 return *this;
18451 }
18452
18457 eProsima_user_DllExport bool operator ==(
18458 const CompleteBitflag& x) const
18459 {
18460 return (m_common == x.m_common &&
18461 m_detail == x.m_detail);
18462 }
18463
18468 eProsima_user_DllExport bool operator !=(
18469 const CompleteBitflag& x) const
18470 {
18471 return !(*this == x);
18472 }
18473
18478 eProsima_user_DllExport void common(
18479 const CommonBitflag& _common)
18480 {
18481 m_common = _common;
18482 }
18483
18488 eProsima_user_DllExport void common(
18489 CommonBitflag&& _common)
18490 {
18491 m_common = std::move(_common);
18492 }
18493
18498 eProsima_user_DllExport const CommonBitflag& common() const
18499 {
18500 return m_common;
18501 }
18502
18507 eProsima_user_DllExport CommonBitflag& common()
18508 {
18509 return m_common;
18510 }
18511
18512
18517 eProsima_user_DllExport void detail(
18518 const CompleteMemberDetail& _detail)
18519 {
18520 m_detail = _detail;
18521 }
18522
18527 eProsima_user_DllExport void detail(
18528 CompleteMemberDetail&& _detail)
18529 {
18530 m_detail = std::move(_detail);
18531 }
18532
18537 eProsima_user_DllExport const CompleteMemberDetail& detail() const
18538 {
18539 return m_detail;
18540 }
18541
18546 eProsima_user_DllExport CompleteMemberDetail& detail()
18547 {
18548 return m_detail;
18549 }
18550
18551
18552
18553private:
18554
18555 CommonBitflag m_common;
18556 CompleteMemberDetail m_detail;
18557
18558};
18559typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
18560
18566{
18567public:
18568
18572 eProsima_user_DllExport MinimalBitflag()
18573 {
18574 }
18575
18579 eProsima_user_DllExport ~MinimalBitflag()
18580 {
18581 }
18582
18587 eProsima_user_DllExport MinimalBitflag(
18588 const MinimalBitflag& x)
18589 {
18590 m_common = x.m_common;
18591
18592 m_detail = x.m_detail;
18593
18594 }
18595
18600 eProsima_user_DllExport MinimalBitflag(
18601 MinimalBitflag&& x) noexcept
18602 {
18603 m_common = std::move(x.m_common);
18604 m_detail = std::move(x.m_detail);
18605 }
18606
18611 eProsima_user_DllExport MinimalBitflag& operator =(
18612 const MinimalBitflag& x)
18613 {
18614
18615 m_common = x.m_common;
18616
18617 m_detail = x.m_detail;
18618
18619 return *this;
18620 }
18621
18626 eProsima_user_DllExport MinimalBitflag& operator =(
18627 MinimalBitflag&& x) noexcept
18628 {
18629
18630 m_common = std::move(x.m_common);
18631 m_detail = std::move(x.m_detail);
18632 return *this;
18633 }
18634
18639 eProsima_user_DllExport bool operator ==(
18640 const MinimalBitflag& x) const
18641 {
18642 return (m_common == x.m_common &&
18643 m_detail == x.m_detail);
18644 }
18645
18650 eProsima_user_DllExport bool operator !=(
18651 const MinimalBitflag& x) const
18652 {
18653 return !(*this == x);
18654 }
18655
18660 eProsima_user_DllExport void common(
18661 const CommonBitflag& _common)
18662 {
18663 m_common = _common;
18664 }
18665
18670 eProsima_user_DllExport void common(
18671 CommonBitflag&& _common)
18672 {
18673 m_common = std::move(_common);
18674 }
18675
18680 eProsima_user_DllExport const CommonBitflag& common() const
18681 {
18682 return m_common;
18683 }
18684
18689 eProsima_user_DllExport CommonBitflag& common()
18690 {
18691 return m_common;
18692 }
18693
18694
18699 eProsima_user_DllExport void detail(
18700 const MinimalMemberDetail& _detail)
18701 {
18702 m_detail = _detail;
18703 }
18704
18709 eProsima_user_DllExport void detail(
18710 MinimalMemberDetail&& _detail)
18711 {
18712 m_detail = std::move(_detail);
18713 }
18714
18719 eProsima_user_DllExport const MinimalMemberDetail& detail() const
18720 {
18721 return m_detail;
18722 }
18723
18728 eProsima_user_DllExport MinimalMemberDetail& detail()
18729 {
18730 return m_detail;
18731 }
18732
18733
18734
18735private:
18736
18737 CommonBitflag m_common;
18738 MinimalMemberDetail m_detail;
18739
18740};
18741typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
18742
18748{
18749public:
18750
18754 eProsima_user_DllExport CommonBitmaskHeader()
18755 {
18756 }
18757
18761 eProsima_user_DllExport ~CommonBitmaskHeader()
18762 {
18763 }
18764
18769 eProsima_user_DllExport CommonBitmaskHeader(
18770 const CommonBitmaskHeader& x)
18771 {
18772 m_bit_bound = x.m_bit_bound;
18773
18774 }
18775
18780 eProsima_user_DllExport CommonBitmaskHeader(
18781 CommonBitmaskHeader&& x) noexcept
18782 {
18783 m_bit_bound = x.m_bit_bound;
18784 }
18785
18790 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18791 const CommonBitmaskHeader& x)
18792 {
18793
18794 m_bit_bound = x.m_bit_bound;
18795
18796 return *this;
18797 }
18798
18803 eProsima_user_DllExport CommonBitmaskHeader& operator =(
18804 CommonBitmaskHeader&& x) noexcept
18805 {
18806
18807 m_bit_bound = x.m_bit_bound;
18808 return *this;
18809 }
18810
18815 eProsima_user_DllExport bool operator ==(
18816 const CommonBitmaskHeader& x) const
18817 {
18818 return (m_bit_bound == x.m_bit_bound);
18819 }
18820
18825 eProsima_user_DllExport bool operator !=(
18826 const CommonBitmaskHeader& x) const
18827 {
18828 return !(*this == x);
18829 }
18830
18835 eProsima_user_DllExport void bit_bound(
18836 BitBound _bit_bound)
18837 {
18838 m_bit_bound = _bit_bound;
18839 }
18840
18845 eProsima_user_DllExport BitBound bit_bound() const
18846 {
18847 return m_bit_bound;
18848 }
18849
18854 eProsima_user_DllExport BitBound& bit_bound()
18855 {
18856 return m_bit_bound;
18857 }
18858
18859
18860
18861private:
18862
18863 BitBound m_bit_bound{0};
18864
18865};
18867
18869
18875{
18876public:
18877
18881 eProsima_user_DllExport CompleteBitmaskType()
18882 {
18883 }
18884
18888 eProsima_user_DllExport ~CompleteBitmaskType()
18889 {
18890 }
18891
18896 eProsima_user_DllExport CompleteBitmaskType(
18897 const CompleteBitmaskType& x)
18898 {
18899 m_bitmask_flags = x.m_bitmask_flags;
18900
18901 m_header = x.m_header;
18902
18903 m_flag_seq = x.m_flag_seq;
18904
18905 }
18906
18911 eProsima_user_DllExport CompleteBitmaskType(
18912 CompleteBitmaskType&& x) noexcept
18913 {
18914 m_bitmask_flags = std::move(x.m_bitmask_flags);
18915 m_header = std::move(x.m_header);
18916 m_flag_seq = std::move(x.m_flag_seq);
18917 }
18918
18923 eProsima_user_DllExport CompleteBitmaskType& operator =(
18924 const CompleteBitmaskType& x)
18925 {
18926
18927 m_bitmask_flags = x.m_bitmask_flags;
18928
18929 m_header = x.m_header;
18930
18931 m_flag_seq = x.m_flag_seq;
18932
18933 return *this;
18934 }
18935
18940 eProsima_user_DllExport CompleteBitmaskType& operator =(
18941 CompleteBitmaskType&& x) noexcept
18942 {
18943
18944 m_bitmask_flags = std::move(x.m_bitmask_flags);
18945 m_header = std::move(x.m_header);
18946 m_flag_seq = std::move(x.m_flag_seq);
18947 return *this;
18948 }
18949
18954 eProsima_user_DllExport bool operator ==(
18955 const CompleteBitmaskType& x) const
18956 {
18957 return (m_bitmask_flags == x.m_bitmask_flags &&
18958 m_header == x.m_header &&
18959 m_flag_seq == x.m_flag_seq);
18960 }
18961
18966 eProsima_user_DllExport bool operator !=(
18967 const CompleteBitmaskType& x) const
18968 {
18969 return !(*this == x);
18970 }
18971
18976 eProsima_user_DllExport void bitmask_flags(
18977 const BitmaskTypeFlag& _bitmask_flags)
18978 {
18979 m_bitmask_flags = _bitmask_flags;
18980 }
18981
18986 eProsima_user_DllExport void bitmask_flags(
18987 BitmaskTypeFlag&& _bitmask_flags)
18988 {
18989 m_bitmask_flags = std::move(_bitmask_flags);
18990 }
18991
18996 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
18997 {
18998 return m_bitmask_flags;
18999 }
19000
19005 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
19006 {
19007 return m_bitmask_flags;
19008 }
19009
19010
19015 eProsima_user_DllExport void header(
19016 const CompleteBitmaskHeader& _header)
19017 {
19018 m_header = _header;
19019 }
19020
19025 eProsima_user_DllExport void header(
19026 CompleteBitmaskHeader&& _header)
19027 {
19028 m_header = std::move(_header);
19029 }
19030
19035 eProsima_user_DllExport const CompleteBitmaskHeader& header() const
19036 {
19037 return m_header;
19038 }
19039
19044 eProsima_user_DllExport CompleteBitmaskHeader& header()
19045 {
19046 return m_header;
19047 }
19048
19049
19054 eProsima_user_DllExport void flag_seq(
19055 const CompleteBitflagSeq& _flag_seq)
19056 {
19057 m_flag_seq = _flag_seq;
19058 }
19059
19064 eProsima_user_DllExport void flag_seq(
19065 CompleteBitflagSeq&& _flag_seq)
19066 {
19067 m_flag_seq = std::move(_flag_seq);
19068 }
19069
19074 eProsima_user_DllExport const CompleteBitflagSeq& flag_seq() const
19075 {
19076 return m_flag_seq;
19077 }
19078
19083 eProsima_user_DllExport CompleteBitflagSeq& flag_seq()
19084 {
19085 return m_flag_seq;
19086 }
19087
19088
19089
19090private:
19091
19092 BitmaskTypeFlag m_bitmask_flags{0};
19093 CompleteBitmaskHeader m_header;
19094 CompleteBitflagSeq m_flag_seq;
19095
19096};
19102{
19103public:
19104
19108 eProsima_user_DllExport MinimalBitmaskType()
19109 {
19110 }
19111
19115 eProsima_user_DllExport ~MinimalBitmaskType()
19116 {
19117 }
19118
19123 eProsima_user_DllExport MinimalBitmaskType(
19124 const MinimalBitmaskType& x)
19125 {
19126 m_bitmask_flags = x.m_bitmask_flags;
19127
19128 m_header = x.m_header;
19129
19130 m_flag_seq = x.m_flag_seq;
19131
19132 }
19133
19138 eProsima_user_DllExport MinimalBitmaskType(
19139 MinimalBitmaskType&& x) noexcept
19140 {
19141 m_bitmask_flags = std::move(x.m_bitmask_flags);
19142 m_header = std::move(x.m_header);
19143 m_flag_seq = std::move(x.m_flag_seq);
19144 }
19145
19150 eProsima_user_DllExport MinimalBitmaskType& operator =(
19151 const MinimalBitmaskType& x)
19152 {
19153
19154 m_bitmask_flags = x.m_bitmask_flags;
19155
19156 m_header = x.m_header;
19157
19158 m_flag_seq = x.m_flag_seq;
19159
19160 return *this;
19161 }
19162
19167 eProsima_user_DllExport MinimalBitmaskType& operator =(
19168 MinimalBitmaskType&& x) noexcept
19169 {
19170
19171 m_bitmask_flags = std::move(x.m_bitmask_flags);
19172 m_header = std::move(x.m_header);
19173 m_flag_seq = std::move(x.m_flag_seq);
19174 return *this;
19175 }
19176
19181 eProsima_user_DllExport bool operator ==(
19182 const MinimalBitmaskType& x) const
19183 {
19184 return (m_bitmask_flags == x.m_bitmask_flags &&
19185 m_header == x.m_header &&
19186 m_flag_seq == x.m_flag_seq);
19187 }
19188
19193 eProsima_user_DllExport bool operator !=(
19194 const MinimalBitmaskType& x) const
19195 {
19196 return !(*this == x);
19197 }
19198
19203 eProsima_user_DllExport void bitmask_flags(
19204 const BitmaskTypeFlag& _bitmask_flags)
19205 {
19206 m_bitmask_flags = _bitmask_flags;
19207 }
19208
19213 eProsima_user_DllExport void bitmask_flags(
19214 BitmaskTypeFlag&& _bitmask_flags)
19215 {
19216 m_bitmask_flags = std::move(_bitmask_flags);
19217 }
19218
19223 eProsima_user_DllExport const BitmaskTypeFlag& bitmask_flags() const
19224 {
19225 return m_bitmask_flags;
19226 }
19227
19232 eProsima_user_DllExport BitmaskTypeFlag& bitmask_flags()
19233 {
19234 return m_bitmask_flags;
19235 }
19236
19237
19242 eProsima_user_DllExport void header(
19243 const MinimalBitmaskHeader& _header)
19244 {
19245 m_header = _header;
19246 }
19247
19252 eProsima_user_DllExport void header(
19253 MinimalBitmaskHeader&& _header)
19254 {
19255 m_header = std::move(_header);
19256 }
19257
19262 eProsima_user_DllExport const MinimalBitmaskHeader& header() const
19263 {
19264 return m_header;
19265 }
19266
19271 eProsima_user_DllExport MinimalBitmaskHeader& header()
19272 {
19273 return m_header;
19274 }
19275
19276
19281 eProsima_user_DllExport void flag_seq(
19282 const MinimalBitflagSeq& _flag_seq)
19283 {
19284 m_flag_seq = _flag_seq;
19285 }
19286
19291 eProsima_user_DllExport void flag_seq(
19292 MinimalBitflagSeq&& _flag_seq)
19293 {
19294 m_flag_seq = std::move(_flag_seq);
19295 }
19296
19301 eProsima_user_DllExport const MinimalBitflagSeq& flag_seq() const
19302 {
19303 return m_flag_seq;
19304 }
19305
19310 eProsima_user_DllExport MinimalBitflagSeq& flag_seq()
19311 {
19312 return m_flag_seq;
19313 }
19314
19315
19316
19317private:
19318
19319 BitmaskTypeFlag m_bitmask_flags{0};
19320 MinimalBitmaskHeader m_header;
19321 MinimalBitflagSeq m_flag_seq;
19322
19323};
19329{
19330public:
19331
19335 eProsima_user_DllExport CommonBitfield()
19336 {
19337 }
19338
19342 eProsima_user_DllExport ~CommonBitfield()
19343 {
19344 }
19345
19350 eProsima_user_DllExport CommonBitfield(
19351 const CommonBitfield& x)
19352 {
19353 m_position = x.m_position;
19354
19355 m_flags = x.m_flags;
19356
19357 m_bitcount = x.m_bitcount;
19358
19359 m_holder_type = x.m_holder_type;
19360
19361 }
19362
19367 eProsima_user_DllExport CommonBitfield(
19368 CommonBitfield&& x) noexcept
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 }
19375
19380 eProsima_user_DllExport CommonBitfield& operator =(
19381 const CommonBitfield& x)
19382 {
19383
19384 m_position = x.m_position;
19385
19386 m_flags = x.m_flags;
19387
19388 m_bitcount = x.m_bitcount;
19389
19390 m_holder_type = x.m_holder_type;
19391
19392 return *this;
19393 }
19394
19399 eProsima_user_DllExport CommonBitfield& operator =(
19400 CommonBitfield&& x) noexcept
19401 {
19402
19403 m_position = x.m_position;
19404 m_flags = std::move(x.m_flags);
19405 m_bitcount = x.m_bitcount;
19406 m_holder_type = x.m_holder_type;
19407 return *this;
19408 }
19409
19414 eProsima_user_DllExport bool operator ==(
19415 const CommonBitfield& x) const
19416 {
19417 return (m_position == x.m_position &&
19418 m_flags == x.m_flags &&
19419 m_bitcount == x.m_bitcount &&
19420 m_holder_type == x.m_holder_type);
19421 }
19422
19427 eProsima_user_DllExport bool operator !=(
19428 const CommonBitfield& x) const
19429 {
19430 return !(*this == x);
19431 }
19432
19437 eProsima_user_DllExport void position(
19438 uint16_t _position)
19439 {
19440 m_position = _position;
19441 }
19442
19447 eProsima_user_DllExport uint16_t position() const
19448 {
19449 return m_position;
19450 }
19451
19456 eProsima_user_DllExport uint16_t& position()
19457 {
19458 return m_position;
19459 }
19460
19461
19466 eProsima_user_DllExport void flags(
19467 const BitsetMemberFlag& _flags)
19468 {
19469 m_flags = _flags;
19470 }
19471
19476 eProsima_user_DllExport void flags(
19477 BitsetMemberFlag&& _flags)
19478 {
19479 m_flags = std::move(_flags);
19480 }
19481
19486 eProsima_user_DllExport const BitsetMemberFlag& flags() const
19487 {
19488 return m_flags;
19489 }
19490
19495 eProsima_user_DllExport BitsetMemberFlag& flags()
19496 {
19497 return m_flags;
19498 }
19499
19500
19505 eProsima_user_DllExport void bitcount(
19506 uint8_t _bitcount)
19507 {
19508 m_bitcount = _bitcount;
19509 }
19510
19515 eProsima_user_DllExport uint8_t bitcount() const
19516 {
19517 return m_bitcount;
19518 }
19519
19524 eProsima_user_DllExport uint8_t& bitcount()
19525 {
19526 return m_bitcount;
19527 }
19528
19529
19534 eProsima_user_DllExport void holder_type(
19535 TypeKind _holder_type)
19536 {
19537 m_holder_type = _holder_type;
19538 }
19539
19544 eProsima_user_DllExport TypeKind holder_type() const
19545 {
19546 return m_holder_type;
19547 }
19548
19553 eProsima_user_DllExport TypeKind& holder_type()
19554 {
19555 return m_holder_type;
19556 }
19557
19558
19559
19560private:
19561
19562 uint16_t m_position{0};
19563 BitsetMemberFlag m_flags{0};
19564 uint8_t m_bitcount{0};
19565 TypeKind m_holder_type{0};
19566
19567};
19573{
19574public:
19575
19579 eProsima_user_DllExport CompleteBitfield()
19580 {
19581 }
19582
19586 eProsima_user_DllExport ~CompleteBitfield()
19587 {
19588 }
19589
19594 eProsima_user_DllExport CompleteBitfield(
19595 const CompleteBitfield& x)
19596 {
19597 m_common = x.m_common;
19598
19599 m_detail = x.m_detail;
19600
19601 }
19602
19607 eProsima_user_DllExport CompleteBitfield(
19608 CompleteBitfield&& x) noexcept
19609 {
19610 m_common = std::move(x.m_common);
19611 m_detail = std::move(x.m_detail);
19612 }
19613
19618 eProsima_user_DllExport CompleteBitfield& operator =(
19619 const CompleteBitfield& x)
19620 {
19621
19622 m_common = x.m_common;
19623
19624 m_detail = x.m_detail;
19625
19626 return *this;
19627 }
19628
19633 eProsima_user_DllExport CompleteBitfield& operator =(
19634 CompleteBitfield&& x) noexcept
19635 {
19636
19637 m_common = std::move(x.m_common);
19638 m_detail = std::move(x.m_detail);
19639 return *this;
19640 }
19641
19646 eProsima_user_DllExport bool operator ==(
19647 const CompleteBitfield& x) const
19648 {
19649 return (m_common == x.m_common &&
19650 m_detail == x.m_detail);
19651 }
19652
19657 eProsima_user_DllExport bool operator !=(
19658 const CompleteBitfield& x) const
19659 {
19660 return !(*this == x);
19661 }
19662
19667 eProsima_user_DllExport void common(
19668 const CommonBitfield& _common)
19669 {
19670 m_common = _common;
19671 }
19672
19677 eProsima_user_DllExport void common(
19678 CommonBitfield&& _common)
19679 {
19680 m_common = std::move(_common);
19681 }
19682
19687 eProsima_user_DllExport const CommonBitfield& common() const
19688 {
19689 return m_common;
19690 }
19691
19696 eProsima_user_DllExport CommonBitfield& common()
19697 {
19698 return m_common;
19699 }
19700
19701
19706 eProsima_user_DllExport void detail(
19707 const CompleteMemberDetail& _detail)
19708 {
19709 m_detail = _detail;
19710 }
19711
19716 eProsima_user_DllExport void detail(
19717 CompleteMemberDetail&& _detail)
19718 {
19719 m_detail = std::move(_detail);
19720 }
19721
19726 eProsima_user_DllExport const CompleteMemberDetail& detail() const
19727 {
19728 return m_detail;
19729 }
19730
19735 eProsima_user_DllExport CompleteMemberDetail& detail()
19736 {
19737 return m_detail;
19738 }
19739
19740
19741
19742private:
19743
19744 CommonBitfield m_common;
19745 CompleteMemberDetail m_detail;
19746
19747};
19748typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
19749
19755{
19756public:
19757
19761 eProsima_user_DllExport MinimalBitfield()
19762 {
19763 }
19764
19768 eProsima_user_DllExport ~MinimalBitfield()
19769 {
19770 }
19771
19776 eProsima_user_DllExport MinimalBitfield(
19777 const MinimalBitfield& x)
19778 {
19779 m_common = x.m_common;
19780
19781 m_name_hash = x.m_name_hash;
19782
19783 }
19784
19789 eProsima_user_DllExport MinimalBitfield(
19790 MinimalBitfield&& x) noexcept
19791 {
19792 m_common = std::move(x.m_common);
19793 m_name_hash = std::move(x.m_name_hash);
19794 }
19795
19800 eProsima_user_DllExport MinimalBitfield& operator =(
19801 const MinimalBitfield& x)
19802 {
19803
19804 m_common = x.m_common;
19805
19806 m_name_hash = x.m_name_hash;
19807
19808 return *this;
19809 }
19810
19815 eProsima_user_DllExport MinimalBitfield& operator =(
19816 MinimalBitfield&& x) noexcept
19817 {
19818
19819 m_common = std::move(x.m_common);
19820 m_name_hash = std::move(x.m_name_hash);
19821 return *this;
19822 }
19823
19828 eProsima_user_DllExport bool operator ==(
19829 const MinimalBitfield& x) const
19830 {
19831 return (m_common == x.m_common &&
19832 m_name_hash == x.m_name_hash);
19833 }
19834
19839 eProsima_user_DllExport bool operator !=(
19840 const MinimalBitfield& x) const
19841 {
19842 return !(*this == x);
19843 }
19844
19849 eProsima_user_DllExport void common(
19850 const CommonBitfield& _common)
19851 {
19852 m_common = _common;
19853 }
19854
19859 eProsima_user_DllExport void common(
19860 CommonBitfield&& _common)
19861 {
19862 m_common = std::move(_common);
19863 }
19864
19869 eProsima_user_DllExport const CommonBitfield& common() const
19870 {
19871 return m_common;
19872 }
19873
19878 eProsima_user_DllExport CommonBitfield& common()
19879 {
19880 return m_common;
19881 }
19882
19883
19888 eProsima_user_DllExport void name_hash(
19889 const NameHash& _name_hash)
19890 {
19891 m_name_hash = _name_hash;
19892 }
19893
19898 eProsima_user_DllExport void name_hash(
19899 NameHash&& _name_hash)
19900 {
19901 m_name_hash = std::move(_name_hash);
19902 }
19903
19908 eProsima_user_DllExport const NameHash& name_hash() const
19909 {
19910 return m_name_hash;
19911 }
19912
19917 eProsima_user_DllExport NameHash& name_hash()
19918 {
19919 return m_name_hash;
19920 }
19921
19922
19923
19924private:
19925
19926 CommonBitfield m_common;
19927 NameHash m_name_hash{0};
19928
19929};
19930typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
19931
19937{
19938public:
19939
19943 eProsima_user_DllExport CompleteBitsetHeader()
19944 {
19945 }
19946
19950 eProsima_user_DllExport ~CompleteBitsetHeader()
19951 {
19952 }
19953
19958 eProsima_user_DllExport CompleteBitsetHeader(
19959 const CompleteBitsetHeader& x)
19960 {
19961 m_detail = x.m_detail;
19962
19963 }
19964
19969 eProsima_user_DllExport CompleteBitsetHeader(
19970 CompleteBitsetHeader&& x) noexcept
19971 {
19972 m_detail = std::move(x.m_detail);
19973 }
19974
19979 eProsima_user_DllExport CompleteBitsetHeader& operator =(
19980 const CompleteBitsetHeader& x)
19981 {
19982
19983 m_detail = x.m_detail;
19984
19985 return *this;
19986 }
19987
19992 eProsima_user_DllExport CompleteBitsetHeader& operator =(
19993 CompleteBitsetHeader&& x) noexcept
19994 {
19995
19996 m_detail = std::move(x.m_detail);
19997 return *this;
19998 }
19999
20004 eProsima_user_DllExport bool operator ==(
20005 const CompleteBitsetHeader& x) const
20006 {
20007 return (m_detail == x.m_detail);
20008 }
20009
20014 eProsima_user_DllExport bool operator !=(
20015 const CompleteBitsetHeader& x) const
20016 {
20017 return !(*this == x);
20018 }
20019
20024 eProsima_user_DllExport void detail(
20025 const CompleteTypeDetail& _detail)
20026 {
20027 m_detail = _detail;
20028 }
20029
20034 eProsima_user_DllExport void detail(
20035 CompleteTypeDetail&& _detail)
20036 {
20037 m_detail = std::move(_detail);
20038 }
20039
20044 eProsima_user_DllExport const CompleteTypeDetail& detail() const
20045 {
20046 return m_detail;
20047 }
20048
20053 eProsima_user_DllExport CompleteTypeDetail& detail()
20054 {
20055 return m_detail;
20056 }
20057
20058
20059
20060private:
20061
20062 CompleteTypeDetail m_detail;
20063
20064};
20070{
20071public:
20072
20076 eProsima_user_DllExport MinimalBitsetHeader()
20077 {
20078 }
20079
20083 eProsima_user_DllExport ~MinimalBitsetHeader()
20084 {
20085 }
20086
20091 eProsima_user_DllExport MinimalBitsetHeader(
20092 const MinimalBitsetHeader& x)
20093 {
20094 static_cast<void>(x);
20095 }
20096
20101 eProsima_user_DllExport MinimalBitsetHeader(
20102 MinimalBitsetHeader&& x) noexcept
20103 {
20104 static_cast<void>(x);
20105 }
20106
20111 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20112 const MinimalBitsetHeader& x)
20113 {
20114
20115 static_cast<void>(x);
20116
20117 return *this;
20118 }
20119
20124 eProsima_user_DllExport MinimalBitsetHeader& operator =(
20125 MinimalBitsetHeader&& x) noexcept
20126 {
20127
20128 static_cast<void>(x);
20129
20130 return *this;
20131 }
20132
20137 eProsima_user_DllExport bool operator ==(
20138 const MinimalBitsetHeader& x) const
20139 {
20140 static_cast<void>(x);
20141 return true;
20142 }
20143
20148 eProsima_user_DllExport bool operator !=(
20149 const MinimalBitsetHeader& x) const
20150 {
20151 return !(*this == x);
20152 }
20153
20154
20155
20156private:
20157
20158
20159};
20165{
20166public:
20167
20171 eProsima_user_DllExport CompleteBitsetType()
20172 {
20173 }
20174
20178 eProsima_user_DllExport ~CompleteBitsetType()
20179 {
20180 }
20181
20186 eProsima_user_DllExport CompleteBitsetType(
20187 const CompleteBitsetType& x)
20188 {
20189 m_bitset_flags = x.m_bitset_flags;
20190
20191 m_header = x.m_header;
20192
20193 m_field_seq = x.m_field_seq;
20194
20195 }
20196
20201 eProsima_user_DllExport CompleteBitsetType(
20202 CompleteBitsetType&& x) noexcept
20203 {
20204 m_bitset_flags = std::move(x.m_bitset_flags);
20205 m_header = std::move(x.m_header);
20206 m_field_seq = std::move(x.m_field_seq);
20207 }
20208
20213 eProsima_user_DllExport CompleteBitsetType& operator =(
20214 const CompleteBitsetType& x)
20215 {
20216
20217 m_bitset_flags = x.m_bitset_flags;
20218
20219 m_header = x.m_header;
20220
20221 m_field_seq = x.m_field_seq;
20222
20223 return *this;
20224 }
20225
20230 eProsima_user_DllExport CompleteBitsetType& operator =(
20231 CompleteBitsetType&& x) noexcept
20232 {
20233
20234 m_bitset_flags = std::move(x.m_bitset_flags);
20235 m_header = std::move(x.m_header);
20236 m_field_seq = std::move(x.m_field_seq);
20237 return *this;
20238 }
20239
20244 eProsima_user_DllExport bool operator ==(
20245 const CompleteBitsetType& x) const
20246 {
20247 return (m_bitset_flags == x.m_bitset_flags &&
20248 m_header == x.m_header &&
20249 m_field_seq == x.m_field_seq);
20250 }
20251
20256 eProsima_user_DllExport bool operator !=(
20257 const CompleteBitsetType& x) const
20258 {
20259 return !(*this == x);
20260 }
20261
20266 eProsima_user_DllExport void bitset_flags(
20267 const BitsetTypeFlag& _bitset_flags)
20268 {
20269 m_bitset_flags = _bitset_flags;
20270 }
20271
20276 eProsima_user_DllExport void bitset_flags(
20277 BitsetTypeFlag&& _bitset_flags)
20278 {
20279 m_bitset_flags = std::move(_bitset_flags);
20280 }
20281
20286 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20287 {
20288 return m_bitset_flags;
20289 }
20290
20295 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20296 {
20297 return m_bitset_flags;
20298 }
20299
20300
20305 eProsima_user_DllExport void header(
20306 const CompleteBitsetHeader& _header)
20307 {
20308 m_header = _header;
20309 }
20310
20315 eProsima_user_DllExport void header(
20316 CompleteBitsetHeader&& _header)
20317 {
20318 m_header = std::move(_header);
20319 }
20320
20325 eProsima_user_DllExport const CompleteBitsetHeader& header() const
20326 {
20327 return m_header;
20328 }
20329
20334 eProsima_user_DllExport CompleteBitsetHeader& header()
20335 {
20336 return m_header;
20337 }
20338
20339
20344 eProsima_user_DllExport void field_seq(
20345 const CompleteBitfieldSeq& _field_seq)
20346 {
20347 m_field_seq = _field_seq;
20348 }
20349
20354 eProsima_user_DllExport void field_seq(
20355 CompleteBitfieldSeq&& _field_seq)
20356 {
20357 m_field_seq = std::move(_field_seq);
20358 }
20359
20364 eProsima_user_DllExport const CompleteBitfieldSeq& field_seq() const
20365 {
20366 return m_field_seq;
20367 }
20368
20373 eProsima_user_DllExport CompleteBitfieldSeq& field_seq()
20374 {
20375 return m_field_seq;
20376 }
20377
20378
20379
20380private:
20381
20382 BitsetTypeFlag m_bitset_flags{0};
20383 CompleteBitsetHeader m_header;
20384 CompleteBitfieldSeq m_field_seq;
20385
20386};
20392{
20393public:
20394
20398 eProsima_user_DllExport MinimalBitsetType()
20399 {
20400 }
20401
20405 eProsima_user_DllExport ~MinimalBitsetType()
20406 {
20407 }
20408
20413 eProsima_user_DllExport MinimalBitsetType(
20414 const MinimalBitsetType& x)
20415 {
20416 m_bitset_flags = x.m_bitset_flags;
20417
20418 m_header = x.m_header;
20419
20420 m_field_seq = x.m_field_seq;
20421
20422 }
20423
20428 eProsima_user_DllExport MinimalBitsetType(
20429 MinimalBitsetType&& x) noexcept
20430 {
20431 m_bitset_flags = std::move(x.m_bitset_flags);
20432 m_header = std::move(x.m_header);
20433 m_field_seq = std::move(x.m_field_seq);
20434 }
20435
20440 eProsima_user_DllExport MinimalBitsetType& operator =(
20441 const MinimalBitsetType& x)
20442 {
20443
20444 m_bitset_flags = x.m_bitset_flags;
20445
20446 m_header = x.m_header;
20447
20448 m_field_seq = x.m_field_seq;
20449
20450 return *this;
20451 }
20452
20457 eProsima_user_DllExport MinimalBitsetType& operator =(
20458 MinimalBitsetType&& x) noexcept
20459 {
20460
20461 m_bitset_flags = std::move(x.m_bitset_flags);
20462 m_header = std::move(x.m_header);
20463 m_field_seq = std::move(x.m_field_seq);
20464 return *this;
20465 }
20466
20471 eProsima_user_DllExport bool operator ==(
20472 const MinimalBitsetType& x) const
20473 {
20474 return (m_bitset_flags == x.m_bitset_flags &&
20475 m_header == x.m_header &&
20476 m_field_seq == x.m_field_seq);
20477 }
20478
20483 eProsima_user_DllExport bool operator !=(
20484 const MinimalBitsetType& x) const
20485 {
20486 return !(*this == x);
20487 }
20488
20493 eProsima_user_DllExport void bitset_flags(
20494 const BitsetTypeFlag& _bitset_flags)
20495 {
20496 m_bitset_flags = _bitset_flags;
20497 }
20498
20503 eProsima_user_DllExport void bitset_flags(
20504 BitsetTypeFlag&& _bitset_flags)
20505 {
20506 m_bitset_flags = std::move(_bitset_flags);
20507 }
20508
20513 eProsima_user_DllExport const BitsetTypeFlag& bitset_flags() const
20514 {
20515 return m_bitset_flags;
20516 }
20517
20522 eProsima_user_DllExport BitsetTypeFlag& bitset_flags()
20523 {
20524 return m_bitset_flags;
20525 }
20526
20527
20532 eProsima_user_DllExport void header(
20533 const MinimalBitsetHeader& _header)
20534 {
20535 m_header = _header;
20536 }
20537
20542 eProsima_user_DllExport void header(
20543 MinimalBitsetHeader&& _header)
20544 {
20545 m_header = std::move(_header);
20546 }
20547
20552 eProsima_user_DllExport const MinimalBitsetHeader& header() const
20553 {
20554 return m_header;
20555 }
20556
20561 eProsima_user_DllExport MinimalBitsetHeader& header()
20562 {
20563 return m_header;
20564 }
20565
20566
20571 eProsima_user_DllExport void field_seq(
20572 const MinimalBitfieldSeq& _field_seq)
20573 {
20574 m_field_seq = _field_seq;
20575 }
20576
20581 eProsima_user_DllExport void field_seq(
20582 MinimalBitfieldSeq&& _field_seq)
20583 {
20584 m_field_seq = std::move(_field_seq);
20585 }
20586
20591 eProsima_user_DllExport const MinimalBitfieldSeq& field_seq() const
20592 {
20593 return m_field_seq;
20594 }
20595
20600 eProsima_user_DllExport MinimalBitfieldSeq& field_seq()
20601 {
20602 return m_field_seq;
20603 }
20604
20605
20606
20607private:
20608
20609 BitsetTypeFlag m_bitset_flags{0};
20610 MinimalBitsetHeader m_header;
20611 MinimalBitfieldSeq m_field_seq;
20612
20613};
20619{
20620public:
20621
20625 eProsima_user_DllExport CompleteExtendedType()
20626 {
20627 }
20628
20632 eProsima_user_DllExport ~CompleteExtendedType()
20633 {
20634 }
20635
20640 eProsima_user_DllExport CompleteExtendedType(
20641 const CompleteExtendedType& x)
20642 {
20643 static_cast<void>(x);
20644 }
20645
20650 eProsima_user_DllExport CompleteExtendedType(
20651 CompleteExtendedType&& x) noexcept
20652 {
20653 static_cast<void>(x);
20654 }
20655
20660 eProsima_user_DllExport CompleteExtendedType& operator =(
20661 const CompleteExtendedType& x)
20662 {
20663
20664 static_cast<void>(x);
20665
20666 return *this;
20667 }
20668
20673 eProsima_user_DllExport CompleteExtendedType& operator =(
20674 CompleteExtendedType&& x) noexcept
20675 {
20676
20677 static_cast<void>(x);
20678
20679 return *this;
20680 }
20681
20686 eProsima_user_DllExport bool operator ==(
20687 const CompleteExtendedType& x) const
20688 {
20689 static_cast<void>(x);
20690 return true;
20691 }
20692
20697 eProsima_user_DllExport bool operator !=(
20698 const CompleteExtendedType& x) const
20699 {
20700 return !(*this == x);
20701 }
20702
20703
20704
20705private:
20706
20707
20708};
20714{
20715public:
20716
20720 eProsima_user_DllExport CompleteTypeObject()
20721 {
20722 selected_member_ = 0x0000000b;
20723 member_destructor_ = [&]() {m_extended_type.~CompleteExtendedType();};
20725
20726 }
20727
20731 eProsima_user_DllExport ~CompleteTypeObject()
20732 {
20733 if (member_destructor_)
20734 {
20735 member_destructor_();
20736 }
20737 }
20738
20743 eProsima_user_DllExport CompleteTypeObject(
20744 const CompleteTypeObject& x)
20745 {
20746 m__d = x.m__d;
20747
20748 switch (x.selected_member_)
20749 {
20750 case 0x00000001:
20751 alias_type_() = x.m_alias_type;
20752 break;
20753
20754 case 0x00000002:
20755 annotation_type_() = x.m_annotation_type;
20756 break;
20757
20758 case 0x00000003:
20759 struct_type_() = x.m_struct_type;
20760 break;
20761
20762 case 0x00000004:
20763 union_type_() = x.m_union_type;
20764 break;
20765
20766 case 0x00000005:
20767 bitset_type_() = x.m_bitset_type;
20768 break;
20769
20770 case 0x00000006:
20771 sequence_type_() = x.m_sequence_type;
20772 break;
20773
20774 case 0x00000007:
20775 array_type_() = x.m_array_type;
20776 break;
20777
20778 case 0x00000008:
20779 map_type_() = x.m_map_type;
20780 break;
20781
20782 case 0x00000009:
20783 enumerated_type_() = x.m_enumerated_type;
20784 break;
20785
20786 case 0x0000000a:
20787 bitmask_type_() = x.m_bitmask_type;
20788 break;
20789
20790 case 0x0000000b:
20791 extended_type_() = x.m_extended_type;
20792 break;
20793
20794 }
20795 }
20796
20801 eProsima_user_DllExport CompleteTypeObject(
20802 CompleteTypeObject&& x) noexcept
20803 {
20804 m__d = x.m__d;
20805
20806 switch (x.selected_member_)
20807 {
20808 case 0x00000001:
20809 alias_type_() = std::move(x.m_alias_type);
20810 break;
20811
20812 case 0x00000002:
20813 annotation_type_() = std::move(x.m_annotation_type);
20814 break;
20815
20816 case 0x00000003:
20817 struct_type_() = std::move(x.m_struct_type);
20818 break;
20819
20820 case 0x00000004:
20821 union_type_() = std::move(x.m_union_type);
20822 break;
20823
20824 case 0x00000005:
20825 bitset_type_() = std::move(x.m_bitset_type);
20826 break;
20827
20828 case 0x00000006:
20829 sequence_type_() = std::move(x.m_sequence_type);
20830 break;
20831
20832 case 0x00000007:
20833 array_type_() = std::move(x.m_array_type);
20834 break;
20835
20836 case 0x00000008:
20837 map_type_() = std::move(x.m_map_type);
20838 break;
20839
20840 case 0x00000009:
20841 enumerated_type_() = std::move(x.m_enumerated_type);
20842 break;
20843
20844 case 0x0000000a:
20845 bitmask_type_() = std::move(x.m_bitmask_type);
20846 break;
20847
20848 case 0x0000000b:
20849 extended_type_() = std::move(x.m_extended_type);
20850 break;
20851
20852 }
20853 }
20854
20859 eProsima_user_DllExport CompleteTypeObject& operator =(
20860 const CompleteTypeObject& x)
20861 {
20862 m__d = x.m__d;
20863
20864 switch (x.selected_member_)
20865 {
20866 case 0x00000001:
20867 alias_type_() = x.m_alias_type;
20868 break;
20869
20870 case 0x00000002:
20871 annotation_type_() = x.m_annotation_type;
20872 break;
20873
20874 case 0x00000003:
20875 struct_type_() = x.m_struct_type;
20876 break;
20877
20878 case 0x00000004:
20879 union_type_() = x.m_union_type;
20880 break;
20881
20882 case 0x00000005:
20883 bitset_type_() = x.m_bitset_type;
20884 break;
20885
20886 case 0x00000006:
20887 sequence_type_() = x.m_sequence_type;
20888 break;
20889
20890 case 0x00000007:
20891 array_type_() = x.m_array_type;
20892 break;
20893
20894 case 0x00000008:
20895 map_type_() = x.m_map_type;
20896 break;
20897
20898 case 0x00000009:
20899 enumerated_type_() = x.m_enumerated_type;
20900 break;
20901
20902 case 0x0000000a:
20903 bitmask_type_() = x.m_bitmask_type;
20904 break;
20905
20906 case 0x0000000b:
20907 extended_type_() = x.m_extended_type;
20908 break;
20909
20910 }
20911
20912 return *this;
20913 }
20914
20919 eProsima_user_DllExport CompleteTypeObject& operator =(
20920 CompleteTypeObject&& x) noexcept
20921 {
20922 m__d = x.m__d;
20923
20924 switch (x.selected_member_)
20925 {
20926 case 0x00000001:
20927 alias_type_() = std::move(x.m_alias_type);
20928 break;
20929
20930 case 0x00000002:
20931 annotation_type_() = std::move(x.m_annotation_type);
20932 break;
20933
20934 case 0x00000003:
20935 struct_type_() = std::move(x.m_struct_type);
20936 break;
20937
20938 case 0x00000004:
20939 union_type_() = std::move(x.m_union_type);
20940 break;
20941
20942 case 0x00000005:
20943 bitset_type_() = std::move(x.m_bitset_type);
20944 break;
20945
20946 case 0x00000006:
20947 sequence_type_() = std::move(x.m_sequence_type);
20948 break;
20949
20950 case 0x00000007:
20951 array_type_() = std::move(x.m_array_type);
20952 break;
20953
20954 case 0x00000008:
20955 map_type_() = std::move(x.m_map_type);
20956 break;
20957
20958 case 0x00000009:
20959 enumerated_type_() = std::move(x.m_enumerated_type);
20960 break;
20961
20962 case 0x0000000a:
20963 bitmask_type_() = std::move(x.m_bitmask_type);
20964 break;
20965
20966 case 0x0000000b:
20967 extended_type_() = std::move(x.m_extended_type);
20968 break;
20969
20970 }
20971
20972 return *this;
20973 }
20974
20979 eProsima_user_DllExport bool operator ==(
20980 const CompleteTypeObject& x) const
20981 {
20982 bool ret_value {false};
20983
20984 if (x.selected_member_ == selected_member_)
20985 {
20986 if (0x0FFFFFFFu != selected_member_)
20987 {
20988 if (x.m__d == m__d)
20989 {
20990 switch (selected_member_)
20991 {
20992 case 0x00000001:
20993 ret_value = (x.m_alias_type == m_alias_type);
20994 break;
20995
20996 case 0x00000002:
20997 ret_value = (x.m_annotation_type == m_annotation_type);
20998 break;
20999
21000 case 0x00000003:
21001 ret_value = (x.m_struct_type == m_struct_type);
21002 break;
21003
21004 case 0x00000004:
21005 ret_value = (x.m_union_type == m_union_type);
21006 break;
21007
21008 case 0x00000005:
21009 ret_value = (x.m_bitset_type == m_bitset_type);
21010 break;
21011
21012 case 0x00000006:
21013 ret_value = (x.m_sequence_type == m_sequence_type);
21014 break;
21015
21016 case 0x00000007:
21017 ret_value = (x.m_array_type == m_array_type);
21018 break;
21019
21020 case 0x00000008:
21021 ret_value = (x.m_map_type == m_map_type);
21022 break;
21023
21024 case 0x00000009:
21025 ret_value = (x.m_enumerated_type == m_enumerated_type);
21026 break;
21027
21028 case 0x0000000a:
21029 ret_value = (x.m_bitmask_type == m_bitmask_type);
21030 break;
21031
21032 case 0x0000000b:
21033 ret_value = (x.m_extended_type == m_extended_type);
21034 break;
21035
21036 }
21037 }
21038 }
21039 else
21040 {
21041 ret_value = true;
21042 }
21043 }
21044
21045 return ret_value;
21046 }
21047
21052 eProsima_user_DllExport bool operator !=(
21053 const CompleteTypeObject& x) const
21054 {
21055 return !(*this == x);
21056 }
21057
21063 eProsima_user_DllExport void _d(
21064 uint8_t __d)
21065 {
21066 bool valid_discriminator = false;
21067
21068 switch (__d)
21069 {
21070 case TK_ALIAS:
21071 if (0x00000001 == selected_member_)
21072 {
21073 valid_discriminator = true;
21074 }
21075 break;
21076
21077 case TK_ANNOTATION:
21078 if (0x00000002 == selected_member_)
21079 {
21080 valid_discriminator = true;
21081 }
21082 break;
21083
21084 case TK_STRUCTURE:
21085 if (0x00000003 == selected_member_)
21086 {
21087 valid_discriminator = true;
21088 }
21089 break;
21090
21091 case TK_UNION:
21092 if (0x00000004 == selected_member_)
21093 {
21094 valid_discriminator = true;
21095 }
21096 break;
21097
21098 case TK_BITSET:
21099 if (0x00000005 == selected_member_)
21100 {
21101 valid_discriminator = true;
21102 }
21103 break;
21104
21105 case TK_SEQUENCE:
21106 if (0x00000006 == selected_member_)
21107 {
21108 valid_discriminator = true;
21109 }
21110 break;
21111
21112 case TK_ARRAY:
21113 if (0x00000007 == selected_member_)
21114 {
21115 valid_discriminator = true;
21116 }
21117 break;
21118
21119 case TK_MAP:
21120 if (0x00000008 == selected_member_)
21121 {
21122 valid_discriminator = true;
21123 }
21124 break;
21125
21126 case TK_ENUM:
21127 if (0x00000009 == selected_member_)
21128 {
21129 valid_discriminator = true;
21130 }
21131 break;
21132
21133 case TK_BITMASK:
21134 if (0x0000000a == selected_member_)
21135 {
21136 valid_discriminator = true;
21137 }
21138 break;
21139
21140 default:
21141 if (0x0000000b == selected_member_)
21142 {
21143 valid_discriminator = true;
21144 }
21145 break;
21146
21147 }
21148
21149 if (!valid_discriminator)
21150 {
21151 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
21152 }
21153
21154 m__d = __d;
21155 }
21156
21161 eProsima_user_DllExport uint8_t _d() const
21162 {
21163 return m__d;
21164 }
21165
21170 eProsima_user_DllExport void alias_type(
21171 const CompleteAliasType& _alias_type)
21172 {
21173 alias_type_() = _alias_type;
21174 m__d = TK_ALIAS;
21175 }
21176
21181 eProsima_user_DllExport void alias_type(
21182 CompleteAliasType&& _alias_type)
21183 {
21184 alias_type_() = _alias_type;
21185 m__d = TK_ALIAS;
21186 }
21187
21193 eProsima_user_DllExport const CompleteAliasType& alias_type() const
21194 {
21195 if (0x00000001 != selected_member_)
21196 {
21197 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21198 }
21199
21200 return m_alias_type;
21201 }
21202
21208 eProsima_user_DllExport CompleteAliasType& alias_type()
21209 {
21210 if (0x00000001 != selected_member_)
21211 {
21212 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21213 }
21214
21215 return m_alias_type;
21216 }
21217
21218
21223 eProsima_user_DllExport void annotation_type(
21224 const CompleteAnnotationType& _annotation_type)
21225 {
21226 annotation_type_() = _annotation_type;
21227 m__d = TK_ANNOTATION;
21228 }
21229
21234 eProsima_user_DllExport void annotation_type(
21235 CompleteAnnotationType&& _annotation_type)
21236 {
21237 annotation_type_() = _annotation_type;
21238 m__d = TK_ANNOTATION;
21239 }
21240
21246 eProsima_user_DllExport const CompleteAnnotationType& annotation_type() const
21247 {
21248 if (0x00000002 != selected_member_)
21249 {
21250 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21251 }
21252
21253 return m_annotation_type;
21254 }
21255
21261 eProsima_user_DllExport CompleteAnnotationType& annotation_type()
21262 {
21263 if (0x00000002 != selected_member_)
21264 {
21265 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21266 }
21267
21268 return m_annotation_type;
21269 }
21270
21271
21276 eProsima_user_DllExport void struct_type(
21277 const CompleteStructType& _struct_type)
21278 {
21279 struct_type_() = _struct_type;
21280 m__d = TK_STRUCTURE;
21281 }
21282
21287 eProsima_user_DllExport void struct_type(
21288 CompleteStructType&& _struct_type)
21289 {
21290 struct_type_() = _struct_type;
21291 m__d = TK_STRUCTURE;
21292 }
21293
21299 eProsima_user_DllExport const CompleteStructType& struct_type() const
21300 {
21301 if (0x00000003 != selected_member_)
21302 {
21303 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21304 }
21305
21306 return m_struct_type;
21307 }
21308
21314 eProsima_user_DllExport CompleteStructType& struct_type()
21315 {
21316 if (0x00000003 != selected_member_)
21317 {
21318 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21319 }
21320
21321 return m_struct_type;
21322 }
21323
21324
21329 eProsima_user_DllExport void union_type(
21330 const CompleteUnionType& _union_type)
21331 {
21332 union_type_() = _union_type;
21333 m__d = TK_UNION;
21334 }
21335
21340 eProsima_user_DllExport void union_type(
21341 CompleteUnionType&& _union_type)
21342 {
21343 union_type_() = _union_type;
21344 m__d = TK_UNION;
21345 }
21346
21352 eProsima_user_DllExport const CompleteUnionType& union_type() const
21353 {
21354 if (0x00000004 != selected_member_)
21355 {
21356 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21357 }
21358
21359 return m_union_type;
21360 }
21361
21367 eProsima_user_DllExport CompleteUnionType& union_type()
21368 {
21369 if (0x00000004 != selected_member_)
21370 {
21371 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21372 }
21373
21374 return m_union_type;
21375 }
21376
21377
21382 eProsima_user_DllExport void bitset_type(
21383 const CompleteBitsetType& _bitset_type)
21384 {
21385 bitset_type_() = _bitset_type;
21386 m__d = TK_BITSET;
21387 }
21388
21393 eProsima_user_DllExport void bitset_type(
21394 CompleteBitsetType&& _bitset_type)
21395 {
21396 bitset_type_() = _bitset_type;
21397 m__d = TK_BITSET;
21398 }
21399
21405 eProsima_user_DllExport const CompleteBitsetType& bitset_type() const
21406 {
21407 if (0x00000005 != selected_member_)
21408 {
21409 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21410 }
21411
21412 return m_bitset_type;
21413 }
21414
21420 eProsima_user_DllExport CompleteBitsetType& bitset_type()
21421 {
21422 if (0x00000005 != selected_member_)
21423 {
21424 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21425 }
21426
21427 return m_bitset_type;
21428 }
21429
21430
21435 eProsima_user_DllExport void sequence_type(
21436 const CompleteSequenceType& _sequence_type)
21437 {
21438 sequence_type_() = _sequence_type;
21439 m__d = TK_SEQUENCE;
21440 }
21441
21446 eProsima_user_DllExport void sequence_type(
21447 CompleteSequenceType&& _sequence_type)
21448 {
21449 sequence_type_() = _sequence_type;
21450 m__d = TK_SEQUENCE;
21451 }
21452
21458 eProsima_user_DllExport const CompleteSequenceType& sequence_type() const
21459 {
21460 if (0x00000006 != selected_member_)
21461 {
21462 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21463 }
21464
21465 return m_sequence_type;
21466 }
21467
21473 eProsima_user_DllExport CompleteSequenceType& sequence_type()
21474 {
21475 if (0x00000006 != selected_member_)
21476 {
21477 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21478 }
21479
21480 return m_sequence_type;
21481 }
21482
21483
21488 eProsima_user_DllExport void array_type(
21489 const CompleteArrayType& _array_type)
21490 {
21491 array_type_() = _array_type;
21492 m__d = TK_ARRAY;
21493 }
21494
21499 eProsima_user_DllExport void array_type(
21500 CompleteArrayType&& _array_type)
21501 {
21502 array_type_() = _array_type;
21503 m__d = TK_ARRAY;
21504 }
21505
21511 eProsima_user_DllExport const CompleteArrayType& array_type() const
21512 {
21513 if (0x00000007 != selected_member_)
21514 {
21515 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21516 }
21517
21518 return m_array_type;
21519 }
21520
21526 eProsima_user_DllExport CompleteArrayType& array_type()
21527 {
21528 if (0x00000007 != selected_member_)
21529 {
21530 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21531 }
21532
21533 return m_array_type;
21534 }
21535
21536
21541 eProsima_user_DllExport void map_type(
21542 const CompleteMapType& _map_type)
21543 {
21544 map_type_() = _map_type;
21545 m__d = TK_MAP;
21546 }
21547
21552 eProsima_user_DllExport void map_type(
21553 CompleteMapType&& _map_type)
21554 {
21555 map_type_() = _map_type;
21556 m__d = TK_MAP;
21557 }
21558
21564 eProsima_user_DllExport const CompleteMapType& map_type() const
21565 {
21566 if (0x00000008 != selected_member_)
21567 {
21568 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21569 }
21570
21571 return m_map_type;
21572 }
21573
21579 eProsima_user_DllExport CompleteMapType& map_type()
21580 {
21581 if (0x00000008 != selected_member_)
21582 {
21583 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21584 }
21585
21586 return m_map_type;
21587 }
21588
21589
21594 eProsima_user_DllExport void enumerated_type(
21595 const CompleteEnumeratedType& _enumerated_type)
21596 {
21597 enumerated_type_() = _enumerated_type;
21598 m__d = TK_ENUM;
21599 }
21600
21605 eProsima_user_DllExport void enumerated_type(
21606 CompleteEnumeratedType&& _enumerated_type)
21607 {
21608 enumerated_type_() = _enumerated_type;
21609 m__d = TK_ENUM;
21610 }
21611
21617 eProsima_user_DllExport const CompleteEnumeratedType& enumerated_type() const
21618 {
21619 if (0x00000009 != selected_member_)
21620 {
21621 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21622 }
21623
21624 return m_enumerated_type;
21625 }
21626
21632 eProsima_user_DllExport CompleteEnumeratedType& enumerated_type()
21633 {
21634 if (0x00000009 != selected_member_)
21635 {
21636 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21637 }
21638
21639 return m_enumerated_type;
21640 }
21641
21642
21647 eProsima_user_DllExport void bitmask_type(
21648 const CompleteBitmaskType& _bitmask_type)
21649 {
21650 bitmask_type_() = _bitmask_type;
21651 m__d = TK_BITMASK;
21652 }
21653
21658 eProsima_user_DllExport void bitmask_type(
21659 CompleteBitmaskType&& _bitmask_type)
21660 {
21661 bitmask_type_() = _bitmask_type;
21662 m__d = TK_BITMASK;
21663 }
21664
21670 eProsima_user_DllExport const CompleteBitmaskType& bitmask_type() const
21671 {
21672 if (0x0000000a != selected_member_)
21673 {
21674 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21675 }
21676
21677 return m_bitmask_type;
21678 }
21679
21685 eProsima_user_DllExport CompleteBitmaskType& bitmask_type()
21686 {
21687 if (0x0000000a != selected_member_)
21688 {
21689 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21690 }
21691
21692 return m_bitmask_type;
21693 }
21694
21695
21700 eProsima_user_DllExport void extended_type(
21701 const CompleteExtendedType& _extended_type)
21702 {
21703 extended_type_() = _extended_type;
21704 m__d = 127;
21705 }
21706
21711 eProsima_user_DllExport void extended_type(
21712 CompleteExtendedType&& _extended_type)
21713 {
21714 extended_type_() = _extended_type;
21715 m__d = 127;
21716 }
21717
21723 eProsima_user_DllExport const CompleteExtendedType& extended_type() const
21724 {
21725 if (0x0000000b != selected_member_)
21726 {
21727 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21728 }
21729
21730 return m_extended_type;
21731 }
21732
21738 eProsima_user_DllExport CompleteExtendedType& extended_type()
21739 {
21740 if (0x0000000b != selected_member_)
21741 {
21742 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
21743 }
21744
21745 return m_extended_type;
21746 }
21747
21748
21749
21750private:
21751
21752 CompleteAliasType& alias_type_()
21753 {
21754 if (0x00000001 != selected_member_)
21755 {
21756 if (member_destructor_)
21757 {
21758 member_destructor_();
21759 }
21760
21761 selected_member_ = 0x00000001;
21762 member_destructor_ = [&]() {m_alias_type.~CompleteAliasType();};
21763 new(&m_alias_type) CompleteAliasType();
21764
21765 }
21766
21767 return m_alias_type;
21768 }
21769
21770 CompleteAnnotationType& annotation_type_()
21771 {
21772 if (0x00000002 != selected_member_)
21773 {
21774 if (member_destructor_)
21775 {
21776 member_destructor_();
21777 }
21778
21779 selected_member_ = 0x00000002;
21780 member_destructor_ = [&]() {m_annotation_type.~CompleteAnnotationType();};
21781 new(&m_annotation_type) CompleteAnnotationType();
21782
21783 }
21784
21785 return m_annotation_type;
21786 }
21787
21788 CompleteStructType& struct_type_()
21789 {
21790 if (0x00000003 != selected_member_)
21791 {
21792 if (member_destructor_)
21793 {
21794 member_destructor_();
21795 }
21796
21797 selected_member_ = 0x00000003;
21798 member_destructor_ = [&]() {m_struct_type.~CompleteStructType();};
21799 new(&m_struct_type) CompleteStructType();
21800
21801 }
21802
21803 return m_struct_type;
21804 }
21805
21806 CompleteUnionType& union_type_()
21807 {
21808 if (0x00000004 != selected_member_)
21809 {
21810 if (member_destructor_)
21811 {
21812 member_destructor_();
21813 }
21814
21815 selected_member_ = 0x00000004;
21816 member_destructor_ = [&]() {m_union_type.~CompleteUnionType();};
21817 new(&m_union_type) CompleteUnionType();
21818
21819 }
21820
21821 return m_union_type;
21822 }
21823
21824 CompleteBitsetType& bitset_type_()
21825 {
21826 if (0x00000005 != selected_member_)
21827 {
21828 if (member_destructor_)
21829 {
21830 member_destructor_();
21831 }
21832
21833 selected_member_ = 0x00000005;
21834 member_destructor_ = [&]() {m_bitset_type.~CompleteBitsetType();};
21835 new(&m_bitset_type) CompleteBitsetType();
21836
21837 }
21838
21839 return m_bitset_type;
21840 }
21841
21842 CompleteSequenceType& sequence_type_()
21843 {
21844 if (0x00000006 != selected_member_)
21845 {
21846 if (member_destructor_)
21847 {
21848 member_destructor_();
21849 }
21850
21851 selected_member_ = 0x00000006;
21852 member_destructor_ = [&]() {m_sequence_type.~CompleteSequenceType();};
21853 new(&m_sequence_type) CompleteSequenceType();
21854
21855 }
21856
21857 return m_sequence_type;
21858 }
21859
21860 CompleteArrayType& array_type_()
21861 {
21862 if (0x00000007 != selected_member_)
21863 {
21864 if (member_destructor_)
21865 {
21866 member_destructor_();
21867 }
21868
21869 selected_member_ = 0x00000007;
21870 member_destructor_ = [&]() {m_array_type.~CompleteArrayType();};
21871 new(&m_array_type) CompleteArrayType();
21872
21873 }
21874
21875 return m_array_type;
21876 }
21877
21878 CompleteMapType& map_type_()
21879 {
21880 if (0x00000008 != selected_member_)
21881 {
21882 if (member_destructor_)
21883 {
21884 member_destructor_();
21885 }
21886
21887 selected_member_ = 0x00000008;
21888 member_destructor_ = [&]() {m_map_type.~CompleteMapType();};
21889 new(&m_map_type) CompleteMapType();
21890
21891 }
21892
21893 return m_map_type;
21894 }
21895
21896 CompleteEnumeratedType& enumerated_type_()
21897 {
21898 if (0x00000009 != selected_member_)
21899 {
21900 if (member_destructor_)
21901 {
21902 member_destructor_();
21903 }
21904
21905 selected_member_ = 0x00000009;
21906 member_destructor_ = [&]() {m_enumerated_type.~CompleteEnumeratedType();};
21907 new(&m_enumerated_type) CompleteEnumeratedType();
21908
21909 }
21910
21911 return m_enumerated_type;
21912 }
21913
21914 CompleteBitmaskType& bitmask_type_()
21915 {
21916 if (0x0000000a != selected_member_)
21917 {
21918 if (member_destructor_)
21919 {
21920 member_destructor_();
21921 }
21922
21923 selected_member_ = 0x0000000a;
21924 member_destructor_ = [&]() {m_bitmask_type.~CompleteBitmaskType();};
21925 new(&m_bitmask_type) CompleteBitmaskType();
21926
21927 }
21928
21929 return m_bitmask_type;
21930 }
21931
21932 CompleteExtendedType& extended_type_()
21933 {
21934 if (0x0000000b != selected_member_)
21935 {
21936 if (member_destructor_)
21937 {
21938 member_destructor_();
21939 }
21940
21941 selected_member_ = 0x0000000b;
21942 member_destructor_ = [&]() {m_extended_type.~CompleteExtendedType();};
21943 new(&m_extended_type) CompleteExtendedType();
21944
21945 }
21946
21947 return m_extended_type;
21948 }
21949
21950
21951 uint8_t m__d {TK_NONE};
21952
21953 union
21954 {
21966 };
21967
21968 uint32_t selected_member_ {0x0FFFFFFFu};
21969
21970 std::function<void()> member_destructor_;
21971};
21977{
21978public:
21979
21983 eProsima_user_DllExport MinimalExtendedType()
21984 {
21985 }
21986
21990 eProsima_user_DllExport ~MinimalExtendedType()
21991 {
21992 }
21993
21998 eProsima_user_DllExport MinimalExtendedType(
21999 const MinimalExtendedType& x)
22000 {
22001 static_cast<void>(x);
22002 }
22003
22008 eProsima_user_DllExport MinimalExtendedType(
22009 MinimalExtendedType&& x) noexcept
22010 {
22011 static_cast<void>(x);
22012 }
22013
22018 eProsima_user_DllExport MinimalExtendedType& operator =(
22019 const MinimalExtendedType& x)
22020 {
22021
22022 static_cast<void>(x);
22023
22024 return *this;
22025 }
22026
22031 eProsima_user_DllExport MinimalExtendedType& operator =(
22032 MinimalExtendedType&& x) noexcept
22033 {
22034
22035 static_cast<void>(x);
22036
22037 return *this;
22038 }
22039
22044 eProsima_user_DllExport bool operator ==(
22045 const MinimalExtendedType& x) const
22046 {
22047 static_cast<void>(x);
22048 return true;
22049 }
22050
22055 eProsima_user_DllExport bool operator !=(
22056 const MinimalExtendedType& x) const
22057 {
22058 return !(*this == x);
22059 }
22060
22061
22062
22063private:
22064
22065
22066};
22072{
22073public:
22074
22078 eProsima_user_DllExport MinimalTypeObject()
22079 {
22080 selected_member_ = 0x0000000b;
22081 member_destructor_ = [&]() {m_extended_type.~MinimalExtendedType();};
22083
22084 }
22085
22089 eProsima_user_DllExport ~MinimalTypeObject()
22090 {
22091 if (member_destructor_)
22092 {
22093 member_destructor_();
22094 }
22095 }
22096
22101 eProsima_user_DllExport MinimalTypeObject(
22102 const MinimalTypeObject& x)
22103 {
22104 m__d = x.m__d;
22105
22106 switch (x.selected_member_)
22107 {
22108 case 0x00000001:
22109 alias_type_() = x.m_alias_type;
22110 break;
22111
22112 case 0x00000002:
22113 annotation_type_() = x.m_annotation_type;
22114 break;
22115
22116 case 0x00000003:
22117 struct_type_() = x.m_struct_type;
22118 break;
22119
22120 case 0x00000004:
22121 union_type_() = x.m_union_type;
22122 break;
22123
22124 case 0x00000005:
22125 bitset_type_() = x.m_bitset_type;
22126 break;
22127
22128 case 0x00000006:
22129 sequence_type_() = x.m_sequence_type;
22130 break;
22131
22132 case 0x00000007:
22133 array_type_() = x.m_array_type;
22134 break;
22135
22136 case 0x00000008:
22137 map_type_() = x.m_map_type;
22138 break;
22139
22140 case 0x00000009:
22141 enumerated_type_() = x.m_enumerated_type;
22142 break;
22143
22144 case 0x0000000a:
22145 bitmask_type_() = x.m_bitmask_type;
22146 break;
22147
22148 case 0x0000000b:
22149 extended_type_() = x.m_extended_type;
22150 break;
22151
22152 }
22153 }
22154
22159 eProsima_user_DllExport MinimalTypeObject(
22160 MinimalTypeObject&& x) noexcept
22161 {
22162 m__d = x.m__d;
22163
22164 switch (x.selected_member_)
22165 {
22166 case 0x00000001:
22167 alias_type_() = std::move(x.m_alias_type);
22168 break;
22169
22170 case 0x00000002:
22171 annotation_type_() = std::move(x.m_annotation_type);
22172 break;
22173
22174 case 0x00000003:
22175 struct_type_() = std::move(x.m_struct_type);
22176 break;
22177
22178 case 0x00000004:
22179 union_type_() = std::move(x.m_union_type);
22180 break;
22181
22182 case 0x00000005:
22183 bitset_type_() = std::move(x.m_bitset_type);
22184 break;
22185
22186 case 0x00000006:
22187 sequence_type_() = std::move(x.m_sequence_type);
22188 break;
22189
22190 case 0x00000007:
22191 array_type_() = std::move(x.m_array_type);
22192 break;
22193
22194 case 0x00000008:
22195 map_type_() = std::move(x.m_map_type);
22196 break;
22197
22198 case 0x00000009:
22199 enumerated_type_() = std::move(x.m_enumerated_type);
22200 break;
22201
22202 case 0x0000000a:
22203 bitmask_type_() = std::move(x.m_bitmask_type);
22204 break;
22205
22206 case 0x0000000b:
22207 extended_type_() = std::move(x.m_extended_type);
22208 break;
22209
22210 }
22211 }
22212
22217 eProsima_user_DllExport MinimalTypeObject& operator =(
22218 const MinimalTypeObject& x)
22219 {
22220 m__d = x.m__d;
22221
22222 switch (x.selected_member_)
22223 {
22224 case 0x00000001:
22225 alias_type_() = x.m_alias_type;
22226 break;
22227
22228 case 0x00000002:
22229 annotation_type_() = x.m_annotation_type;
22230 break;
22231
22232 case 0x00000003:
22233 struct_type_() = x.m_struct_type;
22234 break;
22235
22236 case 0x00000004:
22237 union_type_() = x.m_union_type;
22238 break;
22239
22240 case 0x00000005:
22241 bitset_type_() = x.m_bitset_type;
22242 break;
22243
22244 case 0x00000006:
22245 sequence_type_() = x.m_sequence_type;
22246 break;
22247
22248 case 0x00000007:
22249 array_type_() = x.m_array_type;
22250 break;
22251
22252 case 0x00000008:
22253 map_type_() = x.m_map_type;
22254 break;
22255
22256 case 0x00000009:
22257 enumerated_type_() = x.m_enumerated_type;
22258 break;
22259
22260 case 0x0000000a:
22261 bitmask_type_() = x.m_bitmask_type;
22262 break;
22263
22264 case 0x0000000b:
22265 extended_type_() = x.m_extended_type;
22266 break;
22267
22268 }
22269
22270 return *this;
22271 }
22272
22277 eProsima_user_DllExport MinimalTypeObject& operator =(
22278 MinimalTypeObject&& x) noexcept
22279 {
22280 m__d = x.m__d;
22281
22282 switch (x.selected_member_)
22283 {
22284 case 0x00000001:
22285 alias_type_() = std::move(x.m_alias_type);
22286 break;
22287
22288 case 0x00000002:
22289 annotation_type_() = std::move(x.m_annotation_type);
22290 break;
22291
22292 case 0x00000003:
22293 struct_type_() = std::move(x.m_struct_type);
22294 break;
22295
22296 case 0x00000004:
22297 union_type_() = std::move(x.m_union_type);
22298 break;
22299
22300 case 0x00000005:
22301 bitset_type_() = std::move(x.m_bitset_type);
22302 break;
22303
22304 case 0x00000006:
22305 sequence_type_() = std::move(x.m_sequence_type);
22306 break;
22307
22308 case 0x00000007:
22309 array_type_() = std::move(x.m_array_type);
22310 break;
22311
22312 case 0x00000008:
22313 map_type_() = std::move(x.m_map_type);
22314 break;
22315
22316 case 0x00000009:
22317 enumerated_type_() = std::move(x.m_enumerated_type);
22318 break;
22319
22320 case 0x0000000a:
22321 bitmask_type_() = std::move(x.m_bitmask_type);
22322 break;
22323
22324 case 0x0000000b:
22325 extended_type_() = std::move(x.m_extended_type);
22326 break;
22327
22328 }
22329
22330 return *this;
22331 }
22332
22337 eProsima_user_DllExport bool operator ==(
22338 const MinimalTypeObject& x) const
22339 {
22340 bool ret_value {false};
22341
22342 if (x.selected_member_ == selected_member_)
22343 {
22344 if (0x0FFFFFFFu != selected_member_)
22345 {
22346 if (x.m__d == m__d)
22347 {
22348 switch (selected_member_)
22349 {
22350 case 0x00000001:
22351 ret_value = (x.m_alias_type == m_alias_type);
22352 break;
22353
22354 case 0x00000002:
22355 ret_value = (x.m_annotation_type == m_annotation_type);
22356 break;
22357
22358 case 0x00000003:
22359 ret_value = (x.m_struct_type == m_struct_type);
22360 break;
22361
22362 case 0x00000004:
22363 ret_value = (x.m_union_type == m_union_type);
22364 break;
22365
22366 case 0x00000005:
22367 ret_value = (x.m_bitset_type == m_bitset_type);
22368 break;
22369
22370 case 0x00000006:
22371 ret_value = (x.m_sequence_type == m_sequence_type);
22372 break;
22373
22374 case 0x00000007:
22375 ret_value = (x.m_array_type == m_array_type);
22376 break;
22377
22378 case 0x00000008:
22379 ret_value = (x.m_map_type == m_map_type);
22380 break;
22381
22382 case 0x00000009:
22383 ret_value = (x.m_enumerated_type == m_enumerated_type);
22384 break;
22385
22386 case 0x0000000a:
22387 ret_value = (x.m_bitmask_type == m_bitmask_type);
22388 break;
22389
22390 case 0x0000000b:
22391 ret_value = (x.m_extended_type == m_extended_type);
22392 break;
22393
22394 }
22395 }
22396 }
22397 else
22398 {
22399 ret_value = true;
22400 }
22401 }
22402
22403 return ret_value;
22404 }
22405
22410 eProsima_user_DllExport bool operator !=(
22411 const MinimalTypeObject& x) const
22412 {
22413 return !(*this == x);
22414 }
22415
22421 eProsima_user_DllExport void _d(
22422 uint8_t __d)
22423 {
22424 bool valid_discriminator = false;
22425
22426 switch (__d)
22427 {
22428 case TK_ALIAS:
22429 if (0x00000001 == selected_member_)
22430 {
22431 valid_discriminator = true;
22432 }
22433 break;
22434
22435 case TK_ANNOTATION:
22436 if (0x00000002 == selected_member_)
22437 {
22438 valid_discriminator = true;
22439 }
22440 break;
22441
22442 case TK_STRUCTURE:
22443 if (0x00000003 == selected_member_)
22444 {
22445 valid_discriminator = true;
22446 }
22447 break;
22448
22449 case TK_UNION:
22450 if (0x00000004 == selected_member_)
22451 {
22452 valid_discriminator = true;
22453 }
22454 break;
22455
22456 case TK_BITSET:
22457 if (0x00000005 == selected_member_)
22458 {
22459 valid_discriminator = true;
22460 }
22461 break;
22462
22463 case TK_SEQUENCE:
22464 if (0x00000006 == selected_member_)
22465 {
22466 valid_discriminator = true;
22467 }
22468 break;
22469
22470 case TK_ARRAY:
22471 if (0x00000007 == selected_member_)
22472 {
22473 valid_discriminator = true;
22474 }
22475 break;
22476
22477 case TK_MAP:
22478 if (0x00000008 == selected_member_)
22479 {
22480 valid_discriminator = true;
22481 }
22482 break;
22483
22484 case TK_ENUM:
22485 if (0x00000009 == selected_member_)
22486 {
22487 valid_discriminator = true;
22488 }
22489 break;
22490
22491 case TK_BITMASK:
22492 if (0x0000000a == selected_member_)
22493 {
22494 valid_discriminator = true;
22495 }
22496 break;
22497
22498 default:
22499 if (0x0000000b == selected_member_)
22500 {
22501 valid_discriminator = true;
22502 }
22503 break;
22504
22505 }
22506
22507 if (!valid_discriminator)
22508 {
22509 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
22510 }
22511
22512 m__d = __d;
22513 }
22514
22519 eProsima_user_DllExport uint8_t _d() const
22520 {
22521 return m__d;
22522 }
22523
22528 eProsima_user_DllExport void alias_type(
22529 const MinimalAliasType& _alias_type)
22530 {
22531 alias_type_() = _alias_type;
22532 m__d = TK_ALIAS;
22533 }
22534
22539 eProsima_user_DllExport void alias_type(
22540 MinimalAliasType&& _alias_type)
22541 {
22542 alias_type_() = _alias_type;
22543 m__d = TK_ALIAS;
22544 }
22545
22551 eProsima_user_DllExport const MinimalAliasType& alias_type() const
22552 {
22553 if (0x00000001 != selected_member_)
22554 {
22555 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22556 }
22557
22558 return m_alias_type;
22559 }
22560
22566 eProsima_user_DllExport MinimalAliasType& alias_type()
22567 {
22568 if (0x00000001 != selected_member_)
22569 {
22570 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22571 }
22572
22573 return m_alias_type;
22574 }
22575
22576
22581 eProsima_user_DllExport void annotation_type(
22582 const MinimalAnnotationType& _annotation_type)
22583 {
22584 annotation_type_() = _annotation_type;
22585 m__d = TK_ANNOTATION;
22586 }
22587
22592 eProsima_user_DllExport void annotation_type(
22593 MinimalAnnotationType&& _annotation_type)
22594 {
22595 annotation_type_() = _annotation_type;
22596 m__d = TK_ANNOTATION;
22597 }
22598
22604 eProsima_user_DllExport const MinimalAnnotationType& annotation_type() const
22605 {
22606 if (0x00000002 != selected_member_)
22607 {
22608 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22609 }
22610
22611 return m_annotation_type;
22612 }
22613
22619 eProsima_user_DllExport MinimalAnnotationType& annotation_type()
22620 {
22621 if (0x00000002 != selected_member_)
22622 {
22623 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22624 }
22625
22626 return m_annotation_type;
22627 }
22628
22629
22634 eProsima_user_DllExport void struct_type(
22635 const MinimalStructType& _struct_type)
22636 {
22637 struct_type_() = _struct_type;
22638 m__d = TK_STRUCTURE;
22639 }
22640
22645 eProsima_user_DllExport void struct_type(
22646 MinimalStructType&& _struct_type)
22647 {
22648 struct_type_() = _struct_type;
22649 m__d = TK_STRUCTURE;
22650 }
22651
22657 eProsima_user_DllExport const MinimalStructType& struct_type() const
22658 {
22659 if (0x00000003 != selected_member_)
22660 {
22661 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22662 }
22663
22664 return m_struct_type;
22665 }
22666
22672 eProsima_user_DllExport MinimalStructType& struct_type()
22673 {
22674 if (0x00000003 != selected_member_)
22675 {
22676 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22677 }
22678
22679 return m_struct_type;
22680 }
22681
22682
22687 eProsima_user_DllExport void union_type(
22688 const MinimalUnionType& _union_type)
22689 {
22690 union_type_() = _union_type;
22691 m__d = TK_UNION;
22692 }
22693
22698 eProsima_user_DllExport void union_type(
22699 MinimalUnionType&& _union_type)
22700 {
22701 union_type_() = _union_type;
22702 m__d = TK_UNION;
22703 }
22704
22710 eProsima_user_DllExport const MinimalUnionType& union_type() const
22711 {
22712 if (0x00000004 != selected_member_)
22713 {
22714 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22715 }
22716
22717 return m_union_type;
22718 }
22719
22725 eProsima_user_DllExport MinimalUnionType& union_type()
22726 {
22727 if (0x00000004 != selected_member_)
22728 {
22729 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22730 }
22731
22732 return m_union_type;
22733 }
22734
22735
22740 eProsima_user_DllExport void bitset_type(
22741 const MinimalBitsetType& _bitset_type)
22742 {
22743 bitset_type_() = _bitset_type;
22744 m__d = TK_BITSET;
22745 }
22746
22751 eProsima_user_DllExport void bitset_type(
22752 MinimalBitsetType&& _bitset_type)
22753 {
22754 bitset_type_() = _bitset_type;
22755 m__d = TK_BITSET;
22756 }
22757
22763 eProsima_user_DllExport const MinimalBitsetType& bitset_type() const
22764 {
22765 if (0x00000005 != selected_member_)
22766 {
22767 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22768 }
22769
22770 return m_bitset_type;
22771 }
22772
22778 eProsima_user_DllExport MinimalBitsetType& bitset_type()
22779 {
22780 if (0x00000005 != selected_member_)
22781 {
22782 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22783 }
22784
22785 return m_bitset_type;
22786 }
22787
22788
22793 eProsima_user_DllExport void sequence_type(
22794 const MinimalSequenceType& _sequence_type)
22795 {
22796 sequence_type_() = _sequence_type;
22797 m__d = TK_SEQUENCE;
22798 }
22799
22804 eProsima_user_DllExport void sequence_type(
22805 MinimalSequenceType&& _sequence_type)
22806 {
22807 sequence_type_() = _sequence_type;
22808 m__d = TK_SEQUENCE;
22809 }
22810
22816 eProsima_user_DllExport const MinimalSequenceType& sequence_type() const
22817 {
22818 if (0x00000006 != selected_member_)
22819 {
22820 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22821 }
22822
22823 return m_sequence_type;
22824 }
22825
22831 eProsima_user_DllExport MinimalSequenceType& sequence_type()
22832 {
22833 if (0x00000006 != selected_member_)
22834 {
22835 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22836 }
22837
22838 return m_sequence_type;
22839 }
22840
22841
22846 eProsima_user_DllExport void array_type(
22847 const MinimalArrayType& _array_type)
22848 {
22849 array_type_() = _array_type;
22850 m__d = TK_ARRAY;
22851 }
22852
22857 eProsima_user_DllExport void array_type(
22858 MinimalArrayType&& _array_type)
22859 {
22860 array_type_() = _array_type;
22861 m__d = TK_ARRAY;
22862 }
22863
22869 eProsima_user_DllExport const MinimalArrayType& array_type() const
22870 {
22871 if (0x00000007 != selected_member_)
22872 {
22873 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22874 }
22875
22876 return m_array_type;
22877 }
22878
22884 eProsima_user_DllExport MinimalArrayType& array_type()
22885 {
22886 if (0x00000007 != selected_member_)
22887 {
22888 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22889 }
22890
22891 return m_array_type;
22892 }
22893
22894
22899 eProsima_user_DllExport void map_type(
22900 const MinimalMapType& _map_type)
22901 {
22902 map_type_() = _map_type;
22903 m__d = TK_MAP;
22904 }
22905
22910 eProsima_user_DllExport void map_type(
22911 MinimalMapType&& _map_type)
22912 {
22913 map_type_() = _map_type;
22914 m__d = TK_MAP;
22915 }
22916
22922 eProsima_user_DllExport const MinimalMapType& map_type() const
22923 {
22924 if (0x00000008 != selected_member_)
22925 {
22926 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22927 }
22928
22929 return m_map_type;
22930 }
22931
22937 eProsima_user_DllExport MinimalMapType& map_type()
22938 {
22939 if (0x00000008 != selected_member_)
22940 {
22941 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22942 }
22943
22944 return m_map_type;
22945 }
22946
22947
22952 eProsima_user_DllExport void enumerated_type(
22953 const MinimalEnumeratedType& _enumerated_type)
22954 {
22955 enumerated_type_() = _enumerated_type;
22956 m__d = TK_ENUM;
22957 }
22958
22963 eProsima_user_DllExport void enumerated_type(
22964 MinimalEnumeratedType&& _enumerated_type)
22965 {
22966 enumerated_type_() = _enumerated_type;
22967 m__d = TK_ENUM;
22968 }
22969
22975 eProsima_user_DllExport const MinimalEnumeratedType& enumerated_type() const
22976 {
22977 if (0x00000009 != selected_member_)
22978 {
22979 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22980 }
22981
22982 return m_enumerated_type;
22983 }
22984
22990 eProsima_user_DllExport MinimalEnumeratedType& enumerated_type()
22991 {
22992 if (0x00000009 != selected_member_)
22993 {
22994 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
22995 }
22996
22997 return m_enumerated_type;
22998 }
22999
23000
23005 eProsima_user_DllExport void bitmask_type(
23006 const MinimalBitmaskType& _bitmask_type)
23007 {
23008 bitmask_type_() = _bitmask_type;
23009 m__d = TK_BITMASK;
23010 }
23011
23016 eProsima_user_DllExport void bitmask_type(
23017 MinimalBitmaskType&& _bitmask_type)
23018 {
23019 bitmask_type_() = _bitmask_type;
23020 m__d = TK_BITMASK;
23021 }
23022
23028 eProsima_user_DllExport const MinimalBitmaskType& bitmask_type() const
23029 {
23030 if (0x0000000a != selected_member_)
23031 {
23032 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23033 }
23034
23035 return m_bitmask_type;
23036 }
23037
23043 eProsima_user_DllExport MinimalBitmaskType& bitmask_type()
23044 {
23045 if (0x0000000a != selected_member_)
23046 {
23047 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23048 }
23049
23050 return m_bitmask_type;
23051 }
23052
23053
23058 eProsima_user_DllExport void extended_type(
23059 const MinimalExtendedType& _extended_type)
23060 {
23061 extended_type_() = _extended_type;
23062 m__d = 127;
23063 }
23064
23069 eProsima_user_DllExport void extended_type(
23070 MinimalExtendedType&& _extended_type)
23071 {
23072 extended_type_() = _extended_type;
23073 m__d = 127;
23074 }
23075
23081 eProsima_user_DllExport const MinimalExtendedType& extended_type() const
23082 {
23083 if (0x0000000b != selected_member_)
23084 {
23085 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23086 }
23087
23088 return m_extended_type;
23089 }
23090
23096 eProsima_user_DllExport MinimalExtendedType& extended_type()
23097 {
23098 if (0x0000000b != selected_member_)
23099 {
23100 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23101 }
23102
23103 return m_extended_type;
23104 }
23105
23106
23107
23108private:
23109
23110 MinimalAliasType& alias_type_()
23111 {
23112 if (0x00000001 != selected_member_)
23113 {
23114 if (member_destructor_)
23115 {
23116 member_destructor_();
23117 }
23118
23119 selected_member_ = 0x00000001;
23120 member_destructor_ = [&]() {m_alias_type.~MinimalAliasType();};
23121 new(&m_alias_type) MinimalAliasType();
23122
23123 }
23124
23125 return m_alias_type;
23126 }
23127
23128 MinimalAnnotationType& annotation_type_()
23129 {
23130 if (0x00000002 != selected_member_)
23131 {
23132 if (member_destructor_)
23133 {
23134 member_destructor_();
23135 }
23136
23137 selected_member_ = 0x00000002;
23138 member_destructor_ = [&]() {m_annotation_type.~MinimalAnnotationType();};
23139 new(&m_annotation_type) MinimalAnnotationType();
23140
23141 }
23142
23143 return m_annotation_type;
23144 }
23145
23146 MinimalStructType& struct_type_()
23147 {
23148 if (0x00000003 != selected_member_)
23149 {
23150 if (member_destructor_)
23151 {
23152 member_destructor_();
23153 }
23154
23155 selected_member_ = 0x00000003;
23156 member_destructor_ = [&]() {m_struct_type.~MinimalStructType();};
23157 new(&m_struct_type) MinimalStructType();
23158
23159 }
23160
23161 return m_struct_type;
23162 }
23163
23164 MinimalUnionType& union_type_()
23165 {
23166 if (0x00000004 != selected_member_)
23167 {
23168 if (member_destructor_)
23169 {
23170 member_destructor_();
23171 }
23172
23173 selected_member_ = 0x00000004;
23174 member_destructor_ = [&]() {m_union_type.~MinimalUnionType();};
23175 new(&m_union_type) MinimalUnionType();
23176
23177 }
23178
23179 return m_union_type;
23180 }
23181
23182 MinimalBitsetType& bitset_type_()
23183 {
23184 if (0x00000005 != selected_member_)
23185 {
23186 if (member_destructor_)
23187 {
23188 member_destructor_();
23189 }
23190
23191 selected_member_ = 0x00000005;
23192 member_destructor_ = [&]() {m_bitset_type.~MinimalBitsetType();};
23193 new(&m_bitset_type) MinimalBitsetType();
23194
23195 }
23196
23197 return m_bitset_type;
23198 }
23199
23200 MinimalSequenceType& sequence_type_()
23201 {
23202 if (0x00000006 != selected_member_)
23203 {
23204 if (member_destructor_)
23205 {
23206 member_destructor_();
23207 }
23208
23209 selected_member_ = 0x00000006;
23210 member_destructor_ = [&]() {m_sequence_type.~MinimalSequenceType();};
23211 new(&m_sequence_type) MinimalSequenceType();
23212
23213 }
23214
23215 return m_sequence_type;
23216 }
23217
23218 MinimalArrayType& array_type_()
23219 {
23220 if (0x00000007 != selected_member_)
23221 {
23222 if (member_destructor_)
23223 {
23224 member_destructor_();
23225 }
23226
23227 selected_member_ = 0x00000007;
23228 member_destructor_ = [&]() {m_array_type.~MinimalArrayType();};
23229 new(&m_array_type) MinimalArrayType();
23230
23231 }
23232
23233 return m_array_type;
23234 }
23235
23236 MinimalMapType& map_type_()
23237 {
23238 if (0x00000008 != selected_member_)
23239 {
23240 if (member_destructor_)
23241 {
23242 member_destructor_();
23243 }
23244
23245 selected_member_ = 0x00000008;
23246 member_destructor_ = [&]() {m_map_type.~MinimalMapType();};
23247 new(&m_map_type) MinimalMapType();
23248
23249 }
23250
23251 return m_map_type;
23252 }
23253
23254 MinimalEnumeratedType& enumerated_type_()
23255 {
23256 if (0x00000009 != selected_member_)
23257 {
23258 if (member_destructor_)
23259 {
23260 member_destructor_();
23261 }
23262
23263 selected_member_ = 0x00000009;
23264 member_destructor_ = [&]() {m_enumerated_type.~MinimalEnumeratedType();};
23265 new(&m_enumerated_type) MinimalEnumeratedType();
23266
23267 }
23268
23269 return m_enumerated_type;
23270 }
23271
23272 MinimalBitmaskType& bitmask_type_()
23273 {
23274 if (0x0000000a != selected_member_)
23275 {
23276 if (member_destructor_)
23277 {
23278 member_destructor_();
23279 }
23280
23281 selected_member_ = 0x0000000a;
23282 member_destructor_ = [&]() {m_bitmask_type.~MinimalBitmaskType();};
23283 new(&m_bitmask_type) MinimalBitmaskType();
23284
23285 }
23286
23287 return m_bitmask_type;
23288 }
23289
23290 MinimalExtendedType& extended_type_()
23291 {
23292 if (0x0000000b != selected_member_)
23293 {
23294 if (member_destructor_)
23295 {
23296 member_destructor_();
23297 }
23298
23299 selected_member_ = 0x0000000b;
23300 member_destructor_ = [&]() {m_extended_type.~MinimalExtendedType();};
23301 new(&m_extended_type) MinimalExtendedType();
23302
23303 }
23304
23305 return m_extended_type;
23306 }
23307
23308
23309 uint8_t m__d {TK_NONE};
23310
23311 union
23312 {
23324 };
23325
23326 uint32_t selected_member_ {0x0FFFFFFFu};
23327
23328 std::function<void()> member_destructor_;
23329};
23335{
23336public:
23337
23341 eProsima_user_DllExport TypeObject()
23342 {
23343 }
23344
23348 eProsima_user_DllExport ~TypeObject()
23349 {
23350 if (member_destructor_)
23351 {
23352 member_destructor_();
23353 }
23354 }
23355
23360 eProsima_user_DllExport TypeObject(
23361 const TypeObject& x)
23362 {
23363 m__d = x.m__d;
23364
23365 switch (x.selected_member_)
23366 {
23367 case 0x00000001:
23368 complete_() = x.m_complete;
23369 break;
23370
23371 case 0x00000002:
23372 minimal_() = x.m_minimal;
23373 break;
23374
23375 }
23376 }
23377
23382 eProsima_user_DllExport TypeObject(
23383 TypeObject&& x) noexcept
23384 {
23385 m__d = x.m__d;
23386
23387 switch (x.selected_member_)
23388 {
23389 case 0x00000001:
23390 complete_() = std::move(x.m_complete);
23391 break;
23392
23393 case 0x00000002:
23394 minimal_() = std::move(x.m_minimal);
23395 break;
23396
23397 }
23398 }
23399
23404 eProsima_user_DllExport TypeObject& operator =(
23405 const TypeObject& x)
23406 {
23407 m__d = x.m__d;
23408
23409 switch (x.selected_member_)
23410 {
23411 case 0x00000001:
23412 complete_() = x.m_complete;
23413 break;
23414
23415 case 0x00000002:
23416 minimal_() = x.m_minimal;
23417 break;
23418
23419 }
23420
23421 return *this;
23422 }
23423
23428 eProsima_user_DllExport TypeObject& operator =(
23429 TypeObject&& x) noexcept
23430 {
23431 m__d = x.m__d;
23432
23433 switch (x.selected_member_)
23434 {
23435 case 0x00000001:
23436 complete_() = std::move(x.m_complete);
23437 break;
23438
23439 case 0x00000002:
23440 minimal_() = std::move(x.m_minimal);
23441 break;
23442
23443 }
23444
23445 return *this;
23446 }
23447
23452 eProsima_user_DllExport bool operator ==(
23453 const TypeObject& x) const
23454 {
23455 bool ret_value {false};
23456
23457 if (x.selected_member_ == selected_member_)
23458 {
23459 if (0x0FFFFFFFu != selected_member_)
23460 {
23461 if (x.m__d == m__d)
23462 {
23463 switch (selected_member_)
23464 {
23465 case 0x00000001:
23466 ret_value = (x.m_complete == m_complete);
23467 break;
23468
23469 case 0x00000002:
23470 ret_value = (x.m_minimal == m_minimal);
23471 break;
23472
23473 }
23474 }
23475 }
23476 else
23477 {
23478 ret_value = true;
23479 }
23480 }
23481
23482 return ret_value;
23483 }
23484
23489 eProsima_user_DllExport bool operator !=(
23490 const TypeObject& x) const
23491 {
23492 return !(*this == x);
23493 }
23494
23500 eProsima_user_DllExport void _d(
23501 uint8_t __d)
23502 {
23503 bool valid_discriminator = false;
23504
23505 switch (__d)
23506 {
23507 case EK_COMPLETE:
23508 if (0x00000001 == selected_member_)
23509 {
23510 valid_discriminator = true;
23511 }
23512 break;
23513
23514 case EK_MINIMAL:
23515 if (0x00000002 == selected_member_)
23516 {
23517 valid_discriminator = true;
23518 }
23519 break;
23520
23521 }
23522
23523 if (!valid_discriminator)
23524 {
23525 throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
23526 }
23527
23528 m__d = __d;
23529 }
23530
23535 eProsima_user_DllExport uint8_t _d() const
23536 {
23537 return m__d;
23538 }
23539
23544 eProsima_user_DllExport void complete(
23545 const CompleteTypeObject& _complete)
23546 {
23547 complete_() = _complete;
23548 m__d = EK_COMPLETE;
23549 }
23550
23555 eProsima_user_DllExport void complete(
23556 CompleteTypeObject&& _complete)
23557 {
23558 complete_() = _complete;
23559 m__d = EK_COMPLETE;
23560 }
23561
23567 eProsima_user_DllExport const CompleteTypeObject& complete() const
23568 {
23569 if (0x00000001 != selected_member_)
23570 {
23571 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23572 }
23573
23574 return m_complete;
23575 }
23576
23582 eProsima_user_DllExport CompleteTypeObject& complete()
23583 {
23584 if (0x00000001 != selected_member_)
23585 {
23586 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23587 }
23588
23589 return m_complete;
23590 }
23591
23592
23597 eProsima_user_DllExport void minimal(
23598 const MinimalTypeObject& _minimal)
23599 {
23600 minimal_() = _minimal;
23601 m__d = EK_MINIMAL;
23602 }
23603
23608 eProsima_user_DllExport void minimal(
23609 MinimalTypeObject&& _minimal)
23610 {
23611 minimal_() = _minimal;
23612 m__d = EK_MINIMAL;
23613 }
23614
23620 eProsima_user_DllExport const MinimalTypeObject& minimal() const
23621 {
23622 if (0x00000002 != selected_member_)
23623 {
23624 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23625 }
23626
23627 return m_minimal;
23628 }
23629
23635 eProsima_user_DllExport MinimalTypeObject& minimal()
23636 {
23637 if (0x00000002 != selected_member_)
23638 {
23639 throw eprosima::fastcdr::exception::BadParamException("This member has not been selected");
23640 }
23641
23642 return m_minimal;
23643 }
23644
23645
23647 {
23648 if (member_destructor_)
23649 {
23650 member_destructor_();
23651 }
23652
23653 selected_member_ = 0x0FFFFFFFu;
23654 }
23655
23656
23657private:
23658
23659 CompleteTypeObject& complete_()
23660 {
23661 if (0x00000001 != selected_member_)
23662 {
23663 if (member_destructor_)
23664 {
23665 member_destructor_();
23666 }
23667
23668 selected_member_ = 0x00000001;
23669 member_destructor_ = [&]() {m_complete.~CompleteTypeObject();};
23670 new(&m_complete) CompleteTypeObject();
23671
23672 }
23673
23674 return m_complete;
23675 }
23676
23677 MinimalTypeObject& minimal_()
23678 {
23679 if (0x00000002 != selected_member_)
23680 {
23681 if (member_destructor_)
23682 {
23683 member_destructor_();
23684 }
23685
23686 selected_member_ = 0x00000002;
23687 member_destructor_ = [&]() {m_minimal.~MinimalTypeObject();};
23688 new(&m_minimal) MinimalTypeObject();
23689
23690 }
23691
23692 return m_minimal;
23693 }
23694
23695
23696 uint8_t m__d {TK_NONE};
23697
23698 union
23699 {
23702 };
23703
23704 uint32_t selected_member_ {0x0FFFFFFFu};
23705
23706 std::function<void()> member_destructor_;
23707};
23708typedef std::vector<TypeObject> TypeObjectSeq;
23709
23711
23717{
23718public:
23719
23723 eProsima_user_DllExport TypeIdentifierTypeObjectPair()
23724 {
23725 }
23726
23730 eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
23731 {
23732 }
23733
23738 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23740 {
23741 m_type_identifier = x.m_type_identifier;
23742
23743 m_type_object = x.m_type_object;
23744
23745 }
23746
23751 eProsima_user_DllExport TypeIdentifierTypeObjectPair(
23752 TypeIdentifierTypeObjectPair&& x) noexcept
23753 {
23754 m_type_identifier = std::move(x.m_type_identifier);
23755 m_type_object = std::move(x.m_type_object);
23756 }
23757
23764 {
23765
23766 m_type_identifier = x.m_type_identifier;
23767
23768 m_type_object = x.m_type_object;
23769
23770 return *this;
23771 }
23772
23778 TypeIdentifierTypeObjectPair&& x) noexcept
23779 {
23780
23781 m_type_identifier = std::move(x.m_type_identifier);
23782 m_type_object = std::move(x.m_type_object);
23783 return *this;
23784 }
23785
23790 eProsima_user_DllExport bool operator ==(
23791 const TypeIdentifierTypeObjectPair& x) const
23792 {
23793 return (m_type_identifier == x.m_type_identifier &&
23794 m_type_object == x.m_type_object);
23795 }
23796
23801 eProsima_user_DllExport bool operator !=(
23802 const TypeIdentifierTypeObjectPair& x) const
23803 {
23804 return !(*this == x);
23805 }
23806
23811 eProsima_user_DllExport void type_identifier(
23812 const TypeIdentifier& _type_identifier)
23813 {
23814 m_type_identifier = _type_identifier;
23815 }
23816
23821 eProsima_user_DllExport void type_identifier(
23822 TypeIdentifier&& _type_identifier)
23823 {
23824 m_type_identifier = std::move(_type_identifier);
23825 }
23826
23831 eProsima_user_DllExport const TypeIdentifier& type_identifier() const
23832 {
23833 return m_type_identifier;
23834 }
23835
23840 eProsima_user_DllExport TypeIdentifier& type_identifier()
23841 {
23842 return m_type_identifier;
23843 }
23844
23845
23850 eProsima_user_DllExport void type_object(
23851 const TypeObject& _type_object)
23852 {
23853 m_type_object = _type_object;
23854 }
23855
23860 eProsima_user_DllExport void type_object(
23861 TypeObject&& _type_object)
23862 {
23863 m_type_object = std::move(_type_object);
23864 }
23865
23870 eProsima_user_DllExport const TypeObject& type_object() const
23871 {
23872 return m_type_object;
23873 }
23874
23879 eProsima_user_DllExport TypeObject& type_object()
23880 {
23881 return m_type_object;
23882 }
23883
23884
23885
23886private:
23887
23888 TypeIdentifier m_type_identifier;
23889 TypeObject m_type_object;
23890
23891};
23892typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
23893
23899{
23900public:
23901
23905 eProsima_user_DllExport TypeIdentifierPair()
23906 {
23907 }
23908
23912 eProsima_user_DllExport ~TypeIdentifierPair()
23913 {
23914 }
23915
23920 eProsima_user_DllExport TypeIdentifierPair(
23921 const TypeIdentifierPair& x)
23922 {
23923 m_type_identifier1 = x.m_type_identifier1;
23924
23925 m_type_identifier2 = x.m_type_identifier2;
23926
23927 }
23928
23933 eProsima_user_DllExport TypeIdentifierPair(
23934 TypeIdentifierPair&& x) noexcept
23935 {
23936 m_type_identifier1 = std::move(x.m_type_identifier1);
23937 m_type_identifier2 = std::move(x.m_type_identifier2);
23938 }
23939
23944 eProsima_user_DllExport TypeIdentifierPair& operator =(
23945 const TypeIdentifierPair& x)
23946 {
23947
23948 m_type_identifier1 = x.m_type_identifier1;
23949
23950 m_type_identifier2 = x.m_type_identifier2;
23951
23952 return *this;
23953 }
23954
23959 eProsima_user_DllExport TypeIdentifierPair& operator =(
23960 TypeIdentifierPair&& x) noexcept
23961 {
23962
23963 m_type_identifier1 = std::move(x.m_type_identifier1);
23964 m_type_identifier2 = std::move(x.m_type_identifier2);
23965 return *this;
23966 }
23967
23972 eProsima_user_DllExport bool operator ==(
23973 const TypeIdentifierPair& x) const
23974 {
23975 return (m_type_identifier1 == x.m_type_identifier1 &&
23976 m_type_identifier2 == x.m_type_identifier2);
23977 }
23978
23983 eProsima_user_DllExport bool operator !=(
23984 const TypeIdentifierPair& x) const
23985 {
23986 return !(*this == x);
23987 }
23988
23993 eProsima_user_DllExport void type_identifier1(
23994 const TypeIdentifier& _type_identifier1)
23995 {
23996 m_type_identifier1 = _type_identifier1;
23997 }
23998
24003 eProsima_user_DllExport void type_identifier1(
24004 TypeIdentifier&& _type_identifier1)
24005 {
24006 m_type_identifier1 = std::move(_type_identifier1);
24007 }
24008
24013 eProsima_user_DllExport const TypeIdentifier& type_identifier1() const
24014 {
24015 return m_type_identifier1;
24016 }
24017
24022 eProsima_user_DllExport TypeIdentifier& type_identifier1()
24023 {
24024 return m_type_identifier1;
24025 }
24026
24027
24032 eProsima_user_DllExport void type_identifier2(
24033 const TypeIdentifier& _type_identifier2)
24034 {
24035 m_type_identifier2 = _type_identifier2;
24036 }
24037
24042 eProsima_user_DllExport void type_identifier2(
24043 TypeIdentifier&& _type_identifier2)
24044 {
24045 m_type_identifier2 = std::move(_type_identifier2);
24046 }
24047
24052 eProsima_user_DllExport const TypeIdentifier& type_identifier2() const
24053 {
24054 return m_type_identifier2;
24055 }
24056
24061 eProsima_user_DllExport TypeIdentifier& type_identifier2()
24062 {
24063 return m_type_identifier2;
24064 }
24065
24066
24067
24068private:
24069
24070 TypeIdentifier m_type_identifier1;
24071 TypeIdentifier m_type_identifier2;
24072
24073};
24074typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
24075
24081{
24082public:
24083
24087 eProsima_user_DllExport TypeIdentfierWithSize()
24088 {
24089 }
24090
24094 eProsima_user_DllExport ~TypeIdentfierWithSize()
24095 {
24096 }
24097
24102 eProsima_user_DllExport TypeIdentfierWithSize(
24103 const TypeIdentfierWithSize& x)
24104 {
24105 m_type_id = x.m_type_id;
24106
24107 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24108
24109 }
24110
24115 eProsima_user_DllExport TypeIdentfierWithSize(
24116 TypeIdentfierWithSize&& x) noexcept
24117 {
24118 m_type_id = std::move(x.m_type_id);
24119 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24120 }
24121
24126 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24127 const TypeIdentfierWithSize& x)
24128 {
24129
24130 m_type_id = x.m_type_id;
24131
24132 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24133
24134 return *this;
24135 }
24136
24141 eProsima_user_DllExport TypeIdentfierWithSize& operator =(
24142 TypeIdentfierWithSize&& x) noexcept
24143 {
24144
24145 m_type_id = std::move(x.m_type_id);
24146 m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24147 return *this;
24148 }
24149
24154 eProsima_user_DllExport bool operator ==(
24155 const TypeIdentfierWithSize& x) const
24156 {
24157 return (m_type_id == x.m_type_id &&
24158 m_typeobject_serialized_size == x.m_typeobject_serialized_size);
24159 }
24160
24165 eProsima_user_DllExport bool operator !=(
24166 const TypeIdentfierWithSize& x) const
24167 {
24168 return !(*this == x);
24169 }
24170
24175 eProsima_user_DllExport void type_id(
24176 const TypeIdentifier& _type_id)
24177 {
24178 m_type_id = _type_id;
24179 }
24180
24185 eProsima_user_DllExport void type_id(
24186 TypeIdentifier&& _type_id)
24187 {
24188 m_type_id = std::move(_type_id);
24189 }
24190
24195 eProsima_user_DllExport const TypeIdentifier& type_id() const
24196 {
24197 return m_type_id;
24198 }
24199
24204 eProsima_user_DllExport TypeIdentifier& type_id()
24205 {
24206 return m_type_id;
24207 }
24208
24209
24214 eProsima_user_DllExport void typeobject_serialized_size(
24215 uint32_t _typeobject_serialized_size)
24216 {
24217 m_typeobject_serialized_size = _typeobject_serialized_size;
24218 }
24219
24224 eProsima_user_DllExport uint32_t typeobject_serialized_size() const
24225 {
24226 return m_typeobject_serialized_size;
24227 }
24228
24233 eProsima_user_DllExport uint32_t& typeobject_serialized_size()
24234 {
24235 return m_typeobject_serialized_size;
24236 }
24237
24238
24239
24240private:
24241
24242 TypeIdentifier m_type_id;
24243 uint32_t m_typeobject_serialized_size{0};
24244
24245};
24246typedef std::vector<TypeIdentfierWithSize> TypeIdentfierWithSizeSeq;
24247
24253{
24254public:
24255
24259 eProsima_user_DllExport TypeIdentifierWithDependencies()
24260 {
24261 }
24262
24266 eProsima_user_DllExport ~TypeIdentifierWithDependencies()
24267 {
24268 }
24269
24274 eProsima_user_DllExport TypeIdentifierWithDependencies(
24276 {
24277 m_typeid_with_size = x.m_typeid_with_size;
24278
24279 m_dependent_typeid_count = x.m_dependent_typeid_count;
24280
24281 m_dependent_typeids = x.m_dependent_typeids;
24282
24283 }
24284
24289 eProsima_user_DllExport TypeIdentifierWithDependencies(
24290 TypeIdentifierWithDependencies&& x) noexcept
24291 {
24292 m_typeid_with_size = std::move(x.m_typeid_with_size);
24293 m_dependent_typeid_count = x.m_dependent_typeid_count;
24294 m_dependent_typeids = std::move(x.m_dependent_typeids);
24295 }
24296
24303 {
24304
24305 m_typeid_with_size = x.m_typeid_with_size;
24306
24307 m_dependent_typeid_count = x.m_dependent_typeid_count;
24308
24309 m_dependent_typeids = x.m_dependent_typeids;
24310
24311 return *this;
24312 }
24313
24319 TypeIdentifierWithDependencies&& x) noexcept
24320 {
24321
24322 m_typeid_with_size = std::move(x.m_typeid_with_size);
24323 m_dependent_typeid_count = x.m_dependent_typeid_count;
24324 m_dependent_typeids = std::move(x.m_dependent_typeids);
24325 return *this;
24326 }
24327
24332 eProsima_user_DllExport bool operator ==(
24333 const TypeIdentifierWithDependencies& x) const
24334 {
24335 return (m_typeid_with_size == x.m_typeid_with_size &&
24336 m_dependent_typeid_count == x.m_dependent_typeid_count &&
24337 m_dependent_typeids == x.m_dependent_typeids);
24338 }
24339
24344 eProsima_user_DllExport bool operator !=(
24345 const TypeIdentifierWithDependencies& x) const
24346 {
24347 return !(*this == x);
24348 }
24349
24354 eProsima_user_DllExport void typeid_with_size(
24355 const TypeIdentfierWithSize& _typeid_with_size)
24356 {
24357 m_typeid_with_size = _typeid_with_size;
24358 }
24359
24364 eProsima_user_DllExport void typeid_with_size(
24365 TypeIdentfierWithSize&& _typeid_with_size)
24366 {
24367 m_typeid_with_size = std::move(_typeid_with_size);
24368 }
24369
24374 eProsima_user_DllExport const TypeIdentfierWithSize& typeid_with_size() const
24375 {
24376 return m_typeid_with_size;
24377 }
24378
24383 eProsima_user_DllExport TypeIdentfierWithSize& typeid_with_size()
24384 {
24385 return m_typeid_with_size;
24386 }
24387
24388
24393 eProsima_user_DllExport void dependent_typeid_count(
24394 int32_t _dependent_typeid_count)
24395 {
24396 m_dependent_typeid_count = _dependent_typeid_count;
24397 }
24398
24403 eProsima_user_DllExport int32_t dependent_typeid_count() const
24404 {
24405 return m_dependent_typeid_count;
24406 }
24407
24412 eProsima_user_DllExport int32_t& dependent_typeid_count()
24413 {
24414 return m_dependent_typeid_count;
24415 }
24416
24417
24422 eProsima_user_DllExport void dependent_typeids(
24423 const std::vector<TypeIdentfierWithSize>& _dependent_typeids)
24424 {
24425 m_dependent_typeids = _dependent_typeids;
24426 }
24427
24432 eProsima_user_DllExport void dependent_typeids(
24433 std::vector<TypeIdentfierWithSize>&& _dependent_typeids)
24434 {
24435 m_dependent_typeids = std::move(_dependent_typeids);
24436 }
24437
24442 eProsima_user_DllExport const std::vector<TypeIdentfierWithSize>& dependent_typeids() const
24443 {
24444 return m_dependent_typeids;
24445 }
24446
24451 eProsima_user_DllExport std::vector<TypeIdentfierWithSize>& dependent_typeids()
24452 {
24453 return m_dependent_typeids;
24454 }
24455
24456
24457
24458private:
24459
24460 TypeIdentfierWithSize m_typeid_with_size;
24461 int32_t m_dependent_typeid_count{0};
24462 std::vector<TypeIdentfierWithSize> m_dependent_typeids;
24463
24464};
24465typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
24466
24472{
24473public:
24474
24478 eProsima_user_DllExport TypeInformation()
24479 {
24480 }
24481
24485 eProsima_user_DllExport ~TypeInformation()
24486 {
24487 }
24488
24493 eProsima_user_DllExport TypeInformation(
24494 const TypeInformation& x)
24495 {
24496 m_minimal = x.m_minimal;
24497
24498 m_complete = x.m_complete;
24499
24500 }
24501
24506 eProsima_user_DllExport TypeInformation(
24507 TypeInformation&& x) noexcept
24508 {
24509 m_minimal = std::move(x.m_minimal);
24510 m_complete = std::move(x.m_complete);
24511 }
24512
24517 eProsima_user_DllExport TypeInformation& operator =(
24518 const TypeInformation& x)
24519 {
24520
24521 m_minimal = x.m_minimal;
24522
24523 m_complete = x.m_complete;
24524
24525 return *this;
24526 }
24527
24532 eProsima_user_DllExport TypeInformation& operator =(
24533 TypeInformation&& x) noexcept
24534 {
24535
24536 m_minimal = std::move(x.m_minimal);
24537 m_complete = std::move(x.m_complete);
24538 return *this;
24539 }
24540
24545 eProsima_user_DllExport bool operator ==(
24546 const TypeInformation& x) const
24547 {
24548 return (m_minimal == x.m_minimal &&
24549 m_complete == x.m_complete);
24550 }
24551
24556 eProsima_user_DllExport bool operator !=(
24557 const TypeInformation& x) const
24558 {
24559 return !(*this == x);
24560 }
24561
24566 eProsima_user_DllExport void minimal(
24567 const TypeIdentifierWithDependencies& _minimal)
24568 {
24569 m_minimal = _minimal;
24570 }
24571
24576 eProsima_user_DllExport void minimal(
24578 {
24579 m_minimal = std::move(_minimal);
24580 }
24581
24586 eProsima_user_DllExport const TypeIdentifierWithDependencies& minimal() const
24587 {
24588 return m_minimal;
24589 }
24590
24595 eProsima_user_DllExport TypeIdentifierWithDependencies& minimal()
24596 {
24597 return m_minimal;
24598 }
24599
24600
24605 eProsima_user_DllExport void complete(
24606 const TypeIdentifierWithDependencies& _complete)
24607 {
24608 m_complete = _complete;
24609 }
24610
24615 eProsima_user_DllExport void complete(
24617 {
24618 m_complete = std::move(_complete);
24619 }
24620
24625 eProsima_user_DllExport const TypeIdentifierWithDependencies& complete() const
24626 {
24627 return m_complete;
24628 }
24629
24634 eProsima_user_DllExport TypeIdentifierWithDependencies& complete()
24635 {
24636 return m_complete;
24637 }
24638
24639
24640
24641private:
24642
24645
24646};
24647typedef std::vector<TypeInformation> TypeInformationSeq;
24648
24649
24650} // namespace xtypes
24651
24652
24653} // namespace dds
24654
24655} // namespace fastdds
24656
24657} // namespace eprosima
24658
24659
24660#endif // _FAST_DDS_GENERATED_EPROSIMA_FASTDDS_DDS_XTYPES_DDS_XTYPES_TYPEOBJECT_HPP_
24661
24662
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:4297
eProsima_user_DllExport bool operator!=(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4795
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:5694
eProsima_user_DllExport void boolean_value(bool _boolean_value)
This function sets a value in member boolean_value.
Definition dds_xtypes_typeobject.hpp:4969
ExtendedAnnotationParameterValue m_extended_value
Definition dds_xtypes_typeobject.hpp:6164
eprosima::fastcdr::fixed_string< ANNOTATION_STR_VALUE_MAX_LEN > m_string8_value
Definition dds_xtypes_typeobject.hpp:6162
wchar_t m_wchar_value
Definition dds_xtypes_typeobject.hpp:6160
eProsima_user_DllExport void int8_value(int8_t _int8_value)
This function sets a value in member int8_value.
Definition dds_xtypes_typeobject.hpp:5053
eProsima_user_DllExport void float32_value(float _float32_value)
This function sets a value in member float32_value.
Definition dds_xtypes_typeobject.hpp:5389
eProsima_user_DllExport void uint8_value(uint8_t _uint8_value)
This function sets a value in member uint8_value.
Definition dds_xtypes_typeobject.hpp:5095
float m_float32_value
Definition dds_xtypes_typeobject.hpp:6156
eProsima_user_DllExport double & float64_value()
This function returns a reference to member float64_value.
Definition dds_xtypes_typeobject.hpp:5458
eProsima_user_DllExport uint64_t & uint64_value()
This function returns a reference to member uint64_value.
Definition dds_xtypes_typeobject.hpp:5374
eProsima_user_DllExport const std::wstring & string16_value() const
This function returns a constant reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5717
eProsima_user_DllExport void uint32_value(uint32_t _uint32_value)
This function sets a value in member uint32_value.
Definition dds_xtypes_typeobject.hpp:5263
eProsima_user_DllExport void extended_value(const ExtendedAnnotationParameterValue &_extended_value)
This function copies the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5747
eProsima_user_DllExport int32_t enumerated_value() const
This function returns the value of member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5611
eProsima_user_DllExport void wchar_value(wchar_t _wchar_value)
This function sets a value in member wchar_value.
Definition dds_xtypes_typeobject.hpp:5557
eProsima_user_DllExport void float128_value(long double _float128_value)
This function sets a value in member float128_value.
Definition dds_xtypes_typeobject.hpp:5473
eProsima_user_DllExport void char_value(char _char_value)
This function sets a value in member char_value.
Definition dds_xtypes_typeobject.hpp:5515
bool m_boolean_value
Definition dds_xtypes_typeobject.hpp:6146
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:5652
int32_t m_enumerated_value
Definition dds_xtypes_typeobject.hpp:6161
eProsima_user_DllExport void extended_value(ExtendedAnnotationParameterValue &&_extended_value)
This function moves the value in member extended_value.
Definition dds_xtypes_typeobject.hpp:5758
eProsima_user_DllExport float float32_value() const
This function returns the value of member float32_value.
Definition dds_xtypes_typeobject.hpp:5401
eProsima_user_DllExport char char_value() const
This function returns the value of member char_value.
Definition dds_xtypes_typeobject.hpp:5527
eProsima_user_DllExport void byte_value(uint8_t _byte_value)
This function sets a value in member byte_value.
Definition dds_xtypes_typeobject.hpp:5011
eProsima_user_DllExport void string16_value(std::wstring &&_string16_value)
This function moves the value in member string16_value.
Definition dds_xtypes_typeobject.hpp:5705
int8_t m_int8_value
Definition dds_xtypes_typeobject.hpp:6148
eProsima_user_DllExport int16_t & int16_value()
This function returns a reference to member int16_value.
Definition dds_xtypes_typeobject.hpp:5164
uint8_t m_uint8_value
Definition dds_xtypes_typeobject.hpp:6149
eProsima_user_DllExport int8_t & int8_value()
This function returns a reference to member int8_value.
Definition dds_xtypes_typeobject.hpp:5080
eProsima_user_DllExport uint8_t byte_value() const
This function returns the value of member byte_value.
Definition dds_xtypes_typeobject.hpp:5023
eProsima_user_DllExport int32_t & enumerated_value()
This function returns a reference to member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5626
uint8_t m_byte_value
Definition dds_xtypes_typeobject.hpp:6147
eProsima_user_DllExport uint16_t uint_16_value() const
This function returns the value of member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5191
eProsima_user_DllExport ExtendedAnnotationParameterValue & extended_value()
This function returns a reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5785
char m_char_value
Definition dds_xtypes_typeobject.hpp:6159
eProsima_user_DllExport uint16_t & uint_16_value()
This function returns a reference to member uint_16_value.
Definition dds_xtypes_typeobject.hpp:5206
eProsima_user_DllExport void float64_value(double _float64_value)
This function sets a value in member float64_value.
Definition dds_xtypes_typeobject.hpp:5431
eProsima_user_DllExport bool operator==(const AnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4690
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:5664
eProsima_user_DllExport std::wstring & string16_value()
This function returns a reference to member string16_value.
Definition dds_xtypes_typeobject.hpp:5732
eProsima_user_DllExport long double float128_value() const
This function returns the value of member float128_value.
Definition dds_xtypes_typeobject.hpp:5485
eProsima_user_DllExport int32_t int32_value() const
This function returns the value of member int32_value.
Definition dds_xtypes_typeobject.hpp:5233
eProsima_user_DllExport wchar_t & wchar_value()
This function returns a reference to member wchar_value.
Definition dds_xtypes_typeobject.hpp:5584
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:5179
eProsima_user_DllExport AnnotationParameterValue & operator=(const AnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4506
eProsima_user_DllExport uint32_t uint32_value() const
This function returns the value of member uint32_value.
Definition dds_xtypes_typeobject.hpp:5275
int64_t m_int64_value
Definition dds_xtypes_typeobject.hpp:6154
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:5679
eProsima_user_DllExport char & char_value()
This function returns a reference to member char_value.
Definition dds_xtypes_typeobject.hpp:5542
eProsima_user_DllExport const ExtendedAnnotationParameterValue & extended_value() const
This function returns a constant reference to member extended_value.
Definition dds_xtypes_typeobject.hpp:5770
eProsima_user_DllExport AnnotationParameterValue(AnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4416
eProsima_user_DllExport uint64_t uint64_value() const
This function returns the value of member uint64_value.
Definition dds_xtypes_typeobject.hpp:5359
eProsima_user_DllExport uint8_t & uint8_value()
This function returns a reference to member uint8_value.
Definition dds_xtypes_typeobject.hpp:5122
std::wstring m_string16_value
Definition dds_xtypes_typeobject.hpp:6163
int16_t m_int16_value
Definition dds_xtypes_typeobject.hpp:6150
eProsima_user_DllExport void uint64_value(uint64_t _uint64_value)
This function sets a value in member uint64_value.
Definition dds_xtypes_typeobject.hpp:5347
eProsima_user_DllExport double float64_value() const
This function returns the value of member float64_value.
Definition dds_xtypes_typeobject.hpp:5443
eProsima_user_DllExport uint8_t & byte_value()
This function returns a reference to member byte_value.
Definition dds_xtypes_typeobject.hpp:5038
eProsima_user_DllExport ~AnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4314
uint64_t m_uint64_value
Definition dds_xtypes_typeobject.hpp:6155
long double m_float128_value
Definition dds_xtypes_typeobject.hpp:6158
eProsima_user_DllExport wchar_t wchar_value() const
This function returns the value of member wchar_value.
Definition dds_xtypes_typeobject.hpp:5569
eProsima_user_DllExport float & float32_value()
This function returns a reference to member float32_value.
Definition dds_xtypes_typeobject.hpp:5416
eProsima_user_DllExport bool & boolean_value()
This function returns a reference to member boolean_value.
Definition dds_xtypes_typeobject.hpp:4996
eProsima_user_DllExport AnnotationParameterValue(const AnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4326
eProsima_user_DllExport long double & float128_value()
This function returns a reference to member float128_value.
Definition dds_xtypes_typeobject.hpp:5500
eProsima_user_DllExport void int16_value(int16_t _int16_value)
This function sets a value in member int16_value.
Definition dds_xtypes_typeobject.hpp:5137
eProsima_user_DllExport int16_t int16_value() const
This function returns the value of member int16_value.
Definition dds_xtypes_typeobject.hpp:5149
eProsima_user_DllExport void int32_value(int32_t _int32_value)
This function sets a value in member int32_value.
Definition dds_xtypes_typeobject.hpp:5221
eProsima_user_DllExport void int64_value(int64_t _int64_value)
This function sets a value in member int64_value.
Definition dds_xtypes_typeobject.hpp:5305
eProsima_user_DllExport int8_t int8_value() const
This function returns the value of member int8_value.
Definition dds_xtypes_typeobject.hpp:5065
eProsima_user_DllExport void enumerated_value(int32_t _enumerated_value)
This function sets a value in member enumerated_value.
Definition dds_xtypes_typeobject.hpp:5599
eProsima_user_DllExport AnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4303
eProsima_user_DllExport int64_t int64_value() const
This function returns the value of member int64_value.
Definition dds_xtypes_typeobject.hpp:5317
int32_t m_int32_value
Definition dds_xtypes_typeobject.hpp:6152
eProsima_user_DllExport uint32_t & uint32_value()
This function returns a reference to member uint32_value.
Definition dds_xtypes_typeobject.hpp:5290
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:4806
uint16_t m_uint_16_value
Definition dds_xtypes_typeobject.hpp:6151
eProsima_user_DllExport int32_t & int32_value()
This function returns a reference to member int32_value.
Definition dds_xtypes_typeobject.hpp:5248
eProsima_user_DllExport uint8_t uint8_value() const
This function returns the value of member uint8_value.
Definition dds_xtypes_typeobject.hpp:5107
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:5641
eProsima_user_DllExport bool boolean_value() const
This function returns the value of member boolean_value.
Definition dds_xtypes_typeobject.hpp:4981
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:4960
uint32_t m_uint32_value
Definition dds_xtypes_typeobject.hpp:6153
eProsima_user_DllExport int64_t & int64_value()
This function returns a reference to member int64_value.
Definition dds_xtypes_typeobject.hpp:5332
double m_float64_value
Definition dds_xtypes_typeobject.hpp:6157
This class represents the structure AppliedAnnotation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6358
eProsima_user_DllExport AppliedAnnotation(AppliedAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6392
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:6501
eProsima_user_DllExport ~AppliedAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6371
eProsima_user_DllExport const TypeIdentifier & annotation_typeid() const
This function returns a constant reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6472
eProsima_user_DllExport void annotation_typeid(TypeIdentifier &&_annotation_typeid)
This function moves the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6462
eProsima_user_DllExport bool operator!=(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6442
eProsima_user_DllExport AppliedAnnotation & operator=(const AppliedAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6403
eProsima_user_DllExport AppliedAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6364
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:6491
eProsima_user_DllExport TypeIdentifier & annotation_typeid()
This function returns a reference to member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6481
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:6511
eProsima_user_DllExport AppliedAnnotation(const AppliedAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6379
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationParameterSeq > & param_seq()
This function returns a reference to member param_seq.
Definition dds_xtypes_typeobject.hpp:6520
eProsima_user_DllExport bool operator==(const AppliedAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6431
eProsima_user_DllExport void annotation_typeid(const TypeIdentifier &_annotation_typeid)
This function copies the value in member annotation_typeid.
Definition dds_xtypes_typeobject.hpp:6452
This class represents the structure AppliedAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6176
eProsima_user_DllExport bool operator==(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6249
eProsima_user_DllExport bool operator!=(const AppliedAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6260
eProsima_user_DllExport AppliedAnnotationParameter & operator=(const AppliedAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6221
eProsima_user_DllExport AppliedAnnotationParameter(AppliedAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6210
eProsima_user_DllExport const AnnotationParameterValue & value() const
This function returns a constant reference to member value.
Definition dds_xtypes_typeobject.hpp:6329
eProsima_user_DllExport void paramname_hash(const NameHash &_paramname_hash)
This function copies the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6270
eProsima_user_DllExport void value(AnnotationParameterValue &&_value)
This function moves the value in member value.
Definition dds_xtypes_typeobject.hpp:6319
eProsima_user_DllExport const NameHash & paramname_hash() const
This function returns a constant reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6290
eProsima_user_DllExport AnnotationParameterValue & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:6338
eProsima_user_DllExport AppliedAnnotationParameter(const AppliedAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6197
eProsima_user_DllExport void paramname_hash(NameHash &&_paramname_hash)
This function moves the value in member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6280
eProsima_user_DllExport void value(const AnnotationParameterValue &_value)
This function copies the value in member value.
Definition dds_xtypes_typeobject.hpp:6309
eProsima_user_DllExport ~AppliedAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6189
eProsima_user_DllExport NameHash & paramname_hash()
This function returns a reference to member paramname_hash.
Definition dds_xtypes_typeobject.hpp:6299
eProsima_user_DllExport AppliedAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6182
This class represents the structure AppliedBuiltinMemberAnnotations defined by the user in the IDL fi...
Definition dds_xtypes_typeobject.hpp:6767
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & min()
This function returns a reference to member min.
Definition dds_xtypes_typeobject.hpp:6943
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(const AppliedBuiltinMemberAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6788
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:7012
eProsima_user_DllExport void max(eprosima::fastcdr::optional< AnnotationParameterValue > &&_max)
This function moves the value in member max.
Definition dds_xtypes_typeobject.hpp:6963
eProsima_user_DllExport ~AppliedBuiltinMemberAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6780
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:6875
eProsima_user_DllExport void min(eprosima::fastcdr::optional< AnnotationParameterValue > &&_min)
This function moves the value in member min.
Definition dds_xtypes_typeobject.hpp:6924
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:7002
eProsima_user_DllExport void max(const eprosima::fastcdr::optional< AnnotationParameterValue > &_max)
This function copies the value in member max.
Definition dds_xtypes_typeobject.hpp:6953
eProsima_user_DllExport eprosima::fastcdr::optional< AnnotationParameterValue > & max()
This function returns a reference to member max.
Definition dds_xtypes_typeobject.hpp:6982
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & hash_id()
This function returns a reference to member hash_id.
Definition dds_xtypes_typeobject.hpp:7021
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:6895
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & max() const
This function returns a constant reference to member max.
Definition dds_xtypes_typeobject.hpp:6973
eProsima_user_DllExport void min(const eprosima::fastcdr::optional< AnnotationParameterValue > &_min)
This function copies the value in member min.
Definition dds_xtypes_typeobject.hpp:6914
eProsima_user_DllExport AppliedBuiltinMemberAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6773
eProsima_user_DllExport const eprosima::fastcdr::optional< AnnotationParameterValue > & min() const
This function returns a constant reference to member min.
Definition dds_xtypes_typeobject.hpp:6934
eProsima_user_DllExport void unit(eprosima::fastcdr::optional< std::string > &&_unit)
This function moves the value in member unit.
Definition dds_xtypes_typeobject.hpp:6885
eProsima_user_DllExport bool operator==(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6852
eProsima_user_DllExport AppliedBuiltinMemberAnnotations(AppliedBuiltinMemberAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6805
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:6992
eProsima_user_DllExport AppliedBuiltinMemberAnnotations & operator=(const AppliedBuiltinMemberAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6818
eProsima_user_DllExport eprosima::fastcdr::optional< std::string > & unit()
This function returns a reference to member unit.
Definition dds_xtypes_typeobject.hpp:6904
eProsima_user_DllExport bool operator!=(const AppliedBuiltinMemberAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6865
This class represents the structure AppliedBuiltinTypeAnnotations defined by the user in the IDL file...
Definition dds_xtypes_typeobject.hpp:7982
eProsima_user_DllExport bool operator!=(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8059
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8014
eProsima_user_DllExport const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim() const
This function returns a constant reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8089
eProsima_user_DllExport void verbatim(const eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &_verbatim)
This function copies the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8069
eProsima_user_DllExport void verbatim(eprosima::fastcdr::optional< AppliedVerbatimAnnotation > &&_verbatim)
This function moves the value in member verbatim.
Definition dds_xtypes_typeobject.hpp:8079
eProsima_user_DllExport AppliedBuiltinTypeAnnotations()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7988
eProsima_user_DllExport AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8003
eProsima_user_DllExport bool operator==(const AppliedBuiltinTypeAnnotations &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8049
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedVerbatimAnnotation > & verbatim()
This function returns a reference to member verbatim.
Definition dds_xtypes_typeobject.hpp:8098
eProsima_user_DllExport AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8024
eProsima_user_DllExport ~AppliedBuiltinTypeAnnotations()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7995
This class represents the structure AppliedVerbatimAnnotation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:6540
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:6661
eProsima_user_DllExport bool operator!=(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6631
eProsima_user_DllExport void text(const std::string &_text)
This function copies the value in member text.
Definition dds_xtypes_typeobject.hpp:6719
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & language()
This function returns a reference to member language.
Definition dds_xtypes_typeobject.hpp:6709
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:6680
eProsima_user_DllExport AppliedVerbatimAnnotation(AppliedVerbatimAnnotation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:6576
eProsima_user_DllExport void language(eprosima::fastcdr::fixed_string< 32 > &&_language)
This function moves the value in member language.
Definition dds_xtypes_typeobject.hpp:6690
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:6641
eProsima_user_DllExport void placement(eprosima::fastcdr::fixed_string< 32 > &&_placement)
This function moves the value in member placement.
Definition dds_xtypes_typeobject.hpp:6651
eProsima_user_DllExport AppliedVerbatimAnnotation & operator=(const AppliedVerbatimAnnotation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:6588
eProsima_user_DllExport AppliedVerbatimAnnotation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:6546
eProsima_user_DllExport eprosima::fastcdr::fixed_string< 32 > & placement()
This function returns a reference to member placement.
Definition dds_xtypes_typeobject.hpp:6670
eProsima_user_DllExport AppliedVerbatimAnnotation(const AppliedVerbatimAnnotation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:6561
eProsima_user_DllExport ~AppliedVerbatimAnnotation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:6553
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:6700
eProsima_user_DllExport std::string & text()
This function returns a reference to member text.
Definition dds_xtypes_typeobject.hpp:6748
eProsima_user_DllExport bool operator==(const AppliedVerbatimAnnotation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:6619
eProsima_user_DllExport void text(std::string &&_text)
This function moves the value in member text.
Definition dds_xtypes_typeobject.hpp:6729
eProsima_user_DllExport const std::string & text() const
This function returns a constant reference to member text.
Definition dds_xtypes_typeobject.hpp:6739
This class represents the structure CommonAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12555
eProsima_user_DllExport const AliasMemberFlag & related_flags() const
This function returns a constant reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12669
eProsima_user_DllExport CommonAliasBody(const CommonAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12576
eProsima_user_DllExport CommonAliasBody & operator=(const CommonAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12600
eProsima_user_DllExport void related_flags(const AliasMemberFlag &_related_flags)
This function copies the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12649
eProsima_user_DllExport void related_type(TypeIdentifier &&_related_type)
This function moves the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12698
eProsima_user_DllExport const TypeIdentifier & related_type() const
This function returns a constant reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12708
eProsima_user_DllExport bool operator!=(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12639
eProsima_user_DllExport ~CommonAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12568
eProsima_user_DllExport void related_type(const TypeIdentifier &_related_type)
This function copies the value in member related_type.
Definition dds_xtypes_typeobject.hpp:12688
eProsima_user_DllExport void related_flags(AliasMemberFlag &&_related_flags)
This function moves the value in member related_flags.
Definition dds_xtypes_typeobject.hpp:12659
eProsima_user_DllExport bool operator==(const CommonAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12628
eProsima_user_DllExport AliasMemberFlag & related_flags()
This function returns a reference to member related_flags.
Definition dds_xtypes_typeobject.hpp:12678
eProsima_user_DllExport TypeIdentifier & related_type()
This function returns a reference to member related_type.
Definition dds_xtypes_typeobject.hpp:12717
eProsima_user_DllExport CommonAliasBody(CommonAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12589
eProsima_user_DllExport CommonAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12561
This class represents the structure CommonAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11235
eProsima_user_DllExport AnnotationParameterFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11358
eProsima_user_DllExport void member_flags(const AnnotationParameterFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11329
eProsima_user_DllExport bool operator!=(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11319
eProsima_user_DllExport CommonAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11241
eProsima_user_DllExport const AnnotationParameterFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:11349
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:11378
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:11397
eProsima_user_DllExport void member_flags(AnnotationParameterFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:11339
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:11368
eProsima_user_DllExport ~CommonAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11248
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:11388
eProsima_user_DllExport CommonAnnotationParameter(CommonAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11269
eProsima_user_DllExport CommonAnnotationParameter(const CommonAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11256
eProsima_user_DllExport bool operator==(const CommonAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11308
eProsima_user_DllExport CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11280
This class represents the structure CommonArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15340
eProsima_user_DllExport LBoundSeq & bound_seq()
This function returns a reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15456
eProsima_user_DllExport const LBoundSeq & bound_seq() const
This function returns a constant reference to member bound_seq.
Definition dds_xtypes_typeobject.hpp:15447
eProsima_user_DllExport bool operator!=(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15417
eProsima_user_DllExport CommonArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15346
eProsima_user_DllExport CommonArrayHeader(const CommonArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15361
eProsima_user_DllExport void bound_seq(const LBoundSeq &_bound_seq)
This function copies the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15427
eProsima_user_DllExport void bound_seq(LBoundSeq &&_bound_seq)
This function moves the value in member bound_seq.
Definition dds_xtypes_typeobject.hpp:15437
eProsima_user_DllExport CommonArrayHeader & operator=(const CommonArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15382
eProsima_user_DllExport ~CommonArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15353
eProsima_user_DllExport CommonArrayHeader(CommonArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15372
eProsima_user_DllExport bool operator==(const CommonArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15407
This class represents the structure CommonBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19329
eProsima_user_DllExport uint8_t & bitcount()
This function returns a reference to member bitcount.
Definition dds_xtypes_typeobject.hpp:19524
eProsima_user_DllExport const BitsetMemberFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:19486
eProsima_user_DllExport bool operator!=(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19427
eProsima_user_DllExport BitsetMemberFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:19495
eProsima_user_DllExport bool operator==(const CommonBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19414
eProsima_user_DllExport void bitcount(uint8_t _bitcount)
This function sets a value in member bitcount.
Definition dds_xtypes_typeobject.hpp:19505
eProsima_user_DllExport CommonBitfield(CommonBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19367
eProsima_user_DllExport CommonBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19335
eProsima_user_DllExport uint8_t bitcount() const
This function returns the value of member bitcount.
Definition dds_xtypes_typeobject.hpp:19515
eProsima_user_DllExport void holder_type(TypeKind _holder_type)
This function sets a value in member holder_type.
Definition dds_xtypes_typeobject.hpp:19534
eProsima_user_DllExport void flags(BitsetMemberFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:19476
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:19456
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:19447
eProsima_user_DllExport ~CommonBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19342
eProsima_user_DllExport void flags(const BitsetMemberFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:19466
eProsima_user_DllExport CommonBitfield(const CommonBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19350
eProsima_user_DllExport TypeKind & holder_type()
This function returns a reference to member holder_type.
Definition dds_xtypes_typeobject.hpp:19553
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:19437
eProsima_user_DllExport TypeKind holder_type() const
This function returns the value of member holder_type.
Definition dds_xtypes_typeobject.hpp:19544
eProsima_user_DllExport CommonBitfield & operator=(const CommonBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19380
This class represents the structure CommonBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18214
eProsima_user_DllExport void flags(BitflagFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:18347
eProsima_user_DllExport CommonBitflag & operator=(const CommonBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18259
eProsima_user_DllExport CommonBitflag(CommonBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18248
eProsima_user_DllExport bool operator==(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18287
eProsima_user_DllExport const BitflagFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:18357
eProsima_user_DllExport CommonBitflag(const CommonBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18235
eProsima_user_DllExport uint16_t & position()
This function returns a reference to member position.
Definition dds_xtypes_typeobject.hpp:18327
eProsima_user_DllExport bool operator!=(const CommonBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18298
eProsima_user_DllExport CommonBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18220
eProsima_user_DllExport void flags(const BitflagFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:18337
eProsima_user_DllExport uint16_t position() const
This function returns the value of member position.
Definition dds_xtypes_typeobject.hpp:18318
eProsima_user_DllExport BitflagFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:18366
eProsima_user_DllExport ~CommonBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18227
eProsima_user_DllExport void position(uint16_t _position)
This function sets a value in member position.
Definition dds_xtypes_typeobject.hpp:18308
This class represents the structure CommonBitmaskHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18748
eProsima_user_DllExport CommonBitmaskHeader(const CommonBitmaskHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18769
eProsima_user_DllExport ~CommonBitmaskHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18761
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:18835
eProsima_user_DllExport CommonBitmaskHeader(CommonBitmaskHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18780
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:18845
eProsima_user_DllExport CommonBitmaskHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18754
eProsima_user_DllExport bool operator==(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18815
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:18854
eProsima_user_DllExport bool operator!=(const CommonBitmaskHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18825
eProsima_user_DllExport CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18790
This class represents the structure CommonCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13957
eProsima_user_DllExport const TypeIdentifier & type() const
This function returns a constant reference to member type.
Definition dds_xtypes_typeobject.hpp:14110
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14080
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14061
eProsima_user_DllExport CommonCollectionElement & operator=(const CommonCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14002
eProsima_user_DllExport bool operator!=(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14041
eProsima_user_DllExport CommonCollectionElement(const CommonCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13978
eProsima_user_DllExport void type(const TypeIdentifier &_type)
This function copies the value in member type.
Definition dds_xtypes_typeobject.hpp:14090
eProsima_user_DllExport TypeIdentifier & type()
This function returns a reference to member type.
Definition dds_xtypes_typeobject.hpp:14119
eProsima_user_DllExport CommonCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13963
eProsima_user_DllExport ~CommonCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13970
eProsima_user_DllExport bool operator==(const CommonCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14030
eProsima_user_DllExport void type(TypeIdentifier &&_type)
This function moves the value in member type.
Definition dds_xtypes_typeobject.hpp:14100
eProsima_user_DllExport CommonCollectionElement(CommonCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13991
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:14051
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:14071
This class represents the structure CommonCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14450
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:14556
eProsima_user_DllExport bool operator!=(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14527
eProsima_user_DllExport CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14492
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:14537
eProsima_user_DllExport CommonCollectionHeader(CommonCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14482
eProsima_user_DllExport CommonCollectionHeader(const CommonCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14471
eProsima_user_DllExport ~CommonCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14463
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:14547
eProsima_user_DllExport CommonCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14456
eProsima_user_DllExport bool operator==(const CommonCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14517
This class represents the structure CommonDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9881
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10034
eProsima_user_DllExport void member_flags(UnionDiscriminatorFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9985
eProsima_user_DllExport void member_flags(const UnionDiscriminatorFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9975
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:10043
eProsima_user_DllExport bool operator==(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9954
eProsima_user_DllExport const UnionDiscriminatorFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9995
eProsima_user_DllExport ~CommonDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9894
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:10024
eProsima_user_DllExport UnionDiscriminatorFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:10004
eProsima_user_DllExport bool operator!=(const CommonDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9965
eProsima_user_DllExport CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9926
eProsima_user_DllExport CommonDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9887
eProsima_user_DllExport CommonDiscriminatorMember(CommonDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9915
eProsima_user_DllExport CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9902
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:10014
This class represents the structure CommonEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17324
eProsima_user_DllExport bool operator==(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17391
eProsima_user_DllExport void bit_bound(BitBound _bit_bound)
This function sets a value in member bit_bound.
Definition dds_xtypes_typeobject.hpp:17411
eProsima_user_DllExport BitBound bit_bound() const
This function returns the value of member bit_bound.
Definition dds_xtypes_typeobject.hpp:17421
eProsima_user_DllExport CommonEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17330
eProsima_user_DllExport bool operator!=(const CommonEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17401
eProsima_user_DllExport CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17345
eProsima_user_DllExport CommonEnumeratedHeader(CommonEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17356
eProsima_user_DllExport ~CommonEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17337
eProsima_user_DllExport CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17366
eProsima_user_DllExport BitBound & bit_bound()
This function returns a reference to member bit_bound.
Definition dds_xtypes_typeobject.hpp:17430
This class represents the structure CommonEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16790
eProsima_user_DllExport void flags(EnumeratedLiteralFlag &&_flags)
This function moves the value in member flags.
Definition dds_xtypes_typeobject.hpp:16923
eProsima_user_DllExport const EnumeratedLiteralFlag & flags() const
This function returns a constant reference to member flags.
Definition dds_xtypes_typeobject.hpp:16933
eProsima_user_DllExport int32_t & value()
This function returns a reference to member value.
Definition dds_xtypes_typeobject.hpp:16903
eProsima_user_DllExport void value(int32_t _value)
This function sets a value in member value.
Definition dds_xtypes_typeobject.hpp:16884
eProsima_user_DllExport CommonEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16796
eProsima_user_DllExport ~CommonEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16803
eProsima_user_DllExport void flags(const EnumeratedLiteralFlag &_flags)
This function copies the value in member flags.
Definition dds_xtypes_typeobject.hpp:16913
eProsima_user_DllExport EnumeratedLiteralFlag & flags()
This function returns a reference to member flags.
Definition dds_xtypes_typeobject.hpp:16942
eProsima_user_DllExport int32_t value() const
This function returns the value of member value.
Definition dds_xtypes_typeobject.hpp:16894
eProsima_user_DllExport bool operator==(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16863
eProsima_user_DllExport CommonEnumeratedLiteral(CommonEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16824
eProsima_user_DllExport CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16811
eProsima_user_DllExport CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16835
eProsima_user_DllExport bool operator!=(const CommonEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16874
This class represents the structure CommonStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7041
eProsima_user_DllExport void member_flags(const StructMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7171
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:7220
eProsima_user_DllExport TypeIdentifier & member_type_id()
This function returns a reference to member member_type_id.
Definition dds_xtypes_typeobject.hpp:7239
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:7210
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:7230
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:7161
eProsima_user_DllExport CommonStructMember & operator=(const CommonStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7089
eProsima_user_DllExport bool operator==(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7120
eProsima_user_DllExport ~CommonStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7054
eProsima_user_DllExport CommonStructMember(CommonStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7077
eProsima_user_DllExport CommonStructMember(const CommonStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7062
eProsima_user_DllExport StructMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7200
eProsima_user_DllExport CommonStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7047
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:7142
eProsima_user_DllExport const StructMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:7191
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:7152
eProsima_user_DllExport bool operator!=(const CommonStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7132
eProsima_user_DllExport void member_flags(StructMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:7181
This class represents the structure CommonUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9253
eProsima_user_DllExport CommonUnionMember & operator=(const CommonUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9304
eProsima_user_DllExport CommonUnionMember(CommonUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9291
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9449
eProsima_user_DllExport void member_flags(const UnionMemberFlag &_member_flags)
This function copies the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9390
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:9458
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9439
eProsima_user_DllExport bool operator==(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9338
eProsima_user_DllExport UnionMemberFlag & member_flags()
This function returns a reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9419
eProsima_user_DllExport const UnionMemberFlag & member_flags() const
This function returns a constant reference to member member_flags.
Definition dds_xtypes_typeobject.hpp:9410
eProsima_user_DllExport void member_flags(UnionMemberFlag &&_member_flags)
This function moves the value in member member_flags.
Definition dds_xtypes_typeobject.hpp:9400
eProsima_user_DllExport const UnionCaseLabelSeq & label_seq() const
This function returns a constant reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9488
eProsima_user_DllExport MemberId & member_id()
This function returns a reference to member member_id.
Definition dds_xtypes_typeobject.hpp:9380
eProsima_user_DllExport CommonUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9259
eProsima_user_DllExport UnionCaseLabelSeq & label_seq()
This function returns a reference to member label_seq.
Definition dds_xtypes_typeobject.hpp:9497
eProsima_user_DllExport void label_seq(const UnionCaseLabelSeq &_label_seq)
This function copies the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9468
eProsima_user_DllExport ~CommonUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9266
eProsima_user_DllExport bool operator!=(const CommonUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9351
eProsima_user_DllExport void member_id(MemberId _member_id)
This function sets a value in member member_id.
Definition dds_xtypes_typeobject.hpp:9361
eProsima_user_DllExport MemberId member_id() const
This function returns the value of member member_id.
Definition dds_xtypes_typeobject.hpp:9371
eProsima_user_DllExport void label_seq(UnionCaseLabelSeq &&_label_seq)
This function moves the value in member label_seq.
Definition dds_xtypes_typeobject.hpp:9478
eProsima_user_DllExport CommonUnionMember(const CommonUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9274
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:9429
This class represents the structure CompleteAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12735
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:12856
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:12943
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:12904
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:12836
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:12885
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:12846
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:12934
eProsima_user_DllExport CompleteAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12741
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:12895
eProsima_user_DllExport CompleteAliasBody(CompleteAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12771
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:12914
eProsima_user_DllExport ~CompleteAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12748
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:12865
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:12875
eProsima_user_DllExport CompleteAliasBody & operator=(const CompleteAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12783
eProsima_user_DllExport CompleteAliasBody(const CompleteAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12756
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:12924
eProsima_user_DllExport bool operator==(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12814
eProsima_user_DllExport bool operator!=(const CompleteAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12826
This class represents the structure CompleteAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13095
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:13192
eProsima_user_DllExport bool operator!=(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13172
eProsima_user_DllExport CompleteAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13101
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:13211
eProsima_user_DllExport ~CompleteAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13108
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:13182
eProsima_user_DllExport CompleteAliasHeader(const CompleteAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13116
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:13202
eProsima_user_DllExport bool operator==(const CompleteAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13162
eProsima_user_DllExport CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13137
eProsima_user_DllExport CompleteAliasHeader(CompleteAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13127
This class represents the structure CompleteAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13323
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13444
eProsima_user_DllExport void header(const CompleteAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13463
eProsima_user_DllExport CompleteAliasType(CompleteAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13359
eProsima_user_DllExport void header(CompleteAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13473
eProsima_user_DllExport const CompleteAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13522
eProsima_user_DllExport bool operator!=(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13414
eProsima_user_DllExport bool operator==(const CompleteAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13402
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13424
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13434
eProsima_user_DllExport CompleteAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13329
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13453
eProsima_user_DllExport CompleteAliasType(const CompleteAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13344
eProsima_user_DllExport ~CompleteAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13336
eProsima_user_DllExport CompleteAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13531
eProsima_user_DllExport const CompleteAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13483
eProsima_user_DllExport CompleteAliasType & operator=(const CompleteAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13371
eProsima_user_DllExport void body(CompleteAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13512
eProsima_user_DllExport void body(const CompleteAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13502
eProsima_user_DllExport CompleteAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13492
This class represents the structure CompleteAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11873
eProsima_user_DllExport CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11915
eProsima_user_DllExport CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11894
eProsima_user_DllExport bool operator!=(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11950
eProsima_user_DllExport void annotation_name(QualifiedTypeName &&_annotation_name)
This function moves the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:11970
eProsima_user_DllExport const QualifiedTypeName & annotation_name() const
This function returns a constant reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:11980
eProsima_user_DllExport void annotation_name(const QualifiedTypeName &_annotation_name)
This function copies the value in member annotation_name.
Definition dds_xtypes_typeobject.hpp:11960
eProsima_user_DllExport bool operator==(const CompleteAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11940
eProsima_user_DllExport QualifiedTypeName & annotation_name()
This function returns a reference to member annotation_name.
Definition dds_xtypes_typeobject.hpp:11989
eProsima_user_DllExport CompleteAnnotationHeader(CompleteAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11905
eProsima_user_DllExport CompleteAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11879
eProsima_user_DllExport ~CompleteAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11886
This class represents the structure CompleteAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11415
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11536
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11516
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:11555
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:11584
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11614
eProsima_user_DllExport CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11436
eProsima_user_DllExport bool operator==(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11494
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11526
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:11575
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11545
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11623
eProsima_user_DllExport CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11463
eProsima_user_DllExport CompleteAnnotationParameter(CompleteAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11451
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11604
eProsima_user_DllExport bool operator!=(const CompleteAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11506
eProsima_user_DllExport ~CompleteAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11428
eProsima_user_DllExport CompleteAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11421
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11594
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:11565
This class represents the structure CompleteAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12101
eProsima_user_DllExport bool operator==(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12180
eProsima_user_DllExport ~CompleteAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12114
eProsima_user_DllExport const CompleteAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12261
eProsima_user_DllExport CompleteAnnotationType(const CompleteAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12122
eProsima_user_DllExport CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12149
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12231
eProsima_user_DllExport const CompleteAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12300
eProsima_user_DllExport CompleteAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12107
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12212
eProsima_user_DllExport void header(const CompleteAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12241
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12202
eProsima_user_DllExport void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12280
eProsima_user_DllExport CompleteAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12270
eProsima_user_DllExport void header(CompleteAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12251
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12222
eProsima_user_DllExport CompleteAnnotationType(CompleteAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12137
eProsima_user_DllExport CompleteAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12309
eProsima_user_DllExport void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12290
eProsima_user_DllExport bool operator!=(const CompleteAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12192
This class represents the structure CompleteArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15473
eProsima_user_DllExport bool operator==(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15546
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:15616
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:15635
eProsima_user_DllExport CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15518
eProsima_user_DllExport ~CompleteArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15486
eProsima_user_DllExport CompleteArrayHeader(CompleteArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15507
eProsima_user_DllExport CompleteArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15479
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:15606
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15577
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15596
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15587
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:15626
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15567
eProsima_user_DllExport bool operator!=(const CompleteArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15557
eProsima_user_DllExport CompleteArrayHeader(const CompleteArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15494
This class represents the structure CompleteArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15786
eProsima_user_DllExport CompleteArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15955
eProsima_user_DllExport CompleteArrayType & operator=(const CompleteArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15834
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15897
eProsima_user_DllExport const CompleteArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15946
eProsima_user_DllExport bool operator==(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15865
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15975
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15916
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15965
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15887
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15985
eProsima_user_DllExport CompleteArrayType(const CompleteArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15807
eProsima_user_DllExport CompleteArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15792
eProsima_user_DllExport CompleteArrayType(CompleteArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15822
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15907
eProsima_user_DllExport ~CompleteArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15799
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15994
eProsima_user_DllExport void header(const CompleteArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15926
eProsima_user_DllExport bool operator!=(const CompleteArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15877
eProsima_user_DllExport void header(CompleteArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15936
This class represents the structure CompleteBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19573
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19696
eProsima_user_DllExport CompleteBitfield(const CompleteBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19594
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:19706
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19687
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:19716
eProsima_user_DllExport CompleteBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19579
eProsima_user_DllExport bool operator==(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19646
eProsima_user_DllExport CompleteBitfield & operator=(const CompleteBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19618
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19667
eProsima_user_DllExport CompleteBitfield(CompleteBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19607
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:19735
eProsima_user_DllExport bool operator!=(const CompleteBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19657
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19677
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:19726
eProsima_user_DllExport ~CompleteBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19586
This class represents the structure CompleteBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18384
eProsima_user_DllExport CompleteBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18390
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18507
eProsima_user_DllExport ~CompleteBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18397
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18517
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18478
eProsima_user_DllExport bool operator==(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18457
eProsima_user_DllExport CompleteBitflag(CompleteBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18418
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18488
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18527
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18498
eProsima_user_DllExport bool operator!=(const CompleteBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18468
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18546
eProsima_user_DllExport CompleteBitflag(const CompleteBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18405
eProsima_user_DllExport CompleteBitflag & operator=(const CompleteBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18429
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18537
This class represents the structure CompleteBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18875
eProsima_user_DllExport CompleteBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19083
eProsima_user_DllExport void header(CompleteBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:19025
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18996
eProsima_user_DllExport const CompleteBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19035
eProsima_user_DllExport ~CompleteBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18888
eProsima_user_DllExport void flag_seq(const CompleteBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19054
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18976
eProsima_user_DllExport bool operator!=(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18966
eProsima_user_DllExport CompleteBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19044
eProsima_user_DllExport CompleteBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18881
eProsima_user_DllExport void flag_seq(CompleteBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19064
eProsima_user_DllExport const CompleteBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19074
eProsima_user_DllExport bool operator==(const CompleteBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18954
eProsima_user_DllExport void header(const CompleteBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:19015
eProsima_user_DllExport CompleteBitmaskType(CompleteBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18911
eProsima_user_DllExport CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18923
eProsima_user_DllExport CompleteBitmaskType(const CompleteBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18896
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19005
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:18986
This class represents the structure CompleteBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19937
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:20034
eProsima_user_DllExport CompleteBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19943
eProsima_user_DllExport CompleteBitsetHeader(const CompleteBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19958
eProsima_user_DllExport bool operator!=(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20014
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:20053
eProsima_user_DllExport CompleteBitsetHeader(CompleteBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19969
eProsima_user_DllExport CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19979
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:20024
eProsima_user_DllExport ~CompleteBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19950
eProsima_user_DllExport bool operator==(const CompleteBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20004
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:20044
This class represents the structure CompleteBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20165
eProsima_user_DllExport bool operator==(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20244
eProsima_user_DllExport bool operator!=(const CompleteBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20256
eProsima_user_DllExport void field_seq(const CompleteBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20344
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20266
eProsima_user_DllExport CompleteBitsetType(const CompleteBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20186
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20286
eProsima_user_DllExport const CompleteBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20364
eProsima_user_DllExport void field_seq(CompleteBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20354
eProsima_user_DllExport const CompleteBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20325
eProsima_user_DllExport void header(CompleteBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20315
eProsima_user_DllExport CompleteBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20171
eProsima_user_DllExport CompleteBitsetType(CompleteBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20201
eProsima_user_DllExport ~CompleteBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20178
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20276
eProsima_user_DllExport CompleteBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20334
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20295
eProsima_user_DllExport CompleteBitsetType & operator=(const CompleteBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20213
eProsima_user_DllExport CompleteBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20373
eProsima_user_DllExport void header(const CompleteBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20305
This class represents the structure CompleteCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14137
eProsima_user_DllExport CompleteElementDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14299
eProsima_user_DllExport bool operator!=(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14221
eProsima_user_DllExport ~CompleteCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14150
eProsima_user_DllExport CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14182
eProsima_user_DllExport void detail(const CompleteElementDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14270
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14231
eProsima_user_DllExport CompleteCollectionElement(const CompleteCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14158
eProsima_user_DllExport void detail(CompleteElementDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14280
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14251
eProsima_user_DllExport const CompleteElementDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14290
eProsima_user_DllExport CompleteCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14143
eProsima_user_DllExport CompleteCollectionElement(CompleteCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14171
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14260
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14241
eProsima_user_DllExport bool operator==(const CompleteCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14210
This class represents the structure CompleteCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14573
eProsima_user_DllExport bool operator==(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14646
eProsima_user_DllExport CompleteCollectionHeader(const CompleteCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14594
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14696
eProsima_user_DllExport ~CompleteCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14586
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14687
eProsima_user_DllExport CompleteCollectionHeader(CompleteCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14607
eProsima_user_DllExport CompleteCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14579
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14667
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14677
eProsima_user_DllExport void detail(eprosima::fastcdr::optional< CompleteTypeDetail > &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:14716
eProsima_user_DllExport const eprosima::fastcdr::optional< CompleteTypeDetail > & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:14726
eProsima_user_DllExport CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14618
eProsima_user_DllExport void detail(const eprosima::fastcdr::optional< CompleteTypeDetail > &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:14706
eProsima_user_DllExport bool operator!=(const CompleteCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14657
eProsima_user_DllExport eprosima::fastcdr::optional< CompleteTypeDetail > & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:14735
This class represents the structure CompleteDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10061
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:10230
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:10201
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:10269
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10191
eProsima_user_DllExport ~CompleteDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10074
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:10221
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:10260
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10182
eProsima_user_DllExport bool operator==(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10140
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:10211
eProsima_user_DllExport CompleteDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10067
eProsima_user_DllExport CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10097
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:10240
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:10250
eProsima_user_DllExport CompleteDiscriminatorMember(const CompleteDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10082
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10172
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10162
eProsima_user_DllExport CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10109
eProsima_user_DllExport bool operator!=(const CompleteDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10152
This class represents the structure CompleteElementDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13777
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:13939
eProsima_user_DllExport CompleteElementDetail(CompleteElementDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13811
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:13900
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:13881
eProsima_user_DllExport bool operator!=(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13861
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:13930
eProsima_user_DllExport CompleteElementDetail(const CompleteElementDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13798
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:13891
eProsima_user_DllExport CompleteElementDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13783
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:13910
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:13871
eProsima_user_DllExport ~CompleteElementDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13790
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:13920
eProsima_user_DllExport CompleteElementDetail & operator=(const CompleteElementDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13822
eProsima_user_DllExport bool operator==(const CompleteElementDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13850
This class represents the structure CompleteEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17447
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17590
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17609
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17570
eProsima_user_DllExport ~CompleteEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17460
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17580
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17561
eProsima_user_DllExport CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17492
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17541
eProsima_user_DllExport CompleteEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17453
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17600
eProsima_user_DllExport bool operator==(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17520
eProsima_user_DllExport CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17481
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17531
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17551
eProsima_user_DllExport CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17468
This class represents the structure CompleteEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16960
eProsima_user_DllExport CompleteEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16966
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17074
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17093
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17044
eProsima_user_DllExport CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17005
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17103
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17083
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17122
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17054
eProsima_user_DllExport ~CompleteEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16973
eProsima_user_DllExport CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16994
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17113
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17064
eProsima_user_DllExport CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16981
eProsima_user_DllExport bool operator==(const CompleteEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17033
This class represents the structure CompleteEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17760
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17890
eProsima_user_DllExport const CompleteEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:17920
eProsima_user_DllExport void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17939
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17861
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:17871
eProsima_user_DllExport const CompleteEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:17959
eProsima_user_DllExport CompleteEnumeratedType(CompleteEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17796
eProsima_user_DllExport ~CompleteEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17773
eProsima_user_DllExport bool operator!=(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17851
eProsima_user_DllExport bool operator==(const CompleteEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17839
eProsima_user_DllExport CompleteEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:17968
eProsima_user_DllExport CompleteEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:17929
eProsima_user_DllExport void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:17949
eProsima_user_DllExport CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17808
eProsima_user_DllExport CompleteEnumeratedType(const CompleteEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17781
eProsima_user_DllExport void header(CompleteEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:17910
eProsima_user_DllExport CompleteEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17766
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:17881
eProsima_user_DllExport void header(const CompleteEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:17900
This class represents the structure CompleteExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20619
eProsima_user_DllExport CompleteExtendedType & operator=(const CompleteExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20660
eProsima_user_DllExport CompleteExtendedType(const CompleteExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20640
eProsima_user_DllExport CompleteExtendedType(CompleteExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20650
eProsima_user_DllExport CompleteExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20625
eProsima_user_DllExport bool operator!=(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20697
eProsima_user_DllExport ~CompleteExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20632
eProsima_user_DllExport bool operator==(const CompleteExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20686
This class represents the structure CompleteMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16240
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16358
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16475
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16397
eProsima_user_DllExport void key(CompleteCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16436
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16407
eProsima_user_DllExport const CompleteCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16446
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16387
eProsima_user_DllExport CompleteMapType & operator=(const CompleteMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16291
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16377
eProsima_user_DllExport CompleteMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16246
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16416
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16465
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16348
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16485
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16368
eProsima_user_DllExport CompleteCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16455
eProsima_user_DllExport CompleteMapType(const CompleteMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16261
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16494
eProsima_user_DllExport void key(const CompleteCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16426
eProsima_user_DllExport bool operator!=(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16338
eProsima_user_DllExport ~CompleteMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16253
eProsima_user_DllExport bool operator==(const CompleteMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16325
eProsima_user_DllExport CompleteMapType(CompleteMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16278
This class represents the structure CompleteMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7258
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:7466
eProsima_user_DllExport void name(const MemberName &_name)
This function copies the value in member name.
Definition dds_xtypes_typeobject.hpp:7359
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinMemberAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:7427
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:7408
eProsima_user_DllExport MemberName & name()
This function returns a reference to member name.
Definition dds_xtypes_typeobject.hpp:7388
eProsima_user_DllExport bool operator!=(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7349
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:7457
eProsima_user_DllExport CompleteMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7264
eProsima_user_DllExport const MemberName & name() const
This function returns a constant reference to member name.
Definition dds_xtypes_typeobject.hpp:7379
eProsima_user_DllExport CompleteMemberDetail(const CompleteMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7279
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:7418
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:7437
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:7398
eProsima_user_DllExport CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7306
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:7447
eProsima_user_DllExport bool operator==(const CompleteMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7337
eProsima_user_DllExport ~CompleteMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7271
eProsima_user_DllExport CompleteMemberDetail(CompleteMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7294
eProsima_user_DllExport void name(MemberName &&_name)
This function moves the value in member name.
Definition dds_xtypes_typeobject.hpp:7369
This class represents the structure CompleteSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14886
eProsima_user_DllExport CompleteSequenceType & operator=(const CompleteSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14934
eProsima_user_DllExport CompleteSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14892
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:14997
eProsima_user_DllExport bool operator==(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14965
eProsima_user_DllExport CompleteSequenceType(CompleteSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14922
eProsima_user_DllExport void element(CompleteCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15075
eProsima_user_DllExport void header(CompleteCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15036
eProsima_user_DllExport const CompleteCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15046
eProsima_user_DllExport void header(const CompleteCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15026
eProsima_user_DllExport bool operator!=(const CompleteSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14977
eProsima_user_DllExport ~CompleteSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14899
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15016
eProsima_user_DllExport CompleteCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15055
eProsima_user_DllExport void element(const CompleteCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15065
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:14987
eProsima_user_DllExport const CompleteCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15085
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15007
eProsima_user_DllExport CompleteSequenceType(const CompleteSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14907
eProsima_user_DllExport CompleteCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15094
This class represents the structure CompleteStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8437
eProsima_user_DllExport ~CompleteStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8450
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8580
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8599
eProsima_user_DllExport CompleteStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8443
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8541
eProsima_user_DllExport CompleteStructHeader(CompleteStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8471
eProsima_user_DllExport bool operator!=(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8521
eProsima_user_DllExport bool operator==(const CompleteStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8510
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8570
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8531
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8560
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8590
eProsima_user_DllExport CompleteStructHeader(const CompleteStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8458
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8551
eProsima_user_DllExport CompleteStructHeader & operator=(const CompleteStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8482
This class represents the structure CompleteStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7618
eProsima_user_DllExport CompleteStructMember(CompleteStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7652
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7751
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7712
eProsima_user_DllExport CompleteStructMember(const CompleteStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7639
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7761
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7741
eProsima_user_DllExport ~CompleteStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7631
eProsima_user_DllExport bool operator!=(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7702
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7780
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7732
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7722
eProsima_user_DllExport CompleteStructMember & operator=(const CompleteStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7663
eProsima_user_DllExport CompleteStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7624
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7771
eProsima_user_DllExport bool operator==(const CompleteStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7691
This class represents the structure CompleteStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8797
eProsima_user_DllExport const CompleteStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:8957
eProsima_user_DllExport CompleteStructType(CompleteStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8833
eProsima_user_DllExport bool operator!=(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8888
eProsima_user_DllExport CompleteStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:8966
eProsima_user_DllExport ~CompleteStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8810
eProsima_user_DllExport CompleteStructType(const CompleteStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8818
eProsima_user_DllExport void header(const CompleteStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:8937
eProsima_user_DllExport CompleteStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8803
eProsima_user_DllExport CompleteStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9005
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8908
eProsima_user_DllExport void member_seq(CompleteStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:8986
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:8898
eProsima_user_DllExport CompleteStructType & operator=(const CompleteStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8845
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8918
eProsima_user_DllExport void header(CompleteStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:8947
eProsima_user_DllExport void member_seq(const CompleteStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:8976
eProsima_user_DllExport const CompleteStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:8996
eProsima_user_DllExport bool operator==(const CompleteStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8876
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:8927
This class represents the structure CompleteTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8210
eProsima_user_DllExport CompleteTypeDetail(const CompleteTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8231
eProsima_user_DllExport const QualifiedTypeName & type_name() const
This function returns a constant reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8409
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedBuiltinTypeAnnotations > & ann_builtin()
This function returns a reference to member ann_builtin.
Definition dds_xtypes_typeobject.hpp:8340
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:8311
eProsima_user_DllExport eprosima::fastcdr::optional< AppliedAnnotationSeq > & ann_custom()
This function returns a reference to member ann_custom.
Definition dds_xtypes_typeobject.hpp:8379
eProsima_user_DllExport bool operator==(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8289
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:8331
eProsima_user_DllExport CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8258
eProsima_user_DllExport QualifiedTypeName & type_name()
This function returns a reference to member type_name.
Definition dds_xtypes_typeobject.hpp:8418
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:8370
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:8321
eProsima_user_DllExport void type_name(const QualifiedTypeName &_type_name)
This function copies the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8389
eProsima_user_DllExport CompleteTypeDetail(CompleteTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8246
eProsima_user_DllExport void type_name(QualifiedTypeName &&_type_name)
This function moves the value in member type_name.
Definition dds_xtypes_typeobject.hpp:8399
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:8350
eProsima_user_DllExport bool operator!=(const CompleteTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8301
eProsima_user_DllExport ~CompleteTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8223
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:8360
eProsima_user_DllExport CompleteTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8216
This class represents the union CompleteTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20714
CompleteStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:21957
eProsima_user_DllExport const CompleteBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21670
eProsima_user_DllExport const CompleteMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21564
eProsima_user_DllExport CompleteBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21420
CompleteExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:21965
CompleteAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:21955
eProsima_user_DllExport void array_type(CompleteArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21499
eProsima_user_DllExport void bitset_type(CompleteBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21393
eProsima_user_DllExport const CompleteBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:21405
eProsima_user_DllExport CompleteAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21261
eProsima_user_DllExport CompleteAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21208
eProsima_user_DllExport void map_type(const CompleteMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21541
eProsima_user_DllExport void annotation_type(CompleteAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21234
CompleteBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:21959
eProsima_user_DllExport void struct_type(const CompleteStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21276
eProsima_user_DllExport void bitmask_type(CompleteBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21658
eProsima_user_DllExport const CompleteAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:21246
eProsima_user_DllExport void struct_type(CompleteStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:21287
eProsima_user_DllExport void bitmask_type(const CompleteBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21647
eProsima_user_DllExport const CompleteStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21299
eProsima_user_DllExport CompleteTypeObject(const CompleteTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20743
CompleteAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:21956
eProsima_user_DllExport CompleteBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:21685
eProsima_user_DllExport CompleteStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:21314
eProsima_user_DllExport CompleteTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20720
eProsima_user_DllExport CompleteTypeObject(CompleteTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20801
eProsima_user_DllExport void sequence_type(const CompleteSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21435
eProsima_user_DllExport bool operator==(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20979
eProsima_user_DllExport void bitset_type(const CompleteBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:21382
eProsima_user_DllExport void union_type(CompleteUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21340
eProsima_user_DllExport CompleteUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21367
eProsima_user_DllExport ~CompleteTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20731
eProsima_user_DllExport bool operator!=(const CompleteTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:21052
eProsima_user_DllExport CompleteTypeObject & operator=(const CompleteTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20859
eProsima_user_DllExport void alias_type(const CompleteAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21170
eProsima_user_DllExport const CompleteSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21458
eProsima_user_DllExport void union_type(const CompleteUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:21329
CompleteArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:21961
eProsima_user_DllExport CompleteEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21632
eProsima_user_DllExport const CompleteEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21617
CompleteEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:21963
eProsima_user_DllExport void sequence_type(CompleteSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:21446
eProsima_user_DllExport CompleteExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21738
eProsima_user_DllExport void enumerated_type(CompleteEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21605
eProsima_user_DllExport const CompleteArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21511
eProsima_user_DllExport void alias_type(CompleteAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:21181
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:21063
eProsima_user_DllExport CompleteArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:21526
eProsima_user_DllExport void extended_type(CompleteExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21711
CompleteBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:21964
CompleteMapType m_map_type
Definition dds_xtypes_typeobject.hpp:21962
eProsima_user_DllExport void map_type(CompleteMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:21552
eProsima_user_DllExport CompleteSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:21473
CompleteSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:21960
eProsima_user_DllExport const CompleteUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:21352
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:21161
eProsima_user_DllExport void extended_type(const CompleteExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:21700
eProsima_user_DllExport const CompleteExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:21723
eProsima_user_DllExport CompleteMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:21579
eProsima_user_DllExport void enumerated_type(const CompleteEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:21594
eProsima_user_DllExport void annotation_type(const CompleteAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:21223
CompleteUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:21958
eProsima_user_DllExport void array_type(const CompleteArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:21488
eProsima_user_DllExport const CompleteAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:21193
This class represents the structure CompleteUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10421
eProsima_user_DllExport void detail(CompleteTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10518
eProsima_user_DllExport CompleteTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10537
eProsima_user_DllExport ~CompleteUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10434
eProsima_user_DllExport void detail(const CompleteTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10508
eProsima_user_DllExport bool operator!=(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10498
eProsima_user_DllExport CompleteUnionHeader(const CompleteUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10442
eProsima_user_DllExport CompleteUnionHeader(CompleteUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10453
eProsima_user_DllExport bool operator==(const CompleteUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10488
eProsima_user_DllExport const CompleteTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10528
eProsima_user_DllExport CompleteUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10427
eProsima_user_DllExport CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10463
This class represents the structure CompleteUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9517
eProsima_user_DllExport CompleteUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9523
eProsima_user_DllExport CompleteUnionMember(const CompleteUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9538
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9611
eProsima_user_DllExport void detail(const CompleteMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9650
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9621
eProsima_user_DllExport ~CompleteUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9530
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9640
eProsima_user_DllExport void detail(CompleteMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9660
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9631
eProsima_user_DllExport CompleteUnionMember & operator=(const CompleteUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9562
eProsima_user_DllExport bool operator!=(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9601
eProsima_user_DllExport bool operator==(const CompleteUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9590
eProsima_user_DllExport CompleteUnionMember(CompleteUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9551
eProsima_user_DllExport CompleteMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9679
eProsima_user_DllExport const CompleteMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9670
This class represents the structure CompleteUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10687
eProsima_user_DllExport bool operator==(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10772
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10805
eProsima_user_DllExport CompleteUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10941
eProsima_user_DllExport CompleteUnionType(CompleteUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10725
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:10795
eProsima_user_DllExport CompleteUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10693
eProsima_user_DllExport const CompleteUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:10932
eProsima_user_DllExport ~CompleteUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10700
eProsima_user_DllExport void discriminator(CompleteDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10883
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10824
eProsima_user_DllExport CompleteUnionType & operator=(const CompleteUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10738
eProsima_user_DllExport void member_seq(CompleteUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10922
eProsima_user_DllExport bool operator!=(const CompleteUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10785
eProsima_user_DllExport const CompleteDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10893
eProsima_user_DllExport void discriminator(const CompleteDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:10873
eProsima_user_DllExport CompleteDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:10902
eProsima_user_DllExport const CompleteUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:10854
eProsima_user_DllExport void header(CompleteUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:10844
eProsima_user_DllExport void header(const CompleteUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:10834
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:10815
eProsima_user_DllExport CompleteUnionType(const CompleteUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10708
eProsima_user_DllExport void member_seq(const CompleteUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:10912
eProsima_user_DllExport CompleteUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:10863
This class represents the structure Dummy defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2721
eProsima_user_DllExport bool operator!=(const Dummy &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2799
eProsima_user_DllExport Dummy()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2727
eProsima_user_DllExport Dummy & operator=(const Dummy &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2762
eProsima_user_DllExport Dummy(Dummy &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2752
eProsima_user_DllExport ~Dummy()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2734
eProsima_user_DllExport Dummy(const Dummy &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2742
eProsima_user_DllExport bool operator==(const Dummy &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2788
This class represents the structure ExtendedAnnotationParameterValue defined by the user in the IDL f...
Definition dds_xtypes_typeobject.hpp:4202
eProsima_user_DllExport ExtendedAnnotationParameterValue(ExtendedAnnotationParameterValue &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:4233
eProsima_user_DllExport bool operator==(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4269
eProsima_user_DllExport ExtendedAnnotationParameterValue & operator=(const ExtendedAnnotationParameterValue &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:4243
eProsima_user_DllExport bool operator!=(const ExtendedAnnotationParameterValue &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:4280
eProsima_user_DllExport ExtendedAnnotationParameterValue(const ExtendedAnnotationParameterValue &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:4223
eProsima_user_DllExport ExtendedAnnotationParameterValue()
Default constructor.
Definition dds_xtypes_typeobject.hpp:4208
eProsima_user_DllExport ~ExtendedAnnotationParameterValue()
Default destructor.
Definition dds_xtypes_typeobject.hpp:4215
This class represents the structure ExtendedTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2626
eProsima_user_DllExport ExtendedTypeDefn(const ExtendedTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2647
eProsima_user_DllExport bool operator!=(const ExtendedTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2704
eProsima_user_DllExport ~ExtendedTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2639
eProsima_user_DllExport ExtendedTypeDefn(ExtendedTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2657
eProsima_user_DllExport bool operator==(const ExtendedTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2693
eProsima_user_DllExport ExtendedTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2632
eProsima_user_DllExport ExtendedTypeDefn & operator=(const ExtendedTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2667
This class represents the structure MinimalAliasBody defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12962
eProsima_user_DllExport const CommonAliasBody & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:13069
eProsima_user_DllExport void common(const CommonAliasBody &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:13049
eProsima_user_DllExport MinimalAliasBody()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12968
eProsima_user_DllExport void common(CommonAliasBody &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:13059
eProsima_user_DllExport MinimalAliasBody(MinimalAliasBody &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12994
eProsima_user_DllExport bool operator==(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13029
eProsima_user_DllExport CommonAliasBody & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:13078
eProsima_user_DllExport ~MinimalAliasBody()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12975
eProsima_user_DllExport MinimalAliasBody(const MinimalAliasBody &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12983
eProsima_user_DllExport MinimalAliasBody & operator=(const MinimalAliasBody &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13004
eProsima_user_DllExport bool operator!=(const MinimalAliasBody &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13039
This class represents the structure MinimalAliasHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13228
eProsima_user_DllExport MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13269
eProsima_user_DllExport MinimalAliasHeader(const MinimalAliasHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13249
eProsima_user_DllExport MinimalAliasHeader(MinimalAliasHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13259
eProsima_user_DllExport ~MinimalAliasHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13241
eProsima_user_DllExport bool operator==(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13295
eProsima_user_DllExport bool operator!=(const MinimalAliasHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13306
eProsima_user_DllExport MinimalAliasHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13234
This class represents the structure MinimalAliasType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:13550
eProsima_user_DllExport const AliasTypeFlag & alias_flags() const
This function returns a constant reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13671
eProsima_user_DllExport MinimalAliasType & operator=(const MinimalAliasType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:13598
eProsima_user_DllExport MinimalAliasType(const MinimalAliasType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:13571
eProsima_user_DllExport void body(const MinimalAliasBody &_body)
This function copies the value in member body.
Definition dds_xtypes_typeobject.hpp:13729
eProsima_user_DllExport MinimalAliasType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:13556
eProsima_user_DllExport void header(const MinimalAliasHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:13690
eProsima_user_DllExport void header(MinimalAliasHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:13700
eProsima_user_DllExport MinimalAliasBody & body()
This function returns a reference to member body.
Definition dds_xtypes_typeobject.hpp:13758
eProsima_user_DllExport bool operator==(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13629
eProsima_user_DllExport void alias_flags(const AliasTypeFlag &_alias_flags)
This function copies the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13651
eProsima_user_DllExport bool operator!=(const MinimalAliasType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:13641
eProsima_user_DllExport void alias_flags(AliasTypeFlag &&_alias_flags)
This function moves the value in member alias_flags.
Definition dds_xtypes_typeobject.hpp:13661
eProsima_user_DllExport ~MinimalAliasType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:13563
eProsima_user_DllExport AliasTypeFlag & alias_flags()
This function returns a reference to member alias_flags.
Definition dds_xtypes_typeobject.hpp:13680
eProsima_user_DllExport void body(MinimalAliasBody &&_body)
This function moves the value in member body.
Definition dds_xtypes_typeobject.hpp:13739
eProsima_user_DllExport const MinimalAliasBody & body() const
This function returns a constant reference to member body.
Definition dds_xtypes_typeobject.hpp:13749
eProsima_user_DllExport const MinimalAliasHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:13710
eProsima_user_DllExport MinimalAliasHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:13719
eProsima_user_DllExport MinimalAliasType(MinimalAliasType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:13586
This class represents the structure MinimalAnnotationHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12006
eProsima_user_DllExport MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12047
eProsima_user_DllExport MinimalAnnotationHeader(MinimalAnnotationHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12037
eProsima_user_DllExport MinimalAnnotationHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12012
eProsima_user_DllExport bool operator!=(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12084
eProsima_user_DllExport ~MinimalAnnotationHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12019
eProsima_user_DllExport MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12027
eProsima_user_DllExport bool operator==(const MinimalAnnotationHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12073
This class represents the structure MinimalAnnotationParameter defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:11644
eProsima_user_DllExport const CommonAnnotationParameter & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:11765
eProsima_user_DllExport bool operator!=(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11735
eProsima_user_DllExport void common(const CommonAnnotationParameter &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:11745
eProsima_user_DllExport bool operator==(const MinimalAnnotationParameter &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11723
eProsima_user_DllExport MinimalAnnotationParameter(MinimalAnnotationParameter &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:11680
eProsima_user_DllExport MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11692
eProsima_user_DllExport const AnnotationParameterValue & default_value() const
This function returns a constant reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11843
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11784
eProsima_user_DllExport void common(CommonAnnotationParameter &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:11755
eProsima_user_DllExport CommonAnnotationParameter & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:11774
eProsima_user_DllExport AnnotationParameterValue & default_value()
This function returns a reference to member default_value.
Definition dds_xtypes_typeobject.hpp:11852
eProsima_user_DllExport ~MinimalAnnotationParameter()
Default destructor.
Definition dds_xtypes_typeobject.hpp:11657
eProsima_user_DllExport void default_value(AnnotationParameterValue &&_default_value)
This function moves the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11833
eProsima_user_DllExport MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:11665
eProsima_user_DllExport void default_value(const AnnotationParameterValue &_default_value)
This function copies the value in member default_value.
Definition dds_xtypes_typeobject.hpp:11823
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11804
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:11794
eProsima_user_DllExport MinimalAnnotationParameter()
Default constructor.
Definition dds_xtypes_typeobject.hpp:11650
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:11813
This class represents the structure MinimalAnnotationType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:12328
eProsima_user_DllExport MinimalAnnotationHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:12497
eProsima_user_DllExport void header(MinimalAnnotationHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:12478
eProsima_user_DllExport MinimalAnnotationParameterSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12536
eProsima_user_DllExport ~MinimalAnnotationType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:12341
eProsima_user_DllExport MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:12376
eProsima_user_DllExport AnnotationTypeFlag & annotation_flag()
This function returns a reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12458
eProsima_user_DllExport MinimalAnnotationType(MinimalAnnotationType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:12364
eProsima_user_DllExport void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
This function moves the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12439
eProsima_user_DllExport const MinimalAnnotationHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:12488
eProsima_user_DllExport bool operator==(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12407
eProsima_user_DllExport MinimalAnnotationType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:12334
eProsima_user_DllExport MinimalAnnotationType(const MinimalAnnotationType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:12349
eProsima_user_DllExport void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
This function copies the value in member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12429
eProsima_user_DllExport void header(const MinimalAnnotationHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:12468
eProsima_user_DllExport void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12517
eProsima_user_DllExport const AnnotationTypeFlag & annotation_flag() const
This function returns a constant reference to member annotation_flag.
Definition dds_xtypes_typeobject.hpp:12449
eProsima_user_DllExport void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:12507
eProsima_user_DllExport bool operator!=(const MinimalAnnotationType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:12419
eProsima_user_DllExport const MinimalAnnotationParameterSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:12527
This class represents the structure MinimalArrayHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15653
eProsima_user_DllExport MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15695
eProsima_user_DllExport ~MinimalArrayHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15666
eProsima_user_DllExport bool operator==(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15720
eProsima_user_DllExport MinimalArrayHeader(MinimalArrayHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15685
eProsima_user_DllExport MinimalArrayHeader(const MinimalArrayHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15674
eProsima_user_DllExport void common(CommonArrayHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:15750
eProsima_user_DllExport CommonArrayHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:15769
eProsima_user_DllExport const CommonArrayHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:15760
eProsima_user_DllExport void common(const CommonArrayHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:15740
eProsima_user_DllExport MinimalArrayHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15659
eProsima_user_DllExport bool operator!=(const MinimalArrayHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15730
This class represents the structure MinimalArrayType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16013
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16124
eProsima_user_DllExport void header(MinimalArrayHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16163
eProsima_user_DllExport bool operator==(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16092
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16202
eProsima_user_DllExport void header(const MinimalArrayHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16153
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16212
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16143
eProsima_user_DllExport const MinimalArrayHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16173
eProsima_user_DllExport ~MinimalArrayType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16026
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16114
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16192
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16134
eProsima_user_DllExport MinimalArrayType(MinimalArrayType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16049
eProsima_user_DllExport bool operator!=(const MinimalArrayType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16104
eProsima_user_DllExport MinimalArrayType & operator=(const MinimalArrayType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16061
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16221
eProsima_user_DllExport MinimalArrayType(const MinimalArrayType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16034
eProsima_user_DllExport MinimalArrayType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16019
eProsima_user_DllExport MinimalArrayHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16182
This class represents the structure MinimalBitfield defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19755
eProsima_user_DllExport MinimalBitfield(const MinimalBitfield &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19776
eProsima_user_DllExport CommonBitfield & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:19878
eProsima_user_DllExport const CommonBitfield & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:19869
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19888
eProsima_user_DllExport bool operator!=(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19839
eProsima_user_DllExport MinimalBitfield & operator=(const MinimalBitfield &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19800
eProsima_user_DllExport MinimalBitfield(MinimalBitfield &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19789
eProsima_user_DllExport ~MinimalBitfield()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19768
eProsima_user_DllExport bool operator==(const MinimalBitfield &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19828
eProsima_user_DllExport void common(const CommonBitfield &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:19849
eProsima_user_DllExport void common(CommonBitfield &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:19859
eProsima_user_DllExport MinimalBitfield()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19761
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19908
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:19898
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:19917
This class represents the structure MinimalBitflag defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:18566
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:18699
eProsima_user_DllExport CommonBitflag & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:18689
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:18719
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:18728
eProsima_user_DllExport MinimalBitflag(MinimalBitflag &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18600
eProsima_user_DllExport ~MinimalBitflag()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18579
eProsima_user_DllExport void common(const CommonBitflag &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:18660
eProsima_user_DllExport void common(CommonBitflag &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:18670
eProsima_user_DllExport bool operator!=(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18650
eProsima_user_DllExport const CommonBitflag & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:18680
eProsima_user_DllExport MinimalBitflag(const MinimalBitflag &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18587
eProsima_user_DllExport bool operator==(const MinimalBitflag &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18639
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:18709
eProsima_user_DllExport MinimalBitflag()
Default constructor.
Definition dds_xtypes_typeobject.hpp:18572
eProsima_user_DllExport MinimalBitflag & operator=(const MinimalBitflag &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18611
This class represents the structure MinimalBitmaskType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:19102
eProsima_user_DllExport void header(const MinimalBitmaskHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:19242
eProsima_user_DllExport ~MinimalBitmaskType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:19115
eProsima_user_DllExport const BitmaskTypeFlag & bitmask_flags() const
This function returns a constant reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19223
eProsima_user_DllExport MinimalBitmaskHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:19271
eProsima_user_DllExport void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
This function copies the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19203
eProsima_user_DllExport MinimalBitmaskType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:19108
eProsima_user_DllExport const MinimalBitflagSeq & flag_seq() const
This function returns a constant reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19301
eProsima_user_DllExport MinimalBitmaskType(MinimalBitmaskType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:19138
eProsima_user_DllExport void flag_seq(MinimalBitflagSeq &&_flag_seq)
This function moves the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19291
eProsima_user_DllExport bool operator==(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19181
eProsima_user_DllExport MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:19150
eProsima_user_DllExport void header(MinimalBitmaskHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:19252
eProsima_user_DllExport void flag_seq(const MinimalBitflagSeq &_flag_seq)
This function copies the value in member flag_seq.
Definition dds_xtypes_typeobject.hpp:19281
eProsima_user_DllExport MinimalBitflagSeq & flag_seq()
This function returns a reference to member flag_seq.
Definition dds_xtypes_typeobject.hpp:19310
eProsima_user_DllExport bool operator!=(const MinimalBitmaskType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:19193
eProsima_user_DllExport MinimalBitmaskType(const MinimalBitmaskType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:19123
eProsima_user_DllExport BitmaskTypeFlag & bitmask_flags()
This function returns a reference to member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19232
eProsima_user_DllExport const MinimalBitmaskHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:19262
eProsima_user_DllExport void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
This function moves the value in member bitmask_flags.
Definition dds_xtypes_typeobject.hpp:19213
This class represents the structure MinimalBitsetHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20070
eProsima_user_DllExport MinimalBitsetHeader(MinimalBitsetHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20101
eProsima_user_DllExport MinimalBitsetHeader(const MinimalBitsetHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20091
eProsima_user_DllExport ~MinimalBitsetHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20083
eProsima_user_DllExport bool operator!=(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20148
eProsima_user_DllExport MinimalBitsetHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20076
eProsima_user_DllExport MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20111
eProsima_user_DllExport bool operator==(const MinimalBitsetHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20137
This class represents the structure MinimalBitsetType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:20392
eProsima_user_DllExport MinimalBitsetType(MinimalBitsetType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:20428
eProsima_user_DllExport ~MinimalBitsetType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:20405
eProsima_user_DllExport void field_seq(const MinimalBitfieldSeq &_field_seq)
This function copies the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20571
eProsima_user_DllExport void header(const MinimalBitsetHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:20532
eProsima_user_DllExport void field_seq(MinimalBitfieldSeq &&_field_seq)
This function moves the value in member field_seq.
Definition dds_xtypes_typeobject.hpp:20581
eProsima_user_DllExport void bitset_flags(const BitsetTypeFlag &_bitset_flags)
This function copies the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20493
eProsima_user_DllExport const BitsetTypeFlag & bitset_flags() const
This function returns a constant reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20513
eProsima_user_DllExport bool operator==(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20471
eProsima_user_DllExport MinimalBitsetType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:20398
eProsima_user_DllExport MinimalBitfieldSeq & field_seq()
This function returns a reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20600
eProsima_user_DllExport const MinimalBitfieldSeq & field_seq() const
This function returns a constant reference to member field_seq.
Definition dds_xtypes_typeobject.hpp:20591
eProsima_user_DllExport MinimalBitsetHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:20561
eProsima_user_DllExport void bitset_flags(BitsetTypeFlag &&_bitset_flags)
This function moves the value in member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20503
eProsima_user_DllExport const MinimalBitsetHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:20552
eProsima_user_DllExport MinimalBitsetType & operator=(const MinimalBitsetType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:20440
eProsima_user_DllExport MinimalBitsetType(const MinimalBitsetType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:20413
eProsima_user_DllExport BitsetTypeFlag & bitset_flags()
This function returns a reference to member bitset_flags.
Definition dds_xtypes_typeobject.hpp:20522
eProsima_user_DllExport bool operator!=(const MinimalBitsetType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:20483
eProsima_user_DllExport void header(MinimalBitsetHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:20542
This class represents the structure MinimalCollectionElement defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14317
eProsima_user_DllExport MinimalCollectionElement(MinimalCollectionElement &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14349
eProsima_user_DllExport MinimalCollectionElement()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14323
eProsima_user_DllExport bool operator!=(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14394
eProsima_user_DllExport void common(const CommonCollectionElement &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14404
eProsima_user_DllExport MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14359
eProsima_user_DllExport MinimalCollectionElement(const MinimalCollectionElement &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14338
eProsima_user_DllExport const CommonCollectionElement & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14424
eProsima_user_DllExport bool operator==(const MinimalCollectionElement &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14384
eProsima_user_DllExport CommonCollectionElement & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14433
eProsima_user_DllExport ~MinimalCollectionElement()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14330
eProsima_user_DllExport void common(CommonCollectionElement &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14414
This class represents the structure MinimalCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:14753
eProsima_user_DllExport CommonCollectionHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:14869
eProsima_user_DllExport MinimalCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:14759
eProsima_user_DllExport const CommonCollectionHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:14860
eProsima_user_DllExport bool operator==(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14820
eProsima_user_DllExport bool operator!=(const MinimalCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:14830
eProsima_user_DllExport ~MinimalCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:14766
eProsima_user_DllExport MinimalCollectionHeader(MinimalCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:14785
eProsima_user_DllExport void common(const CommonCollectionHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:14840
eProsima_user_DllExport void common(CommonCollectionHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:14850
eProsima_user_DllExport MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:14795
eProsima_user_DllExport MinimalCollectionHeader(const MinimalCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:14774
This class represents the structure MinimalDiscriminatorMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10288
eProsima_user_DllExport MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10309
eProsima_user_DllExport CommonDiscriminatorMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:10404
eProsima_user_DllExport const CommonDiscriminatorMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:10395
eProsima_user_DllExport MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10330
eProsima_user_DllExport bool operator==(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10355
eProsima_user_DllExport ~MinimalDiscriminatorMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10301
eProsima_user_DllExport MinimalDiscriminatorMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10294
eProsima_user_DllExport bool operator!=(const MinimalDiscriminatorMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10365
eProsima_user_DllExport void common(CommonDiscriminatorMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:10385
eProsima_user_DllExport void common(const CommonDiscriminatorMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:10375
eProsima_user_DllExport MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10320
This class represents the structure MinimalEnumeratedHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17627
eProsima_user_DllExport CommonEnumeratedHeader & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17743
eProsima_user_DllExport MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17659
eProsima_user_DllExport const CommonEnumeratedHeader & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17734
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17704
eProsima_user_DllExport ~MinimalEnumeratedHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17640
eProsima_user_DllExport void common(const CommonEnumeratedHeader &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17714
eProsima_user_DllExport MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17648
eProsima_user_DllExport MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17669
eProsima_user_DllExport void common(CommonEnumeratedHeader &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17724
eProsima_user_DllExport bool operator==(const MinimalEnumeratedHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17694
eProsima_user_DllExport MinimalEnumeratedHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17633
This class represents the structure MinimalEnumeratedLiteral defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17142
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:17275
eProsima_user_DllExport MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:17187
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:17295
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:17304
eProsima_user_DllExport bool operator==(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17215
eProsima_user_DllExport const CommonEnumeratedLiteral & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:17256
eProsima_user_DllExport CommonEnumeratedLiteral & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:17265
eProsima_user_DllExport ~MinimalEnumeratedLiteral()
Default destructor.
Definition dds_xtypes_typeobject.hpp:17155
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:17285
eProsima_user_DllExport MinimalEnumeratedLiteral()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17148
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedLiteral &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:17226
eProsima_user_DllExport void common(const CommonEnumeratedLiteral &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:17236
eProsima_user_DllExport MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:17163
eProsima_user_DllExport MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:17176
eProsima_user_DllExport void common(CommonEnumeratedLiteral &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:17246
This class represents the structure MinimalEnumeratedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:17987
eProsima_user_DllExport MinimalEnumeratedHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:18156
eProsima_user_DllExport EnumTypeFlag & enum_flags()
This function returns a reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18117
eProsima_user_DllExport MinimalEnumeratedLiteralSeq & literal_seq()
This function returns a reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18195
eProsima_user_DllExport MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:18035
eProsima_user_DllExport MinimalEnumeratedType(MinimalEnumeratedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:18023
eProsima_user_DllExport void enum_flags(const EnumTypeFlag &_enum_flags)
This function copies the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18088
eProsima_user_DllExport bool operator==(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18066
eProsima_user_DllExport bool operator!=(const MinimalEnumeratedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:18078
eProsima_user_DllExport void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
This function moves the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18176
eProsima_user_DllExport void enum_flags(EnumTypeFlag &&_enum_flags)
This function moves the value in member enum_flags.
Definition dds_xtypes_typeobject.hpp:18098
eProsima_user_DllExport void header(MinimalEnumeratedHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:18137
eProsima_user_DllExport void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
This function copies the value in member literal_seq.
Definition dds_xtypes_typeobject.hpp:18166
eProsima_user_DllExport ~MinimalEnumeratedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:18000
eProsima_user_DllExport void header(const MinimalEnumeratedHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:18127
eProsima_user_DllExport const MinimalEnumeratedLiteralSeq & literal_seq() const
This function returns a constant reference to member literal_seq.
Definition dds_xtypes_typeobject.hpp:18186
eProsima_user_DllExport MinimalEnumeratedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:17993
eProsima_user_DllExport const MinimalEnumeratedHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:18147
eProsima_user_DllExport const EnumTypeFlag & enum_flags() const
This function returns a constant reference to member enum_flags.
Definition dds_xtypes_typeobject.hpp:18108
eProsima_user_DllExport MinimalEnumeratedType(const MinimalEnumeratedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:18008
This class represents the structure MinimalExtendedType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:21977
eProsima_user_DllExport MinimalExtendedType & operator=(const MinimalExtendedType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:22018
eProsima_user_DllExport bool operator==(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22044
eProsima_user_DllExport bool operator!=(const MinimalExtendedType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22055
eProsima_user_DllExport MinimalExtendedType(MinimalExtendedType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:22008
eProsima_user_DllExport MinimalExtendedType(const MinimalExtendedType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:21998
eProsima_user_DllExport MinimalExtendedType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:21983
eProsima_user_DllExport ~MinimalExtendedType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:21990
This class represents the structure MinimalMapType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:16514
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16632
eProsima_user_DllExport bool operator!=(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16612
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:16690
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:16749
eProsima_user_DllExport void key(const MinimalCollectionElement &_key)
This function copies the value in member key.
Definition dds_xtypes_typeobject.hpp:16700
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:16759
eProsima_user_DllExport MinimalCollectionElement & key()
This function returns a reference to member key.
Definition dds_xtypes_typeobject.hpp:16729
eProsima_user_DllExport ~MinimalMapType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:16527
eProsima_user_DllExport MinimalMapType(MinimalMapType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:16552
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:16681
eProsima_user_DllExport void key(MinimalCollectionElement &&_key)
This function moves the value in member key.
Definition dds_xtypes_typeobject.hpp:16710
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16651
eProsima_user_DllExport MinimalMapType(const MinimalMapType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:16535
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:16622
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:16739
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:16661
eProsima_user_DllExport MinimalMapType & operator=(const MinimalMapType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:16565
eProsima_user_DllExport MinimalMapType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:16520
eProsima_user_DllExport const MinimalCollectionElement & key() const
This function returns a constant reference to member key.
Definition dds_xtypes_typeobject.hpp:16720
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:16642
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:16768
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:16671
eProsima_user_DllExport bool operator==(const MinimalMapType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:16599
This class represents the structure MinimalMemberDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7485
eProsima_user_DllExport bool operator==(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7552
eProsima_user_DllExport void name_hash(const NameHash &_name_hash)
This function copies the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7572
eProsima_user_DllExport ~MinimalMemberDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7498
eProsima_user_DllExport MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7527
eProsima_user_DllExport bool operator!=(const MinimalMemberDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7562
eProsima_user_DllExport MinimalMemberDetail(const MinimalMemberDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7506
eProsima_user_DllExport MinimalMemberDetail(MinimalMemberDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7517
eProsima_user_DllExport MinimalMemberDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7491
eProsima_user_DllExport const NameHash & name_hash() const
This function returns a constant reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7592
eProsima_user_DllExport void name_hash(NameHash &&_name_hash)
This function moves the value in member name_hash.
Definition dds_xtypes_typeobject.hpp:7582
eProsima_user_DllExport NameHash & name_hash()
This function returns a reference to member name_hash.
Definition dds_xtypes_typeobject.hpp:7601
This class represents the structure MinimalSequenceType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:15113
eProsima_user_DllExport void collection_flag(CollectionTypeFlag &&_collection_flag)
This function moves the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15224
eProsima_user_DllExport MinimalCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:15282
eProsima_user_DllExport MinimalSequenceType(const MinimalSequenceType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:15134
eProsima_user_DllExport void element(MinimalCollectionElement &&_element)
This function moves the value in member element.
Definition dds_xtypes_typeobject.hpp:15302
eProsima_user_DllExport bool operator!=(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15204
eProsima_user_DllExport const MinimalCollectionElement & element() const
This function returns a constant reference to member element.
Definition dds_xtypes_typeobject.hpp:15312
eProsima_user_DllExport MinimalSequenceType(MinimalSequenceType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:15149
eProsima_user_DllExport MinimalSequenceType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:15119
eProsima_user_DllExport bool operator==(const MinimalSequenceType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:15192
eProsima_user_DllExport const MinimalCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:15273
eProsima_user_DllExport CollectionTypeFlag & collection_flag()
This function returns a reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15243
eProsima_user_DllExport void collection_flag(const CollectionTypeFlag &_collection_flag)
This function copies the value in member collection_flag.
Definition dds_xtypes_typeobject.hpp:15214
eProsima_user_DllExport void element(const MinimalCollectionElement &_element)
This function copies the value in member element.
Definition dds_xtypes_typeobject.hpp:15292
eProsima_user_DllExport void header(const MinimalCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:15253
eProsima_user_DllExport const CollectionTypeFlag & collection_flag() const
This function returns a constant reference to member collection_flag.
Definition dds_xtypes_typeobject.hpp:15234
eProsima_user_DllExport MinimalSequenceType & operator=(const MinimalSequenceType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:15161
eProsima_user_DllExport MinimalCollectionElement & element()
This function returns a reference to member element.
Definition dds_xtypes_typeobject.hpp:15321
eProsima_user_DllExport void header(MinimalCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:15263
eProsima_user_DllExport ~MinimalSequenceType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:15126
This class represents the structure MinimalStructHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8617
eProsima_user_DllExport bool operator==(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8690
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:8779
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:8750
eProsima_user_DllExport void base_type(TypeIdentifier &&_base_type)
This function moves the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8721
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:8770
eProsima_user_DllExport ~MinimalStructHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8630
eProsima_user_DllExport bool operator!=(const MinimalStructHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8701
eProsima_user_DllExport MinimalStructHeader & operator=(const MinimalStructHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8662
eProsima_user_DllExport MinimalStructHeader(const MinimalStructHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8638
eProsima_user_DllExport void base_type(const TypeIdentifier &_base_type)
This function copies the value in member base_type.
Definition dds_xtypes_typeobject.hpp:8711
eProsima_user_DllExport TypeIdentifier & base_type()
This function returns a reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8740
eProsima_user_DllExport MinimalStructHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8623
eProsima_user_DllExport const TypeIdentifier & base_type() const
This function returns a constant reference to member base_type.
Definition dds_xtypes_typeobject.hpp:8731
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:8760
eProsima_user_DllExport MinimalStructHeader(MinimalStructHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8651
This class represents the structure MinimalStructMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:7800
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:7933
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:7953
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:7962
eProsima_user_DllExport MinimalStructMember(MinimalStructMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:7834
eProsima_user_DllExport MinimalStructMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:7806
eProsima_user_DllExport void common(const CommonStructMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:7894
eProsima_user_DllExport MinimalStructMember & operator=(const MinimalStructMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:7845
eProsima_user_DllExport CommonStructMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:7923
eProsima_user_DllExport MinimalStructMember(const MinimalStructMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:7821
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:7943
eProsima_user_DllExport const CommonStructMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:7914
eProsima_user_DllExport void common(CommonStructMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:7904
eProsima_user_DllExport ~MinimalStructMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:7813
eProsima_user_DllExport bool operator==(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7873
eProsima_user_DllExport bool operator!=(const MinimalStructMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:7884
This class represents the structure MinimalStructType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9024
eProsima_user_DllExport void header(const MinimalStructHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:9164
eProsima_user_DllExport const MinimalStructMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9223
eProsima_user_DllExport void header(MinimalStructHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:9174
eProsima_user_DllExport MinimalStructType & operator=(const MinimalStructType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9072
eProsima_user_DllExport MinimalStructType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9030
eProsima_user_DllExport MinimalStructType(const MinimalStructType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9045
eProsima_user_DllExport MinimalStructMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:9232
eProsima_user_DllExport ~MinimalStructType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9037
eProsima_user_DllExport void member_seq(MinimalStructMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9213
eProsima_user_DllExport bool operator!=(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9115
eProsima_user_DllExport void struct_flags(StructTypeFlag &&_struct_flags)
This function moves the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9135
eProsima_user_DllExport void struct_flags(const StructTypeFlag &_struct_flags)
This function copies the value in member struct_flags.
Definition dds_xtypes_typeobject.hpp:9125
eProsima_user_DllExport bool operator==(const MinimalStructType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9103
eProsima_user_DllExport const StructTypeFlag & struct_flags() const
This function returns a constant reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9145
eProsima_user_DllExport const MinimalStructHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:9184
eProsima_user_DllExport MinimalStructType(MinimalStructType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9060
eProsima_user_DllExport void member_seq(const MinimalStructMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:9203
eProsima_user_DllExport StructTypeFlag & struct_flags()
This function returns a reference to member struct_flags.
Definition dds_xtypes_typeobject.hpp:9154
eProsima_user_DllExport MinimalStructHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:9193
This class represents the structure MinimalTypeDetail defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:8115
eProsima_user_DllExport bool operator!=(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8193
eProsima_user_DllExport MinimalTypeDetail(const MinimalTypeDetail &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:8136
eProsima_user_DllExport MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:8156
eProsima_user_DllExport MinimalTypeDetail(MinimalTypeDetail &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:8146
eProsima_user_DllExport MinimalTypeDetail()
Default constructor.
Definition dds_xtypes_typeobject.hpp:8121
eProsima_user_DllExport bool operator==(const MinimalTypeDetail &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:8182
eProsima_user_DllExport ~MinimalTypeDetail()
Default destructor.
Definition dds_xtypes_typeobject.hpp:8128
This class represents the union MinimalTypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:22072
eProsima_user_DllExport MinimalStructType & struct_type()
This function returns a reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22672
eProsima_user_DllExport void union_type(const MinimalUnionType &_union_type)
This function copies the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22687
eProsima_user_DllExport const MinimalEnumeratedType & enumerated_type() const
This function returns a constant reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22975
eProsima_user_DllExport MinimalTypeObject & operator=(const MinimalTypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:22217
eProsima_user_DllExport void bitmask_type(MinimalBitmaskType &&_bitmask_type)
This function moves the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23016
MinimalExtendedType m_extended_type
Definition dds_xtypes_typeobject.hpp:23323
eProsima_user_DllExport bool operator==(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22337
MinimalEnumeratedType m_enumerated_type
Definition dds_xtypes_typeobject.hpp:23321
eProsima_user_DllExport void bitset_type(MinimalBitsetType &&_bitset_type)
This function moves the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22751
eProsima_user_DllExport void bitmask_type(const MinimalBitmaskType &_bitmask_type)
This function copies the value in member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23005
MinimalUnionType m_union_type
Definition dds_xtypes_typeobject.hpp:23316
eProsima_user_DllExport void alias_type(const MinimalAliasType &_alias_type)
This function copies the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22528
MinimalAliasType m_alias_type
Definition dds_xtypes_typeobject.hpp:23313
eProsima_user_DllExport MinimalExtendedType & extended_type()
This function returns a reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23096
eProsima_user_DllExport MinimalBitsetType & bitset_type()
This function returns a reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22778
eProsima_user_DllExport void enumerated_type(MinimalEnumeratedType &&_enumerated_type)
This function moves the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22963
eProsima_user_DllExport MinimalSequenceType & sequence_type()
This function returns a reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22831
eProsima_user_DllExport const MinimalExtendedType & extended_type() const
This function returns a constant reference to member extended_type.
Definition dds_xtypes_typeobject.hpp:23081
eProsima_user_DllExport void extended_type(MinimalExtendedType &&_extended_type)
This function moves the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23069
eProsima_user_DllExport void map_type(const MinimalMapType &_map_type)
This function copies the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22899
eProsima_user_DllExport const MinimalArrayType & array_type() const
This function returns a constant reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22869
eProsima_user_DllExport void array_type(MinimalArrayType &&_array_type)
This function moves the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22857
eProsima_user_DllExport MinimalAliasType & alias_type()
This function returns a reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22566
eProsima_user_DllExport const MinimalUnionType & union_type() const
This function returns a constant reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22710
eProsima_user_DllExport const MinimalStructType & struct_type() const
This function returns a constant reference to member struct_type.
Definition dds_xtypes_typeobject.hpp:22657
eProsima_user_DllExport MinimalTypeObject(const MinimalTypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:22101
eProsima_user_DllExport MinimalTypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:22078
eProsima_user_DllExport void sequence_type(MinimalSequenceType &&_sequence_type)
This function moves the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22804
MinimalAnnotationType m_annotation_type
Definition dds_xtypes_typeobject.hpp:23314
eProsima_user_DllExport MinimalEnumeratedType & enumerated_type()
This function returns a reference to member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22990
eProsima_user_DllExport void enumerated_type(const MinimalEnumeratedType &_enumerated_type)
This function copies the value in member enumerated_type.
Definition dds_xtypes_typeobject.hpp:22952
eProsima_user_DllExport MinimalBitmaskType & bitmask_type()
This function returns a reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23043
eProsima_user_DllExport void extended_type(const MinimalExtendedType &_extended_type)
This function copies the value in member extended_type.
Definition dds_xtypes_typeobject.hpp:23058
eProsima_user_DllExport const MinimalBitmaskType & bitmask_type() const
This function returns a constant reference to member bitmask_type.
Definition dds_xtypes_typeobject.hpp:23028
eProsima_user_DllExport MinimalAnnotationType & annotation_type()
This function returns a reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22619
MinimalArrayType m_array_type
Definition dds_xtypes_typeobject.hpp:23319
eProsima_user_DllExport void sequence_type(const MinimalSequenceType &_sequence_type)
This function copies the value in member sequence_type.
Definition dds_xtypes_typeobject.hpp:22793
eProsima_user_DllExport const MinimalAliasType & alias_type() const
This function returns a constant reference to member alias_type.
Definition dds_xtypes_typeobject.hpp:22551
eProsima_user_DllExport void annotation_type(MinimalAnnotationType &&_annotation_type)
This function moves the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22592
eProsima_user_DllExport void annotation_type(const MinimalAnnotationType &_annotation_type)
This function copies the value in member annotation_type.
Definition dds_xtypes_typeobject.hpp:22581
eProsima_user_DllExport void union_type(MinimalUnionType &&_union_type)
This function moves the value in member union_type.
Definition dds_xtypes_typeobject.hpp:22698
eProsima_user_DllExport const MinimalSequenceType & sequence_type() const
This function returns a constant reference to member sequence_type.
Definition dds_xtypes_typeobject.hpp:22816
eProsima_user_DllExport void alias_type(MinimalAliasType &&_alias_type)
This function moves the value in member alias_type.
Definition dds_xtypes_typeobject.hpp:22539
eProsima_user_DllExport void struct_type(MinimalStructType &&_struct_type)
This function moves the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22645
eProsima_user_DllExport MinimalUnionType & union_type()
This function returns a reference to member union_type.
Definition dds_xtypes_typeobject.hpp:22725
eProsima_user_DllExport void map_type(MinimalMapType &&_map_type)
This function moves the value in member map_type.
Definition dds_xtypes_typeobject.hpp:22910
eProsima_user_DllExport const MinimalAnnotationType & annotation_type() const
This function returns a constant reference to member annotation_type.
Definition dds_xtypes_typeobject.hpp:22604
eProsima_user_DllExport void struct_type(const MinimalStructType &_struct_type)
This function copies the value in member struct_type.
Definition dds_xtypes_typeobject.hpp:22634
MinimalMapType m_map_type
Definition dds_xtypes_typeobject.hpp:23320
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:22421
eProsima_user_DllExport MinimalTypeObject(MinimalTypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:22159
eProsima_user_DllExport const MinimalBitsetType & bitset_type() const
This function returns a constant reference to member bitset_type.
Definition dds_xtypes_typeobject.hpp:22763
eProsima_user_DllExport MinimalArrayType & array_type()
This function returns a reference to member array_type.
Definition dds_xtypes_typeobject.hpp:22884
MinimalBitmaskType m_bitmask_type
Definition dds_xtypes_typeobject.hpp:23322
eProsima_user_DllExport void bitset_type(const MinimalBitsetType &_bitset_type)
This function copies the value in member bitset_type.
Definition dds_xtypes_typeobject.hpp:22740
eProsima_user_DllExport MinimalMapType & map_type()
This function returns a reference to member map_type.
Definition dds_xtypes_typeobject.hpp:22937
eProsima_user_DllExport const MinimalMapType & map_type() const
This function returns a constant reference to member map_type.
Definition dds_xtypes_typeobject.hpp:22922
eProsima_user_DllExport ~MinimalTypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:22089
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:22519
MinimalStructType m_struct_type
Definition dds_xtypes_typeobject.hpp:23315
eProsima_user_DllExport void array_type(const MinimalArrayType &_array_type)
This function copies the value in member array_type.
Definition dds_xtypes_typeobject.hpp:22846
MinimalBitsetType m_bitset_type
Definition dds_xtypes_typeobject.hpp:23317
MinimalSequenceType m_sequence_type
Definition dds_xtypes_typeobject.hpp:23318
eProsima_user_DllExport bool operator!=(const MinimalTypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:22410
This class represents the structure MinimalUnionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10554
eProsima_user_DllExport MinimalTypeDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:10670
eProsima_user_DllExport void detail(const MinimalTypeDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:10641
eProsima_user_DllExport MinimalUnionHeader(MinimalUnionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10586
eProsima_user_DllExport const MinimalTypeDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:10661
eProsima_user_DllExport MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:10596
eProsima_user_DllExport bool operator!=(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10631
eProsima_user_DllExport MinimalUnionHeader(const MinimalUnionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10575
eProsima_user_DllExport MinimalUnionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10560
eProsima_user_DllExport ~MinimalUnionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10567
eProsima_user_DllExport void detail(MinimalTypeDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:10651
eProsima_user_DllExport bool operator==(const MinimalUnionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:10621
This class represents the structure MinimalUnionMember defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:9699
eProsima_user_DllExport void detail(const MinimalMemberDetail &_detail)
This function copies the value in member detail.
Definition dds_xtypes_typeobject.hpp:9832
eProsima_user_DllExport const MinimalMemberDetail & detail() const
This function returns a constant reference to member detail.
Definition dds_xtypes_typeobject.hpp:9852
eProsima_user_DllExport MinimalMemberDetail & detail()
This function returns a reference to member detail.
Definition dds_xtypes_typeobject.hpp:9861
eProsima_user_DllExport void common(const CommonUnionMember &_common)
This function copies the value in member common.
Definition dds_xtypes_typeobject.hpp:9793
eProsima_user_DllExport MinimalUnionMember & operator=(const MinimalUnionMember &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:9744
eProsima_user_DllExport void common(CommonUnionMember &&_common)
This function moves the value in member common.
Definition dds_xtypes_typeobject.hpp:9803
eProsima_user_DllExport CommonUnionMember & common()
This function returns a reference to member common.
Definition dds_xtypes_typeobject.hpp:9822
eProsima_user_DllExport bool operator!=(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9783
eProsima_user_DllExport const CommonUnionMember & common() const
This function returns a constant reference to member common.
Definition dds_xtypes_typeobject.hpp:9813
eProsima_user_DllExport void detail(MinimalMemberDetail &&_detail)
This function moves the value in member detail.
Definition dds_xtypes_typeobject.hpp:9842
eProsima_user_DllExport ~MinimalUnionMember()
Default destructor.
Definition dds_xtypes_typeobject.hpp:9712
eProsima_user_DllExport MinimalUnionMember(const MinimalUnionMember &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:9720
eProsima_user_DllExport bool operator==(const MinimalUnionMember &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:9772
eProsima_user_DllExport MinimalUnionMember()
Default constructor.
Definition dds_xtypes_typeobject.hpp:9705
eProsima_user_DllExport MinimalUnionMember(MinimalUnionMember &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:9733
This class represents the structure MinimalUnionType defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:10961
eProsima_user_DllExport void discriminator(MinimalDiscriminatorMember &&_discriminator)
This function moves the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11157
eProsima_user_DllExport MinimalDiscriminatorMember & discriminator()
This function returns a reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11176
eProsima_user_DllExport void union_flags(UnionTypeFlag &&_union_flags)
This function moves the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11079
eProsima_user_DllExport MinimalUnionType(const MinimalUnionType &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:10982
eProsima_user_DllExport void union_flags(const UnionTypeFlag &_union_flags)
This function copies the value in member union_flags.
Definition dds_xtypes_typeobject.hpp:11069
eProsima_user_DllExport void header(const MinimalUnionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:11108
eProsima_user_DllExport MinimalUnionType()
Default constructor.
Definition dds_xtypes_typeobject.hpp:10967
eProsima_user_DllExport const MinimalDiscriminatorMember & discriminator() const
This function returns a constant reference to member discriminator.
Definition dds_xtypes_typeobject.hpp:11167
eProsima_user_DllExport void discriminator(const MinimalDiscriminatorMember &_discriminator)
This function copies the value in member discriminator.
Definition dds_xtypes_typeobject.hpp:11147
eProsima_user_DllExport UnionTypeFlag & union_flags()
This function returns a reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11098
eProsima_user_DllExport MinimalUnionMemberSeq & member_seq()
This function returns a reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11215
eProsima_user_DllExport ~MinimalUnionType()
Default destructor.
Definition dds_xtypes_typeobject.hpp:10974
eProsima_user_DllExport MinimalUnionType(MinimalUnionType &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:10999
eProsima_user_DllExport bool operator!=(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11059
eProsima_user_DllExport const UnionTypeFlag & union_flags() const
This function returns a constant reference to member union_flags.
Definition dds_xtypes_typeobject.hpp:11089
eProsima_user_DllExport void header(MinimalUnionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:11118
eProsima_user_DllExport void member_seq(MinimalUnionMemberSeq &&_member_seq)
This function moves the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11196
eProsima_user_DllExport MinimalUnionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:11137
eProsima_user_DllExport void member_seq(const MinimalUnionMemberSeq &_member_seq)
This function copies the value in member member_seq.
Definition dds_xtypes_typeobject.hpp:11186
eProsima_user_DllExport const MinimalUnionMemberSeq & member_seq() const
This function returns a constant reference to member member_seq.
Definition dds_xtypes_typeobject.hpp:11206
eProsima_user_DllExport MinimalUnionType & operator=(const MinimalUnionType &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:11012
eProsima_user_DllExport const MinimalUnionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:11128
eProsima_user_DllExport bool operator==(const MinimalUnionType &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:11046
This class represents the structure PlainArrayLElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1570
eProsima_user_DllExport LBoundSeq & array_bound_seq()
This function returns a reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1739
eProsima_user_DllExport PlainArrayLElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1576
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:1749
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:1769
eProsima_user_DllExport PlainArrayLElemDefn(const PlainArrayLElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1591
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:1759
eProsima_user_DllExport ~PlainArrayLElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1583
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1681
eProsima_user_DllExport bool operator!=(const PlainArrayLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1661
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1691
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:1730
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1671
eProsima_user_DllExport PlainArrayLElemDefn(PlainArrayLElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1606
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:1720
eProsima_user_DllExport bool operator==(const PlainArrayLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1649
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1700
eProsima_user_DllExport PlainArrayLElemDefn & operator=(const PlainArrayLElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1618
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:1710
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1778
This class represents the structure PlainArraySElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1343
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:1483
eProsima_user_DllExport ~PlainArraySElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1356
eProsima_user_DllExport PlainArraySElemDefn(PlainArraySElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1379
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:1522
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:1542
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:1532
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:1493
eProsima_user_DllExport bool operator==(const PlainArraySElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1422
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1454
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1464
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1444
eProsima_user_DllExport SBoundSeq & array_bound_seq()
This function returns a reference to member array_bound_seq.
Definition dds_xtypes_typeobject.hpp:1512
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1473
eProsima_user_DllExport PlainArraySElemDefn & operator=(const PlainArraySElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1391
eProsima_user_DllExport PlainArraySElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1349
eProsima_user_DllExport bool operator!=(const PlainArraySElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1434
eProsima_user_DllExport PlainArraySElemDefn(const PlainArraySElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1364
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1551
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:1503
This class represents the structure PlainCollectionHeader defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:739
eProsima_user_DllExport CollectionElementFlag & element_flags()
This function returns a reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:891
eProsima_user_DllExport PlainCollectionHeader(const PlainCollectionHeader &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:760
eProsima_user_DllExport void element_flags(CollectionElementFlag &&_element_flags)
This function moves the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:872
eProsima_user_DllExport PlainCollectionHeader()
Default constructor.
Definition dds_xtypes_typeobject.hpp:745
eProsima_user_DllExport EquivalenceKind & equiv_kind()
This function returns a reference to member equiv_kind.
Definition dds_xtypes_typeobject.hpp:852
eProsima_user_DllExport ~PlainCollectionHeader()
Default destructor.
Definition dds_xtypes_typeobject.hpp:752
eProsima_user_DllExport PlainCollectionHeader(PlainCollectionHeader &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:773
eProsima_user_DllExport EquivalenceKind equiv_kind() const
This function returns the value of member equiv_kind.
Definition dds_xtypes_typeobject.hpp:843
eProsima_user_DllExport void equiv_kind(EquivalenceKind _equiv_kind)
This function sets a value in member equiv_kind.
Definition dds_xtypes_typeobject.hpp:833
eProsima_user_DllExport bool operator==(const PlainCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:812
eProsima_user_DllExport void element_flags(const CollectionElementFlag &_element_flags)
This function copies the value in member element_flags.
Definition dds_xtypes_typeobject.hpp:862
eProsima_user_DllExport PlainCollectionHeader & operator=(const PlainCollectionHeader &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:784
eProsima_user_DllExport const CollectionElementFlag & element_flags() const
This function returns a constant reference to member element_flags.
Definition dds_xtypes_typeobject.hpp:882
eProsima_user_DllExport bool operator!=(const PlainCollectionHeader &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:823
This class represents the structure PlainMapLTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2108
eProsima_user_DllExport PlainMapLTypeDefn(PlainMapLTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2148
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:2281
eProsima_user_DllExport CollectionElementFlag & key_flags()
This function returns a reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2359
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:2369
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:2291
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:2311
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:2301
eProsima_user_DllExport bool operator!=(const PlainMapLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2213
eProsima_user_DllExport const CollectionElementFlag & key_flags() const
This function returns a constant reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2350
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:2262
eProsima_user_DllExport PlainMapLTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2114
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & key_identifier()
This function returns a reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2398
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:2233
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:2243
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:2223
eProsima_user_DllExport PlainMapLTypeDefn(const PlainMapLTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2129
eProsima_user_DllExport PlainMapLTypeDefn & operator=(const PlainMapLTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2162
eProsima_user_DllExport void key_flags(const CollectionElementFlag &_key_flags)
This function copies the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2330
eProsima_user_DllExport bool operator==(const PlainMapLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2199
eProsima_user_DllExport ~PlainMapLTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2121
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:2272
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:2379
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:2252
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2320
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:2389
eProsima_user_DllExport void key_flags(CollectionElementFlag &&_key_flags)
This function moves the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2340
This class represents the structure PlainMapSTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1797
eProsima_user_DllExport CollectionElementFlag & key_flags()
This function returns a reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2048
eProsima_user_DllExport PlainMapSTypeDefn(PlainMapSTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1837
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:2058
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:1980
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:2000
eProsima_user_DllExport bool operator==(const PlainMapSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1888
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:1990
eProsima_user_DllExport PlainMapSTypeDefn & operator=(const PlainMapSTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1851
eProsima_user_DllExport const CollectionElementFlag & key_flags() const
This function returns a constant reference to member key_flags.
Definition dds_xtypes_typeobject.hpp:2039
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1961
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1951
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & key_identifier()
This function returns a reference to member key_identifier.
Definition dds_xtypes_typeobject.hpp:2087
eProsima_user_DllExport PlainMapSTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1803
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1922
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1932
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1912
eProsima_user_DllExport void key_flags(const CollectionElementFlag &_key_flags)
This function copies the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2019
eProsima_user_DllExport bool operator!=(const PlainMapSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1902
eProsima_user_DllExport ~PlainMapSTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1810
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:2068
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1941
eProsima_user_DllExport PlainMapSTypeDefn(const PlainMapSTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1818
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1970
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:2009
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:2078
eProsima_user_DllExport void key_flags(CollectionElementFlag &&_key_flags)
This function moves the value in member key_flags.
Definition dds_xtypes_typeobject.hpp:2029
This class represents the structure PlainSequenceLElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:1126
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1285
eProsima_user_DllExport PlainSequenceLElemDefn & operator=(const PlainSequenceLElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:1174
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:1295
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:1315
eProsima_user_DllExport PlainSequenceLElemDefn(const PlainSequenceLElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:1147
eProsima_user_DllExport ~PlainSequenceLElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:1139
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:1305
eProsima_user_DllExport bool operator!=(const PlainSequenceLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1217
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1266
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1237
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1247
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1227
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1276
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1256
eProsima_user_DllExport PlainSequenceLElemDefn(PlainSequenceLElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:1162
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1324
eProsima_user_DllExport bool operator==(const PlainSequenceLElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1205
eProsima_user_DllExport PlainSequenceLElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:1132
This class represents the structure PlainSequenceSElemDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:909
eProsima_user_DllExport PlainSequenceSElemDefn(const PlainSequenceSElemDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:930
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:1078
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:1098
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:1088
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:1059
eProsima_user_DllExport PlainSequenceSElemDefn & operator=(const PlainSequenceSElemDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:957
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:1049
eProsima_user_DllExport void header(PlainCollectionHeader &&_header)
This function moves the value in member header.
Definition dds_xtypes_typeobject.hpp:1020
eProsima_user_DllExport const PlainCollectionHeader & header() const
This function returns a constant reference to member header.
Definition dds_xtypes_typeobject.hpp:1030
eProsima_user_DllExport bool operator!=(const PlainSequenceSElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:1000
eProsima_user_DllExport void header(const PlainCollectionHeader &_header)
This function copies the value in member header.
Definition dds_xtypes_typeobject.hpp:1010
eProsima_user_DllExport PlainSequenceSElemDefn(PlainSequenceSElemDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:945
eProsima_user_DllExport PlainSequenceSElemDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:915
eProsima_user_DllExport bool operator==(const PlainSequenceSElemDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:988
eProsima_user_DllExport ~PlainSequenceSElemDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:922
eProsima_user_DllExport PlainCollectionHeader & header()
This function returns a reference to member header.
Definition dds_xtypes_typeobject.hpp:1039
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:1068
eProsima_user_DllExport eprosima::fastcdr::external< TypeIdentifier > & element_identifier()
This function returns a reference to member element_identifier.
Definition dds_xtypes_typeobject.hpp:1107
This class represents the structure StringLTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:616
eProsima_user_DllExport LBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:722
eProsima_user_DllExport ~StringLTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:629
eProsima_user_DllExport void bound(LBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:703
eProsima_user_DllExport StringLTypeDefn(StringLTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:648
eProsima_user_DllExport StringLTypeDefn & operator=(const StringLTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:658
eProsima_user_DllExport LBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:713
eProsima_user_DllExport StringLTypeDefn(const StringLTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:637
eProsima_user_DllExport bool operator==(const StringLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:683
eProsima_user_DllExport bool operator!=(const StringLTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:693
eProsima_user_DllExport StringLTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:622
This class represents the structure StringSTypeDefn defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:493
eProsima_user_DllExport StringSTypeDefn & operator=(const StringSTypeDefn &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:535
eProsima_user_DllExport StringSTypeDefn()
Default constructor.
Definition dds_xtypes_typeobject.hpp:499
eProsima_user_DllExport SBound bound() const
This function returns the value of member bound.
Definition dds_xtypes_typeobject.hpp:590
eProsima_user_DllExport void bound(SBound _bound)
This function sets a value in member bound.
Definition dds_xtypes_typeobject.hpp:580
eProsima_user_DllExport bool operator==(const StringSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:560
eProsima_user_DllExport bool operator!=(const StringSTypeDefn &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:570
eProsima_user_DllExport SBound & bound()
This function returns a reference to member bound.
Definition dds_xtypes_typeobject.hpp:599
eProsima_user_DllExport StringSTypeDefn(const StringSTypeDefn &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:514
eProsima_user_DllExport StringSTypeDefn(StringSTypeDefn &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:525
eProsima_user_DllExport ~StringSTypeDefn()
Default destructor.
Definition dds_xtypes_typeobject.hpp:506
This class represents the structure StronglyConnectedComponentId defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2419
eProsima_user_DllExport TypeObjectHashId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:2549
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:2530
eProsima_user_DllExport ~StronglyConnectedComponentId()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2432
eProsima_user_DllExport int32_t scc_index() const
This function returns the value of member scc_index.
Definition dds_xtypes_typeobject.hpp:2598
eProsima_user_DllExport bool operator!=(const StronglyConnectedComponentId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2510
eProsima_user_DllExport int32_t & scc_length()
This function returns a reference to member scc_length.
Definition dds_xtypes_typeobject.hpp:2578
eProsima_user_DllExport bool operator==(const StronglyConnectedComponentId &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:2498
eProsima_user_DllExport StronglyConnectedComponentId(const StronglyConnectedComponentId &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2440
eProsima_user_DllExport StronglyConnectedComponentId()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2425
eProsima_user_DllExport StronglyConnectedComponentId & operator=(const StronglyConnectedComponentId &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2467
eProsima_user_DllExport StronglyConnectedComponentId(StronglyConnectedComponentId &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2455
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:2520
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:2540
eProsima_user_DllExport void scc_index(int32_t _scc_index)
This function sets a value in member scc_index.
Definition dds_xtypes_typeobject.hpp:2588
eProsima_user_DllExport int32_t scc_length() const
This function returns the value of member scc_length.
Definition dds_xtypes_typeobject.hpp:2569
eProsima_user_DllExport int32_t & scc_index()
This function returns a reference to member scc_index.
Definition dds_xtypes_typeobject.hpp:2607
eProsima_user_DllExport void scc_length(int32_t _scc_length)
This function sets a value in member scc_length.
Definition dds_xtypes_typeobject.hpp:2559
This class represents the structure TypeIdentfierWithSize defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24081
eProsima_user_DllExport const TypeIdentifier & type_id() const
This function returns a constant reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24195
eProsima_user_DllExport bool operator==(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24154
eProsima_user_DllExport bool operator!=(const TypeIdentfierWithSize &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24165
eProsima_user_DllExport TypeIdentifier & type_id()
This function returns a reference to member type_id.
Definition dds_xtypes_typeobject.hpp:24204
eProsima_user_DllExport TypeIdentfierWithSize(TypeIdentfierWithSize &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24115
eProsima_user_DllExport void type_id(TypeIdentifier &&_type_id)
This function moves the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24185
eProsima_user_DllExport uint32_t typeobject_serialized_size() const
This function returns the value of member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24224
eProsima_user_DllExport ~TypeIdentfierWithSize()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24094
eProsima_user_DllExport uint32_t & typeobject_serialized_size()
This function returns a reference to member typeobject_serialized_size.
Definition dds_xtypes_typeobject.hpp:24233
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:24214
eProsima_user_DllExport TypeIdentfierWithSize & operator=(const TypeIdentfierWithSize &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24126
eProsima_user_DllExport TypeIdentfierWithSize(const TypeIdentfierWithSize &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24102
eProsima_user_DllExport TypeIdentfierWithSize()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24087
eProsima_user_DllExport void type_id(const TypeIdentifier &_type_id)
This function copies the value in member type_id.
Definition dds_xtypes_typeobject.hpp:24175
This class represents the union TypeIdentifier defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2816
eProsima_user_DllExport const StringLTypeDefn & string_ldefn() const
This function returns a constant reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3446
eProsima_user_DllExport TypeIdentifier(TypeIdentifier &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:2907
Dummy m_no_value
Definition dds_xtypes_typeobject.hpp:4173
eProsima_user_DllExport void equivalence_hash(EquivalenceHash &&_equivalence_hash)
This function moves the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3858
eProsima_user_DllExport const EquivalenceHash & equivalence_hash() const
This function returns a constant reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3870
eProsima_user_DllExport ~TypeIdentifier()
Default destructor.
Definition dds_xtypes_typeobject.hpp:2833
eProsima_user_DllExport PlainMapSTypeDefn & map_sdefn()
This function returns a reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3726
eProsima_user_DllExport void map_ldefn(const PlainMapLTypeDefn &_map_ldefn)
This function copies the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3741
StronglyConnectedComponentId m_sc_component_id
Definition dds_xtypes_typeobject.hpp:4182
eProsima_user_DllExport const PlainMapSTypeDefn & map_sdefn() const
This function returns a constant reference to member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3711
eProsima_user_DllExport StringLTypeDefn & string_ldefn()
This function returns a reference to member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3461
eProsima_user_DllExport void seq_sdefn(PlainSequenceSElemDefn &&_seq_sdefn)
This function moves the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3487
eProsima_user_DllExport void string_sdefn(StringSTypeDefn &&_string_sdefn)
This function moves the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3381
eProsima_user_DllExport void array_ldefn(PlainArrayLElemDefn &&_array_ldefn)
This function moves the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3646
eProsima_user_DllExport bool operator==(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3097
eProsima_user_DllExport const PlainMapLTypeDefn & map_ldefn() const
This function returns a constant reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3764
eProsima_user_DllExport TypeIdentifier & operator=(const TypeIdentifier &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:2969
eProsima_user_DllExport void map_ldefn(PlainMapLTypeDefn &&_map_ldefn)
This function moves the value in member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3752
eProsima_user_DllExport void string_ldefn(StringLTypeDefn &&_string_ldefn)
This function moves the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3434
eProsima_user_DllExport void string_ldefn(const StringLTypeDefn &_string_ldefn)
This function copies the value in member string_ldefn.
Definition dds_xtypes_typeobject.hpp:3423
PlainArrayLElemDefn m_array_ldefn
Definition dds_xtypes_typeobject.hpp:4179
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:3794
eProsima_user_DllExport TypeIdentifier(const TypeIdentifier &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:2845
eProsima_user_DllExport ExtendedTypeDefn & extended_defn()
This function returns a reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3938
eProsima_user_DllExport void seq_ldefn(const PlainSequenceLElemDefn &_seq_ldefn)
This function copies the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3529
eProsima_user_DllExport void no_value(Dummy &&_no_value)
This function moves the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3328
eProsima_user_DllExport const StringSTypeDefn & string_sdefn() const
This function returns a constant reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3393
StringSTypeDefn m_string_sdefn
Definition dds_xtypes_typeobject.hpp:4174
PlainSequenceSElemDefn m_seq_sdefn
Definition dds_xtypes_typeobject.hpp:4176
eProsima_user_DllExport const PlainArrayLElemDefn & array_ldefn() const
This function returns a constant reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3658
eProsima_user_DllExport const Dummy & no_value() const
This function returns a constant reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3340
ExtendedTypeDefn m_extended_defn
Definition dds_xtypes_typeobject.hpp:4184
eProsima_user_DllExport const PlainSequenceLElemDefn & seq_ldefn() const
This function returns a constant reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3552
eProsima_user_DllExport void array_sdefn(const PlainArraySElemDefn &_array_sdefn)
This function copies the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3582
eProsima_user_DllExport TypeIdentifier()
Default constructor.
Definition dds_xtypes_typeobject.hpp:2822
eProsima_user_DllExport bool operator!=(const TypeIdentifier &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:3174
eProsima_user_DllExport PlainSequenceLElemDefn & seq_ldefn()
This function returns a reference to member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3567
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:3805
eProsima_user_DllExport const ExtendedTypeDefn & extended_defn() const
This function returns a constant reference to member extended_defn.
Definition dds_xtypes_typeobject.hpp:3923
eProsima_user_DllExport const PlainSequenceSElemDefn & seq_sdefn() const
This function returns a constant reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3499
eProsima_user_DllExport void map_sdefn(PlainMapSTypeDefn &&_map_sdefn)
This function moves the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3699
PlainSequenceLElemDefn m_seq_ldefn
Definition dds_xtypes_typeobject.hpp:4177
eProsima_user_DllExport void array_ldefn(const PlainArrayLElemDefn &_array_ldefn)
This function copies the value in member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3635
eProsima_user_DllExport EquivalenceHash & equivalence_hash()
This function returns a reference to member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3885
eProsima_user_DllExport StringSTypeDefn & string_sdefn()
This function returns a reference to member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3408
eProsima_user_DllExport const PlainArraySElemDefn & array_sdefn() const
This function returns a constant reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3605
eProsima_user_DllExport PlainArrayLElemDefn & array_ldefn()
This function returns a reference to member array_ldefn.
Definition dds_xtypes_typeobject.hpp:3673
StringLTypeDefn m_string_ldefn
Definition dds_xtypes_typeobject.hpp:4175
eProsima_user_DllExport void extended_defn(ExtendedTypeDefn &&_extended_defn)
This function moves the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3911
PlainArraySElemDefn m_array_sdefn
Definition dds_xtypes_typeobject.hpp:4178
eProsima_user_DllExport void no_value(const Dummy &_no_value)
This function copies the value in member no_value.
Definition dds_xtypes_typeobject.hpp:3317
PlainMapSTypeDefn m_map_sdefn
Definition dds_xtypes_typeobject.hpp:4180
PlainMapLTypeDefn m_map_ldefn
Definition dds_xtypes_typeobject.hpp:4181
eProsima_user_DllExport void seq_sdefn(const PlainSequenceSElemDefn &_seq_sdefn)
This function copies the value in member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3476
eProsima_user_DllExport void string_sdefn(const StringSTypeDefn &_string_sdefn)
This function copies the value in member string_sdefn.
Definition dds_xtypes_typeobject.hpp:3370
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:3185
EquivalenceHash m_equivalence_hash
Definition dds_xtypes_typeobject.hpp:4183
eProsima_user_DllExport void seq_ldefn(PlainSequenceLElemDefn &&_seq_ldefn)
This function moves the value in member seq_ldefn.
Definition dds_xtypes_typeobject.hpp:3540
eProsima_user_DllExport PlainMapLTypeDefn & map_ldefn()
This function returns a reference to member map_ldefn.
Definition dds_xtypes_typeobject.hpp:3779
eProsima_user_DllExport void map_sdefn(const PlainMapSTypeDefn &_map_sdefn)
This function copies the value in member map_sdefn.
Definition dds_xtypes_typeobject.hpp:3688
eProsima_user_DllExport void array_sdefn(PlainArraySElemDefn &&_array_sdefn)
This function moves the value in member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3593
eProsima_user_DllExport void extended_defn(const ExtendedTypeDefn &_extended_defn)
This function copies the value in member extended_defn.
Definition dds_xtypes_typeobject.hpp:3900
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:3817
eProsima_user_DllExport PlainSequenceSElemDefn & seq_sdefn()
This function returns a reference to member seq_sdefn.
Definition dds_xtypes_typeobject.hpp:3514
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:3308
eProsima_user_DllExport StronglyConnectedComponentId & sc_component_id()
This function returns a reference to member sc_component_id.
Definition dds_xtypes_typeobject.hpp:3832
eProsima_user_DllExport Dummy & no_value()
This function returns a reference to member no_value.
Definition dds_xtypes_typeobject.hpp:3355
eProsima_user_DllExport PlainArraySElemDefn & array_sdefn()
This function returns a reference to member array_sdefn.
Definition dds_xtypes_typeobject.hpp:3620
eProsima_user_DllExport void equivalence_hash(const EquivalenceHash &_equivalence_hash)
This function copies the value in member equivalence_hash.
Definition dds_xtypes_typeobject.hpp:3847
This class represents the structure TypeIdentifierPair defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23899
eProsima_user_DllExport TypeIdentifierPair(TypeIdentifierPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23933
eProsima_user_DllExport TypeIdentifierPair(const TypeIdentifierPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23920
eProsima_user_DllExport void type_identifier1(const TypeIdentifier &_type_identifier1)
This function copies the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:23993
eProsima_user_DllExport TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23944
eProsima_user_DllExport void type_identifier2(TypeIdentifier &&_type_identifier2)
This function moves the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24042
eProsima_user_DllExport TypeIdentifier & type_identifier1()
This function returns a reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24022
eProsima_user_DllExport void type_identifier1(TypeIdentifier &&_type_identifier1)
This function moves the value in member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24003
eProsima_user_DllExport const TypeIdentifier & type_identifier2() const
This function returns a constant reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24052
eProsima_user_DllExport bool operator!=(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23983
eProsima_user_DllExport void type_identifier2(const TypeIdentifier &_type_identifier2)
This function copies the value in member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24032
eProsima_user_DllExport TypeIdentifierPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23905
eProsima_user_DllExport const TypeIdentifier & type_identifier1() const
This function returns a constant reference to member type_identifier1.
Definition dds_xtypes_typeobject.hpp:24013
eProsima_user_DllExport ~TypeIdentifierPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23912
eProsima_user_DllExport TypeIdentifier & type_identifier2()
This function returns a reference to member type_identifier2.
Definition dds_xtypes_typeobject.hpp:24061
eProsima_user_DllExport bool operator==(const TypeIdentifierPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23972
This class represents the structure TypeIdentifierTypeObjectPair defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23717
eProsima_user_DllExport const TypeObject & type_object() const
This function returns a constant reference to member type_object.
Definition dds_xtypes_typeobject.hpp:23870
eProsima_user_DllExport TypeIdentifierTypeObjectPair()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23723
eProsima_user_DllExport void type_identifier(TypeIdentifier &&_type_identifier)
This function moves the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23821
eProsima_user_DllExport void type_object(const TypeObject &_type_object)
This function copies the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23850
eProsima_user_DllExport TypeIdentifier & type_identifier()
This function returns a reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23840
eProsima_user_DllExport TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23762
eProsima_user_DllExport bool operator!=(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23801
eProsima_user_DllExport const TypeIdentifier & type_identifier() const
This function returns a constant reference to member type_identifier.
Definition dds_xtypes_typeobject.hpp:23831
eProsima_user_DllExport ~TypeIdentifierTypeObjectPair()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23730
eProsima_user_DllExport TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23738
eProsima_user_DllExport TypeObject & type_object()
This function returns a reference to member type_object.
Definition dds_xtypes_typeobject.hpp:23879
eProsima_user_DllExport bool operator==(const TypeIdentifierTypeObjectPair &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23790
eProsima_user_DllExport TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23751
eProsima_user_DllExport void type_identifier(const TypeIdentifier &_type_identifier)
This function copies the value in member type_identifier.
Definition dds_xtypes_typeobject.hpp:23811
eProsima_user_DllExport void type_object(TypeObject &&_type_object)
This function moves the value in member type_object.
Definition dds_xtypes_typeobject.hpp:23860
This class represents the structure TypeIdentifierWithDependencies defined by the user in the IDL fil...
Definition dds_xtypes_typeobject.hpp:24253
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:24393
eProsima_user_DllExport std::vector< TypeIdentfierWithSize > & dependent_typeids()
This function returns a reference to member dependent_typeids.
Definition dds_xtypes_typeobject.hpp:24451
eProsima_user_DllExport TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24274
eProsima_user_DllExport TypeIdentifierWithDependencies()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24259
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:24442
eProsima_user_DllExport TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24301
eProsima_user_DllExport int32_t dependent_typeid_count() const
This function returns the value of member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24403
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:24374
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:24422
eProsima_user_DllExport TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24289
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:24354
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:24432
eProsima_user_DllExport bool operator!=(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24344
eProsima_user_DllExport int32_t & dependent_typeid_count()
This function returns a reference to member dependent_typeid_count.
Definition dds_xtypes_typeobject.hpp:24412
eProsima_user_DllExport ~TypeIdentifierWithDependencies()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24266
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:24364
eProsima_user_DllExport bool operator==(const TypeIdentifierWithDependencies &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24332
eProsima_user_DllExport TypeIdentfierWithSize & typeid_with_size()
This function returns a reference to member typeid_with_size.
Definition dds_xtypes_typeobject.hpp:24383
This class represents the structure TypeInformation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24472
eProsima_user_DllExport TypeInformation()
Default constructor.
Definition dds_xtypes_typeobject.hpp:24478
eProsima_user_DllExport void minimal(TypeIdentifierWithDependencies &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24576
eProsima_user_DllExport bool operator!=(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24556
eProsima_user_DllExport const TypeIdentifierWithDependencies & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24586
eProsima_user_DllExport const TypeIdentifierWithDependencies & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:24625
eProsima_user_DllExport TypeIdentifierWithDependencies & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:24595
eProsima_user_DllExport void complete(const TypeIdentifierWithDependencies &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:24605
eProsima_user_DllExport TypeInformation & operator=(const TypeInformation &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:24517
eProsima_user_DllExport TypeIdentifierWithDependencies & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:24634
eProsima_user_DllExport bool operator==(const TypeInformation &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:24545
eProsima_user_DllExport void minimal(const TypeIdentifierWithDependencies &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:24566
eProsima_user_DllExport ~TypeInformation()
Default destructor.
Definition dds_xtypes_typeobject.hpp:24485
eProsima_user_DllExport void complete(TypeIdentifierWithDependencies &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:24615
eProsima_user_DllExport TypeInformation(TypeInformation &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:24506
eProsima_user_DllExport TypeInformation(const TypeInformation &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:24493
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:281
eProsima_user_DllExport EquivalenceHash & hash()
This function returns a reference to member hash.
Definition dds_xtypes_typeobject.hpp:368
eProsima_user_DllExport const EquivalenceHash & hash() const
This function returns a constant reference to member hash.
Definition dds_xtypes_typeobject.hpp:353
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:379
eProsima_user_DllExport void hash(const EquivalenceHash &_hash)
This function copies the value in member hash.
Definition dds_xtypes_typeobject.hpp:330
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:341
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:292
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:321
EquivalenceHash m_hash
Definition dds_xtypes_typeobject.hpp:415
This class represents the union TypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23335
eProsima_user_DllExport const MinimalTypeObject & minimal() const
This function returns a constant reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23620
eProsima_user_DllExport void complete(CompleteTypeObject &&_complete)
This function moves the value in member complete.
Definition dds_xtypes_typeobject.hpp:23555
eProsima_user_DllExport bool operator!=(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23489
eProsima_user_DllExport TypeObject(const TypeObject &x)
Copy constructor.
Definition dds_xtypes_typeobject.hpp:23360
eProsima_user_DllExport CompleteTypeObject & complete()
This function returns a reference to member complete.
Definition dds_xtypes_typeobject.hpp:23582
eProsima_user_DllExport ~TypeObject()
Default destructor.
Definition dds_xtypes_typeobject.hpp:23348
eProsima_user_DllExport TypeObject(TypeObject &&x) noexcept
Move constructor.
Definition dds_xtypes_typeobject.hpp:23382
eProsima_user_DllExport void minimal(const MinimalTypeObject &_minimal)
This function copies the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23597
eProsima_user_DllExport MinimalTypeObject & minimal()
This function returns a reference to member minimal.
Definition dds_xtypes_typeobject.hpp:23635
void _default()
Definition dds_xtypes_typeobject.hpp:23646
eProsima_user_DllExport TypeObject & operator=(const TypeObject &x)
Copy assignment.
Definition dds_xtypes_typeobject.hpp:23404
eProsima_user_DllExport const CompleteTypeObject & complete() const
This function returns a constant reference to member complete.
Definition dds_xtypes_typeobject.hpp:23567
MinimalTypeObject m_minimal
Definition dds_xtypes_typeobject.hpp:23701
eProsima_user_DllExport void minimal(MinimalTypeObject &&_minimal)
This function moves the value in member minimal.
Definition dds_xtypes_typeobject.hpp:23608
CompleteTypeObject m_complete
Definition dds_xtypes_typeobject.hpp:23700
eProsima_user_DllExport void _d(uint8_t __d)
This function sets the discriminator value.
Definition dds_xtypes_typeobject.hpp:23500
eProsima_user_DllExport uint8_t _d() const
This function returns the value of the discriminator.
Definition dds_xtypes_typeobject.hpp:23535
eProsima_user_DllExport TypeObject()
Default constructor.
Definition dds_xtypes_typeobject.hpp:23341
eProsima_user_DllExport void complete(const CompleteTypeObject &_complete)
This function copies the value in member complete.
Definition dds_xtypes_typeobject.hpp:23544
eProsima_user_DllExport bool operator==(const TypeObject &x) const
Comparison operator.
Definition dds_xtypes_typeobject.hpp:23452
TypeFlagBits
This enumeration represents the TypeFlag bitflags defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:461
MemberFlagBits
This enumeration represents the MemberFlag bitflags defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:427
@ IS_FINAL
Definition dds_xtypes_typeobject.hpp:462
@ IS_MUTABLE
Definition dds_xtypes_typeobject.hpp:464
@ IS_NESTED
Definition dds_xtypes_typeobject.hpp:465
@ IS_APPENDABLE
Definition dds_xtypes_typeobject.hpp:463
@ IS_AUTOID_HASH
Definition dds_xtypes_typeobject.hpp:466
@ IS_MUST_UNDERSTAND
Definition dds_xtypes_typeobject.hpp:432
@ TRY_CONSTRUCT1
Definition dds_xtypes_typeobject.hpp:428
@ TRY_CONSTRUCT2
Definition dds_xtypes_typeobject.hpp:429
@ IS_KEY
Definition dds_xtypes_typeobject.hpp:433
@ IS_EXTERNAL
Definition dds_xtypes_typeobject.hpp:430
@ IS_DEFAULT
Definition dds_xtypes_typeobject.hpp:434
@ IS_OPTIONAL
Definition dds_xtypes_typeobject.hpp:431
Definition DomainParticipant.hpp:45
MemberFlag BitsetMemberFlag
Definition dds_xtypes_typeobject.hpp:453
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition dds_xtypes_typeobject.hpp:19930
uint32_t MemberId
Definition dds_xtypes_typeobject.hpp:4193
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:437
const uint8_t TI_PLAIN_SEQUENCE_SMALL
Definition dds_xtypes_typeobject.hpp:113
std::vector< TypeObject > TypeObjectSeq
Definition dds_xtypes_typeobject.hpp:23708
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition dds_xtypes_typeobject.hpp:24465
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:9692
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition dds_xtypes_typeobject.hpp:6533
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition dds_xtypes_typeobject.hpp:24074
TypeFlag BitsetTypeFlag
Definition dds_xtypes_typeobject.hpp:483
const uint8_t TK_INT8
Definition dds_xtypes_typeobject.hpp:91
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition dds_xtypes_typeobject.hpp:17135
const uint16_t MemberFlagMinimalMask
Definition dds_xtypes_typeobject.hpp:455
const uint8_t TK_UINT16
Definition dds_xtypes_typeobject.hpp:85
TypeFlag CollectionTypeFlag
Definition dds_xtypes_typeobject.hpp:473
const uint8_t TK_UINT32
Definition dds_xtypes_typeobject.hpp:86
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition dds_xtypes_typeobject.hpp:7975
TypeFlag EnumTypeFlag
Definition dds_xtypes_typeobject.hpp:479
std::vector< LBound > LBoundSeq
Definition dds_xtypes_typeobject.hpp:134
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition dds_xtypes_typeobject.hpp:17317
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:445
const uint8_t TK_ENUM
Definition dds_xtypes_typeobject.hpp:98
TypeFlag AliasTypeFlag
Definition dds_xtypes_typeobject.hpp:477
const uint16_t TypeFlagMinimalMask
Definition dds_xtypes_typeobject.hpp:485
const uint8_t EK_COMPLETE
Definition dds_xtypes_typeobject.hpp:75
MemberFlag UnionDiscriminatorFlag
Definition dds_xtypes_typeobject.hpp:443
uint8_t EquivalenceKind
Definition dds_xtypes_typeobject.hpp:72
TypeFlag UnionTypeFlag
Definition dds_xtypes_typeobject.hpp:471
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition dds_xtypes_typeobject.hpp:9874
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:469
const uint8_t TI_PLAIN_MAP_LARGE
Definition dds_xtypes_typeobject.hpp:118
std::vector< TypeIdentfierWithSize > TypeIdentfierWithSizeSeq
Definition dds_xtypes_typeobject.hpp:24246
std::vector< AppliedAnnotationParameter > AppliedAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:6351
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:4191
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition dds_xtypes_typeobject.hpp:11866
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:18741
std::array< uint8_t, 4 > NameHash
Definition dds_xtypes_typeobject.hpp:130
MemberFlag StructMemberFlag
Definition dds_xtypes_typeobject.hpp:439
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:19748
const uint8_t TK_ARRAY
Definition dds_xtypes_typeobject.hpp:105
TypeFlag BitmaskTypeFlag
Definition dds_xtypes_typeobject.hpp:481
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:4196
const uint8_t TK_CHAR16
Definition dds_xtypes_typeobject.hpp:94
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18868
std::vector< int32_t > UnionCaseLabelSeq
Definition dds_xtypes_typeobject.hpp:9246
MemberFlag UnionMemberFlag
Definition dds_xtypes_typeobject.hpp:441
TypeFlag AnnotationTypeFlag
Definition dds_xtypes_typeobject.hpp:475
const uint8_t TK_INT16
Definition dds_xtypes_typeobject.hpp:82
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition dds_xtypes_typeobject.hpp:23892
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:16783
MemberFlag AliasMemberFlag
Definition dds_xtypes_typeobject.hpp:449
uint8_t TypeIdentiferKind
Definition dds_xtypes_typeobject.hpp:107
const uint32_t ANNOTATION_STR_VALUE_MAX_LEN
Definition dds_xtypes_typeobject.hpp:4195
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:24647
const uint8_t TI_PLAIN_ARRAY_SMALL
Definition dds_xtypes_typeobject.hpp:115
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition dds_xtypes_typeobject.hpp:18559
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:11637
MemberFlag BitflagFlag
Definition dds_xtypes_typeobject.hpp:451
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:436
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:447
uint16_t TypeFlag
Definition dds_xtypes_typeobject.hpp:468
const uint8_t TK_BITMASK
Definition dds_xtypes_typeobject.hpp:99
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition dds_xtypes_typeobject.hpp:18866
TypeObjectSeq StronglyConnectedComponent
Definition dds_xtypes_typeobject.hpp:23710
const uint8_t TI_STRING16_LARGE
Definition dds_xtypes_typeobject.hpp:112
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition dds_xtypes_typeobject.hpp:7793
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.