Fast RTPS  Version 2.6.0
Fast RTPS
TypeObject.h
1 // Copyright 2018 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #ifndef TYPES_TYPE_OBJECT_H
16 #define TYPES_TYPE_OBJECT_H
17 
18 #include <fastrtps/types/TypesBase.h>
19 #include <fastrtps/types/TypeObjectHashId.h>
20 #include <fastrtps/types/TypeIdentifier.h>
21 #include <fastrtps/types/AnnotationParameterValue.h>
22 #include <cstdint>
23 #include <array>
24 
25 namespace eprosima {
26 namespace fastcdr {
27 class Cdr;
28 }
29 }
30 
31 // The types in this file shall be serialized with XCDR encoding version 2
32 namespace eprosima {
33 namespace fastrtps {
34 
35 namespace types {
36 
37 /*struct CommonStructMember final {
38  MemberId member_id;
39  StructMemberFlag member_flags;
40  TypeIdentifier member_type_id;
41  };*/
43 {
44 public:
45 
46  RTPS_DllAPI CommonStructMember();
47  RTPS_DllAPI ~CommonStructMember();
48  RTPS_DllAPI CommonStructMember(
49  const CommonStructMember& x);
50  RTPS_DllAPI CommonStructMember(
51  CommonStructMember&& x);
53  const CommonStructMember& x);
55  CommonStructMember&& x);
56 
57  RTPS_DllAPI inline void member_id(
58  const MemberId& _member_id) { m_member_id = _member_id; }
59  RTPS_DllAPI inline void member_id(
60  MemberId&& _member_id) { m_member_id = std::move(_member_id); }
61  RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }
62  RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }
63 
64  RTPS_DllAPI inline void member_flags(
65  const StructMemberFlag& _member_flags) { m_member_flags = _member_flags; }
66  RTPS_DllAPI inline void member_flags(
67  StructMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
68  RTPS_DllAPI inline const StructMemberFlag& member_flags() const { return m_member_flags; }
69  RTPS_DllAPI inline StructMemberFlag& member_flags() { return m_member_flags; }
70 
71  RTPS_DllAPI inline void member_type_id(
72  const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }
73  RTPS_DllAPI inline void member_type_id(
74  TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }
75  RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }
76  RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }
77 
78  RTPS_DllAPI static size_t getCdrSerializedSize(
79  const CommonStructMember& data,
80  size_t current_alignment = 0);
81  RTPS_DllAPI void serialize(
82  eprosima::fastcdr::Cdr& cdr) const;
83  RTPS_DllAPI void deserialize(
84  eprosima::fastcdr::Cdr& cdr);
85 
86  RTPS_DllAPI bool operator==(
87  const CommonStructMember& other) const;
88 
89  RTPS_DllAPI bool consistent(
90  const CommonStructMember& x,
91  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
92 
93 private:
94 
95  MemberId m_member_id;
96  StructMemberFlag m_member_flags;
97  TypeIdentifier m_member_type_id;
98 };
99 
100 // COMPLETE Details for a member of an aggregate type
101 /*struct CompleteMemberDetail final{
102  MemberName name;
103  AppliedBuiltinMemberAnnotations ann_builtin; // Optional
104  AppliedAnnotationSeq ann_custom; // Optional
105  };*/
107 {
108 public:
109 
110  RTPS_DllAPI CompleteMemberDetail();
111  RTPS_DllAPI ~CompleteMemberDetail();
112  RTPS_DllAPI CompleteMemberDetail(
113  const CompleteMemberDetail& x);
114  RTPS_DllAPI CompleteMemberDetail(
117  const CompleteMemberDetail& x);
120 
121  RTPS_DllAPI inline void name(
122  const MemberName& _name) { m_name = _name; }
123  RTPS_DllAPI inline void name(
124  MemberName&& _name) { m_name = std::move(_name); }
125  RTPS_DllAPI inline const MemberName& name() const { return m_name; }
126  RTPS_DllAPI inline MemberName& name() { return m_name; }
127 
128  RTPS_DllAPI inline void ann_builtin(
129  const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
130  RTPS_DllAPI inline void ann_builtin(
131  AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
132  RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
133  RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
134 
135  RTPS_DllAPI inline void ann_custom(
136  const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
137  RTPS_DllAPI inline void ann_custom(
138  AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
139  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
140  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
141 
142  RTPS_DllAPI static size_t getCdrSerializedSize(
143  const CompleteMemberDetail& data,
144  size_t current_alignment = 0);
145  RTPS_DllAPI void serialize(
146  eprosima::fastcdr::Cdr& cdr) const;
147  RTPS_DllAPI void deserialize(
148  eprosima::fastcdr::Cdr& cdr);
149 
150  RTPS_DllAPI bool operator==(
151  const CompleteMemberDetail& other) const;
152 
153  RTPS_DllAPI bool consistent(
154  const CompleteMemberDetail& x,
155  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
156 
157 private:
158 
159  MemberName m_name;
160  AppliedBuiltinMemberAnnotations m_ann_builtin;
161  AppliedAnnotationSeq m_ann_custom;
162 };
163 
164 // MINIMAL Details for a member of an aggregate type
165 /*struct MinimalMemberDetail final{
166  NameHash name_hash;
167  };*/
168 
170 {
171 public:
172 
173  RTPS_DllAPI MinimalMemberDetail();
174  RTPS_DllAPI ~MinimalMemberDetail();
175  RTPS_DllAPI MinimalMemberDetail(
176  const MinimalMemberDetail& x);
177  RTPS_DllAPI MinimalMemberDetail(
178  MinimalMemberDetail&& x);
180  const MinimalMemberDetail& x);
182  MinimalMemberDetail&& x);
183 
184  RTPS_DllAPI inline void name_hash(
185  const NameHash& _name_hash) { m_name_hash = _name_hash; }
186  RTPS_DllAPI inline void name_hash(
187  NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }
188  RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }
189  RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }
190 
191  RTPS_DllAPI static size_t getCdrSerializedSize(
192  const MinimalMemberDetail& data,
193  size_t current_alignment = 0);
194  RTPS_DllAPI void serialize(
195  eprosima::fastcdr::Cdr& cdr) const;
196  RTPS_DllAPI void deserialize(
197  eprosima::fastcdr::Cdr& cdr);
198 
199  RTPS_DllAPI bool operator==(
200  const MinimalMemberDetail& other) const;
201 
202  RTPS_DllAPI bool consistent(
203  const MinimalMemberDetail& x,
204  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
205 
206 private:
207 
208  NameHash m_name_hash;
209 };
210 
211 // Member of an aggregate type
212 /*struct CompleteStructMember {
213  CommonStructMember common;
214  CompleteMemberDetail detail;
215  };*/
217 {
218 public:
219 
220  RTPS_DllAPI CompleteStructMember();
221  RTPS_DllAPI ~CompleteStructMember();
222  RTPS_DllAPI CompleteStructMember(
223  const CompleteStructMember& x);
224  RTPS_DllAPI CompleteStructMember(
227  const CompleteStructMember& x);
230 
231  RTPS_DllAPI inline void common(
232  const CommonStructMember& _common) { m_common = _common; }
233  RTPS_DllAPI inline void common(
234  CommonStructMember&& _common) { m_common = std::move(_common); }
235  RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }
236  RTPS_DllAPI inline CommonStructMember& common() { return m_common; }
237 
238  RTPS_DllAPI inline void detail(
239  const CompleteMemberDetail& _detail) { m_detail = _detail; }
240  RTPS_DllAPI inline void detail(
241  CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
242  RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
243  RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
244 
245  RTPS_DllAPI static size_t getCdrSerializedSize(
246  const CompleteStructMember& data,
247  size_t current_alignment = 0);
248  RTPS_DllAPI void serialize(
249  eprosima::fastcdr::Cdr& cdr) const;
250  RTPS_DllAPI void deserialize(
251  eprosima::fastcdr::Cdr& cdr);
252 
253  RTPS_DllAPI bool operator==(
254  const CompleteStructMember& other) const;
255 
256  RTPS_DllAPI bool consistent(
257  const CompleteStructMember& x,
258  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
259 
260 private:
261 
262  CommonStructMember m_common;
263  CompleteMemberDetail m_detail;
264 };
265 
266 // Ordered by the member_index
267 typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
268 
269 // Member of an aggregate type
270 /*struct MinimalStructMember {
271  CommonStructMember common;
272  MinimalMemberDetail detail;
273  };*/
275 {
276 public:
277 
278  RTPS_DllAPI MinimalStructMember();
279  RTPS_DllAPI ~MinimalStructMember();
280  RTPS_DllAPI MinimalStructMember(
281  const MinimalStructMember& x);
282  RTPS_DllAPI MinimalStructMember(
283  MinimalStructMember&& x);
285  const MinimalStructMember& x);
287  MinimalStructMember&& x);
288 
289  RTPS_DllAPI inline void common(
290  const CommonStructMember& _common) { m_common = _common; }
291  RTPS_DllAPI inline void common(
292  CommonStructMember&& _common) { m_common = std::move(_common); }
293  RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }
294  RTPS_DllAPI inline CommonStructMember& common() { return m_common; }
295 
296  RTPS_DllAPI inline void detail(
297  const MinimalMemberDetail& _detail) { m_detail = _detail; }
298  RTPS_DllAPI inline void detail(
299  MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
300  RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
301  RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
302 
303  RTPS_DllAPI static size_t getCdrSerializedSize(
304  const MinimalStructMember& data,
305  size_t current_alignment = 0);
306  RTPS_DllAPI void serialize(
307  eprosima::fastcdr::Cdr& cdr) const;
308  RTPS_DllAPI void deserialize(
309  eprosima::fastcdr::Cdr& cdr);
310 
311  RTPS_DllAPI bool operator==(
312  const MinimalStructMember& other) const;
313 
314  RTPS_DllAPI bool consistent(
315  const MinimalStructMember& x,
316  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
317 
318 private:
319 
320  CommonStructMember m_common;
321  MinimalMemberDetail m_detail;
322 };
323 
324 // Ordered by common.member_id
325 typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
326 
327 /*struct AppliedBuiltinTypeAnnotations {
328  AppliedVerbatimAnnotation verbatim; // verbatim(...) // optional
329  };*/
331 {
332 public:
333 
344 
345  RTPS_DllAPI inline void verbatim(
346  const AppliedVerbatimAnnotation& _verbatim) { m_verbatim = _verbatim; }
347  RTPS_DllAPI inline void verbatim(
348  AppliedVerbatimAnnotation&& _verbatim) { m_verbatim = std::move(_verbatim); }
349  RTPS_DllAPI inline const AppliedVerbatimAnnotation& verbatim() const { return m_verbatim; }
350  RTPS_DllAPI inline AppliedVerbatimAnnotation& verbatim() { return m_verbatim; }
351 
352  RTPS_DllAPI static size_t getCdrSerializedSize(
353  const AppliedBuiltinTypeAnnotations& data,
354  size_t current_alignment = 0);
355  RTPS_DllAPI void serialize(
356  eprosima::fastcdr::Cdr& cdr) const;
357  RTPS_DllAPI void deserialize(
358  eprosima::fastcdr::Cdr& cdr);
359 
360  RTPS_DllAPI bool operator==(
361  const AppliedBuiltinTypeAnnotations& other) const;
362 
363  RTPS_DllAPI bool consistent(
365  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
366 
367 private:
368 
369  AppliedVerbatimAnnotation m_verbatim;
370 };
371 
372 /*struct MinimalTypeDetail final{
373  // Empty. Available for future extension
374  };*/
376 {
377 public:
378 
379  RTPS_DllAPI MinimalTypeDetail();
380  RTPS_DllAPI ~MinimalTypeDetail();
381  RTPS_DllAPI MinimalTypeDetail(
382  const MinimalTypeDetail& x);
383  RTPS_DllAPI MinimalTypeDetail(
384  MinimalTypeDetail&& x);
386  const MinimalTypeDetail& x);
388  MinimalTypeDetail&& x);
389 
390  RTPS_DllAPI static size_t getCdrSerializedSize(
391  const MinimalTypeDetail& data,
392  size_t current_alignment = 0);
393  RTPS_DllAPI void serialize(
394  eprosima::fastcdr::Cdr& cdr) const;
395  RTPS_DllAPI void deserialize(
396  eprosima::fastcdr::Cdr& cdr);
397 
398  RTPS_DllAPI bool operator==(
399  const MinimalTypeDetail&) const { return true; }
400 
401  RTPS_DllAPI bool consistent(
402  const MinimalTypeDetail& x,
403  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
404 
405 private:
406 
407 };
408 
409 /*struct CompleteTypeDetail final{
410  AppliedBuiltinTypeAnnotations ann_builtin; // optional
411  AppliedAnnotationSeq ann_custom; // optional
412  QualifiedTypeName type_name;
413  };*/
415 {
416 public:
417 
418  RTPS_DllAPI CompleteTypeDetail();
419  RTPS_DllAPI ~CompleteTypeDetail();
420  RTPS_DllAPI CompleteTypeDetail(
421  const CompleteTypeDetail& x);
422  RTPS_DllAPI CompleteTypeDetail(
423  CompleteTypeDetail&& x);
425  const CompleteTypeDetail& x);
427  CompleteTypeDetail&& x);
428 
429  RTPS_DllAPI inline void ann_builtin(
430  const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
431  RTPS_DllAPI inline void ann_builtin(
432  AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
433  RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }
434  RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }
435 
436  RTPS_DllAPI inline void ann_custom(
437  const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
438  RTPS_DllAPI inline void ann_custom(
439  AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
440  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
441  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
442 
443  RTPS_DllAPI inline void type_name(
444  const QualifiedTypeName& _type_name) { m_type_name = _type_name; }
445  RTPS_DllAPI inline void type_name(
446  QualifiedTypeName&& _type_name) { m_type_name = std::move(_type_name); }
447  RTPS_DllAPI inline const QualifiedTypeName& type_name() const { return m_type_name; }
448  RTPS_DllAPI inline QualifiedTypeName& type_name() { return m_type_name; }
449 
450  RTPS_DllAPI static size_t getCdrSerializedSize(
451  const CompleteTypeDetail& data,
452  size_t current_alignment = 0);
453  RTPS_DllAPI void serialize(
454  eprosima::fastcdr::Cdr& cdr) const;
455  RTPS_DllAPI void deserialize(
456  eprosima::fastcdr::Cdr& cdr);
457 
458  RTPS_DllAPI bool operator==(
459  const CompleteTypeDetail& other) const;
460 
461  RTPS_DllAPI bool consistent(
462  const CompleteTypeDetail& x,
463  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
464 
465 private:
466 
467  AppliedBuiltinTypeAnnotations m_ann_builtin;
468  AppliedAnnotationSeq m_ann_custom;
469  QualifiedTypeName m_type_name;
470 };
471 /*struct CompleteStructHeader {
472  TypeIdentifier base_type;
473  CompleteTypeDetail detail;
474  };*/
476 {
477 public:
478 
479  RTPS_DllAPI CompleteStructHeader();
480  RTPS_DllAPI ~CompleteStructHeader();
481  RTPS_DllAPI CompleteStructHeader(
482  const CompleteStructHeader& x);
483  RTPS_DllAPI CompleteStructHeader(
486  const CompleteStructHeader& x);
489 
490  RTPS_DllAPI inline void base_type(
491  const TypeIdentifier& _base_type) { m_base_type = _base_type; }
492  RTPS_DllAPI inline void base_type(
493  TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
494  RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
495  RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
496 
497  RTPS_DllAPI inline void detail(
498  const CompleteTypeDetail& _detail) { m_detail = _detail; }
499  RTPS_DllAPI inline void detail(
500  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
501  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
502  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
503 
504  RTPS_DllAPI static size_t getCdrSerializedSize(
505  const CompleteStructHeader& data,
506  size_t current_alignment = 0);
507  RTPS_DllAPI void serialize(
508  eprosima::fastcdr::Cdr& cdr) const;
509  RTPS_DllAPI void deserialize(
510  eprosima::fastcdr::Cdr& cdr);
511 
512  RTPS_DllAPI bool operator==(
513  const CompleteStructHeader& other) const;
514 
515  RTPS_DllAPI bool consistent(
516  const CompleteStructHeader& x,
517  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
518 
519 private:
520 
521  TypeIdentifier m_base_type;
522  CompleteTypeDetail m_detail;
523 };
524 /*struct MinimalStructHeader {
525  TypeIdentifier base_type;
526  MinimalTypeDetail detail;
527  };*/
529 {
530 public:
531 
532  RTPS_DllAPI MinimalStructHeader();
533  RTPS_DllAPI ~MinimalStructHeader();
534  RTPS_DllAPI MinimalStructHeader(
535  const MinimalStructHeader& x);
536  RTPS_DllAPI MinimalStructHeader(
537  MinimalStructHeader&& x);
539  const MinimalStructHeader& x);
541  MinimalStructHeader&& x);
542 
543  RTPS_DllAPI inline void base_type(
544  const TypeIdentifier& _base_type) { m_base_type = _base_type; }
545  RTPS_DllAPI inline void base_type(
546  TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
547  RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
548  RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
549 
550  RTPS_DllAPI inline void detail(
551  const MinimalTypeDetail& _detail) { m_detail = _detail; }
552  RTPS_DllAPI inline void detail(
553  MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }
554  RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }
555  RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }
556 
557  RTPS_DllAPI static size_t getCdrSerializedSize(
558  const MinimalStructHeader& data,
559  size_t current_alignment = 0);
560  RTPS_DllAPI void serialize(
561  eprosima::fastcdr::Cdr& cdr) const;
562  RTPS_DllAPI void deserialize(
563  eprosima::fastcdr::Cdr& cdr);
564 
565  RTPS_DllAPI bool operator==(
566  const MinimalStructHeader& other) const;
567 
568  RTPS_DllAPI bool consistent(
569  const MinimalStructHeader& x,
570  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
571 
572 private:
573 
574  TypeIdentifier m_base_type;
575  MinimalTypeDetail m_detail;
576 };
577 
578 /*struct CompleteStructType final{
579  StructTypeFlag struct_flags;
580  CompleteStructHeader header;
581  CompleteStructMemberSeq member_seq;
582  };*/
584 {
585 public:
586 
587  RTPS_DllAPI CompleteStructType();
588  RTPS_DllAPI ~CompleteStructType();
589  RTPS_DllAPI CompleteStructType(
590  const CompleteStructType& x);
591  RTPS_DllAPI CompleteStructType(
592  CompleteStructType&& x);
594  const CompleteStructType& x);
596  CompleteStructType&& x);
597 
598  RTPS_DllAPI inline void struct_flags(
599  const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }
600  RTPS_DllAPI inline void struct_flags(
601  StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }
602  RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }
603  RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }
604 
605  RTPS_DllAPI inline void header(
606  const CompleteStructHeader& _header) { m_header = _header; }
607  RTPS_DllAPI inline void header(
608  CompleteStructHeader&& _header) { m_header = std::move(_header); }
609  RTPS_DllAPI inline const CompleteStructHeader& header() const { return m_header; }
610  RTPS_DllAPI inline CompleteStructHeader& header() { return m_header; }
611 
612  RTPS_DllAPI inline void member_seq(
613  const CompleteStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }
614  RTPS_DllAPI inline void member_seq(
615  CompleteStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
616  RTPS_DllAPI inline const CompleteStructMemberSeq& member_seq() const { return m_member_seq; }
617  RTPS_DllAPI inline CompleteStructMemberSeq& member_seq() { return m_member_seq; }
618 
619  RTPS_DllAPI static size_t getCdrSerializedSize(
620  const CompleteStructType& data,
621  size_t current_alignment = 0);
622  RTPS_DllAPI void serialize(
623  eprosima::fastcdr::Cdr& cdr) const;
624  RTPS_DllAPI void deserialize(
625  eprosima::fastcdr::Cdr& cdr);
626 
627  RTPS_DllAPI bool operator==(
628  const CompleteStructType& other) const;
629 
630  RTPS_DllAPI bool consistent(
631  const CompleteStructType& x,
632  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
633 
634 private:
635 
636  StructTypeFlag m_struct_flags;
637  CompleteStructHeader m_header;
638  CompleteStructMemberSeq m_member_seq;
639 };
640 
641 /*struct MinimalStructType final{
642  StructTypeFlag struct_flags;
643  MinimalStructHeader header;
644  MinimalStructMemberSeq member_seq;
645  };*/
647 {
648 public:
649 
650  RTPS_DllAPI MinimalStructType();
651  RTPS_DllAPI ~MinimalStructType();
652  RTPS_DllAPI MinimalStructType(
653  const MinimalStructType& x);
654  RTPS_DllAPI MinimalStructType(
655  MinimalStructType&& x);
657  const MinimalStructType& x);
659  MinimalStructType&& x);
660 
661  RTPS_DllAPI inline void struct_flags(
662  const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }
663  RTPS_DllAPI inline void struct_flags(
664  StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }
665  RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }
666  RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }
667 
668  RTPS_DllAPI inline void header(
669  const MinimalStructHeader& _header) { m_header = _header; }
670  RTPS_DllAPI inline void header(
671  MinimalStructHeader&& _header) { m_header = std::move(_header); }
672  RTPS_DllAPI inline const MinimalStructHeader& header() const { return m_header; }
673  RTPS_DllAPI inline MinimalStructHeader& header() { return m_header; }
674 
675  RTPS_DllAPI inline void member_seq(
676  const MinimalStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }
677  RTPS_DllAPI inline void member_seq(
678  MinimalStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
679  RTPS_DllAPI inline const MinimalStructMemberSeq& member_seq() const { return m_member_seq; }
680  RTPS_DllAPI inline MinimalStructMemberSeq& member_seq() { return m_member_seq; }
681 
682  RTPS_DllAPI static size_t getCdrSerializedSize(
683  const MinimalStructType& data,
684  size_t current_alignment = 0);
685  RTPS_DllAPI void serialize(
686  eprosima::fastcdr::Cdr& cdr) const;
687  RTPS_DllAPI void deserialize(
688  eprosima::fastcdr::Cdr& cdr);
689 
690  RTPS_DllAPI bool operator==(
691  const MinimalStructType& other) const;
692 
693  RTPS_DllAPI bool consistent(
694  const MinimalStructType& x,
695  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
696 
697 private:
698 
699  StructTypeFlag m_struct_flags;
700  MinimalStructHeader m_header;
701  MinimalStructMemberSeq m_member_seq;
702 };
703 
704 // --- Union: ---------------------------------------------------------
705 
706 // Case labels that apply to a member of a union type
707 // Ordered by their values
708 typedef std::vector<int32_t> UnionCaseLabelSeq;
709 
710 /*struct CommonUnionMember final{
711  MemberId member_id;
712  UnionMemberFlag member_flags;
713  TypeIdentifier type_id;
714  UnionCaseLabelSeq label_seq;
715  };*/
717 {
718 public:
719 
720  RTPS_DllAPI CommonUnionMember();
721  RTPS_DllAPI ~CommonUnionMember();
722  RTPS_DllAPI CommonUnionMember(
723  const CommonUnionMember& x);
724  RTPS_DllAPI CommonUnionMember(
725  CommonUnionMember&& x);
727  const CommonUnionMember& x);
729  CommonUnionMember&& x);
730 
731  RTPS_DllAPI inline void member_id(
732  const MemberId& _member_id) { m_member_id = _member_id; }
733  RTPS_DllAPI inline void member_id(
734  MemberId&& _member_id) { m_member_id = std::move(_member_id); }
735  RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }
736  RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }
737 
738  RTPS_DllAPI inline void member_flags(
739  const UnionMemberFlag& _member_flags) { m_member_flags = _member_flags; }
740  RTPS_DllAPI inline void member_flags(
741  UnionMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
742  RTPS_DllAPI inline const UnionMemberFlag& member_flags() const { return m_member_flags; }
743  RTPS_DllAPI inline UnionMemberFlag& member_flags() { return m_member_flags; }
744 
745  RTPS_DllAPI inline void type_id(
746  const TypeIdentifier& _type_id) { m_type_id = _type_id; }
747  RTPS_DllAPI inline void type_id(
748  TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
749  RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
750  RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
751 
752  RTPS_DllAPI inline void label_seq(
753  const UnionCaseLabelSeq& _label_seq) { m_label_seq = _label_seq; }
754  RTPS_DllAPI inline void label_seq(
755  UnionCaseLabelSeq&& _label_seq) { m_label_seq = std::move(_label_seq); }
756  RTPS_DllAPI inline const UnionCaseLabelSeq& label_seq() const { return m_label_seq; }
757  RTPS_DllAPI inline UnionCaseLabelSeq& label_seq() { return m_label_seq; }
758 
759  RTPS_DllAPI static size_t getCdrSerializedSize(
760  const CommonUnionMember& data,
761  size_t current_alignment = 0);
762  RTPS_DllAPI void serialize(
763  eprosima::fastcdr::Cdr& cdr) const;
764  RTPS_DllAPI void deserialize(
765  eprosima::fastcdr::Cdr& cdr);
766 
767  RTPS_DllAPI bool operator==(
768  const CommonUnionMember& other) const;
769 
770  RTPS_DllAPI bool consistent(
771  const CommonUnionMember& x,
772  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
773 
774 private:
775 
776  MemberId m_member_id;
777  UnionMemberFlag m_member_flags;
778  TypeIdentifier m_type_id;
779  UnionCaseLabelSeq m_label_seq;
780 };
781 
782 // Member of a union type
783 /*struct CompleteUnionMember {
784  CommonUnionMember common;
785  CompleteMemberDetail detail;
786  };*/
788 {
789 public:
790 
791  RTPS_DllAPI CompleteUnionMember();
792  RTPS_DllAPI ~CompleteUnionMember();
793  RTPS_DllAPI CompleteUnionMember(
794  const CompleteUnionMember& x);
795  RTPS_DllAPI CompleteUnionMember(
796  CompleteUnionMember&& x);
798  const CompleteUnionMember& x);
800  CompleteUnionMember&& x);
801 
802  RTPS_DllAPI inline void common(
803  const CommonUnionMember& _common) { m_common = _common; }
804  RTPS_DllAPI inline void common(
805  CommonUnionMember&& _common) { m_common = std::move(_common); }
806  RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }
807  RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }
808 
809  RTPS_DllAPI inline void detail(
810  const CompleteMemberDetail& _detail) { m_detail = _detail; }
811  RTPS_DllAPI inline void detail(
812  CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
813  RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
814  RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
815 
816  RTPS_DllAPI static size_t getCdrSerializedSize(
817  const CompleteUnionMember& data,
818  size_t current_alignment = 0);
819  RTPS_DllAPI void serialize(
820  eprosima::fastcdr::Cdr& cdr) const;
821  RTPS_DllAPI void deserialize(
822  eprosima::fastcdr::Cdr& cdr);
823 
824  RTPS_DllAPI bool operator==(
825  const CompleteUnionMember& other) const;
826 
827  RTPS_DllAPI bool consistent(
828  const CompleteUnionMember& x,
829  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
830 
831 private:
832 
833  CommonUnionMember m_common;
834  CompleteMemberDetail m_detail;
835 };
836 
837 // Ordered by member_index
838 typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
839 
840 // Member of a union type
841 /*struct MinimalUnionMember {
842  CommonUnionMember common;
843  MinimalMemberDetail detail;
844  };*/
846 {
847 public:
848 
849  RTPS_DllAPI MinimalUnionMember();
850  RTPS_DllAPI ~MinimalUnionMember();
851  RTPS_DllAPI MinimalUnionMember(
852  const MinimalUnionMember& x);
853  RTPS_DllAPI MinimalUnionMember(
854  MinimalUnionMember&& x);
856  const MinimalUnionMember& x);
858  MinimalUnionMember&& x);
859 
860  RTPS_DllAPI inline void common(
861  const CommonUnionMember& _common) { m_common = _common; }
862  RTPS_DllAPI inline void common(
863  CommonUnionMember&& _common) { m_common = std::move(_common); }
864  RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }
865  RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }
866 
867  RTPS_DllAPI inline void detail(
868  const MinimalMemberDetail& _detail) { m_detail = _detail; }
869  RTPS_DllAPI inline void detail(
870  MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
871  RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
872  RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
873 
874  RTPS_DllAPI static size_t getCdrSerializedSize(
875  const MinimalUnionMember& data,
876  size_t current_alignment = 0);
877  RTPS_DllAPI void serialize(
878  eprosima::fastcdr::Cdr& cdr) const;
879  RTPS_DllAPI void deserialize(
880  eprosima::fastcdr::Cdr& cdr);
881 
882  RTPS_DllAPI bool operator==(
883  const MinimalUnionMember& other) const;
884 
885  RTPS_DllAPI bool consistent(
886  const MinimalUnionMember& x,
887  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
888 
889 private:
890 
891  CommonUnionMember m_common;
892  MinimalMemberDetail m_detail;
893 };
894 
895 // Ordered by MinimalUnionMember.common.member_id
896 typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
897 
898 /*struct CommonDiscriminatorMember final{
899  UnionDiscriminatorFlag member_flags;
900  TypeIdentifier type_id;
901  };*/
903 {
904 public:
905 
909  const CommonDiscriminatorMember& x);
913  const CommonDiscriminatorMember& x);
916 
917  RTPS_DllAPI inline void member_flags(
918  const UnionDiscriminatorFlag& _member_flags) { m_member_flags = _member_flags; }
919  RTPS_DllAPI inline void member_flags(
920  UnionDiscriminatorFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
921  RTPS_DllAPI inline const UnionDiscriminatorFlag& member_flags() const { return m_member_flags; }
922  RTPS_DllAPI inline UnionDiscriminatorFlag& member_flags() { return m_member_flags; }
923 
924  RTPS_DllAPI inline void type_id(
925  const TypeIdentifier& _type_id) { m_type_id = _type_id; }
926  RTPS_DllAPI inline void type_id(
927  TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
928  RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
929  RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
930 
931  RTPS_DllAPI static size_t getCdrSerializedSize(
932  const CommonDiscriminatorMember& data,
933  size_t current_alignment = 0);
934  RTPS_DllAPI void serialize(
935  eprosima::fastcdr::Cdr& cdr) const;
936  RTPS_DllAPI void deserialize(
937  eprosima::fastcdr::Cdr& cdr);
938 
939  RTPS_DllAPI bool operator==(
940  const CommonDiscriminatorMember& other) const;
941 
942  RTPS_DllAPI bool consistent(
943  const CommonDiscriminatorMember& x,
944  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
945 
946 private:
947 
948  UnionDiscriminatorFlag m_member_flags;
949  TypeIdentifier m_type_id;
950 };
951 
952 // Member of a union type
953 /*struct CompleteDiscriminatorMember {
954  CommonDiscriminatorMember common;
955  AppliedBuiltinTypeAnnotations ann_builtin; // Optional
956  AppliedAnnotationSeq ann_custom; // Optional
957  };*/
959 {
960 public:
961 
965  const CompleteDiscriminatorMember& x);
969  const CompleteDiscriminatorMember& x);
972 
973  RTPS_DllAPI inline void common(
974  const CommonDiscriminatorMember& _common) { m_common = _common; }
975  RTPS_DllAPI inline void common(
976  CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }
977  RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }
978  RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }
979 
980  RTPS_DllAPI inline void ann_builtin(
981  const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
982  RTPS_DllAPI inline void ann_builtin(
983  AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
984  RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }
985  RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }
986 
987  RTPS_DllAPI inline void ann_custom(
988  const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
989  RTPS_DllAPI inline void ann_custom(
990  AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
991  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
992  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
993 
994  RTPS_DllAPI static size_t getCdrSerializedSize(
995  const CompleteDiscriminatorMember& data,
996  size_t current_alignment = 0);
997  RTPS_DllAPI void serialize(
998  eprosima::fastcdr::Cdr& cdr) const;
999  RTPS_DllAPI void deserialize(
1000  eprosima::fastcdr::Cdr& cdr);
1001 
1002  RTPS_DllAPI bool operator==(
1003  const CompleteDiscriminatorMember& other) const;
1004 
1005  RTPS_DllAPI bool consistent(
1006  const CompleteDiscriminatorMember& x,
1007  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1008 
1009 private:
1010 
1011  CommonDiscriminatorMember m_common;
1012  AppliedBuiltinTypeAnnotations m_ann_builtin;
1013  AppliedAnnotationSeq m_ann_custom;
1014 };
1015 
1016 // Member of a union type
1017 /*struct MinimalDiscriminatorMember {
1018  CommonDiscriminatorMember common;
1019  };*/
1021 {
1022 public:
1023 
1027  const MinimalDiscriminatorMember& x);
1031  const MinimalDiscriminatorMember& x);
1034 
1035  RTPS_DllAPI inline void common(
1036  const CommonDiscriminatorMember& _common) { m_common = _common; }
1037  RTPS_DllAPI inline void common(
1038  CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }
1039  RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }
1040  RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }
1041 
1042  RTPS_DllAPI static size_t getCdrSerializedSize(
1043  const MinimalDiscriminatorMember& data,
1044  size_t current_alignment = 0);
1045  RTPS_DllAPI void serialize(
1046  eprosima::fastcdr::Cdr& cdr) const;
1047  RTPS_DllAPI void deserialize(
1048  eprosima::fastcdr::Cdr& cdr);
1049 
1050  RTPS_DllAPI bool operator==(
1051  const MinimalDiscriminatorMember& other) const;
1052 
1053  RTPS_DllAPI bool consistent(
1054  const MinimalDiscriminatorMember& x,
1055  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1056 
1057 private:
1058 
1059  CommonDiscriminatorMember m_common;
1060 };
1061 
1062 /*struct CompleteUnionHeader {
1063  CompleteTypeDetail detail;
1064  };*/
1066 {
1067 public:
1068 
1069  RTPS_DllAPI CompleteUnionHeader();
1070  RTPS_DllAPI ~CompleteUnionHeader();
1071  RTPS_DllAPI CompleteUnionHeader(
1072  const CompleteUnionHeader& x);
1073  RTPS_DllAPI CompleteUnionHeader(
1074  CompleteUnionHeader&& x);
1076  const CompleteUnionHeader& x);
1078  CompleteUnionHeader&& x);
1079 
1080  RTPS_DllAPI inline void detail(
1081  const CompleteTypeDetail& _detail) { m_detail = _detail; }
1082  RTPS_DllAPI inline void detail(
1083  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
1084  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
1085  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
1086 
1087  RTPS_DllAPI static size_t getCdrSerializedSize(
1088  const CompleteUnionHeader& data,
1089  size_t current_alignment = 0);
1090  RTPS_DllAPI void serialize(
1091  eprosima::fastcdr::Cdr& cdr) const;
1092  RTPS_DllAPI void deserialize(
1093  eprosima::fastcdr::Cdr& cdr);
1094 
1095  RTPS_DllAPI bool operator==(
1096  const CompleteUnionHeader& other) const;
1097 
1098  RTPS_DllAPI bool consistent(
1099  const CompleteUnionHeader& x,
1100  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1101 
1102 private:
1103 
1104  CompleteTypeDetail m_detail;
1105 };
1106 
1107 /*struct MinimalUnionHeader {
1108  MinimalTypeDetail detail;
1109  };*/
1111 {
1112 public:
1113 
1114  RTPS_DllAPI MinimalUnionHeader();
1115  RTPS_DllAPI ~MinimalUnionHeader();
1116  RTPS_DllAPI MinimalUnionHeader(
1117  const MinimalUnionHeader& x);
1118  RTPS_DllAPI MinimalUnionHeader(
1119  MinimalUnionHeader&& x);
1121  const MinimalUnionHeader& x);
1123  MinimalUnionHeader&& x);
1124 
1125  RTPS_DllAPI inline void detail(
1126  const MinimalTypeDetail& _detail) { m_detail = _detail; }
1127  RTPS_DllAPI inline void detail(
1128  MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }
1129  RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }
1130  RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }
1131 
1132  RTPS_DllAPI static size_t getCdrSerializedSize(
1133  const MinimalUnionHeader& data,
1134  size_t current_alignment = 0);
1135  RTPS_DllAPI void serialize(
1136  eprosima::fastcdr::Cdr& cdr) const;
1137  RTPS_DllAPI void deserialize(
1138  eprosima::fastcdr::Cdr& cdr);
1139 
1140  RTPS_DllAPI bool operator==(
1141  const MinimalUnionHeader& other) const;
1142 
1143  RTPS_DllAPI bool consistent(
1144  const MinimalUnionHeader& x,
1145  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1146 
1147 private:
1148 
1149  MinimalTypeDetail m_detail;
1150 };
1151 
1152 /*struct CompleteUnionType final{
1153  UnionTypeFlag union_flags;
1154  CompleteUnionHeader header;
1155  CompleteDiscriminatorMember discriminator;
1156  CompleteUnionMemberSeq member_seq;
1157  };*/
1159 {
1160 public:
1161 
1162  RTPS_DllAPI CompleteUnionType();
1163  RTPS_DllAPI ~CompleteUnionType();
1164  RTPS_DllAPI CompleteUnionType(
1165  const CompleteUnionType& x);
1166  RTPS_DllAPI CompleteUnionType(
1167  CompleteUnionType&& x);
1169  const CompleteUnionType& x);
1171  CompleteUnionType&& x);
1172 
1173  RTPS_DllAPI inline void union_flags(
1174  const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }
1175  RTPS_DllAPI inline void union_flags(
1176  UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }
1177  RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }
1178  RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }
1179 
1180  RTPS_DllAPI inline void header(
1181  const CompleteUnionHeader& _header) { m_header = _header; }
1182  RTPS_DllAPI inline void header(
1183  CompleteUnionHeader&& _header) { m_header = std::move(_header); }
1184  RTPS_DllAPI inline const CompleteUnionHeader& header() const { return m_header; }
1185  RTPS_DllAPI inline CompleteUnionHeader& header() { return m_header; }
1186 
1187  RTPS_DllAPI inline void discriminator(
1188  const CompleteDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }
1189  RTPS_DllAPI inline void discriminator(
1190  CompleteDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }
1191  RTPS_DllAPI inline const CompleteDiscriminatorMember& discriminator() const { return m_discriminator; }
1192  RTPS_DllAPI inline CompleteDiscriminatorMember& discriminator() { return m_discriminator; }
1193 
1194  RTPS_DllAPI inline void member_seq(
1195  const CompleteUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }
1196  RTPS_DllAPI inline void member_seq(
1197  CompleteUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1198  RTPS_DllAPI inline const CompleteUnionMemberSeq& member_seq() const { return m_member_seq; }
1199  RTPS_DllAPI inline CompleteUnionMemberSeq& member_seq() { return m_member_seq; }
1200 
1201  RTPS_DllAPI static size_t getCdrSerializedSize(
1202  const CompleteUnionType& data,
1203  size_t current_alignment = 0);
1204  RTPS_DllAPI void serialize(
1205  eprosima::fastcdr::Cdr& cdr) const;
1206  RTPS_DllAPI void deserialize(
1207  eprosima::fastcdr::Cdr& cdr);
1208 
1209  RTPS_DllAPI bool operator==(
1210  const CompleteUnionType& other) const;
1211 
1212  RTPS_DllAPI bool consistent(
1213  const CompleteUnionType& x,
1214  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1215 
1216 private:
1217 
1218  UnionTypeFlag m_union_flags;
1219  CompleteUnionHeader m_header;
1220  CompleteDiscriminatorMember m_discriminator;
1221  CompleteUnionMemberSeq m_member_seq;
1222 };
1223 
1224 /*struct MinimalUnionType final{
1225  UnionTypeFlag union_flags;
1226  MinimalUnionHeader header;
1227  MinimalDiscriminatorMember discriminator;
1228  MinimalUnionMemberSeq member_seq;
1229  };*/
1231 {
1232 public:
1233 
1234  RTPS_DllAPI MinimalUnionType();
1235  RTPS_DllAPI ~MinimalUnionType();
1236  RTPS_DllAPI MinimalUnionType(
1237  const MinimalUnionType& x);
1238  RTPS_DllAPI MinimalUnionType(
1239  MinimalUnionType&& x);
1241  const MinimalUnionType& x);
1243  MinimalUnionType&& x);
1244 
1245  RTPS_DllAPI inline void union_flags(
1246  const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }
1247  RTPS_DllAPI inline void union_flags(
1248  UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }
1249  RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }
1250  RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }
1251 
1252  RTPS_DllAPI inline void header(
1253  const MinimalUnionHeader& _header) { m_header = _header; }
1254  RTPS_DllAPI inline void header(
1255  MinimalUnionHeader&& _header) { m_header = std::move(_header); }
1256  RTPS_DllAPI inline const MinimalUnionHeader& header() const { return m_header; }
1257  RTPS_DllAPI inline MinimalUnionHeader& header() { return m_header; }
1258 
1259  RTPS_DllAPI inline void discriminator(
1260  const MinimalDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }
1261  RTPS_DllAPI inline void discriminator(
1262  MinimalDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }
1263  RTPS_DllAPI inline const MinimalDiscriminatorMember& discriminator() const { return m_discriminator; }
1264  RTPS_DllAPI inline MinimalDiscriminatorMember& discriminator() { return m_discriminator; }
1265 
1266  RTPS_DllAPI inline void member_seq(
1267  const MinimalUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }
1268  RTPS_DllAPI inline void member_seq(
1269  MinimalUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1270  RTPS_DllAPI inline const MinimalUnionMemberSeq& member_seq() const { return m_member_seq; }
1271  RTPS_DllAPI inline MinimalUnionMemberSeq& member_seq() { return m_member_seq; }
1272 
1273  RTPS_DllAPI static size_t getCdrSerializedSize(
1274  const MinimalUnionType& data,
1275  size_t current_alignment = 0);
1276  RTPS_DllAPI void serialize(
1277  eprosima::fastcdr::Cdr& cdr) const;
1278  RTPS_DllAPI void deserialize(
1279  eprosima::fastcdr::Cdr& cdr);
1280 
1281  RTPS_DllAPI bool operator==(
1282  const MinimalUnionType& other) const;
1283 
1284  RTPS_DllAPI bool consistent(
1285  const MinimalUnionType& x,
1286  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1287 
1288 private:
1289 
1290  UnionTypeFlag m_union_flags;
1291  MinimalUnionHeader m_header;
1292  MinimalDiscriminatorMember m_discriminator;
1293  MinimalUnionMemberSeq m_member_seq;
1294 };
1295 
1296 // --- Annotation: ---------------------------------------------------
1297 /*struct CommonAnnotationParameter final{
1298  AnnotationParameterFlag member_flags;
1299  TypeIdentifier member_type_id;
1300  };*/
1302 {
1303 public:
1304 
1308  const CommonAnnotationParameter& x);
1312  const CommonAnnotationParameter& x);
1315 
1316  RTPS_DllAPI inline void member_flags(
1317  const AnnotationParameterFlag& _member_flags) { m_member_flags = _member_flags; }
1318  RTPS_DllAPI inline void member_flags(
1319  AnnotationParameterFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
1320  RTPS_DllAPI inline const AnnotationParameterFlag& member_flags() const { return m_member_flags; }
1321  RTPS_DllAPI inline AnnotationParameterFlag& member_flags() { return m_member_flags; }
1322 
1323  RTPS_DllAPI inline void member_type_id(
1324  const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }
1325  RTPS_DllAPI inline void member_type_id(
1326  TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }
1327  RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }
1328  RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }
1329 
1330  RTPS_DllAPI static size_t getCdrSerializedSize(
1331  const CommonAnnotationParameter& data,
1332  size_t current_alignment = 0);
1333  RTPS_DllAPI void serialize(
1334  eprosima::fastcdr::Cdr& cdr) const;
1335  RTPS_DllAPI void deserialize(
1336  eprosima::fastcdr::Cdr& cdr);
1337 
1338  RTPS_DllAPI bool operator==(
1339  const CommonAnnotationParameter& other) const;
1340 
1341  RTPS_DllAPI bool consistent(
1342  const CommonAnnotationParameter& x,
1343  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1344 
1345 private:
1346 
1347  AnnotationParameterFlag m_member_flags;
1348  TypeIdentifier m_member_type_id;
1349 };
1350 
1351 // Member of an annotation type
1352 
1353 /*struct CompleteAnnotationParameter {
1354  CommonAnnotationParameter common;
1355  MemberName name;
1356  AnnotationParameterValue default_value;
1357  };*/
1359 {
1360 public:
1361 
1365  const CompleteAnnotationParameter& x);
1369  const CompleteAnnotationParameter& x);
1372 
1373  RTPS_DllAPI inline void common(
1374  const CommonAnnotationParameter& _common) { m_common = _common; }
1375  RTPS_DllAPI inline void common(
1376  CommonAnnotationParameter&& _common) { m_common = std::move(_common); }
1377  RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }
1378  RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }
1379 
1380  RTPS_DllAPI inline void name(
1381  const MemberName& _name) { m_name = _name; }
1382  RTPS_DllAPI inline void name(
1383  MemberName&& _name) { m_name = std::move(_name); }
1384  RTPS_DllAPI inline const MemberName& name() const { return m_name; }
1385  RTPS_DllAPI inline MemberName& name() { return m_name; }
1386 
1387  RTPS_DllAPI inline void default_value(
1388  const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }
1389  RTPS_DllAPI inline void default_value(
1390  AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }
1391  RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }
1392  RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }
1393 
1394  RTPS_DllAPI static size_t getCdrSerializedSize(
1395  const CompleteAnnotationParameter& data,
1396  size_t current_alignment = 0);
1397  RTPS_DllAPI void serialize(
1398  eprosima::fastcdr::Cdr& cdr) const;
1399  RTPS_DllAPI void deserialize(
1400  eprosima::fastcdr::Cdr& cdr);
1401 
1402  RTPS_DllAPI bool operator==(
1403  const CompleteAnnotationParameter& other) const;
1404 
1405  RTPS_DllAPI bool consistent(
1406  const CompleteAnnotationParameter& x,
1407  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1408 
1409 private:
1410 
1411  CommonAnnotationParameter m_common;
1412  MemberName m_name;
1413  AnnotationParameterValue m_default_value;
1414 };
1415 // Ordered by CompleteAnnotationParameter.name
1416 typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
1417 /*struct MinimalAnnotationParameter {
1418  CommonAnnotationParameter common;
1419  NameHash name_hash;
1420  AnnotationParameterValue default_value;
1421  };*/
1423 {
1424 public:
1425 
1429  const MinimalAnnotationParameter& x);
1433  const MinimalAnnotationParameter& x);
1436 
1437  RTPS_DllAPI inline void common(
1438  const CommonAnnotationParameter& _common) { m_common = _common; }
1439  RTPS_DllAPI inline void common(
1440  CommonAnnotationParameter&& _common) { m_common = std::move(_common); }
1441  RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }
1442  RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }
1443 
1444  RTPS_DllAPI inline void name(
1445  const MemberName& _name) { m_name = _name; }
1446  RTPS_DllAPI inline void name(
1447  MemberName&& _name) { m_name = std::move(_name); }
1448  RTPS_DllAPI inline const MemberName& name() const { return m_name; }
1449  RTPS_DllAPI inline MemberName& name() { return m_name; }
1450 
1451  RTPS_DllAPI inline void default_value(
1452  const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }
1453  RTPS_DllAPI inline void default_value(
1454  AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }
1455  RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }
1456  RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }
1457 
1458  RTPS_DllAPI static size_t getCdrSerializedSize(
1459  const MinimalAnnotationParameter& data,
1460  size_t current_alignment = 0);
1461  RTPS_DllAPI void serialize(
1462  eprosima::fastcdr::Cdr& cdr) const;
1463  RTPS_DllAPI void deserialize(
1464  eprosima::fastcdr::Cdr& cdr);
1465 
1466  RTPS_DllAPI bool operator==(
1467  const MinimalAnnotationParameter& other) const;
1468 
1469  RTPS_DllAPI bool consistent(
1470  const MinimalAnnotationParameter& x,
1471  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1472 
1473 private:
1474 
1475  CommonAnnotationParameter m_common;
1476  MemberName m_name;
1477  AnnotationParameterValue m_default_value;
1478 };
1479 
1480 // Ordered by MinimalAnnotationParameter.name_hash
1481 typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
1482 /*struct CompleteAnnotationHeader {
1483  QualifiedTypeName annotation_name;
1484  };*/
1486 {
1487 public:
1488 
1492  const CompleteAnnotationHeader& x);
1496  const CompleteAnnotationHeader& x);
1499 
1500  RTPS_DllAPI inline void annotation_name(
1501  const QualifiedTypeName& _annotation_name) { m_annotation_name = _annotation_name; }
1502  RTPS_DllAPI inline void annotation_name(
1503  QualifiedTypeName&& _annotation_name) { m_annotation_name = std::move(_annotation_name); }
1504  RTPS_DllAPI inline const QualifiedTypeName& annotation_name() const { return m_annotation_name; }
1505  RTPS_DllAPI inline QualifiedTypeName& annotation_name() { return m_annotation_name; }
1506 
1507  RTPS_DllAPI static size_t getCdrSerializedSize(
1508  const CompleteAnnotationHeader& data,
1509  size_t current_alignment = 0);
1510  RTPS_DllAPI void serialize(
1511  eprosima::fastcdr::Cdr& cdr) const;
1512  RTPS_DllAPI void deserialize(
1513  eprosima::fastcdr::Cdr& cdr);
1514 
1515  RTPS_DllAPI bool operator==(
1516  const CompleteAnnotationHeader& other) const;
1517 
1518  RTPS_DllAPI bool consistent(
1519  const CompleteAnnotationHeader& x,
1520  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1521 
1522 private:
1523 
1524  QualifiedTypeName m_annotation_name;
1525 };
1526 
1527 /*struct MinimalAnnotationHeader {
1528  // Empty. Available for future extension
1529  };*/
1531 {
1532 public:
1533 
1537  const MinimalAnnotationHeader& x);
1541  const MinimalAnnotationHeader& x);
1544 
1545  RTPS_DllAPI static size_t getCdrSerializedSize(
1546  const MinimalAnnotationHeader& data,
1547  size_t current_alignment = 0);
1548  RTPS_DllAPI void serialize(
1549  eprosima::fastcdr::Cdr& cdr) const;
1550  RTPS_DllAPI void deserialize(
1551  eprosima::fastcdr::Cdr& cdr);
1552 
1553  RTPS_DllAPI bool operator==(
1554  const MinimalAnnotationHeader&) const { return true; }
1555 
1556  RTPS_DllAPI bool consistent(
1557  const MinimalAnnotationHeader& x,
1558  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1559 
1560 private:
1561 
1562 };
1563 
1564 /*struct CompleteAnnotationType final{
1565  AnnotationTypeFlag annotation_flag;
1566  CompleteAnnotationHeader header;
1567  CompleteAnnotationParameterSeq member_seq;
1568  };*/
1570 {
1571 public:
1572 
1573  RTPS_DllAPI CompleteAnnotationType();
1576  const CompleteAnnotationType& x);
1580  const CompleteAnnotationType& x);
1583 
1584  RTPS_DllAPI inline void annotation_flag(
1585  const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }
1586  RTPS_DllAPI inline void annotation_flag(
1587  AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }
1588  RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }
1589  RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }
1590 
1591  RTPS_DllAPI inline void header(
1592  const CompleteAnnotationHeader& _header) { m_header = _header; }
1593  RTPS_DllAPI inline void header(
1594  CompleteAnnotationHeader&& _header) { m_header = std::move(_header); }
1595  RTPS_DllAPI inline const CompleteAnnotationHeader& header() const { return m_header; }
1596  RTPS_DllAPI inline CompleteAnnotationHeader& header() { return m_header; }
1597 
1598  RTPS_DllAPI inline void member_seq(
1599  const CompleteAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }
1600  RTPS_DllAPI inline void member_seq(
1601  CompleteAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1602  RTPS_DllAPI inline const CompleteAnnotationParameterSeq& member_seq() const { return m_member_seq; }
1603  RTPS_DllAPI inline CompleteAnnotationParameterSeq& member_seq() { return m_member_seq; }
1604 
1605  RTPS_DllAPI static size_t getCdrSerializedSize(
1606  const CompleteAnnotationType& data,
1607  size_t current_alignment = 0);
1608  RTPS_DllAPI void serialize(
1609  eprosima::fastcdr::Cdr& cdr) const;
1610  RTPS_DllAPI void deserialize(
1611  eprosima::fastcdr::Cdr& cdr);
1612 
1613  RTPS_DllAPI bool operator==(
1614  const CompleteAnnotationType& other) const;
1615 
1616  RTPS_DllAPI bool consistent(
1617  const CompleteAnnotationType& x,
1618  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1619 
1620 private:
1621 
1622  AnnotationTypeFlag m_annotation_flag;
1623  CompleteAnnotationHeader m_header;
1624  CompleteAnnotationParameterSeq m_member_seq;
1625 };
1626 /*struct MinimalAnnotationType final{
1627  AnnotationTypeFlag annotation_flag;
1628  MinimalAnnotationHeader header;
1629  MinimalAnnotationParameterSeq member_seq;
1630  };*/
1632 {
1633 public:
1634 
1635  RTPS_DllAPI MinimalAnnotationType();
1636  RTPS_DllAPI ~MinimalAnnotationType();
1638  const MinimalAnnotationType& x);
1640  MinimalAnnotationType&& x);
1642  const MinimalAnnotationType& x);
1644  MinimalAnnotationType&& x);
1645 
1646  RTPS_DllAPI inline void annotation_flag(
1647  const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }
1648  RTPS_DllAPI inline void annotation_flag(
1649  AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }
1650  RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }
1651  RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }
1652 
1653  RTPS_DllAPI inline void header(
1654  const MinimalAnnotationHeader& _header) { m_header = _header; }
1655  RTPS_DllAPI inline void header(
1656  MinimalAnnotationHeader&& _header) { m_header = std::move(_header); }
1657  RTPS_DllAPI inline const MinimalAnnotationHeader& header() const { return m_header; }
1658  RTPS_DllAPI inline MinimalAnnotationHeader& header() { return m_header; }
1659 
1660  RTPS_DllAPI inline void member_seq(
1661  const MinimalAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }
1662  RTPS_DllAPI inline void member_seq(
1663  MinimalAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
1664  RTPS_DllAPI inline const MinimalAnnotationParameterSeq& member_seq() const { return m_member_seq; }
1665  RTPS_DllAPI inline MinimalAnnotationParameterSeq& member_seq() { return m_member_seq; }
1666 
1667  RTPS_DllAPI static size_t getCdrSerializedSize(
1668  const MinimalAnnotationType& data,
1669  size_t current_alignment = 0);
1670  RTPS_DllAPI void serialize(
1671  eprosima::fastcdr::Cdr& cdr) const;
1672  RTPS_DllAPI void deserialize(
1673  eprosima::fastcdr::Cdr& cdr);
1674 
1675  RTPS_DllAPI bool operator==(
1676  const MinimalAnnotationType& other) const;
1677 
1678  RTPS_DllAPI bool consistent(
1679  const MinimalAnnotationType& x,
1680  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1681 
1682 private:
1683 
1684  AnnotationTypeFlag m_annotation_flag;
1685  MinimalAnnotationHeader m_header;
1686  MinimalAnnotationParameterSeq m_member_seq;
1687 };
1688 
1689 // --- Alias: ---------------------------------------------------------
1690 /*struct CommonAliasBody final{
1691  AliasMemberFlag related_flags;
1692  TypeIdentifier related_type;
1693  };*/
1695 {
1696 public:
1697 
1698  RTPS_DllAPI CommonAliasBody();
1699  RTPS_DllAPI ~CommonAliasBody();
1700  RTPS_DllAPI CommonAliasBody(
1701  const CommonAliasBody& x);
1702  RTPS_DllAPI CommonAliasBody(
1703  CommonAliasBody&& x);
1705  const CommonAliasBody& x);
1707  CommonAliasBody&& x);
1708 
1709  RTPS_DllAPI inline void related_flags(
1710  const AliasMemberFlag& _related_flags) { m_related_flags = _related_flags; }
1711  RTPS_DllAPI inline void related_flags(
1712  AliasMemberFlag&& _related_flags) { m_related_flags = std::move(_related_flags); }
1713  RTPS_DllAPI inline const AliasMemberFlag& related_flags() const { return m_related_flags; }
1714  RTPS_DllAPI inline AliasMemberFlag& related_flags() { return m_related_flags; }
1715 
1716  RTPS_DllAPI inline void related_type(
1717  const TypeIdentifier& _related_type) { m_related_type = _related_type; }
1718  RTPS_DllAPI inline void related_type(
1719  TypeIdentifier&& _related_type) { m_related_type = std::move(_related_type); }
1720  RTPS_DllAPI inline const TypeIdentifier& related_type() const { return m_related_type; }
1721  RTPS_DllAPI inline TypeIdentifier& related_type() { return m_related_type; }
1722 
1723  RTPS_DllAPI static size_t getCdrSerializedSize(
1724  const CommonAliasBody& data,
1725  size_t current_alignment = 0);
1726  RTPS_DllAPI void serialize(
1727  eprosima::fastcdr::Cdr& cdr) const;
1728  RTPS_DllAPI void deserialize(
1729  eprosima::fastcdr::Cdr& cdr);
1730 
1731  RTPS_DllAPI bool operator==(
1732  const CommonAliasBody& other) const;
1733 
1734  // RTPS_DllAPI bool consistent(const CommonAliasBody &x,
1735  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1736 
1737 private:
1738 
1739  AliasMemberFlag m_related_flags;
1740  TypeIdentifier m_related_type;
1741 };
1742 
1743 /*struct CompleteAliasBody {
1744  CommonAliasBody common;
1745  AppliedBuiltinMemberAnnotations ann_builtin; // Optional
1746  AppliedAnnotationSeq ann_custom; // Optional
1747  };*/
1749 {
1750 public:
1751 
1752  RTPS_DllAPI CompleteAliasBody();
1753  RTPS_DllAPI ~CompleteAliasBody();
1754  RTPS_DllAPI CompleteAliasBody(
1755  const CompleteAliasBody& x);
1756  RTPS_DllAPI CompleteAliasBody(
1757  CompleteAliasBody&& x);
1759  const CompleteAliasBody& x);
1761  CompleteAliasBody&& x);
1762 
1763  RTPS_DllAPI inline void common(
1764  const CommonAliasBody& _common) { m_common = _common; }
1765  RTPS_DllAPI inline void common(
1766  CommonAliasBody&& _common) { m_common = std::move(_common); }
1767  RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }
1768  RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }
1769 
1770  RTPS_DllAPI inline void ann_builtin(
1771  const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
1772  RTPS_DllAPI inline void ann_builtin(
1773  AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
1774  RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
1775  RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
1776 
1777  RTPS_DllAPI inline void ann_custom(
1778  const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
1779  RTPS_DllAPI inline void ann_custom(
1780  AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
1781  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
1782  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
1783 
1784  RTPS_DllAPI static size_t getCdrSerializedSize(
1785  const CompleteAliasBody& data,
1786  size_t current_alignment = 0);
1787  RTPS_DllAPI void serialize(
1788  eprosima::fastcdr::Cdr& cdr) const;
1789  RTPS_DllAPI void deserialize(
1790  eprosima::fastcdr::Cdr& cdr);
1791 
1792  RTPS_DllAPI bool operator==(
1793  const CompleteAliasBody& other) const;
1794 
1795  // RTPS_DllAPI bool consistent(const CompleteAliasBody &x,
1796  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1797 
1798 private:
1799 
1800  CommonAliasBody m_common;
1801  AppliedBuiltinMemberAnnotations m_ann_builtin;
1802  AppliedAnnotationSeq m_ann_custom;
1803 };
1804 
1805 /*struct MinimalAliasBody {
1806  CommonAliasBody common;
1807  };*/
1809 {
1810 public:
1811 
1812  RTPS_DllAPI MinimalAliasBody();
1813  RTPS_DllAPI ~MinimalAliasBody();
1814  RTPS_DllAPI MinimalAliasBody(
1815  const MinimalAliasBody& x);
1816  RTPS_DllAPI MinimalAliasBody(
1817  MinimalAliasBody&& x);
1819  const MinimalAliasBody& x);
1821  MinimalAliasBody&& x);
1822 
1823  RTPS_DllAPI inline void common(
1824  const CommonAliasBody& _common) { m_common = _common; }
1825  RTPS_DllAPI inline void common(
1826  CommonAliasBody&& _common) { m_common = std::move(_common); }
1827  RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }
1828  RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }
1829 
1830  RTPS_DllAPI static size_t getCdrSerializedSize(
1831  const MinimalAliasBody& data,
1832  size_t current_alignment = 0);
1833  RTPS_DllAPI void serialize(
1834  eprosima::fastcdr::Cdr& cdr) const;
1835  RTPS_DllAPI void deserialize(
1836  eprosima::fastcdr::Cdr& cdr);
1837 
1838  RTPS_DllAPI bool operator==(
1839  const MinimalAliasBody& other) const;
1840 
1841  // RTPS_DllAPI bool consistent(const MinimalAliasBody &x,
1842  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1843 
1844 private:
1845 
1846  CommonAliasBody m_common;
1847 };
1848 
1849 /*struct CompleteAliasHeader {
1850  CompleteTypeDetail detail;
1851  };*/
1853 {
1854 public:
1855 
1856  RTPS_DllAPI CompleteAliasHeader();
1857  RTPS_DllAPI ~CompleteAliasHeader();
1858  RTPS_DllAPI CompleteAliasHeader(
1859  const CompleteAliasHeader& x);
1860  RTPS_DllAPI CompleteAliasHeader(
1861  CompleteAliasHeader&& x);
1863  const CompleteAliasHeader& x);
1865  CompleteAliasHeader&& x);
1866 
1867  RTPS_DllAPI inline void detail(
1868  const CompleteTypeDetail& _detail) { m_detail = _detail; }
1869  RTPS_DllAPI inline void detail(
1870  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
1871  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
1872  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
1873 
1874  RTPS_DllAPI static size_t getCdrSerializedSize(
1875  const CompleteAliasHeader& data,
1876  size_t current_alignment = 0);
1877  RTPS_DllAPI void serialize(
1878  eprosima::fastcdr::Cdr& cdr) const;
1879  RTPS_DllAPI void deserialize(
1880  eprosima::fastcdr::Cdr& cdr);
1881 
1882  RTPS_DllAPI bool operator==(
1883  const CompleteAliasHeader& other) const;
1884 
1885  // RTPS_DllAPI bool consistent(const CompleteAliasHeader &x,
1886  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1887 
1888 private:
1889 
1890  CompleteTypeDetail m_detail;
1891 };
1892 
1893 /*struct MinimalAliasHeader {
1894  // Empty. Available for future extension
1895  };*/
1897 {
1898 public:
1899 
1900  RTPS_DllAPI MinimalAliasHeader();
1901  RTPS_DllAPI ~MinimalAliasHeader();
1902  RTPS_DllAPI MinimalAliasHeader(
1903  const MinimalAliasHeader& x);
1904  RTPS_DllAPI MinimalAliasHeader(
1905  MinimalAliasHeader&& x);
1907  const MinimalAliasHeader& x);
1909  MinimalAliasHeader&& x);
1910 
1911  RTPS_DllAPI static size_t getCdrSerializedSize(
1912  const MinimalAliasHeader& data,
1913  size_t current_alignment = 0);
1914  RTPS_DllAPI void serialize(
1915  eprosima::fastcdr::Cdr& cdr) const;
1916  RTPS_DllAPI void deserialize(
1917  eprosima::fastcdr::Cdr& cdr);
1918 
1919  RTPS_DllAPI bool operator==(
1920  const MinimalAliasHeader&) const { return true; }
1921 
1922  // RTPS_DllAPI bool consistent(const MinimalAliasHeader &x,
1923  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1924 
1925 private:
1926 
1927 };
1928 
1929 /*struct CompleteAliasType final{
1930  AliasTypeFlag alias_flags;
1931  CompleteAliasHeader header;
1932  CompleteAliasBody body;
1933  };*/
1935 {
1936 public:
1937 
1938  RTPS_DllAPI CompleteAliasType();
1939  RTPS_DllAPI ~CompleteAliasType();
1940  RTPS_DllAPI CompleteAliasType(
1941  const CompleteAliasType& x);
1942  RTPS_DllAPI CompleteAliasType(
1943  CompleteAliasType&& x);
1945  const CompleteAliasType& x);
1947  CompleteAliasType&& x);
1948 
1949  RTPS_DllAPI inline void alias_flags(
1950  const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }
1951  RTPS_DllAPI inline void alias_flags(
1952  AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }
1953  RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }
1954  RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }
1955 
1956  RTPS_DllAPI inline void header(
1957  const CompleteAliasHeader& _header) { m_header = _header; }
1958  RTPS_DllAPI inline void header(
1959  CompleteAliasHeader&& _header) { m_header = std::move(_header); }
1960  RTPS_DllAPI inline const CompleteAliasHeader& header() const { return m_header; }
1961  RTPS_DllAPI inline CompleteAliasHeader& header() { return m_header; }
1962 
1963  RTPS_DllAPI inline void body(
1964  const CompleteAliasBody& _body) { m_body = _body; }
1965  RTPS_DllAPI inline void body(
1966  CompleteAliasBody&& _body) { m_body = std::move(_body); }
1967  RTPS_DllAPI inline const CompleteAliasBody& body() const { return m_body; }
1968  RTPS_DllAPI inline CompleteAliasBody& body() { return m_body; }
1969 
1970  RTPS_DllAPI static size_t getCdrSerializedSize(
1971  const CompleteAliasType& data,
1972  size_t current_alignment = 0);
1973  RTPS_DllAPI void serialize(
1974  eprosima::fastcdr::Cdr& cdr) const;
1975  RTPS_DllAPI void deserialize(
1976  eprosima::fastcdr::Cdr& cdr);
1977 
1978  RTPS_DllAPI bool operator==(
1979  const CompleteAliasType& other) const;
1980 
1981  // RTPS_DllAPI bool consistent(const CompleteAliasType &x,
1982  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
1983 
1984 private:
1985 
1986  AliasTypeFlag m_alias_flags;
1987  CompleteAliasHeader m_header;
1988  CompleteAliasBody m_body;
1989 };
1990 /*struct MinimalAliasType final{
1991  AliasTypeFlag alias_flags;
1992  MinimalAliasHeader header;
1993  MinimalAliasBody body;
1994  };*/
1996 {
1997 public:
1998 
1999  RTPS_DllAPI MinimalAliasType();
2000  RTPS_DllAPI ~MinimalAliasType();
2001  RTPS_DllAPI MinimalAliasType(
2002  const MinimalAliasType& x);
2003  RTPS_DllAPI MinimalAliasType(
2004  MinimalAliasType&& x);
2006  const MinimalAliasType& x);
2008  MinimalAliasType&& x);
2009 
2010  RTPS_DllAPI inline void alias_flags(
2011  const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }
2012  RTPS_DllAPI inline void alias_flags(
2013  AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }
2014  RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }
2015  RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }
2016 
2017  RTPS_DllAPI inline void header(
2018  const MinimalAliasHeader& _header) { m_header = _header; }
2019  RTPS_DllAPI inline void header(
2020  MinimalAliasHeader&& _header) { m_header = std::move(_header); }
2021  RTPS_DllAPI inline const MinimalAliasHeader& header() const { return m_header; }
2022  RTPS_DllAPI inline MinimalAliasHeader& header() { return m_header; }
2023 
2024  RTPS_DllAPI inline void body(
2025  const MinimalAliasBody& _body) { m_body = _body; }
2026  RTPS_DllAPI inline void body(
2027  MinimalAliasBody&& _body) { m_body = std::move(_body); }
2028  RTPS_DllAPI inline const MinimalAliasBody& body() const { return m_body; }
2029  RTPS_DllAPI inline MinimalAliasBody& body() { return m_body; }
2030 
2031  RTPS_DllAPI static size_t getCdrSerializedSize(
2032  const MinimalAliasType& data,
2033  size_t current_alignment = 0);
2034  RTPS_DllAPI void serialize(
2035  eprosima::fastcdr::Cdr& cdr) const;
2036  RTPS_DllAPI void deserialize(
2037  eprosima::fastcdr::Cdr& cdr);
2038 
2039  RTPS_DllAPI bool operator==(
2040  const MinimalAliasType& other) const;
2041 
2042  // RTPS_DllAPI bool consistent(const MinimalAliasType &x,
2043  // const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2044 
2045 private:
2046 
2047  AliasTypeFlag m_alias_flags;
2048  MinimalAliasHeader m_header;
2049  MinimalAliasBody m_body;
2050 };
2051 
2052 // --- Collections: ---------------------------------------------------
2053 /*struct CompleteElementDetail final{
2054  AppliedBuiltinMemberAnnotations ann_builtin; // Optional
2055  AppliedAnnotationSeq ann_custom; // Optional
2056  };*/
2058 {
2059 public:
2060 
2061  RTPS_DllAPI CompleteElementDetail();
2062  RTPS_DllAPI ~CompleteElementDetail();
2064  const CompleteElementDetail& x);
2066  CompleteElementDetail&& x);
2068  const CompleteElementDetail& x);
2070  CompleteElementDetail&& x);
2071 
2072  RTPS_DllAPI inline void ann_builtin(
2073  const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
2074  RTPS_DllAPI inline void ann_builtin(
2075  AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
2076  RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
2077  RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
2078 
2079  RTPS_DllAPI inline void ann_custom(
2080  const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
2081  RTPS_DllAPI inline void ann_custom(
2082  AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
2083  RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
2084  RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
2085 
2086  RTPS_DllAPI static size_t getCdrSerializedSize(
2087  const CompleteElementDetail& data,
2088  size_t current_alignment = 0);
2089  RTPS_DllAPI void serialize(
2090  eprosima::fastcdr::Cdr& cdr) const;
2091  RTPS_DllAPI void deserialize(
2092  eprosima::fastcdr::Cdr& cdr);
2093 
2094  RTPS_DllAPI bool operator==(
2095  const CompleteElementDetail& other) const;
2096 
2097  RTPS_DllAPI bool consistent(
2098  const CompleteElementDetail& x,
2099  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2100 
2101 private:
2102 
2103  AppliedBuiltinMemberAnnotations m_ann_builtin;
2104  AppliedAnnotationSeq m_ann_custom;
2105 };
2106 /*struct CommonCollectionElement final{
2107  CollectionElementFlag element_flags;
2108  TypeIdentifier type;
2109  };*/
2111 {
2112 public:
2113 
2117  const CommonCollectionElement& x);
2121  const CommonCollectionElement& x);
2124 
2125  RTPS_DllAPI inline void element_flags(
2126  const CollectionElementFlag& _element_flags) { m_element_flags = _element_flags; }
2127  RTPS_DllAPI inline void element_flags(
2128  CollectionElementFlag&& _element_flags) { m_element_flags = std::move(_element_flags); }
2129  RTPS_DllAPI inline const CollectionElementFlag& element_flags() const { return m_element_flags; }
2130  RTPS_DllAPI inline CollectionElementFlag& element_flags() { return m_element_flags; }
2131 
2132  RTPS_DllAPI inline void type(
2133  const TypeIdentifier& _type) { m_type = _type; }
2134  RTPS_DllAPI inline void type(
2135  TypeIdentifier&& _type) { m_type = std::move(_type); }
2136  RTPS_DllAPI inline const TypeIdentifier& type() const { return m_type; }
2137  RTPS_DllAPI inline TypeIdentifier& type() { return m_type; }
2138 
2139  RTPS_DllAPI static size_t getCdrSerializedSize(
2140  const CommonCollectionElement& data,
2141  size_t current_alignment = 0);
2142  RTPS_DllAPI void serialize(
2143  eprosima::fastcdr::Cdr& cdr) const;
2144  RTPS_DllAPI void deserialize(
2145  eprosima::fastcdr::Cdr& cdr);
2146 
2147  RTPS_DllAPI bool operator==(
2148  const CommonCollectionElement& other) const;
2149 
2150  RTPS_DllAPI bool consistent(
2151  const CommonCollectionElement& x,
2152  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2153 
2154 private:
2155 
2156  CollectionElementFlag m_element_flags;
2157  TypeIdentifier m_type;
2158 };
2159 
2160 /*struct CompleteCollectionElement {
2161  CommonCollectionElement common;
2162  CompleteElementDetail detail;
2163  };*/
2165 {
2166 public:
2167 
2171  const CompleteCollectionElement& x);
2175  const CompleteCollectionElement& x);
2178 
2179  RTPS_DllAPI inline void common(
2180  const CommonCollectionElement& _common) { m_common = _common; }
2181  RTPS_DllAPI inline void common(
2182  CommonCollectionElement&& _common) { m_common = std::move(_common); }
2183  RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }
2184  RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }
2185 
2186  RTPS_DllAPI inline void detail(
2187  const CompleteElementDetail& _detail) { m_detail = _detail; }
2188  RTPS_DllAPI inline void detail(
2189  CompleteElementDetail&& _detail) { m_detail = std::move(_detail); }
2190  RTPS_DllAPI inline const CompleteElementDetail& detail() const { return m_detail; }
2191  RTPS_DllAPI inline CompleteElementDetail& detail() { return m_detail; }
2192 
2193  RTPS_DllAPI static size_t getCdrSerializedSize(
2194  const CompleteCollectionElement& data,
2195  size_t current_alignment = 0);
2196  RTPS_DllAPI void serialize(
2197  eprosima::fastcdr::Cdr& cdr) const;
2198  RTPS_DllAPI void deserialize(
2199  eprosima::fastcdr::Cdr& cdr);
2200 
2201  RTPS_DllAPI bool operator==(
2202  const CompleteCollectionElement& other) const;
2203 
2204  RTPS_DllAPI bool consistent(
2205  const CompleteCollectionElement& x,
2206  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2207 
2208 private:
2209 
2210  CommonCollectionElement m_common;
2211  CompleteElementDetail m_detail;
2212 };
2213 
2214 /*struct MinimalCollectionElement {
2215  CommonCollectionElement common;
2216  };*/
2218 {
2219 public:
2220 
2224  const MinimalCollectionElement& x);
2228  const MinimalCollectionElement& x);
2231 
2232  RTPS_DllAPI inline void common(
2233  const CommonCollectionElement& _common) { m_common = _common; }
2234  RTPS_DllAPI inline void common(
2235  CommonCollectionElement&& _common) { m_common = std::move(_common); }
2236  RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }
2237  RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }
2238 
2239  RTPS_DllAPI static size_t getCdrSerializedSize(
2240  const MinimalCollectionElement& data,
2241  size_t current_alignment = 0);
2242  RTPS_DllAPI void serialize(
2243  eprosima::fastcdr::Cdr& cdr) const;
2244  RTPS_DllAPI void deserialize(
2245  eprosima::fastcdr::Cdr& cdr);
2246 
2247  RTPS_DllAPI bool operator==(
2248  const MinimalCollectionElement& other) const;
2249 
2250  RTPS_DllAPI bool consistent(
2251  const MinimalCollectionElement& x,
2252  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2253 
2254 private:
2255 
2256  CommonCollectionElement m_common;
2257 };
2258 
2259 /*struct CommonCollectionHeader final{
2260  LBound bound;
2261  };*/
2263 {
2264 public:
2265 
2266  RTPS_DllAPI CommonCollectionHeader();
2269  const CommonCollectionHeader& x);
2273  const CommonCollectionHeader& x);
2276 
2277  RTPS_DllAPI inline void bound(
2278  const LBound& _bound) { m_bound = _bound; }
2279  RTPS_DllAPI inline void bound(
2280  LBound&& _bound) { m_bound = std::move(_bound); }
2281  RTPS_DllAPI inline const LBound& bound() const { return m_bound; }
2282  RTPS_DllAPI inline LBound& bound() { return m_bound; }
2283 
2284  RTPS_DllAPI static size_t getCdrSerializedSize(
2285  const CommonCollectionHeader& data,
2286  size_t current_alignment = 0);
2287  RTPS_DllAPI void serialize(
2288  eprosima::fastcdr::Cdr& cdr) const;
2289  RTPS_DllAPI void deserialize(
2290  eprosima::fastcdr::Cdr& cdr);
2291 
2292  RTPS_DllAPI bool operator==(
2293  const CommonCollectionHeader& other) const;
2294 
2295  RTPS_DllAPI bool consistent(
2296  const CommonCollectionHeader& x,
2297  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2298 
2299 private:
2300 
2301  LBound m_bound;
2302 };
2303 
2304 /*struct CompleteCollectionHeader {
2305  CommonCollectionHeader common;
2306  CompleteTypeDetail detail; // Optional // not present for anonymous
2307  };*/
2309 {
2310 public:
2311 
2315  const CompleteCollectionHeader& x);
2319  const CompleteCollectionHeader& x);
2322 
2323  RTPS_DllAPI inline void common(
2324  const CommonCollectionHeader& _common) { m_common = _common; }
2325  RTPS_DllAPI inline void common(
2326  CommonCollectionHeader&& _common) { m_common = std::move(_common); }
2327  RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }
2328  RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }
2329 
2330  RTPS_DllAPI inline void detail(
2331  const CompleteTypeDetail& _detail) { m_detail = _detail; }
2332  RTPS_DllAPI inline void detail(
2333  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
2334  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
2335  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
2336 
2337  RTPS_DllAPI static size_t getCdrSerializedSize(
2338  const CompleteCollectionHeader& data,
2339  size_t current_alignment = 0);
2340  RTPS_DllAPI void serialize(
2341  eprosima::fastcdr::Cdr& cdr) const;
2342  RTPS_DllAPI void deserialize(
2343  eprosima::fastcdr::Cdr& cdr);
2344 
2345  RTPS_DllAPI bool operator==(
2346  const CompleteCollectionHeader& other) const;
2347 
2348  RTPS_DllAPI bool consistent(
2349  const CompleteCollectionHeader& x,
2350  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2351 
2352 private:
2353 
2354  CommonCollectionHeader m_common;
2355  CompleteTypeDetail m_detail;
2356 };
2357 
2358 /*struct MinimalCollectionHeader {
2359  CommonCollectionHeader common;
2360  };*/
2362 {
2363 public:
2364 
2368  const MinimalCollectionHeader& x);
2372  const MinimalCollectionHeader& x);
2375 
2376  RTPS_DllAPI inline void common(
2377  const CommonCollectionHeader& _common) { m_common = _common; }
2378  RTPS_DllAPI inline void common(
2379  CommonCollectionHeader&& _common) { m_common = std::move(_common); }
2380  RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }
2381  RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }
2382 
2383  RTPS_DllAPI static size_t getCdrSerializedSize(
2384  const MinimalCollectionHeader& data,
2385  size_t current_alignment = 0);
2386  RTPS_DllAPI void serialize(
2387  eprosima::fastcdr::Cdr& cdr) const;
2388  RTPS_DllAPI void deserialize(
2389  eprosima::fastcdr::Cdr& cdr);
2390 
2391  RTPS_DllAPI bool operator==(
2392  const MinimalCollectionHeader& other) const;
2393 
2394  RTPS_DllAPI bool consistent(
2395  const MinimalCollectionHeader& x,
2396  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2397 
2398 private:
2399 
2400  CommonCollectionHeader m_common;
2401 };
2402 
2403 // --- Sequence: -----------------------------------------------------
2404 /*struct CompleteSequenceType final{
2405  CollectionTypeFlag collection_flag;
2406  CompleteCollectionHeader header;
2407  CompleteCollectionElement element;
2408  };*/
2410 {
2411 public:
2412 
2413  RTPS_DllAPI CompleteSequenceType();
2414  RTPS_DllAPI ~CompleteSequenceType();
2416  const CompleteSequenceType& x);
2418  CompleteSequenceType&& x);
2420  const CompleteSequenceType& x);
2422  CompleteSequenceType&& x);
2423 
2424  RTPS_DllAPI inline void collection_flag(
2425  const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2426  RTPS_DllAPI inline void collection_flag(
2427  CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2428  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2429  RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2430 
2431  RTPS_DllAPI inline void header(
2432  const CompleteCollectionHeader& _header) { m_header = _header; }
2433  RTPS_DllAPI inline void header(
2434  CompleteCollectionHeader&& _header) { m_header = std::move(_header); }
2435  RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }
2436  RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }
2437 
2438  RTPS_DllAPI inline void element(
2439  const CompleteCollectionElement& _element) { m_element = _element; }
2440  RTPS_DllAPI inline void element(
2441  CompleteCollectionElement&& _element) { m_element = std::move(_element); }
2442  RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
2443  RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
2444 
2445  RTPS_DllAPI static size_t getCdrSerializedSize(
2446  const CompleteSequenceType& data,
2447  size_t current_alignment = 0);
2448  RTPS_DllAPI void serialize(
2449  eprosima::fastcdr::Cdr& cdr) const;
2450  RTPS_DllAPI void deserialize(
2451  eprosima::fastcdr::Cdr& cdr);
2452 
2453  RTPS_DllAPI bool operator==(
2454  const CompleteSequenceType& other) const;
2455 
2456  RTPS_DllAPI bool consistent(
2457  const CompleteSequenceType& x,
2458  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2459 
2460 private:
2461 
2462  CollectionTypeFlag m_collection_flag;
2463  CompleteCollectionHeader m_header;
2464  CompleteCollectionElement m_element;
2465 };
2466 
2467 /*struct MinimalSequenceType final{
2468  CollectionTypeFlag collection_flag;
2469  MinimalCollectionHeader header;
2470  MinimalCollectionElement element;
2471  };*/
2473 {
2474 public:
2475 
2476  RTPS_DllAPI MinimalSequenceType();
2477  RTPS_DllAPI ~MinimalSequenceType();
2478  RTPS_DllAPI MinimalSequenceType(
2479  const MinimalSequenceType& x);
2480  RTPS_DllAPI MinimalSequenceType(
2481  MinimalSequenceType&& x);
2483  const MinimalSequenceType& x);
2485  MinimalSequenceType&& x);
2486 
2487  RTPS_DllAPI inline void collection_flag(
2488  const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2489  RTPS_DllAPI inline void collection_flag(
2490  CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2491  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2492  RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2493 
2494  RTPS_DllAPI inline void header(
2495  const MinimalCollectionHeader& _header) { m_header = _header; }
2496  RTPS_DllAPI inline void header(
2497  MinimalCollectionHeader&& _header) { m_header = std::move(_header); }
2498  RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }
2499  RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }
2500 
2501  RTPS_DllAPI inline void element(
2502  const MinimalCollectionElement& _element) { m_element = _element; }
2503  RTPS_DllAPI inline void element(
2504  MinimalCollectionElement&& _element) { m_element = std::move(_element); }
2505  RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
2506  RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
2507 
2508  RTPS_DllAPI static size_t getCdrSerializedSize(
2509  const MinimalSequenceType& data,
2510  size_t current_alignment = 0);
2511  RTPS_DllAPI void serialize(
2512  eprosima::fastcdr::Cdr& cdr) const;
2513  RTPS_DllAPI void deserialize(
2514  eprosima::fastcdr::Cdr& cdr);
2515 
2516  RTPS_DllAPI bool operator==(
2517  const MinimalSequenceType& other) const;
2518 
2519  RTPS_DllAPI bool consistent(
2520  const MinimalSequenceType& x,
2521  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2522 
2523 private:
2524 
2525  CollectionTypeFlag m_collection_flag;
2526  MinimalCollectionHeader m_header;
2527  MinimalCollectionElement m_element;
2528 };
2529 
2530 // --- Array: -----------------------------------------------------
2531 /*struct CommonArrayHeader final{
2532  LBoundSeq bound_seq;
2533  };*/
2535 {
2536 public:
2537 
2538  RTPS_DllAPI CommonArrayHeader();
2539  RTPS_DllAPI ~CommonArrayHeader();
2540  RTPS_DllAPI CommonArrayHeader(
2541  const CommonArrayHeader& x);
2542  RTPS_DllAPI CommonArrayHeader(
2543  CommonArrayHeader&& x);
2545  const CommonArrayHeader& x);
2547  CommonArrayHeader&& x);
2548 
2549  RTPS_DllAPI inline void bound_seq(
2550  const LBoundSeq& _bound_seq) { m_bound_seq = _bound_seq; }
2551  RTPS_DllAPI inline void bound_seq(
2552  LBoundSeq&& _bound_seq) { m_bound_seq = std::move(_bound_seq); }
2553  RTPS_DllAPI inline const LBoundSeq& bound_seq() const { return m_bound_seq; }
2554  RTPS_DllAPI inline LBoundSeq& bound_seq() { return m_bound_seq; }
2555 
2556  RTPS_DllAPI static size_t getCdrSerializedSize(
2557  const CommonArrayHeader& data,
2558  size_t current_alignment = 0);
2559  RTPS_DllAPI void serialize(
2560  eprosima::fastcdr::Cdr& cdr) const;
2561  RTPS_DllAPI void deserialize(
2562  eprosima::fastcdr::Cdr& cdr);
2563 
2564  RTPS_DllAPI bool operator==(
2565  const CommonArrayHeader& other) const;
2566 
2567  RTPS_DllAPI bool consistent(
2568  const CommonArrayHeader& x,
2569  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2570 
2571 private:
2572 
2573  LBoundSeq m_bound_seq;
2574 };
2575 
2576 /*struct CompleteArrayHeader {
2577  CommonArrayHeader common;
2578  CompleteTypeDetail detail;
2579  };*/
2581 {
2582 public:
2583 
2584  RTPS_DllAPI CompleteArrayHeader();
2585  RTPS_DllAPI ~CompleteArrayHeader();
2586  RTPS_DllAPI CompleteArrayHeader(
2587  const CompleteArrayHeader& x);
2588  RTPS_DllAPI CompleteArrayHeader(
2589  CompleteArrayHeader&& x);
2591  const CompleteArrayHeader& x);
2593  CompleteArrayHeader&& x);
2594 
2595  RTPS_DllAPI inline void common(
2596  const CommonArrayHeader& _common) { m_common = _common; }
2597  RTPS_DllAPI inline void common(
2598  CommonArrayHeader&& _common) { m_common = std::move(_common); }
2599  RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }
2600  RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }
2601 
2602  RTPS_DllAPI inline void detail(
2603  const CompleteTypeDetail& _detail) { m_detail = _detail; }
2604  RTPS_DllAPI inline void detail(
2605  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
2606  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
2607  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
2608 
2609  RTPS_DllAPI static size_t getCdrSerializedSize(
2610  const CompleteArrayHeader& data,
2611  size_t current_alignment = 0);
2612  RTPS_DllAPI void serialize(
2613  eprosima::fastcdr::Cdr& cdr) const;
2614  RTPS_DllAPI void deserialize(
2615  eprosima::fastcdr::Cdr& cdr);
2616 
2617  RTPS_DllAPI bool operator==(
2618  const CompleteArrayHeader& other) const;
2619 
2620  RTPS_DllAPI bool consistent(
2621  const CompleteArrayHeader& x,
2622  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2623 
2624 private:
2625 
2626  CommonArrayHeader m_common;
2627  CompleteTypeDetail m_detail;
2628 };
2629 
2630 /*struct MinimalArrayHeader {
2631  CommonArrayHeader common;
2632  };*/
2634 {
2635 public:
2636 
2637  RTPS_DllAPI MinimalArrayHeader();
2638  RTPS_DllAPI ~MinimalArrayHeader();
2639  RTPS_DllAPI MinimalArrayHeader(
2640  const MinimalArrayHeader& x);
2641  RTPS_DllAPI MinimalArrayHeader(
2642  MinimalArrayHeader&& x);
2644  const MinimalArrayHeader& x);
2646  MinimalArrayHeader&& x);
2647 
2648  RTPS_DllAPI inline void common(
2649  const CommonArrayHeader& _common) { m_common = _common; }
2650  RTPS_DllAPI inline void common(
2651  CommonArrayHeader&& _common) { m_common = std::move(_common); }
2652  RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }
2653  RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }
2654 
2655  RTPS_DllAPI static size_t getCdrSerializedSize(
2656  const MinimalArrayHeader& data,
2657  size_t current_alignment = 0);
2658  RTPS_DllAPI void serialize(
2659  eprosima::fastcdr::Cdr& cdr) const;
2660  RTPS_DllAPI void deserialize(
2661  eprosima::fastcdr::Cdr& cdr);
2662 
2663  RTPS_DllAPI bool operator==(
2664  const MinimalArrayHeader& other) const;
2665 
2666  RTPS_DllAPI bool consistent(
2667  const MinimalArrayHeader& x,
2668  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2669 
2670 private:
2671 
2672  CommonArrayHeader m_common;
2673 };
2674 
2675 /*struct CompleteArrayType {
2676  CollectionTypeFlag collection_flag;
2677  CompleteArrayHeader header;
2678  CompleteCollectionElement element;
2679  };*/
2681 {
2682 public:
2683 
2684  RTPS_DllAPI CompleteArrayType();
2685  RTPS_DllAPI ~CompleteArrayType();
2686  RTPS_DllAPI CompleteArrayType(
2687  const CompleteArrayType& x);
2688  RTPS_DllAPI CompleteArrayType(
2689  CompleteArrayType&& x);
2691  const CompleteArrayType& x);
2693  CompleteArrayType&& x);
2694 
2695  RTPS_DllAPI inline void collection_flag(
2696  const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2697  RTPS_DllAPI inline void collection_flag(
2698  CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2699  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2700  RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2701 
2702  RTPS_DllAPI inline void header(
2703  const CompleteArrayHeader& _header) { m_header = _header; }
2704  RTPS_DllAPI inline void header(
2705  CompleteArrayHeader&& _header) { m_header = std::move(_header); }
2706  RTPS_DllAPI inline const CompleteArrayHeader& header() const { return m_header; }
2707  RTPS_DllAPI inline CompleteArrayHeader& header() { return m_header; }
2708 
2709  RTPS_DllAPI inline void element(
2710  const CompleteCollectionElement& _element) { m_element = _element; }
2711  RTPS_DllAPI inline void element(
2712  CompleteCollectionElement&& _element) { m_element = std::move(_element); }
2713  RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
2714  RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
2715 
2716  RTPS_DllAPI static size_t getCdrSerializedSize(
2717  const CompleteArrayType& data,
2718  size_t current_alignment = 0);
2719  RTPS_DllAPI void serialize(
2720  eprosima::fastcdr::Cdr& cdr) const;
2721  RTPS_DllAPI void deserialize(
2722  eprosima::fastcdr::Cdr& cdr);
2723 
2724  RTPS_DllAPI bool operator==(
2725  const CompleteArrayType& other) const;
2726 
2727  RTPS_DllAPI bool consistent(
2728  const CompleteArrayType& x,
2729  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2730 
2731 private:
2732 
2733  CollectionTypeFlag m_collection_flag;
2734  CompleteArrayHeader m_header;
2735  CompleteCollectionElement m_element;
2736 };
2737 
2738 /*struct MinimalArrayType final{
2739  CollectionTypeFlag collection_flag;
2740  MinimalArrayHeader header;
2741  MinimalCollectionElement element;
2742  };*/
2744 {
2745 public:
2746 
2747  RTPS_DllAPI MinimalArrayType();
2748  RTPS_DllAPI ~MinimalArrayType();
2749  RTPS_DllAPI MinimalArrayType(
2750  const MinimalArrayType& x);
2751  RTPS_DllAPI MinimalArrayType(
2752  MinimalArrayType&& x);
2754  const MinimalArrayType& x);
2756  MinimalArrayType&& x);
2757 
2758  RTPS_DllAPI inline void collection_flag(
2759  const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2760  RTPS_DllAPI inline void collection_flag(
2761  CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2762  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2763  RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2764 
2765  RTPS_DllAPI inline void header(
2766  const MinimalArrayHeader& _header) { m_header = _header; }
2767  RTPS_DllAPI inline void header(
2768  MinimalArrayHeader&& _header) { m_header = std::move(_header); }
2769  RTPS_DllAPI inline const MinimalArrayHeader& header() const { return m_header; }
2770  RTPS_DllAPI inline MinimalArrayHeader& header() { return m_header; }
2771 
2772  RTPS_DllAPI inline void element(
2773  const MinimalCollectionElement& _element) { m_element = _element; }
2774  RTPS_DllAPI inline void element(
2775  MinimalCollectionElement&& _element) { m_element = std::move(_element); }
2776  RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
2777  RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
2778 
2779  RTPS_DllAPI static size_t getCdrSerializedSize(
2780  const MinimalArrayType& data,
2781  size_t current_alignment = 0);
2782  RTPS_DllAPI void serialize(
2783  eprosima::fastcdr::Cdr& cdr) const;
2784  RTPS_DllAPI void deserialize(
2785  eprosima::fastcdr::Cdr& cdr);
2786 
2787  RTPS_DllAPI bool operator==(
2788  const MinimalArrayType& other) const;
2789 
2790  RTPS_DllAPI bool consistent(
2791  const MinimalArrayType& x,
2792  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2793 
2794 private:
2795 
2796  CollectionTypeFlag m_collection_flag;
2797  MinimalArrayHeader m_header;
2798  MinimalCollectionElement m_element;
2799 };
2800 
2801 // --- Map: -----------------------------------------------------
2802 /*struct CompleteMapType final{
2803  CollectionTypeFlag collection_flag;
2804  CompleteCollectionHeader header;
2805  CompleteCollectionElement key;
2806  CompleteCollectionElement element;
2807  };*/
2808 class CompleteMapType final
2809 {
2810 public:
2811 
2812  RTPS_DllAPI CompleteMapType();
2813  RTPS_DllAPI ~CompleteMapType();
2814  RTPS_DllAPI CompleteMapType(
2815  const CompleteMapType& x);
2816  RTPS_DllAPI CompleteMapType(
2817  CompleteMapType&& x);
2819  const CompleteMapType& x);
2821  CompleteMapType&& x);
2822 
2823  RTPS_DllAPI inline void collection_flag(
2824  const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2825  RTPS_DllAPI inline void collection_flag(
2826  CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2827  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2828  RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2829 
2830  RTPS_DllAPI inline void header(
2831  const CompleteCollectionHeader& _header) { m_header = _header; }
2832  RTPS_DllAPI inline void header(
2833  CompleteCollectionHeader&& _header) { m_header = std::move(_header); }
2834  RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }
2835  RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }
2836 
2837  RTPS_DllAPI inline void key(
2838  const CompleteCollectionElement& _key) { m_key = _key; }
2839  RTPS_DllAPI inline void key(
2840  CompleteCollectionElement&& _key) { m_key = std::move(_key); }
2841  RTPS_DllAPI inline const CompleteCollectionElement& key() const { return m_key; }
2842  RTPS_DllAPI inline CompleteCollectionElement& key() { return m_key; }
2843 
2844  RTPS_DllAPI inline void element(
2845  const CompleteCollectionElement& _element) { m_element = _element; }
2846  RTPS_DllAPI inline void element(
2847  CompleteCollectionElement&& _element) { m_element = std::move(_element); }
2848  RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
2849  RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
2850 
2851  RTPS_DllAPI static size_t getCdrSerializedSize(
2852  const CompleteMapType& data,
2853  size_t current_alignment = 0);
2854  RTPS_DllAPI void serialize(
2855  eprosima::fastcdr::Cdr& cdr) const;
2856  RTPS_DllAPI void deserialize(
2857  eprosima::fastcdr::Cdr& cdr);
2858 
2859  RTPS_DllAPI bool operator==(
2860  const CompleteMapType& other) const;
2861 
2862  RTPS_DllAPI bool consistent(
2863  const CompleteMapType& x,
2864  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2865 
2866 private:
2867 
2868  CollectionTypeFlag m_collection_flag;
2869  CompleteCollectionHeader m_header;
2871  CompleteCollectionElement m_element;
2872 };
2873 /*struct MinimalMapType final{
2874  CollectionTypeFlag collection_flag;
2875  MinimalCollectionHeader header;
2876  MinimalCollectionElement key;
2877  MinimalCollectionElement element;
2878  };*/
2879 class MinimalMapType final
2880 {
2881 public:
2882 
2883  RTPS_DllAPI MinimalMapType();
2884  RTPS_DllAPI ~MinimalMapType();
2885  RTPS_DllAPI MinimalMapType(
2886  const MinimalMapType& x);
2887  RTPS_DllAPI MinimalMapType(
2888  MinimalMapType&& x);
2890  const MinimalMapType& x);
2892  MinimalMapType&& x);
2893 
2894  RTPS_DllAPI inline void collection_flag(
2895  const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
2896  RTPS_DllAPI inline void collection_flag(
2897  CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
2898  RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
2899  RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
2900 
2901  RTPS_DllAPI inline void header(
2902  const MinimalCollectionHeader& _header) { m_header = _header; }
2903  RTPS_DllAPI inline void header(
2904  MinimalCollectionHeader&& _header) { m_header = std::move(_header); }
2905  RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }
2906  RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }
2907 
2908  RTPS_DllAPI inline void key(
2909  const MinimalCollectionElement& _key) { m_key = _key; }
2910  RTPS_DllAPI inline void key(
2911  MinimalCollectionElement&& _key) { m_key = std::move(_key); }
2912  RTPS_DllAPI inline const MinimalCollectionElement& key() const { return m_key; }
2913  RTPS_DllAPI inline MinimalCollectionElement& key() { return m_key; }
2914 
2915  RTPS_DllAPI inline void element(
2916  const MinimalCollectionElement& _element) { m_element = _element; }
2917  RTPS_DllAPI inline void element(
2918  MinimalCollectionElement&& _element) { m_element = std::move(_element); }
2919  RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
2920  RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
2921 
2922  RTPS_DllAPI static size_t getCdrSerializedSize(
2923  const MinimalMapType& data,
2924  size_t current_alignment = 0);
2925  RTPS_DllAPI void serialize(
2926  eprosima::fastcdr::Cdr& cdr) const;
2927  RTPS_DllAPI void deserialize(
2928  eprosima::fastcdr::Cdr& cdr);
2929 
2930  RTPS_DllAPI bool operator==(
2931  const MinimalMapType& other) const;
2932 
2933  RTPS_DllAPI bool consistent(
2934  const MinimalMapType& x,
2935  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2936 
2937 private:
2938 
2939  CollectionTypeFlag m_collection_flag;
2940  MinimalCollectionHeader m_header;
2942  MinimalCollectionElement m_element;
2943 };
2944 
2945 // --- Enumeration: ---------------------------------------------------
2946 typedef uint16_t BitBound;
2947 
2948 // Constant in an enumerated type
2949 
2950 /*struct CommonEnumeratedLiteral {
2951  int32_t value;
2952  EnumeratedLiteralFlag flags;
2953  };*/
2955 {
2956 public:
2957 
2961  const CommonEnumeratedLiteral& x);
2965  const CommonEnumeratedLiteral& x);
2968 
2969  RTPS_DllAPI inline void value(
2970  const int32_t& _value) { m_value = _value; }
2971  RTPS_DllAPI inline void value(
2972  int32_t&& _value) { m_value = std::move(_value); }
2973  RTPS_DllAPI inline const int32_t& value() const { return m_value; }
2974  RTPS_DllAPI inline int32_t& value() { return m_value; }
2975 
2976  RTPS_DllAPI inline void flags(
2977  const EnumeratedLiteralFlag& _flags) { m_flags = _flags; }
2978  RTPS_DllAPI inline void flags(
2979  EnumeratedLiteralFlag&& _flags) { m_flags = std::move(_flags); }
2980  RTPS_DllAPI inline const EnumeratedLiteralFlag& flags() const { return m_flags; }
2981  RTPS_DllAPI inline EnumeratedLiteralFlag& flags() { return m_flags; }
2982 
2983  RTPS_DllAPI static size_t getCdrSerializedSize(
2984  const CommonEnumeratedLiteral& data,
2985  size_t current_alignment = 0);
2986  RTPS_DllAPI void serialize(
2987  eprosima::fastcdr::Cdr& cdr) const;
2988  RTPS_DllAPI void deserialize(
2989  eprosima::fastcdr::Cdr& cdr);
2990 
2991  RTPS_DllAPI bool operator==(
2992  const CommonEnumeratedLiteral& other) const;
2993 
2994  RTPS_DllAPI bool consistent(
2995  const CommonEnumeratedLiteral& x,
2996  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
2997 
2998 private:
2999 
3000  int32_t m_value;
3001  EnumeratedLiteralFlag m_flags;
3002 };
3003 
3004 // Constant in an enumerated type
3005 
3006 /*struct CompleteEnumeratedLiteral {
3007  CommonEnumeratedLiteral common;
3008  CompleteMemberDetail detail;
3009  };*/
3011 {
3012 public:
3013 
3017  const CompleteEnumeratedLiteral& x);
3021  const CompleteEnumeratedLiteral& x);
3024 
3025  RTPS_DllAPI inline void common(
3026  const CommonEnumeratedLiteral& _common) { m_common = _common; }
3027  RTPS_DllAPI inline void common(
3028  CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }
3029  RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }
3030  RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }
3031 
3032  RTPS_DllAPI inline void detail(
3033  const CompleteMemberDetail& _detail) { m_detail = _detail; }
3034  RTPS_DllAPI inline void detail(
3035  CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
3036  RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
3037  RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
3038 
3039  RTPS_DllAPI static size_t getCdrSerializedSize(
3040  const CompleteEnumeratedLiteral& data,
3041  size_t current_alignment = 0);
3042  RTPS_DllAPI void serialize(
3043  eprosima::fastcdr::Cdr& cdr) const;
3044  RTPS_DllAPI void deserialize(
3045  eprosima::fastcdr::Cdr& cdr);
3046 
3047  RTPS_DllAPI bool operator==(
3048  const CompleteEnumeratedLiteral& other) const;
3049 
3050  RTPS_DllAPI bool consistent(
3051  const CompleteEnumeratedLiteral& x,
3052  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3053 
3054 private:
3055 
3056  CommonEnumeratedLiteral m_common;
3057  CompleteMemberDetail m_detail;
3058 };
3059 // Ordered by EnumeratedLiteral.common.value
3060 typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
3061 
3062 // Constant in an enumerated type
3063 
3064 /*struct MinimalEnumeratedLiteral {
3065  CommonEnumeratedLiteral common;
3066  MinimalMemberDetail detail;
3067  };*/
3069 {
3070 public:
3071 
3075  const MinimalEnumeratedLiteral& x);
3079  const MinimalEnumeratedLiteral& x);
3082 
3083  RTPS_DllAPI inline void common(
3084  const CommonEnumeratedLiteral& _common) { m_common = _common; }
3085  RTPS_DllAPI inline void common(
3086  CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }
3087  RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }
3088  RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }
3089 
3090  RTPS_DllAPI inline void detail(
3091  const MinimalMemberDetail& _detail) { m_detail = _detail; }
3092  RTPS_DllAPI inline void detail(
3093  MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
3094  RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
3095  RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
3096 
3097  RTPS_DllAPI static size_t getCdrSerializedSize(
3098  const MinimalEnumeratedLiteral& data,
3099  size_t current_alignment = 0);
3100  RTPS_DllAPI void serialize(
3101  eprosima::fastcdr::Cdr& cdr) const;
3102  RTPS_DllAPI void deserialize(
3103  eprosima::fastcdr::Cdr& cdr);
3104 
3105  RTPS_DllAPI bool operator==(
3106  const MinimalEnumeratedLiteral& other) const;
3107 
3108  RTPS_DllAPI bool consistent(
3109  const MinimalEnumeratedLiteral& x,
3110  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3111 
3112 private:
3113 
3114  CommonEnumeratedLiteral m_common;
3115  MinimalMemberDetail m_detail;
3116 };
3117 
3118 // Ordered by EnumeratedLiteral.common.value
3119 typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
3120 
3121 /*struct CommonEnumeratedHeader final{
3122  BitBound bit_bound;
3123  };*/
3125 {
3126 public:
3127 
3128  RTPS_DllAPI CommonEnumeratedHeader();
3131  const CommonEnumeratedHeader& x);
3135  const CommonEnumeratedHeader& x);
3138 
3139  RTPS_DllAPI inline void bit_bound(
3140  const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }
3141  RTPS_DllAPI inline void bit_bound(
3142  BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }
3143  RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }
3144  RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }
3145 
3146  RTPS_DllAPI static size_t getCdrSerializedSize(
3147  const CommonEnumeratedHeader& data,
3148  size_t current_alignment = 0);
3149  RTPS_DllAPI void serialize(
3150  eprosima::fastcdr::Cdr& cdr) const;
3151  RTPS_DllAPI void deserialize(
3152  eprosima::fastcdr::Cdr& cdr);
3153 
3154  RTPS_DllAPI bool operator==(
3155  const CommonEnumeratedHeader& other) const;
3156 
3157  RTPS_DllAPI bool consistent(
3158  const CommonEnumeratedHeader& x,
3159  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3160 
3161 private:
3162 
3163  BitBound m_bit_bound;
3164 };
3165 
3166 /*struct CompleteEnumeratedHeader {
3167  CommonEnumeratedHeader common;
3168  CompleteTypeDetail detail;
3169  };*/
3171 {
3172 public:
3173 
3177  const CompleteEnumeratedHeader& x);
3181  const CompleteEnumeratedHeader& x);
3184 
3185  RTPS_DllAPI inline void common(
3186  const CommonEnumeratedHeader& _common) { m_common = _common; }
3187  RTPS_DllAPI inline void common(
3188  CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }
3189  RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }
3190  RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }
3191 
3192  RTPS_DllAPI inline void detail(
3193  const CompleteTypeDetail& _detail) { m_detail = _detail; }
3194  RTPS_DllAPI inline void detail(
3195  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
3196  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
3197  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
3198 
3199  RTPS_DllAPI static size_t getCdrSerializedSize(
3200  const CompleteEnumeratedHeader& data,
3201  size_t current_alignment = 0);
3202  RTPS_DllAPI void serialize(
3203  eprosima::fastcdr::Cdr& cdr) const;
3204  RTPS_DllAPI void deserialize(
3205  eprosima::fastcdr::Cdr& cdr);
3206 
3207  RTPS_DllAPI bool operator==(
3208  const CompleteEnumeratedHeader& other) const;
3209 
3210  RTPS_DllAPI bool consistent(
3211  const CompleteEnumeratedHeader& x,
3212  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3213 
3214 private:
3215 
3216  CommonEnumeratedHeader m_common;
3217  CompleteTypeDetail m_detail;
3218 };
3219 
3220 /*struct MinimalEnumeratedHeader {
3221  CommonEnumeratedHeader common;
3222  };*/
3224 {
3225 public:
3226 
3230  const MinimalEnumeratedHeader& x);
3234  const MinimalEnumeratedHeader& x);
3237 
3238  RTPS_DllAPI inline void common(
3239  const CommonEnumeratedHeader& _common) { m_common = _common; }
3240  RTPS_DllAPI inline void common(
3241  CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }
3242  RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }
3243  RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }
3244 
3245  RTPS_DllAPI static size_t getCdrSerializedSize(
3246  const MinimalEnumeratedHeader& data,
3247  size_t current_alignment = 0);
3248  RTPS_DllAPI void serialize(
3249  eprosima::fastcdr::Cdr& cdr) const;
3250  RTPS_DllAPI void deserialize(
3251  eprosima::fastcdr::Cdr& cdr);
3252 
3253  RTPS_DllAPI bool operator==(
3254  const MinimalEnumeratedHeader& other) const;
3255 
3256  RTPS_DllAPI bool consistent(
3257  const MinimalEnumeratedHeader& x,
3258  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3259 
3260 private:
3261 
3262  CommonEnumeratedHeader m_common;
3263 };
3264 
3265 // Enumerated type
3266 /*struct CompleteEnumeratedType final{
3267  EnumTypeFlag enum_flags; // unused
3268  CompleteEnumeratedHeader header;
3269  CompleteEnumeratedLiteralSeq literal_seq;
3270  };*/
3272 {
3273 public:
3274 
3275  RTPS_DllAPI CompleteEnumeratedType();
3278  const CompleteEnumeratedType& x);
3282  const CompleteEnumeratedType& x);
3285 
3286  RTPS_DllAPI inline void enum_flags(
3287  const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }
3288  RTPS_DllAPI inline void enum_flags(
3289  EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }
3290  RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }
3291  RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }
3292 
3293  RTPS_DllAPI inline void header(
3294  const CompleteEnumeratedHeader& _header) { m_header = _header; }
3295  RTPS_DllAPI inline void header(
3296  CompleteEnumeratedHeader&& _header) { m_header = std::move(_header); }
3297  RTPS_DllAPI inline const CompleteEnumeratedHeader& header() const { return m_header; }
3298  RTPS_DllAPI inline CompleteEnumeratedHeader& header() { return m_header; }
3299 
3300  RTPS_DllAPI inline void literal_seq(
3301  const CompleteEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }
3302  RTPS_DllAPI inline void literal_seq(
3303  CompleteEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }
3304  RTPS_DllAPI inline const CompleteEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }
3305  RTPS_DllAPI inline CompleteEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }
3306 
3307  RTPS_DllAPI static size_t getCdrSerializedSize(
3308  const CompleteEnumeratedType& data,
3309  size_t current_alignment = 0);
3310  RTPS_DllAPI void serialize(
3311  eprosima::fastcdr::Cdr& cdr) const;
3312  RTPS_DllAPI void deserialize(
3313  eprosima::fastcdr::Cdr& cdr);
3314 
3315  RTPS_DllAPI bool operator==(
3316  const CompleteEnumeratedType& other) const;
3317 
3318  RTPS_DllAPI bool consistent(
3319  const CompleteEnumeratedType& x,
3320  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3321 
3322 private:
3323 
3324  EnumTypeFlag m_enum_flags;
3325  CompleteEnumeratedHeader m_header;
3326  CompleteEnumeratedLiteralSeq m_literal_seq;
3327 };
3328 // Enumerated type
3329 /*struct MinimalEnumeratedType final{
3330  EnumTypeFlag enum_flags; // unused
3331  MinimalEnumeratedHeader header;
3332  MinimalEnumeratedLiteralSeq literal_seq;
3333  };*/
3335 {
3336 public:
3337 
3338  RTPS_DllAPI MinimalEnumeratedType();
3339  RTPS_DllAPI ~MinimalEnumeratedType();
3341  const MinimalEnumeratedType& x);
3343  MinimalEnumeratedType&& x);
3345  const MinimalEnumeratedType& x);
3347  MinimalEnumeratedType&& x);
3348 
3349  RTPS_DllAPI inline void enum_flags(
3350  const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }
3351  RTPS_DllAPI inline void enum_flags(
3352  EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }
3353  RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }
3354  RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }
3355 
3356  RTPS_DllAPI inline void header(
3357  const MinimalEnumeratedHeader& _header) { m_header = _header; }
3358  RTPS_DllAPI inline void header(
3359  MinimalEnumeratedHeader&& _header) { m_header = std::move(_header); }
3360  RTPS_DllAPI inline const MinimalEnumeratedHeader& header() const { return m_header; }
3361  RTPS_DllAPI inline MinimalEnumeratedHeader& header() { return m_header; }
3362 
3363  RTPS_DllAPI inline void literal_seq(
3364  const MinimalEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }
3365  RTPS_DllAPI inline void literal_seq(
3366  MinimalEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }
3367  RTPS_DllAPI inline const MinimalEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }
3368  RTPS_DllAPI inline MinimalEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }
3369 
3370  RTPS_DllAPI static size_t getCdrSerializedSize(
3371  const MinimalEnumeratedType& data,
3372  size_t current_alignment = 0);
3373  RTPS_DllAPI void serialize(
3374  eprosima::fastcdr::Cdr& cdr) const;
3375  RTPS_DllAPI void deserialize(
3376  eprosima::fastcdr::Cdr& cdr);
3377 
3378  RTPS_DllAPI bool operator==(
3379  const MinimalEnumeratedType& other) const;
3380 
3381  RTPS_DllAPI bool consistent(
3382  const MinimalEnumeratedType& x,
3383  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3384 
3385 private:
3386 
3387  EnumTypeFlag m_enum_flags;
3388  MinimalEnumeratedHeader m_header;
3389  MinimalEnumeratedLiteralSeq m_literal_seq;
3390 };
3391 
3392 // --- Bitmask: -------------------------------------------------------
3393 // Bit in a bit mask
3394 /*struct CommonBitflag final{
3395  uint16_t position;
3396  BitflagFlag flags;
3397  };*/
3398 class CommonBitflag final
3399 {
3400 public:
3401 
3402  RTPS_DllAPI CommonBitflag();
3403  RTPS_DllAPI ~CommonBitflag();
3404  RTPS_DllAPI CommonBitflag(
3405  const CommonBitflag& x);
3406  RTPS_DllAPI CommonBitflag(
3407  CommonBitflag&& x);
3408  RTPS_DllAPI CommonBitflag& operator=(
3409  const CommonBitflag& x);
3410  RTPS_DllAPI CommonBitflag& operator=(
3411  CommonBitflag&& x);
3412 
3413  RTPS_DllAPI inline void position(
3414  const uint16_t& _position) { m_position = _position; }
3415  RTPS_DllAPI inline void position(
3416  uint16_t&& _position) { m_position = std::move(_position); }
3417  RTPS_DllAPI inline const uint16_t& position() const { return m_position; }
3418  RTPS_DllAPI inline uint16_t& position() { return m_position; }
3419 
3420  RTPS_DllAPI inline void flags(
3421  const BitflagFlag& _flags) { m_flags = _flags; }
3422  RTPS_DllAPI inline void flags(
3423  BitflagFlag&& _flags) { m_flags = std::move(_flags); }
3424  RTPS_DllAPI inline const BitflagFlag& flags() const { return m_flags; }
3425  RTPS_DllAPI inline BitflagFlag& flags() { return m_flags; }
3426 
3427  RTPS_DllAPI static size_t getCdrSerializedSize(
3428  const CommonBitflag& data,
3429  size_t current_alignment = 0);
3430  RTPS_DllAPI void serialize(
3431  eprosima::fastcdr::Cdr& cdr) const;
3432  RTPS_DllAPI void deserialize(
3433  eprosima::fastcdr::Cdr& cdr);
3434 
3435  RTPS_DllAPI bool operator==(
3436  const CommonBitflag& other) const;
3437 
3438  RTPS_DllAPI bool consistent(
3439  const CommonBitflag& x,
3440  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3441 
3442 private:
3443 
3444  uint16_t m_position;
3445  BitflagFlag m_flags;
3446 };
3447 
3448 /*struct CompleteBitflag {
3449  CommonBitflag common;
3450  CompleteMemberDetail detail;
3451  };*/
3453 {
3454 public:
3455 
3456  RTPS_DllAPI CompleteBitflag();
3457  RTPS_DllAPI ~CompleteBitflag();
3458  RTPS_DllAPI CompleteBitflag(
3459  const CompleteBitflag& x);
3460  RTPS_DllAPI CompleteBitflag(
3461  CompleteBitflag&& x);
3463  const CompleteBitflag& x);
3465  CompleteBitflag&& x);
3466 
3467  RTPS_DllAPI inline void common(
3468  const CommonBitflag& _common) { m_common = _common; }
3469  RTPS_DllAPI inline void common(
3470  CommonBitflag&& _common) { m_common = std::move(_common); }
3471  RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }
3472  RTPS_DllAPI inline CommonBitflag& common() { return m_common; }
3473 
3474  RTPS_DllAPI inline void detail(
3475  const CompleteMemberDetail& _detail) { m_detail = _detail; }
3476  RTPS_DllAPI inline void detail(
3477  CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
3478  RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
3479  RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
3480 
3481  RTPS_DllAPI static size_t getCdrSerializedSize(
3482  const CompleteBitflag& data,
3483  size_t current_alignment = 0);
3484  RTPS_DllAPI void serialize(
3485  eprosima::fastcdr::Cdr& cdr) const;
3486  RTPS_DllAPI void deserialize(
3487  eprosima::fastcdr::Cdr& cdr);
3488 
3489  RTPS_DllAPI bool operator==(
3490  const CompleteBitflag& other) const;
3491 
3492  RTPS_DllAPI bool consistent(
3493  const CompleteBitflag& x,
3494  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3495 
3496 private:
3497 
3498  CommonBitflag m_common;
3499  CompleteMemberDetail m_detail;
3500 };
3501 // Ordered by Bitflag.position
3502 typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
3503 /*struct MinimalBitflag {
3504  CommonBitflag common;
3505  MinimalMemberDetail detail;
3506  };*/
3508 {
3509 public:
3510 
3511  RTPS_DllAPI MinimalBitflag();
3512  RTPS_DllAPI ~MinimalBitflag();
3513  RTPS_DllAPI MinimalBitflag(
3514  const MinimalBitflag& x);
3515  RTPS_DllAPI MinimalBitflag(
3516  MinimalBitflag&& x);
3518  const MinimalBitflag& x);
3520  MinimalBitflag&& x);
3521 
3522  RTPS_DllAPI inline void common(
3523  const CommonBitflag& _common) { m_common = _common; }
3524  RTPS_DllAPI inline void common(
3525  CommonBitflag&& _common) { m_common = std::move(_common); }
3526  RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }
3527  RTPS_DllAPI inline CommonBitflag& common() { return m_common; }
3528 
3529  RTPS_DllAPI inline void detail(
3530  const MinimalMemberDetail& _detail) { m_detail = _detail; }
3531  RTPS_DllAPI inline void detail(
3532  MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
3533  RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
3534  RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
3535 
3536  RTPS_DllAPI static size_t getCdrSerializedSize(
3537  const MinimalBitflag& data,
3538  size_t current_alignment = 0);
3539  RTPS_DllAPI void serialize(
3540  eprosima::fastcdr::Cdr& cdr) const;
3541  RTPS_DllAPI void deserialize(
3542  eprosima::fastcdr::Cdr& cdr);
3543 
3544  RTPS_DllAPI bool operator==(
3545  const MinimalBitflag& other) const;
3546 
3547  RTPS_DllAPI bool consistent(
3548  const MinimalBitflag& x,
3549  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3550 
3551 private:
3552 
3553  CommonBitflag m_common;
3554  MinimalMemberDetail m_detail;
3555 };
3556 
3557 // Ordered by Bitflag.position
3558 typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
3559 
3560 /*struct CommonBitmaskHeader final{
3561  BitBound bit_bound;
3562  };*/
3564 {
3565 public:
3566 
3567  RTPS_DllAPI CommonBitmaskHeader();
3568  RTPS_DllAPI ~CommonBitmaskHeader();
3569  RTPS_DllAPI CommonBitmaskHeader(
3570  const CommonBitmaskHeader& x);
3571  RTPS_DllAPI CommonBitmaskHeader(
3572  CommonBitmaskHeader&& x);
3574  const CommonBitmaskHeader& x);
3576  CommonBitmaskHeader&& x);
3577 
3578  RTPS_DllAPI inline void bit_bound(
3579  const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }
3580  RTPS_DllAPI inline void bit_bound(
3581  BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }
3582  RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }
3583  RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }
3584 
3585  RTPS_DllAPI static size_t getCdrSerializedSize(
3586  const CommonBitmaskHeader& data,
3587  size_t current_alignment = 0);
3588  RTPS_DllAPI void serialize(
3589  eprosima::fastcdr::Cdr& cdr) const;
3590  RTPS_DllAPI void deserialize(
3591  eprosima::fastcdr::Cdr& cdr);
3592 
3593  RTPS_DllAPI bool operator==(
3594  const CommonBitmaskHeader& other) const;
3595 
3596  RTPS_DllAPI bool consistent(
3597  const CommonBitmaskHeader& x,
3598  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3599 
3600 private:
3601 
3602  BitBound m_bit_bound;
3603 };
3605 
3607 /*struct CompleteBitmaskType {
3608  BitmaskTypeFlag bitmask_flags; // unused
3609  CompleteBitmaskHeader header;
3610  CompleteBitflagSeq flag_seq;
3611  };*/
3613 {
3614 public:
3615 
3616  RTPS_DllAPI CompleteBitmaskType();
3617  RTPS_DllAPI ~CompleteBitmaskType();
3618  RTPS_DllAPI CompleteBitmaskType(
3619  const CompleteBitmaskType& x);
3620  RTPS_DllAPI CompleteBitmaskType(
3621  CompleteBitmaskType&& x);
3623  const CompleteBitmaskType& x);
3625  CompleteBitmaskType&& x);
3626 
3627  RTPS_DllAPI inline void bitmask_flags(
3628  const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }
3629  RTPS_DllAPI inline void bitmask_flags(
3630  BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }
3631  RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }
3632  RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }
3633 
3634  RTPS_DllAPI inline void header(
3635  const CompleteBitmaskHeader& _header) { m_header = _header; }
3636  RTPS_DllAPI inline void header(
3637  CompleteBitmaskHeader&& _header) { m_header = std::move(_header); }
3638  RTPS_DllAPI inline const CompleteBitmaskHeader& header() const { return m_header; }
3639  RTPS_DllAPI inline CompleteBitmaskHeader& header() { return m_header; }
3640 
3641  RTPS_DllAPI inline void flag_seq(
3642  const CompleteBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }
3643  RTPS_DllAPI inline void flag_seq(
3644  CompleteBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }
3645  RTPS_DllAPI inline const CompleteBitflagSeq& flag_seq() const { return m_flag_seq; }
3646  RTPS_DllAPI inline CompleteBitflagSeq& flag_seq() { return m_flag_seq; }
3647 
3648  RTPS_DllAPI static size_t getCdrSerializedSize(
3649  const CompleteBitmaskType& data,
3650  size_t current_alignment = 0);
3651  RTPS_DllAPI void serialize(
3652  eprosima::fastcdr::Cdr& cdr) const;
3653  RTPS_DllAPI void deserialize(
3654  eprosima::fastcdr::Cdr& cdr);
3655 
3656  RTPS_DllAPI bool operator==(
3657  const CompleteBitmaskType& other) const;
3658 
3659  RTPS_DllAPI bool consistent(
3660  const CompleteBitmaskType& x,
3661  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3662 
3663 private:
3664 
3665  BitmaskTypeFlag m_bitmask_flags;
3666  CompleteBitmaskHeader m_header;
3667  CompleteBitflagSeq m_flag_seq;
3668 };
3669 
3670 /*struct MinimalBitmaskType {
3671  BitmaskTypeFlag bitmask_flags; // unused
3672  MinimalBitmaskHeader header;
3673  MinimalBitflagSeq flag_seq;
3674  };*/
3676 {
3677 public:
3678 
3679  RTPS_DllAPI MinimalBitmaskType();
3680  RTPS_DllAPI ~MinimalBitmaskType();
3681  RTPS_DllAPI MinimalBitmaskType(
3682  const MinimalBitmaskType& x);
3683  RTPS_DllAPI MinimalBitmaskType(
3684  MinimalBitmaskType&& x);
3686  const MinimalBitmaskType& x);
3688  MinimalBitmaskType&& x);
3689 
3690  RTPS_DllAPI inline void bitmask_flags(
3691  const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }
3692  RTPS_DllAPI inline void bitmask_flags(
3693  BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }
3694  RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }
3695  RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }
3696 
3697  RTPS_DllAPI inline void header(
3698  const MinimalBitmaskHeader& _header) { m_header = _header; }
3699  RTPS_DllAPI inline void header(
3700  MinimalBitmaskHeader&& _header) { m_header = std::move(_header); }
3701  RTPS_DllAPI inline const MinimalBitmaskHeader& header() const { return m_header; }
3702  RTPS_DllAPI inline MinimalBitmaskHeader& header() { return m_header; }
3703 
3704  RTPS_DllAPI inline void flag_seq(
3705  const MinimalBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }
3706  RTPS_DllAPI inline void flag_seq(
3707  MinimalBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }
3708  RTPS_DllAPI inline const MinimalBitflagSeq& flag_seq() const { return m_flag_seq; }
3709  RTPS_DllAPI inline MinimalBitflagSeq& flag_seq() { return m_flag_seq; }
3710 
3711  RTPS_DllAPI static size_t getCdrSerializedSize(
3712  const MinimalBitmaskType& data,
3713  size_t current_alignment = 0);
3714  RTPS_DllAPI void serialize(
3715  eprosima::fastcdr::Cdr& cdr) const;
3716  RTPS_DllAPI void deserialize(
3717  eprosima::fastcdr::Cdr& cdr);
3718 
3719  RTPS_DllAPI bool operator==(
3720  const MinimalBitmaskType& other) const;
3721 
3722  RTPS_DllAPI bool consistent(
3723  const MinimalBitmaskType& x,
3724  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3725 
3726 private:
3727 
3728  BitmaskTypeFlag m_bitmask_flags;
3729  MinimalBitmaskHeader m_header;
3730  MinimalBitflagSeq m_flag_seq;
3731 };
3732 
3733 // --- Bitset: ---------------------------------------------------------
3734 /*struct CommonBitfield final{
3735  uint16_t position;
3736  BitsetMemberFlag flags;
3737  octet bitcount;
3738  TypeKind holder_type; // Must be primitive integer type
3739  };*/
3740 class CommonBitfield final
3741 {
3742 public:
3743 
3744  RTPS_DllAPI CommonBitfield();
3745  RTPS_DllAPI ~CommonBitfield();
3746  RTPS_DllAPI CommonBitfield(
3747  const CommonBitfield& x);
3748  RTPS_DllAPI CommonBitfield(
3749  CommonBitfield&& x);
3751  const CommonBitfield& x);
3753  CommonBitfield&& x);
3754 
3755  RTPS_DllAPI inline void position(
3756  const uint16_t& _position) { m_position = _position; }
3757  RTPS_DllAPI inline void position(
3758  uint16_t&& _position) { m_position = std::move(_position); }
3759  RTPS_DllAPI inline const uint16_t& position() const { return m_position; }
3760  RTPS_DllAPI inline uint16_t& position() { return m_position; }
3761 
3762  RTPS_DllAPI inline void flags(
3763  const BitsetMemberFlag& _flags) { m_flags = _flags; }
3764  RTPS_DllAPI inline void flags(
3765  BitsetMemberFlag&& _flags) { m_flags = std::move(_flags); }
3766  RTPS_DllAPI inline const BitsetMemberFlag& flags() const { return m_flags; }
3767  RTPS_DllAPI inline BitsetMemberFlag& flags() { return m_flags; }
3768 
3769  RTPS_DllAPI inline void bitcount(
3770  const octet& _bitcount) { m_bitcount = _bitcount; }
3771  RTPS_DllAPI inline void bitcount(
3772  octet&& _bitcount) { m_bitcount = std::move(_bitcount); }
3773  RTPS_DllAPI inline const octet& bitcount() const { return m_bitcount; }
3774  RTPS_DllAPI inline octet& bitcount() { return m_bitcount; }
3775 
3776  RTPS_DllAPI inline void holder_type(
3777  const TypeKind& _holder_type) { m_holder_type = _holder_type; }
3778  RTPS_DllAPI inline void holder_type(
3779  TypeKind&& _holder_type) { m_holder_type = std::move(_holder_type); }
3780  RTPS_DllAPI inline const TypeKind& holder_type() const { return m_holder_type; }
3781  RTPS_DllAPI inline TypeKind& holder_type() { return m_holder_type; }
3782 
3783  RTPS_DllAPI static size_t getCdrSerializedSize(
3784  const CommonBitfield& data,
3785  size_t current_alignment = 0);
3786  RTPS_DllAPI void serialize(
3787  eprosima::fastcdr::Cdr& cdr) const;
3788  RTPS_DllAPI void deserialize(
3789  eprosima::fastcdr::Cdr& cdr);
3790 
3791  RTPS_DllAPI bool operator==(
3792  const CommonBitfield& other) const;
3793 
3794  RTPS_DllAPI bool consistent(
3795  const CommonBitfield& x,
3796  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3797 
3798 private:
3799 
3800  uint16_t m_position;
3801  BitsetMemberFlag m_flags;
3802  octet m_bitcount;
3803  TypeKind m_holder_type;
3804 };
3805 
3806 /*struct CompleteBitfield {
3807  CommonBitfield common;
3808  CompleteMemberDetail detail;
3809  };*/
3811 {
3812 public:
3813 
3814  RTPS_DllAPI CompleteBitfield();
3815  RTPS_DllAPI ~CompleteBitfield();
3816  RTPS_DllAPI CompleteBitfield(
3817  const CompleteBitfield& x);
3818  RTPS_DllAPI CompleteBitfield(
3819  CompleteBitfield&& x);
3821  const CompleteBitfield& x);
3823  CompleteBitfield&& x);
3824 
3825  RTPS_DllAPI inline void common(
3826  const CommonBitfield& _common) { m_common = _common; }
3827  RTPS_DllAPI inline void common(
3828  CommonBitfield&& _common) { m_common = std::move(_common); }
3829  RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }
3830  RTPS_DllAPI inline CommonBitfield& common() { return m_common; }
3831 
3832  RTPS_DllAPI inline void detail(
3833  const CompleteMemberDetail& _detail) { m_detail = _detail; }
3834  RTPS_DllAPI inline void detail(
3835  CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
3836  RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
3837  RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
3838 
3839  RTPS_DllAPI static size_t getCdrSerializedSize(
3840  const CompleteBitfield& data,
3841  size_t current_alignment = 0);
3842  RTPS_DllAPI void serialize(
3843  eprosima::fastcdr::Cdr& cdr) const;
3844  RTPS_DllAPI void deserialize(
3845  eprosima::fastcdr::Cdr& cdr);
3846 
3847  RTPS_DllAPI bool operator==(
3848  const CompleteBitfield& other) const;
3849 
3850  RTPS_DllAPI bool consistent(
3851  const CompleteBitfield& x,
3852  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3853 
3854 private:
3855 
3856  CommonBitfield m_common;
3857  CompleteMemberDetail m_detail;
3858 };
3859 // Ordered by Bitfield.position
3860 typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
3861 /*struct MinimalBitfield {
3862  CommonBitfield common;
3863  NameHash name_hash;
3864  };*/
3866 {
3867 public:
3868 
3869  RTPS_DllAPI MinimalBitfield();
3870  RTPS_DllAPI ~MinimalBitfield();
3871  RTPS_DllAPI MinimalBitfield(
3872  const MinimalBitfield& x);
3873  RTPS_DllAPI MinimalBitfield(
3874  MinimalBitfield&& x);
3876  const MinimalBitfield& x);
3878  MinimalBitfield&& x);
3879 
3880  RTPS_DllAPI inline void name_hash(
3881  const NameHash& _name_hash) { m_name_hash = _name_hash; }
3882  RTPS_DllAPI inline void name_hash(
3883  NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }
3884  RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }
3885  RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }
3886 
3887  RTPS_DllAPI inline void common(
3888  const CommonBitfield& _common) { m_common = _common; }
3889  RTPS_DllAPI inline void common(
3890  CommonBitfield&& _common) { m_common = std::move(_common); }
3891  RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }
3892  RTPS_DllAPI inline CommonBitfield& common() { return m_common; }
3893 
3894  RTPS_DllAPI static size_t getCdrSerializedSize(
3895  const MinimalBitfield& data,
3896  size_t current_alignment = 0);
3897  RTPS_DllAPI void serialize(
3898  eprosima::fastcdr::Cdr& cdr) const;
3899  RTPS_DllAPI void deserialize(
3900  eprosima::fastcdr::Cdr& cdr);
3901 
3902  RTPS_DllAPI bool operator==(
3903  const MinimalBitfield& other) const;
3904 
3905  RTPS_DllAPI bool consistent(
3906  const MinimalBitfield& x,
3907  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3908 
3909 private:
3910 
3911  CommonBitfield m_common;
3912  NameHash m_name_hash;
3913 };
3914 // Ordered by Bitfield.position
3915 typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
3916 /*struct CompleteBitsetHeader {
3917  CompleteTypeDetail detail;
3918  };*/
3920 {
3921 public:
3922 
3923  RTPS_DllAPI CompleteBitsetHeader();
3924  RTPS_DllAPI ~CompleteBitsetHeader();
3926  const CompleteBitsetHeader& x);
3928  CompleteBitsetHeader&& x);
3930  const CompleteBitsetHeader& x);
3932  CompleteBitsetHeader&& x);
3933 
3934  RTPS_DllAPI inline void base_type(
3935  const TypeIdentifier& _base_type) { m_base_type = _base_type; }
3936  RTPS_DllAPI inline void base_type(
3937  TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
3938  RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
3939  RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
3940 
3941  RTPS_DllAPI inline void detail(
3942  const CompleteTypeDetail& _detail) { m_detail = _detail; }
3943  RTPS_DllAPI inline void detail(
3944  CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
3945  RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
3946  RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
3947 
3948  RTPS_DllAPI static size_t getCdrSerializedSize(
3949  const CompleteBitsetHeader& data,
3950  size_t current_alignment = 0);
3951  RTPS_DllAPI void serialize(
3952  eprosima::fastcdr::Cdr& cdr) const;
3953  RTPS_DllAPI void deserialize(
3954  eprosima::fastcdr::Cdr& cdr);
3955 
3956  RTPS_DllAPI bool operator==(
3957  const CompleteBitsetHeader& other) const;
3958 
3959  RTPS_DllAPI bool consistent(
3960  const CompleteBitsetHeader& x,
3961  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
3962 
3963 private:
3964 
3965  TypeIdentifier m_base_type;
3966  CompleteTypeDetail m_detail;
3967 };
3968 
3969 /*struct MinimalBitsetHeader {
3970  // Empty. Available for future extension
3971  };*/
3973 {
3974 public:
3975 
3976  RTPS_DllAPI MinimalBitsetHeader();
3977  RTPS_DllAPI ~MinimalBitsetHeader();
3978  RTPS_DllAPI MinimalBitsetHeader(
3979  const MinimalBitsetHeader& x);
3980  RTPS_DllAPI MinimalBitsetHeader(
3981  MinimalBitsetHeader&& x);
3983  const MinimalBitsetHeader& x);
3985  MinimalBitsetHeader&& x);
3986 
3987  RTPS_DllAPI inline void base_type(
3988  const TypeIdentifier& _base_type) { m_base_type = _base_type; }
3989  RTPS_DllAPI inline void base_type(
3990  TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
3991  RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
3992  RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
3993 
3994  RTPS_DllAPI static size_t getCdrSerializedSize(
3995  const MinimalBitsetHeader& data,
3996  size_t current_alignment = 0);
3997  RTPS_DllAPI void serialize(
3998  eprosima::fastcdr::Cdr& cdr) const;
3999  RTPS_DllAPI void deserialize(
4000  eprosima::fastcdr::Cdr& cdr);
4001 
4002  RTPS_DllAPI bool operator==(
4003  const MinimalBitsetHeader& other) const;
4004 
4005  RTPS_DllAPI bool consistent(
4006  const MinimalBitsetHeader& x,
4007  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4008 
4009 private:
4010 
4011  TypeIdentifier m_base_type;
4012 };
4013 /*struct CompleteBitsetType {
4014  BitsetTypeFlag bitset_flags; // unused
4015  CompleteBitsetHeader header;
4016  CompleteBitfieldSeq field_seq;
4017  };*/
4019 {
4020 public:
4021 
4022  RTPS_DllAPI CompleteBitsetType();
4023  RTPS_DllAPI ~CompleteBitsetType();
4024  RTPS_DllAPI CompleteBitsetType(
4025  const CompleteBitsetType& x);
4026  RTPS_DllAPI CompleteBitsetType(
4027  CompleteBitsetType&& x);
4029  const CompleteBitsetType& x);
4031  CompleteBitsetType&& x);
4032 
4033  RTPS_DllAPI inline void bitset_flags(
4034  const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }
4035  RTPS_DllAPI inline void bitset_flags(
4036  BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }
4037  RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }
4038  RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }
4039 
4040  RTPS_DllAPI inline void header(
4041  const CompleteBitsetHeader& _header) { m_header = _header; }
4042  RTPS_DllAPI inline void header(
4043  CompleteBitsetHeader&& _header) { m_header = std::move(_header); }
4044  RTPS_DllAPI inline const CompleteBitsetHeader& header() const { return m_header; }
4045  RTPS_DllAPI inline CompleteBitsetHeader& header() { return m_header; }
4046 
4047  RTPS_DllAPI inline void field_seq(
4048  const CompleteBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }
4049  RTPS_DllAPI inline void field_seq(
4050  CompleteBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }
4051  RTPS_DllAPI inline const CompleteBitfieldSeq& field_seq() const { return m_field_seq; }
4052  RTPS_DllAPI inline CompleteBitfieldSeq& field_seq() { return m_field_seq; }
4053 
4054  RTPS_DllAPI static size_t getCdrSerializedSize(
4055  const CompleteBitsetType& data,
4056  size_t current_alignment = 0);
4057  RTPS_DllAPI void serialize(
4058  eprosima::fastcdr::Cdr& cdr) const;
4059  RTPS_DllAPI void deserialize(
4060  eprosima::fastcdr::Cdr& cdr);
4061 
4062  RTPS_DllAPI bool operator==(
4063  const CompleteBitsetType& other) const;
4064 
4065  RTPS_DllAPI bool consistent(
4066  const CompleteBitsetType& x,
4067  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4068 
4069 private:
4070 
4071  BitsetTypeFlag m_bitset_flags;
4072  CompleteBitsetHeader m_header;
4073  CompleteBitfieldSeq m_field_seq;
4074 };
4075 
4076 /*struct MinimalBitsetType {
4077  BitsetTypeFlag bitset_flags; // unused
4078  MinimalBitsetHeader header;
4079  MinimalBitfieldSeq field_seq;
4080  };*/
4082 {
4083 public:
4084 
4085  RTPS_DllAPI MinimalBitsetType();
4086  RTPS_DllAPI ~MinimalBitsetType();
4087  RTPS_DllAPI MinimalBitsetType(
4088  const MinimalBitsetType& x);
4089  RTPS_DllAPI MinimalBitsetType(
4090  MinimalBitsetType&& x);
4092  const MinimalBitsetType& x);
4094  MinimalBitsetType&& x);
4095 
4096  RTPS_DllAPI inline void bitset_flags(
4097  const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }
4098  RTPS_DllAPI inline void bitset_flags(
4099  BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }
4100  RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }
4101  RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }
4102 
4103  RTPS_DllAPI inline void header(
4104  const MinimalBitsetHeader& _header) { m_header = _header; }
4105  RTPS_DllAPI inline void header(
4106  MinimalBitsetHeader&& _header) { m_header = std::move(_header); }
4107  RTPS_DllAPI inline const MinimalBitsetHeader& header() const { return m_header; }
4108  RTPS_DllAPI inline MinimalBitsetHeader& header() { return m_header; }
4109 
4110  RTPS_DllAPI inline void field_seq(
4111  const MinimalBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }
4112  RTPS_DllAPI inline void field_seq(
4113  MinimalBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }
4114  RTPS_DllAPI inline const MinimalBitfieldSeq& field_seq() const { return m_field_seq; }
4115  RTPS_DllAPI inline MinimalBitfieldSeq& field_seq() { return m_field_seq; }
4116 
4117  RTPS_DllAPI static size_t getCdrSerializedSize(
4118  const MinimalBitsetType& data,
4119  size_t current_alignment = 0);
4120  RTPS_DllAPI void serialize(
4121  eprosima::fastcdr::Cdr& cdr) const;
4122  RTPS_DllAPI void deserialize(
4123  eprosima::fastcdr::Cdr& cdr);
4124 
4125  RTPS_DllAPI bool operator==(
4126  const MinimalBitsetType& other) const;
4127 
4128  RTPS_DllAPI bool consistent(
4129  const MinimalBitsetType& x,
4130  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4131 
4132 private:
4133 
4134  BitsetTypeFlag m_bitset_flags;
4135  MinimalBitsetHeader m_header;
4136  MinimalBitfieldSeq m_field_seq;
4137 };
4138 
4139 // --- Type Object: --------------------------------------------------
4140 // The types associated with each case selection must have extensibility
4141 // kind APPENDABLE or MUTABLE so that they can be extended in the future
4142 
4143 /*struct CompleteExtendedType {
4144  // Empty. Available for future extension
4145  };*/
4147 {
4148 public:
4149 
4150  RTPS_DllAPI CompleteExtendedType();
4151  RTPS_DllAPI ~CompleteExtendedType();
4153  const CompleteExtendedType& x);
4155  CompleteExtendedType&& x);
4157  const CompleteExtendedType& x);
4159  CompleteExtendedType&& x);
4160 
4161  RTPS_DllAPI static size_t getCdrSerializedSize(
4162  const CompleteExtendedType& data,
4163  size_t current_alignment = 0);
4164  RTPS_DllAPI void serialize(
4165  eprosima::fastcdr::Cdr& cdr) const;
4166  RTPS_DllAPI void deserialize(
4167  eprosima::fastcdr::Cdr& cdr);
4168 
4169  RTPS_DllAPI bool operator==(
4170  const CompleteExtendedType&) const { return true; }
4171 
4172  RTPS_DllAPI bool consistent(
4173  const CompleteExtendedType& x,
4174  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4175 
4176 private:
4177 
4178 };
4179 
4180 /*struct MinimalExtendedType {
4181  // Empty. Available for future extension
4182  };*/
4184 {
4185 public:
4186 
4187  RTPS_DllAPI MinimalExtendedType();
4188  RTPS_DllAPI ~MinimalExtendedType();
4189  RTPS_DllAPI MinimalExtendedType(
4190  const MinimalExtendedType& x);
4191  RTPS_DllAPI MinimalExtendedType(
4192  MinimalExtendedType&& x);
4194  const MinimalExtendedType& x);
4196  MinimalExtendedType&& x);
4197 
4198  RTPS_DllAPI static size_t getCdrSerializedSize(
4199  const MinimalExtendedType& data,
4200  size_t current_alignment = 0);
4201  RTPS_DllAPI void serialize(
4202  eprosima::fastcdr::Cdr& cdr) const;
4203  RTPS_DllAPI void deserialize(
4204  eprosima::fastcdr::Cdr& cdr);
4205 
4206  RTPS_DllAPI bool operator==(
4207  const MinimalExtendedType&) const { return true; }
4208 
4209  RTPS_DllAPI bool consistent(
4210  const MinimalExtendedType& x,
4211  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4212 
4213 private:
4214 
4215 };
4216 
4218 {
4219 public:
4220 
4221  RTPS_DllAPI CompleteTypeObject();
4222  RTPS_DllAPI ~CompleteTypeObject();
4223  RTPS_DllAPI CompleteTypeObject(
4224  const CompleteTypeObject& x);
4225  RTPS_DllAPI CompleteTypeObject(
4226  CompleteTypeObject&& x);
4228  const CompleteTypeObject& x);
4230  CompleteTypeObject&& x);
4231  RTPS_DllAPI void _d(
4232  octet __d);
4233  RTPS_DllAPI octet _d() const;
4234  RTPS_DllAPI octet& _d();
4235 
4236  RTPS_DllAPI void alias_type(
4237  CompleteAliasType _alias_type);
4238  RTPS_DllAPI const CompleteAliasType& alias_type() const;
4240 
4241  RTPS_DllAPI void annotation_type(
4242  CompleteAnnotationType _annotation_type);
4243  RTPS_DllAPI const CompleteAnnotationType& annotation_type() const;
4245 
4246  RTPS_DllAPI void struct_type(
4247  CompleteStructType _struct_type);
4248  RTPS_DllAPI const CompleteStructType& struct_type() const;
4250 
4251  RTPS_DllAPI void union_type(
4252  CompleteUnionType _union_type);
4253  RTPS_DllAPI const CompleteUnionType& union_type() const;
4255 
4256  RTPS_DllAPI void bitset_type(
4257  CompleteBitsetType _bitset_type);
4258  RTPS_DllAPI const CompleteBitsetType& bitset_type() const;
4260 
4261  RTPS_DllAPI void sequence_type(
4262  CompleteSequenceType _sequence_type);
4263  RTPS_DllAPI const CompleteSequenceType& sequence_type() const;
4265 
4266  RTPS_DllAPI void array_type(
4267  CompleteArrayType _array_type);
4268  RTPS_DllAPI const CompleteArrayType& array_type() const;
4270 
4271  RTPS_DllAPI void map_type(
4272  CompleteMapType _map_type);
4273  RTPS_DllAPI const CompleteMapType& map_type() const;
4274  RTPS_DllAPI CompleteMapType& map_type();
4275 
4276  RTPS_DllAPI void enumerated_type(
4277  CompleteEnumeratedType _enumerated_type);
4278  RTPS_DllAPI const CompleteEnumeratedType& enumerated_type() const;
4280 
4281  RTPS_DllAPI void bitmask_type(
4282  CompleteBitmaskType _bitmask_type);
4283  RTPS_DllAPI const CompleteBitmaskType& bitmask_type() const;
4285 
4286  RTPS_DllAPI void extended_type(
4287  CompleteExtendedType _extended_type);
4288  RTPS_DllAPI const CompleteExtendedType& extended_type() const;
4290 
4291  RTPS_DllAPI static size_t getCdrSerializedSize(
4292  const CompleteTypeObject& data,
4293  size_t current_alignment = 0);
4294  RTPS_DllAPI void serialize(
4295  eprosima::fastcdr::Cdr& cdr) const;
4296  RTPS_DllAPI void deserialize(
4297  eprosima::fastcdr::Cdr& cdr);
4298 
4299  RTPS_DllAPI bool operator==(
4300  const CompleteTypeObject& other) const;
4301 
4302  RTPS_DllAPI bool consistent(
4303  const CompleteTypeObject& x,
4304  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4305 
4306 private:
4307 
4308  octet m__d;
4309 
4310  CompleteAliasType m_alias_type;
4311  CompleteAnnotationType m_annotation_type;
4312  CompleteStructType m_struct_type;
4313  CompleteUnionType m_union_type;
4314  CompleteBitsetType m_bitset_type;
4315  CompleteSequenceType m_sequence_type;
4316  CompleteArrayType m_array_type;
4317  CompleteMapType m_map_type;
4318  CompleteEnumeratedType m_enumerated_type;
4319  CompleteBitmaskType m_bitmask_type;
4320  CompleteExtendedType m_extended_type;
4321 };
4322 
4324 {
4325 public:
4326 
4327  RTPS_DllAPI MinimalTypeObject();
4328  RTPS_DllAPI ~MinimalTypeObject();
4329  RTPS_DllAPI MinimalTypeObject(
4330  const MinimalTypeObject& x);
4331  RTPS_DllAPI MinimalTypeObject(
4332  MinimalTypeObject&& x);
4334  const MinimalTypeObject& x);
4336  MinimalTypeObject&& x);
4337  RTPS_DllAPI void _d(
4338  octet __d);
4339  RTPS_DllAPI octet _d() const;
4340  RTPS_DllAPI octet& _d();
4341 
4342  RTPS_DllAPI void alias_type(
4343  MinimalAliasType _alias_type);
4344  RTPS_DllAPI const MinimalAliasType& alias_type() const;
4346 
4347  RTPS_DllAPI void annotation_type(
4348  MinimalAnnotationType _annotation_type);
4349  RTPS_DllAPI const MinimalAnnotationType& annotation_type() const;
4351 
4352  RTPS_DllAPI void struct_type(
4353  MinimalStructType _struct_type);
4354  RTPS_DllAPI const MinimalStructType& struct_type() const;
4356 
4357  RTPS_DllAPI void union_type(
4358  MinimalUnionType _union_type);
4359  RTPS_DllAPI const MinimalUnionType& union_type() const;
4361 
4362  RTPS_DllAPI void bitset_type(
4363  MinimalBitsetType _bitset_type);
4364  RTPS_DllAPI const MinimalBitsetType& bitset_type() const;
4366 
4367  RTPS_DllAPI void sequence_type(
4368  MinimalSequenceType _sequence_type);
4369  RTPS_DllAPI const MinimalSequenceType& sequence_type() const;
4371 
4372  RTPS_DllAPI void array_type(
4373  MinimalArrayType _array_type);
4374  RTPS_DllAPI const MinimalArrayType& array_type() const;
4376 
4377  RTPS_DllAPI void map_type(
4378  MinimalMapType _map_type);
4379  RTPS_DllAPI const MinimalMapType& map_type() const;
4380  RTPS_DllAPI MinimalMapType& map_type();
4381 
4382  RTPS_DllAPI void enumerated_type(
4383  MinimalEnumeratedType _enumerated_type);
4384  RTPS_DllAPI const MinimalEnumeratedType& enumerated_type() const;
4386 
4387  RTPS_DllAPI void bitmask_type(
4388  MinimalBitmaskType _bitmask_type);
4389  RTPS_DllAPI const MinimalBitmaskType& bitmask_type() const;
4391 
4392  RTPS_DllAPI void extended_type(
4393  MinimalExtendedType _extended_type);
4394  RTPS_DllAPI const MinimalExtendedType& extended_type() const;
4396 
4397  RTPS_DllAPI static size_t getCdrSerializedSize(
4398  const MinimalTypeObject& data,
4399  size_t current_alignment = 0);
4400  RTPS_DllAPI void serialize(
4401  eprosima::fastcdr::Cdr& cdr) const;
4402  RTPS_DllAPI void deserialize(
4403  eprosima::fastcdr::Cdr& cdr);
4404 
4405  RTPS_DllAPI bool operator==(
4406  const MinimalTypeObject& other) const;
4407 
4408  RTPS_DllAPI bool consistent(
4409  const MinimalTypeObject& x,
4410  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4411 
4412 private:
4413 
4414  octet m__d;
4415 
4416  MinimalAliasType m_alias_type;
4417  MinimalAnnotationType m_annotation_type;
4418  MinimalStructType m_struct_type;
4419  MinimalUnionType m_union_type;
4420  MinimalBitsetType m_bitset_type;
4421  MinimalSequenceType m_sequence_type;
4422  MinimalArrayType m_array_type;
4423  MinimalMapType m_map_type;
4424  MinimalEnumeratedType m_enumerated_type;
4425  MinimalBitmaskType m_bitmask_type;
4426  MinimalExtendedType m_extended_type;
4427 };
4429 {
4430 public:
4431 
4435  RTPS_DllAPI TypeObject();
4436 
4440  RTPS_DllAPI ~TypeObject();
4441 
4446  RTPS_DllAPI TypeObject(
4447  const TypeObject& x);
4448 
4453  RTPS_DllAPI TypeObject(
4454  TypeObject&& x);
4455 
4460  RTPS_DllAPI TypeObject& operator=(
4461  const TypeObject& x);
4462 
4467  RTPS_DllAPI TypeObject& operator=(
4468  TypeObject&& x);
4469 
4475  RTPS_DllAPI void _d(
4476  uint8_t __d);
4477 
4482  RTPS_DllAPI uint8_t _d() const;
4483 
4488  RTPS_DllAPI uint8_t& _d();
4489 
4494  RTPS_DllAPI void complete(
4495  const CompleteTypeObject& _complete);
4496 
4501  RTPS_DllAPI void complete(
4502  CompleteTypeObject&& _complete);
4503 
4509  RTPS_DllAPI const CompleteTypeObject& complete() const;
4510 
4521  RTPS_DllAPI void minimal(
4522  const MinimalTypeObject& _minimal);
4523 
4528  RTPS_DllAPI void minimal(
4529  MinimalTypeObject&& _minimal);
4530 
4536  RTPS_DllAPI const MinimalTypeObject& minimal() const;
4537 
4543  RTPS_DllAPI MinimalTypeObject& minimal();
4544 
4551  RTPS_DllAPI static size_t getCdrSerializedSize(
4552  const TypeObject& data,
4553  size_t current_alignment = 0);
4558  RTPS_DllAPI void serialize(
4559  eprosima::fastcdr::Cdr& cdr) const;
4560 
4565  RTPS_DllAPI void deserialize(
4566  eprosima::fastcdr::Cdr& cdr);
4567 
4568  RTPS_DllAPI bool operator==(
4569  const TypeObject& other) const;
4570 
4576  RTPS_DllAPI bool consistent(
4577  const TypeObject& x,
4578  const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
4579 
4580 private:
4581 
4582  uint8_t m__d;
4583 
4584  CompleteTypeObject m_complete;
4585  MinimalTypeObject m_minimal;
4586 };
4587 
4588 typedef std::vector<TypeObject> TypeObjectSeq;
4589 
4590 // Set of TypeObjects representing a strong component: Equivalence class
4591 // for the Strong Connectivity relationship (mutual reachability between
4592 // types).
4593 // Ordered by fully qualified typename lexicographic order
4595 
4596 /*struct TypeIdentifierTypeObjectPair final {
4597  TypeIdentifier type_identifier;
4598  TypeObject type_object;
4599  };*/
4601 {
4602 public:
4603 
4607  const TypeIdentifierTypeObjectPair& x);
4611  const TypeIdentifierTypeObjectPair& x);
4614 
4615  RTPS_DllAPI inline void type_identifier(
4616  const TypeIdentifier& _type_identifier) { m_type_identifier = _type_identifier; }
4617  RTPS_DllAPI inline void type_identifier(
4618  TypeIdentifier&& _type_identifier) { m_type_identifier = std::move(_type_identifier); }
4619  RTPS_DllAPI inline const TypeIdentifier& type_identifier() const { return m_type_identifier; }
4620  RTPS_DllAPI inline TypeIdentifier& type_identifier() { return m_type_identifier; }
4621 
4622  RTPS_DllAPI inline void type_object(
4623  const TypeObject& _type_object) { m_type_object = _type_object; }
4624  RTPS_DllAPI inline void type_object(
4625  TypeObject&& _type_object) { m_type_object = std::move(_type_object); }
4626  RTPS_DllAPI inline const TypeObject& type_object() const { return m_type_object; }
4627  RTPS_DllAPI inline TypeObject& type_object() { return m_type_object; }
4628 
4629  RTPS_DllAPI static size_t getCdrSerializedSize(
4630  const TypeIdentifierTypeObjectPair& data,
4631  size_t current_alignment = 0);
4632  RTPS_DllAPI void serialize(
4633  eprosima::fastcdr::Cdr& cdr) const;
4634  RTPS_DllAPI void deserialize(
4635  eprosima::fastcdr::Cdr& cdr);
4636 
4637 private:
4638 
4639  TypeIdentifier m_type_identifier;
4640  TypeObject m_type_object;
4641 };
4642 typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
4643 
4644 /*struct TypeIdentifierPair final {
4645  TypeIdentifier type_identifier1;
4646  TypeIdentifier type_identifier2;
4647  };*/
4649 {
4650 public:
4651 
4652  RTPS_DllAPI TypeIdentifierPair();
4653  RTPS_DllAPI ~TypeIdentifierPair();
4654  RTPS_DllAPI TypeIdentifierPair(
4655  const TypeIdentifierPair& x);
4656  RTPS_DllAPI TypeIdentifierPair(
4657  TypeIdentifierPair&& x);
4659  const TypeIdentifierPair& x);
4661  TypeIdentifierPair&& x);
4662 
4663  RTPS_DllAPI inline void type_identifier1(
4664  const TypeIdentifier& _type_identifier1) { m_type_identifier1 = _type_identifier1; }
4665  RTPS_DllAPI inline void type_identifier1(
4666  TypeIdentifier&& _type_identifier1) { m_type_identifier1 = std::move(_type_identifier1); }
4667  RTPS_DllAPI inline const TypeIdentifier& type_identifier1() const { return m_type_identifier1; }
4668  RTPS_DllAPI inline TypeIdentifier& type_identifier1() { return m_type_identifier1; }
4669 
4670  RTPS_DllAPI inline void type_identifier2(
4671  const TypeIdentifier& _type_identifier2) { m_type_identifier2 = _type_identifier2; }
4672  RTPS_DllAPI inline void type_identifier2(
4673  TypeIdentifier&& _type_identifier2) { m_type_identifier2 = std::move(_type_identifier2); }
4674  RTPS_DllAPI inline const TypeIdentifier& type_identifier2() const { return m_type_identifier2; }
4675  RTPS_DllAPI inline TypeIdentifier& type_identifier2() { return m_type_identifier2; }
4676 
4677  RTPS_DllAPI static size_t getCdrSerializedSize(
4678  const TypeIdentifierPair& data,
4679  size_t current_alignment = 0);
4680  RTPS_DllAPI void serialize(
4681  eprosima::fastcdr::Cdr& cdr) const;
4682  RTPS_DllAPI void deserialize(
4683  eprosima::fastcdr::Cdr& cdr);
4684 
4685 private:
4686 
4687  TypeIdentifier m_type_identifier1;
4688  TypeIdentifier m_type_identifier2;
4689 };
4690 
4691 typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
4692 /*struct TypeIdentifierWithSize {
4693  TypeIdentifier type_id;
4694  uint32_t typeobject_serialized_size;
4695  };*/
4697 {
4698 public:
4699 
4700  RTPS_DllAPI TypeIdentifierWithSize();
4703  const TypeIdentifierWithSize& x);
4707  const TypeIdentifierWithSize& x);
4710 
4711  RTPS_DllAPI inline void type_id(
4712  const TypeIdentifier& _type_id) { m_type_id = _type_id; }
4713  RTPS_DllAPI inline void type_id(
4714  TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
4715  RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
4716  RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
4717 
4718  RTPS_DllAPI inline void typeobject_serialized_size(
4719  const uint32_t& _typeobject_serialized_size) { m_typeobject_serialized_size = _typeobject_serialized_size; }
4720  RTPS_DllAPI inline void typeobject_serialized_size(
4721  uint32_t&& _typeobject_serialized_size) {
4722  m_typeobject_serialized_size = std::move(_typeobject_serialized_size);
4723  }
4724  RTPS_DllAPI inline const uint32_t& typeobject_serialized_size() const { return m_typeobject_serialized_size; }
4725  RTPS_DllAPI inline uint32_t& typeobject_serialized_size() { return m_typeobject_serialized_size; }
4726 
4727  RTPS_DllAPI static size_t getCdrSerializedSize(
4728  const TypeIdentifierWithSize& data,
4729  size_t current_alignment = 0);
4730  RTPS_DllAPI void serialize(
4731  eprosima::fastcdr::Cdr& cdr) const;
4732  RTPS_DllAPI void deserialize(
4733  eprosima::fastcdr::Cdr& cdr);
4734 
4735 private:
4736 
4737  TypeIdentifier m_type_id;
4738  uint32_t m_typeobject_serialized_size;
4739 };
4740 
4741 typedef std::vector<TypeIdentifierWithSize> TypeIdentifierWithSizeSeq;
4742 
4743 /*struct TypeIdentifierWithDependencies {
4744  TypeIdentifierWithSize typeid_with_size;
4745  // The total additional types related to minimal_type
4746  int32_t dependent_typeid_count;
4747  TypeIdentifierWithSizeSeq dependent_typeids;
4748  };*/
4750 {
4751 public:
4752 
4763 
4764  RTPS_DllAPI inline void typeid_with_size(
4765  const TypeIdentifierWithSize& _typeid_with_size) { m_typeid_with_size = _typeid_with_size; }
4766  RTPS_DllAPI inline void typeid_with_size(
4767  TypeIdentifierWithSize&& _typeid_with_size) { m_typeid_with_size = std::move(_typeid_with_size); }
4768  RTPS_DllAPI inline const TypeIdentifierWithSize& typeid_with_size() const { return m_typeid_with_size; }
4769  RTPS_DllAPI inline TypeIdentifierWithSize& typeid_with_size() { return m_typeid_with_size; }
4770 
4771  RTPS_DllAPI inline void dependent_typeid_count(
4772  const int32_t& _dependent_typeid_count) { m_dependent_typeid_count = _dependent_typeid_count; }
4773  RTPS_DllAPI inline void dependent_typeid_count(
4774  int32_t&& _dependent_typeid_count) { m_dependent_typeid_count = std::move(_dependent_typeid_count); }
4775  RTPS_DllAPI inline const int32_t& dependent_typeid_count() const { return m_dependent_typeid_count; }
4776  RTPS_DllAPI inline int32_t& dependent_typeid_count() { return m_dependent_typeid_count; }
4777 
4778  RTPS_DllAPI inline void dependent_typeids(
4779  const TypeIdentifierWithSizeSeq& _dependent_typeids) { m_dependent_typeids = _dependent_typeids; }
4780  RTPS_DllAPI inline void dependent_typeids(
4781  TypeIdentifierWithSizeSeq&& _dependent_typeids) { m_dependent_typeids = std::move(_dependent_typeids); }
4782  RTPS_DllAPI inline const TypeIdentifierWithSizeSeq& dependent_typeids() const { return m_dependent_typeids; }
4783  RTPS_DllAPI inline TypeIdentifierWithSizeSeq& dependent_typeids() { return m_dependent_typeids; }
4784 
4785  RTPS_DllAPI static size_t getCdrSerializedSize(
4786  const TypeIdentifierWithDependencies& data,
4787  size_t current_alignment = 0);
4788  RTPS_DllAPI void serialize(
4789  eprosima::fastcdr::Cdr& cdr) const;
4790  RTPS_DllAPI void deserialize(
4791  eprosima::fastcdr::Cdr& cdr);
4792 
4793 private:
4794 
4795  TypeIdentifierWithSize m_typeid_with_size;
4796  int32_t m_dependent_typeid_count;
4797  TypeIdentifierWithSizeSeq m_dependent_typeids;
4798 };
4799 
4800 typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
4802 
4803 // This appears in the builtin DDS topics PublicationBuiltinTopicData
4804 // and SubscriptionBuiltinTopicData
4805 
4806 /*struct TypeInformation {
4807  TypeIdentifierWithDependencies minimal; // @id{0x1001}
4808  TypeIdentifierWithDependencies complete; // @id{0x1002}
4809  };*/
4811 {
4812 public:
4813 
4814  RTPS_DllAPI TypeInformation();
4815  RTPS_DllAPI ~TypeInformation();
4816  RTPS_DllAPI TypeInformation(
4817  const TypeInformation& x);
4818  RTPS_DllAPI TypeInformation(
4819  TypeInformation&& x);
4821  const TypeInformation& x);
4823  TypeInformation&& x);
4824 
4825  RTPS_DllAPI inline void minimal(
4826  const TypeIdentifierWithDependencies& _minimal) { m_minimal = _minimal; }
4827  RTPS_DllAPI inline void minimal(
4828  TypeIdentifierWithDependencies&& _minimal) { m_minimal = std::move(_minimal); }
4829  RTPS_DllAPI inline const TypeIdentifierWithDependencies& minimal() const { return m_minimal; }
4830  RTPS_DllAPI inline TypeIdentifierWithDependencies& minimal() { return m_minimal; }
4831 
4832  RTPS_DllAPI inline void complete(
4833  const TypeIdentifierWithDependencies& _complete) { m_complete = _complete; }
4834  RTPS_DllAPI inline void complete(
4835  TypeIdentifierWithDependencies&& _complete) { m_complete = std::move(_complete); }
4836  RTPS_DllAPI inline const TypeIdentifierWithDependencies& complete() const { return m_complete; }
4837  RTPS_DllAPI inline TypeIdentifierWithDependencies& complete() { return m_complete; }
4838 
4839  RTPS_DllAPI static size_t getCdrSerializedSize(
4840  const TypeInformation& data,
4841  size_t current_alignment = 0);
4842  RTPS_DllAPI void serialize(
4843  eprosima::fastcdr::Cdr& cdr) const;
4844  RTPS_DllAPI void deserialize(
4845  eprosima::fastcdr::Cdr& cdr);
4846 
4847 private:
4848 
4850  TypeIdentifierWithDependencies m_complete;
4851 };
4852 
4853 typedef std::vector<TypeInformation> TypeInformationSeq;
4855 
4856 } // namespace types
4857 } // namespace fastrtps
4858 } // namespace eprosima
4859 
4860 #endif // TYPES_TYPE_OBJECT_H
This class represents the union AnnotationParameterValue defined by the user in the IDL file.
Definition: AnnotationParameterValue.h:166
Definition: AnnotationParameterValue.h:1255
RTPS_DllAPI AppliedBuiltinTypeAnnotations(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI const AppliedVerbatimAnnotation & verbatim() const
Definition: TypeObject.h:349
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const AppliedBuiltinTypeAnnotations &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(AppliedBuiltinTypeAnnotations &&x)
RTPS_DllAPI AppliedBuiltinTypeAnnotations(AppliedBuiltinTypeAnnotations &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const AppliedBuiltinTypeAnnotations &data, size_t current_alignment=0)
RTPS_DllAPI AppliedBuiltinTypeAnnotations & operator=(const AppliedBuiltinTypeAnnotations &x)
RTPS_DllAPI void verbatim(AppliedVerbatimAnnotation &&_verbatim)
Definition: TypeObject.h:347
RTPS_DllAPI AppliedVerbatimAnnotation & verbatim()
Definition: TypeObject.h:350
RTPS_DllAPI bool operator==(const AppliedBuiltinTypeAnnotations &other) const
RTPS_DllAPI void verbatim(const AppliedVerbatimAnnotation &_verbatim)
Definition: TypeObject.h:345
Definition: AnnotationParameterValue.h:1133
Definition: TypeObject.h:1695
RTPS_DllAPI AliasMemberFlag & related_flags()
Definition: TypeObject.h:1714
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonAliasBody &data, size_t current_alignment=0)
RTPS_DllAPI CommonAliasBody & operator=(CommonAliasBody &&x)
RTPS_DllAPI TypeIdentifier & related_type()
Definition: TypeObject.h:1721
RTPS_DllAPI CommonAliasBody(const CommonAliasBody &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonAliasBody(CommonAliasBody &&x)
RTPS_DllAPI const AliasMemberFlag & related_flags() const
Definition: TypeObject.h:1713
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const TypeIdentifier & related_type() const
Definition: TypeObject.h:1720
RTPS_DllAPI void related_flags(AliasMemberFlag &&_related_flags)
Definition: TypeObject.h:1711
RTPS_DllAPI void related_flags(const AliasMemberFlag &_related_flags)
Definition: TypeObject.h:1709
RTPS_DllAPI CommonAliasBody & operator=(const CommonAliasBody &x)
RTPS_DllAPI bool operator==(const CommonAliasBody &other) const
RTPS_DllAPI void related_type(TypeIdentifier &&_related_type)
Definition: TypeObject.h:1718
RTPS_DllAPI void related_type(const TypeIdentifier &_related_type)
Definition: TypeObject.h:1716
RTPS_DllAPI const AnnotationParameterFlag & member_flags() const
Definition: TypeObject.h:1320
RTPS_DllAPI AnnotationParameterFlag & member_flags()
Definition: TypeObject.h:1321
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonAnnotationParameter &data, size_t current_alignment=0)
RTPS_DllAPI CommonAnnotationParameter(CommonAnnotationParameter &&x)
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:1325
RTPS_DllAPI void member_flags(const AnnotationParameterFlag &_member_flags)
Definition: TypeObject.h:1316
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonAnnotationParameter(const CommonAnnotationParameter &x)
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:1323
RTPS_DllAPI void member_flags(AnnotationParameterFlag &&_member_flags)
Definition: TypeObject.h:1318
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonAnnotationParameter & operator=(const CommonAnnotationParameter &x)
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:1328
RTPS_DllAPI bool consistent(const CommonAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CommonAnnotationParameter &other) const
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition: TypeObject.h:1327
RTPS_DllAPI CommonAnnotationParameter & operator=(CommonAnnotationParameter &&x)
RTPS_DllAPI CommonArrayHeader & operator=(CommonArrayHeader &&x)
RTPS_DllAPI bool consistent(const CommonArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI LBoundSeq & bound_seq()
Definition: TypeObject.h:2554
RTPS_DllAPI void bound_seq(const LBoundSeq &_bound_seq)
Definition: TypeObject.h:2549
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonArrayHeader(const CommonArrayHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonArrayHeader &data, size_t current_alignment=0)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const LBoundSeq & bound_seq() const
Definition: TypeObject.h:2553
RTPS_DllAPI CommonArrayHeader(CommonArrayHeader &&x)
RTPS_DllAPI void bound_seq(LBoundSeq &&_bound_seq)
Definition: TypeObject.h:2551
RTPS_DllAPI CommonArrayHeader & operator=(const CommonArrayHeader &x)
RTPS_DllAPI bool operator==(const CommonArrayHeader &other) const
Definition: TypeObject.h:3741
RTPS_DllAPI const BitsetMemberFlag & flags() const
Definition: TypeObject.h:3766
RTPS_DllAPI void bitcount(octet &&_bitcount)
Definition: TypeObject.h:3771
RTPS_DllAPI CommonBitfield(const CommonBitfield &x)
RTPS_DllAPI void holder_type(TypeKind &&_holder_type)
Definition: TypeObject.h:3778
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:3760
RTPS_DllAPI CommonBitfield & operator=(const CommonBitfield &x)
RTPS_DllAPI CommonBitfield(CommonBitfield &&x)
RTPS_DllAPI const octet & bitcount() const
Definition: TypeObject.h:3773
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const CommonBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CommonBitfield &other) const
RTPS_DllAPI void holder_type(const TypeKind &_holder_type)
Definition: TypeObject.h:3776
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI BitsetMemberFlag & flags()
Definition: TypeObject.h:3767
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:3759
RTPS_DllAPI TypeKind & holder_type()
Definition: TypeObject.h:3781
RTPS_DllAPI void bitcount(const octet &_bitcount)
Definition: TypeObject.h:3769
RTPS_DllAPI CommonBitfield & operator=(CommonBitfield &&x)
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:3757
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:3755
RTPS_DllAPI const TypeKind & holder_type() const
Definition: TypeObject.h:3780
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitfield &data, size_t current_alignment=0)
RTPS_DllAPI octet & bitcount()
Definition: TypeObject.h:3774
RTPS_DllAPI void flags(BitsetMemberFlag &&_flags)
Definition: TypeObject.h:3764
RTPS_DllAPI void flags(const BitsetMemberFlag &_flags)
Definition: TypeObject.h:3762
Definition: TypeObject.h:3399
RTPS_DllAPI CommonBitflag(const CommonBitflag &x)
RTPS_DllAPI CommonBitflag & operator=(const CommonBitflag &x)
RTPS_DllAPI uint16_t & position()
Definition: TypeObject.h:3418
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitflag &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonBitflag & operator=(CommonBitflag &&x)
RTPS_DllAPI CommonBitflag(CommonBitflag &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const BitflagFlag & flags() const
Definition: TypeObject.h:3424
RTPS_DllAPI const uint16_t & position() const
Definition: TypeObject.h:3417
RTPS_DllAPI void flags(BitflagFlag &&_flags)
Definition: TypeObject.h:3422
RTPS_DllAPI bool consistent(const CommonBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void flags(const BitflagFlag &_flags)
Definition: TypeObject.h:3420
RTPS_DllAPI void position(uint16_t &&_position)
Definition: TypeObject.h:3415
RTPS_DllAPI void position(const uint16_t &_position)
Definition: TypeObject.h:3413
RTPS_DllAPI bool operator==(const CommonBitflag &other) const
RTPS_DllAPI BitflagFlag & flags()
Definition: TypeObject.h:3425
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:3578
RTPS_DllAPI CommonBitmaskHeader & operator=(const CommonBitmaskHeader &x)
RTPS_DllAPI bool consistent(const CommonBitmaskHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:3583
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:3580
RTPS_DllAPI CommonBitmaskHeader(const CommonBitmaskHeader &x)
RTPS_DllAPI CommonBitmaskHeader(CommonBitmaskHeader &&x)
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:3582
RTPS_DllAPI bool operator==(const CommonBitmaskHeader &other) const
RTPS_DllAPI CommonBitmaskHeader & operator=(CommonBitmaskHeader &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonBitmaskHeader &data, size_t current_alignment=0)
RTPS_DllAPI void element_flags(const CollectionElementFlag &_element_flags)
Definition: TypeObject.h:2125
RTPS_DllAPI CommonCollectionElement(CommonCollectionElement &&x)
RTPS_DllAPI bool operator==(const CommonCollectionElement &other) const
RTPS_DllAPI const TypeIdentifier & type() const
Definition: TypeObject.h:2136
RTPS_DllAPI void type(TypeIdentifier &&_type)
Definition: TypeObject.h:2134
RTPS_DllAPI void element_flags(CollectionElementFlag &&_element_flags)
Definition: TypeObject.h:2127
RTPS_DllAPI CommonCollectionElement & operator=(CommonCollectionElement &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CollectionElementFlag & element_flags()
Definition: TypeObject.h:2130
RTPS_DllAPI TypeIdentifier & type()
Definition: TypeObject.h:2137
RTPS_DllAPI const CollectionElementFlag & element_flags() const
Definition: TypeObject.h:2129
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonCollectionElement(const CommonCollectionElement &x)
RTPS_DllAPI CommonCollectionElement & operator=(const CommonCollectionElement &x)
RTPS_DllAPI bool consistent(const CommonCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void type(const TypeIdentifier &_type)
Definition: TypeObject.h:2132
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonCollectionElement &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const CommonCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bound(const LBound &_bound)
Definition: TypeObject.h:2277
RTPS_DllAPI void bound(LBound &&_bound)
Definition: TypeObject.h:2279
RTPS_DllAPI CommonCollectionHeader(const CommonCollectionHeader &x)
RTPS_DllAPI CommonCollectionHeader(CommonCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CommonCollectionHeader &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonCollectionHeader &data, size_t current_alignment=0)
RTPS_DllAPI CommonCollectionHeader & operator=(CommonCollectionHeader &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const LBound & bound() const
Definition: TypeObject.h:2281
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonCollectionHeader & operator=(const CommonCollectionHeader &x)
RTPS_DllAPI LBound & bound()
Definition: TypeObject.h:2282
RTPS_DllAPI CommonDiscriminatorMember & operator=(CommonDiscriminatorMember &&x)
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:926
RTPS_DllAPI const UnionDiscriminatorFlag & member_flags() const
Definition: TypeObject.h:921
RTPS_DllAPI bool consistent(const CommonDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI UnionDiscriminatorFlag & member_flags()
Definition: TypeObject.h:922
RTPS_DllAPI bool operator==(const CommonDiscriminatorMember &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void member_flags(const UnionDiscriminatorFlag &_member_flags)
Definition: TypeObject.h:917
RTPS_DllAPI CommonDiscriminatorMember & operator=(const CommonDiscriminatorMember &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:929
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonDiscriminatorMember &data, size_t current_alignment=0)
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:924
RTPS_DllAPI CommonDiscriminatorMember(CommonDiscriminatorMember &&x)
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:928
RTPS_DllAPI CommonDiscriminatorMember(const CommonDiscriminatorMember &x)
RTPS_DllAPI void member_flags(UnionDiscriminatorFlag &&_member_flags)
Definition: TypeObject.h:919
RTPS_DllAPI CommonEnumeratedHeader & operator=(CommonEnumeratedHeader &&x)
RTPS_DllAPI void bit_bound(const BitBound &_bit_bound)
Definition: TypeObject.h:3139
RTPS_DllAPI bool consistent(const CommonEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI BitBound & bit_bound()
Definition: TypeObject.h:3144
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void bit_bound(BitBound &&_bit_bound)
Definition: TypeObject.h:3141
RTPS_DllAPI CommonEnumeratedHeader(const CommonEnumeratedHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonEnumeratedHeader &data, size_t current_alignment=0)
RTPS_DllAPI const BitBound & bit_bound() const
Definition: TypeObject.h:3143
RTPS_DllAPI CommonEnumeratedHeader(CommonEnumeratedHeader &&x)
RTPS_DllAPI CommonEnumeratedHeader & operator=(const CommonEnumeratedHeader &x)
RTPS_DllAPI bool operator==(const CommonEnumeratedHeader &other) const
RTPS_DllAPI CommonEnumeratedLiteral & operator=(const CommonEnumeratedLiteral &x)
RTPS_DllAPI const int32_t & value() const
Definition: TypeObject.h:2973
RTPS_DllAPI void flags(const EnumeratedLiteralFlag &_flags)
Definition: TypeObject.h:2976
RTPS_DllAPI const EnumeratedLiteralFlag & flags() const
Definition: TypeObject.h:2980
RTPS_DllAPI CommonEnumeratedLiteral & operator=(CommonEnumeratedLiteral &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void flags(EnumeratedLiteralFlag &&_flags)
Definition: TypeObject.h:2978
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonEnumeratedLiteral(const CommonEnumeratedLiteral &x)
RTPS_DllAPI EnumeratedLiteralFlag & flags()
Definition: TypeObject.h:2981
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonEnumeratedLiteral &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const CommonEnumeratedLiteral &other) const
RTPS_DllAPI void value(const int32_t &_value)
Definition: TypeObject.h:2969
RTPS_DllAPI bool consistent(const CommonEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CommonEnumeratedLiteral(CommonEnumeratedLiteral &&x)
RTPS_DllAPI int32_t & value()
Definition: TypeObject.h:2974
RTPS_DllAPI void value(int32_t &&_value)
Definition: TypeObject.h:2971
RTPS_DllAPI void member_flags(const StructMemberFlag &_member_flags)
Definition: TypeObject.h:64
RTPS_DllAPI const MemberId & member_id() const
Definition: TypeObject.h:61
RTPS_DllAPI CommonStructMember & operator=(CommonStructMember &&x)
RTPS_DllAPI MemberId & member_id()
Definition: TypeObject.h:62
RTPS_DllAPI void member_type_id(TypeIdentifier &&_member_type_id)
Definition: TypeObject.h:73
RTPS_DllAPI CommonStructMember & operator=(const CommonStructMember &x)
RTPS_DllAPI bool operator==(const CommonStructMember &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void member_type_id(const TypeIdentifier &_member_type_id)
Definition: TypeObject.h:71
RTPS_DllAPI bool consistent(const CommonStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition: TypeObject.h:59
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI StructMemberFlag & member_flags()
Definition: TypeObject.h:69
RTPS_DllAPI TypeIdentifier & member_type_id()
Definition: TypeObject.h:76
RTPS_DllAPI const StructMemberFlag & member_flags() const
Definition: TypeObject.h:68
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition: TypeObject.h:57
RTPS_DllAPI CommonStructMember(const CommonStructMember &x)
RTPS_DllAPI CommonStructMember(CommonStructMember &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonStructMember &data, size_t current_alignment=0)
RTPS_DllAPI void member_flags(StructMemberFlag &&_member_flags)
Definition: TypeObject.h:66
RTPS_DllAPI const TypeIdentifier & member_type_id() const
Definition: TypeObject.h:75
RTPS_DllAPI const MemberId & member_id() const
Definition: TypeObject.h:735
RTPS_DllAPI bool operator==(const CommonUnionMember &other) const
RTPS_DllAPI CommonUnionMember & operator=(const CommonUnionMember &x)
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:747
RTPS_DllAPI MemberId & member_id()
Definition: TypeObject.h:736
RTPS_DllAPI UnionCaseLabelSeq & label_seq()
Definition: TypeObject.h:757
RTPS_DllAPI void member_flags(UnionMemberFlag &&_member_flags)
Definition: TypeObject.h:740
RTPS_DllAPI void member_flags(const UnionMemberFlag &_member_flags)
Definition: TypeObject.h:738
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const CommonUnionMember &data, size_t current_alignment=0)
RTPS_DllAPI void member_id(MemberId &&_member_id)
Definition: TypeObject.h:733
RTPS_DllAPI void label_seq(const UnionCaseLabelSeq &_label_seq)
Definition: TypeObject.h:752
RTPS_DllAPI const UnionCaseLabelSeq & label_seq() const
Definition: TypeObject.h:756
RTPS_DllAPI bool consistent(const CommonUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonUnionMember(const CommonUnionMember &x)
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:750
RTPS_DllAPI CommonUnionMember(CommonUnionMember &&x)
RTPS_DllAPI const UnionMemberFlag & member_flags() const
Definition: TypeObject.h:742
RTPS_DllAPI void member_id(const MemberId &_member_id)
Definition: TypeObject.h:731
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:745
RTPS_DllAPI void label_seq(UnionCaseLabelSeq &&_label_seq)
Definition: TypeObject.h:754
RTPS_DllAPI CommonUnionMember & operator=(CommonUnionMember &&x)
RTPS_DllAPI UnionMemberFlag & member_flags()
Definition: TypeObject.h:743
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:749
RTPS_DllAPI CommonAliasBody & common()
Definition: TypeObject.h:1768
RTPS_DllAPI bool operator==(const CompleteAliasBody &other) const
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:1782
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteAliasBody(const CompleteAliasBody &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteAliasBody(CompleteAliasBody &&x)
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition: TypeObject.h:1763
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:1781
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:1774
RTPS_DllAPI CompleteAliasBody & operator=(CompleteAliasBody &&x)
RTPS_DllAPI CompleteAliasBody & operator=(const CompleteAliasBody &x)
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition: TypeObject.h:1765
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:1775
RTPS_DllAPI const CommonAliasBody & common() const
Definition: TypeObject.h:1767
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAliasBody &data, size_t current_alignment=0)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:1779
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:1777
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:1770
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:1772
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:1872
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:1869
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteAliasHeader(CompleteAliasHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:1867
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteAliasHeader &other) const
RTPS_DllAPI CompleteAliasHeader(const CompleteAliasHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAliasHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteAliasHeader & operator=(const CompleteAliasHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:1871
RTPS_DllAPI CompleteAliasHeader & operator=(CompleteAliasHeader &&x)
RTPS_DllAPI CompleteAliasType & operator=(CompleteAliasType &&x)
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition: TypeObject.h:1949
RTPS_DllAPI void header(CompleteAliasHeader &&_header)
Definition: TypeObject.h:1958
RTPS_DllAPI void body(CompleteAliasBody &&_body)
Definition: TypeObject.h:1965
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition: TypeObject.h:1951
RTPS_DllAPI CompleteAliasType & operator=(const CompleteAliasType &x)
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition: TypeObject.h:1953
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void body(const CompleteAliasBody &_body)
Definition: TypeObject.h:1963
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition: TypeObject.h:1954
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAliasType &data, size_t current_alignment=0)
RTPS_DllAPI const CompleteAliasHeader & header() const
Definition: TypeObject.h:1960
RTPS_DllAPI const CompleteAliasBody & body() const
Definition: TypeObject.h:1967
RTPS_DllAPI bool operator==(const CompleteAliasType &other) const
RTPS_DllAPI void header(const CompleteAliasHeader &_header)
Definition: TypeObject.h:1956
RTPS_DllAPI CompleteAliasHeader & header()
Definition: TypeObject.h:1961
RTPS_DllAPI CompleteAliasType(CompleteAliasType &&x)
RTPS_DllAPI CompleteAliasBody & body()
Definition: TypeObject.h:1968
RTPS_DllAPI CompleteAliasType(const CompleteAliasType &x)
RTPS_DllAPI CompleteAnnotationHeader & operator=(CompleteAnnotationHeader &&x)
RTPS_DllAPI void annotation_name(const QualifiedTypeName &_annotation_name)
Definition: TypeObject.h:1500
RTPS_DllAPI void annotation_name(QualifiedTypeName &&_annotation_name)
Definition: TypeObject.h:1502
RTPS_DllAPI bool consistent(const CompleteAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationHeader(CompleteAnnotationHeader &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteAnnotationHeader &other) const
RTPS_DllAPI QualifiedTypeName & annotation_name()
Definition: TypeObject.h:1505
RTPS_DllAPI const QualifiedTypeName & annotation_name() const
Definition: TypeObject.h:1504
RTPS_DllAPI CompleteAnnotationHeader & operator=(const CompleteAnnotationHeader &x)
RTPS_DllAPI CompleteAnnotationHeader(const CompleteAnnotationHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAnnotationHeader &data, size_t current_alignment=0)
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:1384
RTPS_DllAPI CompleteAnnotationParameter & operator=(const CompleteAnnotationParameter &x)
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition: TypeObject.h:1392
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition: TypeObject.h:1377
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition: TypeObject.h:1391
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition: TypeObject.h:1373
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition: TypeObject.h:1387
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:1380
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition: TypeObject.h:1375
RTPS_DllAPI CompleteAnnotationParameter(CompleteAnnotationParameter &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:1385
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:1382
RTPS_DllAPI bool consistent(const CompleteAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationParameter & operator=(CompleteAnnotationParameter &&x)
RTPS_DllAPI CompleteAnnotationParameter(const CompleteAnnotationParameter &x)
RTPS_DllAPI CommonAnnotationParameter & common()
Definition: TypeObject.h:1378
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAnnotationParameter &data, size_t current_alignment=0)
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition: TypeObject.h:1389
RTPS_DllAPI bool operator==(const CompleteAnnotationParameter &other) const
RTPS_DllAPI CompleteAnnotationType & operator=(CompleteAnnotationType &&x)
RTPS_DllAPI void member_seq(CompleteAnnotationParameterSeq &&_member_seq)
Definition: TypeObject.h:1600
RTPS_DllAPI const CompleteAnnotationHeader & header() const
Definition: TypeObject.h:1595
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition: TypeObject.h:1584
RTPS_DllAPI void header(CompleteAnnotationHeader &&_header)
Definition: TypeObject.h:1593
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition: TypeObject.h:1586
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool operator==(const CompleteAnnotationType &other) const
RTPS_DllAPI bool consistent(const CompleteAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteAnnotationType & operator=(const CompleteAnnotationType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteAnnotationType(const CompleteAnnotationType &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteAnnotationType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteAnnotationType(CompleteAnnotationType &&x)
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition: TypeObject.h:1588
RTPS_DllAPI void member_seq(const CompleteAnnotationParameterSeq &_member_seq)
Definition: TypeObject.h:1598
RTPS_DllAPI CompleteAnnotationHeader & header()
Definition: TypeObject.h:1596
RTPS_DllAPI CompleteAnnotationParameterSeq & member_seq()
Definition: TypeObject.h:1603
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition: TypeObject.h:1589
RTPS_DllAPI const CompleteAnnotationParameterSeq & member_seq() const
Definition: TypeObject.h:1602
RTPS_DllAPI void header(const CompleteAnnotationHeader &_header)
Definition: TypeObject.h:1591
RTPS_DllAPI bool consistent(const CompleteArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteArrayHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteArrayHeader & operator=(CompleteArrayHeader &&x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:2607
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition: TypeObject.h:2597
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:2604
RTPS_DllAPI CompleteArrayHeader & operator=(const CompleteArrayHeader &x)
RTPS_DllAPI const CommonArrayHeader & common() const
Definition: TypeObject.h:2599
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteArrayHeader(CompleteArrayHeader &&x)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:2602
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteArrayHeader &other) const
RTPS_DllAPI void common(const CommonArrayHeader &_common)
Definition: TypeObject.h:2595
RTPS_DllAPI CompleteArrayHeader(const CompleteArrayHeader &x)
RTPS_DllAPI CommonArrayHeader & common()
Definition: TypeObject.h:2600
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:2606
RTPS_DllAPI CompleteArrayType & operator=(CompleteArrayType &&x)
RTPS_DllAPI void header(const CompleteArrayHeader &_header)
Definition: TypeObject.h:2702
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:2713
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:2709
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:2711
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteArrayType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:2714
RTPS_DllAPI CompleteArrayHeader & header()
Definition: TypeObject.h:2707
RTPS_DllAPI void header(CompleteArrayHeader &&_header)
Definition: TypeObject.h:2704
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2695
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteArrayType(CompleteArrayType &&x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2699
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteArrayType &other) const
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2700
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2697
RTPS_DllAPI bool consistent(const CompleteArrayType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteArrayType(const CompleteArrayType &x)
RTPS_DllAPI const CompleteArrayHeader & header() const
Definition: TypeObject.h:2706
RTPS_DllAPI CompleteArrayType & operator=(const CompleteArrayType &x)
Definition: TypeObject.h:3811
RTPS_DllAPI CompleteBitfield & operator=(const CompleteBitfield &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonBitfield & common()
Definition: TypeObject.h:3830
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitfield &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition: TypeObject.h:3825
RTPS_DllAPI CompleteBitfield(CompleteBitfield &&x)
RTPS_DllAPI const CommonBitfield & common() const
Definition: TypeObject.h:3829
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:3837
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition: TypeObject.h:3827
RTPS_DllAPI bool consistent(const CompleteBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteBitfield & operator=(CompleteBitfield &&x)
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:3836
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:3832
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:3834
RTPS_DllAPI bool operator==(const CompleteBitfield &other) const
RTPS_DllAPI CompleteBitfield(const CompleteBitfield &x)
Definition: TypeObject.h:3453
RTPS_DllAPI CompleteBitflag(CompleteBitflag &&x)
RTPS_DllAPI CompleteBitflag & operator=(const CompleteBitflag &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition: TypeObject.h:3469
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:3479
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CommonBitflag & common() const
Definition: TypeObject.h:3471
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:3478
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:3474
RTPS_DllAPI CompleteBitflag & operator=(CompleteBitflag &&x)
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:3476
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition: TypeObject.h:3467
RTPS_DllAPI bool operator==(const CompleteBitflag &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitflag &data, size_t current_alignment=0)
RTPS_DllAPI CommonBitflag & common()
Definition: TypeObject.h:3472
RTPS_DllAPI CompleteBitflag(const CompleteBitflag &x)
RTPS_DllAPI CompleteBitmaskType(const CompleteBitmaskType &x)
RTPS_DllAPI CompleteBitmaskType & operator=(CompleteBitmaskType &&x)
RTPS_DllAPI void header(const CompleteBitmaskHeader &_header)
Definition: TypeObject.h:3634
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitmaskType &data, size_t current_alignment=0)
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition: TypeObject.h:3629
RTPS_DllAPI const CompleteBitmaskHeader & header() const
Definition: TypeObject.h:3638
RTPS_DllAPI void flag_seq(const CompleteBitflagSeq &_flag_seq)
Definition: TypeObject.h:3641
RTPS_DllAPI bool operator==(const CompleteBitmaskType &other) const
RTPS_DllAPI CompleteBitmaskHeader & header()
Definition: TypeObject.h:3639
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void flag_seq(CompleteBitflagSeq &&_flag_seq)
Definition: TypeObject.h:3643
RTPS_DllAPI CompleteBitmaskType & operator=(const CompleteBitmaskType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void header(CompleteBitmaskHeader &&_header)
Definition: TypeObject.h:3636
RTPS_DllAPI CompleteBitmaskType(CompleteBitmaskType &&x)
RTPS_DllAPI const CompleteBitflagSeq & flag_seq() const
Definition: TypeObject.h:3645
RTPS_DllAPI bool consistent(const CompleteBitmaskType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
Definition: TypeObject.h:3627
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition: TypeObject.h:3632
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition: TypeObject.h:3631
RTPS_DllAPI CompleteBitflagSeq & flag_seq()
Definition: TypeObject.h:3646
RTPS_DllAPI CompleteBitsetHeader & operator=(CompleteBitsetHeader &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitsetHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:3946
RTPS_DllAPI bool operator==(const CompleteBitsetHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:3943
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:3939
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const CompleteBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:3941
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:3938
RTPS_DllAPI CompleteBitsetHeader(const CompleteBitsetHeader &x)
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:3934
RTPS_DllAPI CompleteBitsetHeader & operator=(const CompleteBitsetHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:3945
RTPS_DllAPI CompleteBitsetHeader(CompleteBitsetHeader &&x)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:3936
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition: TypeObject.h:4035
RTPS_DllAPI void header(const CompleteBitsetHeader &_header)
Definition: TypeObject.h:4040
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition: TypeObject.h:4038
RTPS_DllAPI const CompleteBitfieldSeq & field_seq() const
Definition: TypeObject.h:4051
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteBitsetType &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const CompleteBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void header(CompleteBitsetHeader &&_header)
Definition: TypeObject.h:4042
RTPS_DllAPI CompleteBitsetType(const CompleteBitsetType &x)
RTPS_DllAPI CompleteBitsetHeader & header()
Definition: TypeObject.h:4045
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteBitsetType &other) const
RTPS_DllAPI CompleteBitsetType & operator=(const CompleteBitsetType &x)
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition: TypeObject.h:4033
RTPS_DllAPI void field_seq(CompleteBitfieldSeq &&_field_seq)
Definition: TypeObject.h:4049
RTPS_DllAPI const CompleteBitsetHeader & header() const
Definition: TypeObject.h:4044
RTPS_DllAPI CompleteBitsetType & operator=(CompleteBitsetType &&x)
RTPS_DllAPI CompleteBitfieldSeq & field_seq()
Definition: TypeObject.h:4052
RTPS_DllAPI CompleteBitsetType(CompleteBitsetType &&x)
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition: TypeObject.h:4037
RTPS_DllAPI void field_seq(const CompleteBitfieldSeq &_field_seq)
Definition: TypeObject.h:4047
RTPS_DllAPI CommonCollectionElement & common()
Definition: TypeObject.h:2184
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteCollectionElement &data, size_t current_alignment=0)
RTPS_DllAPI CompleteCollectionElement & operator=(CompleteCollectionElement &&x)
RTPS_DllAPI const CommonCollectionElement & common() const
Definition: TypeObject.h:2183
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition: TypeObject.h:2179
RTPS_DllAPI void detail(CompleteElementDetail &&_detail)
Definition: TypeObject.h:2188
RTPS_DllAPI CompleteCollectionElement(const CompleteCollectionElement &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteCollectionElement & operator=(const CompleteCollectionElement &x)
RTPS_DllAPI const CompleteElementDetail & detail() const
Definition: TypeObject.h:2190
RTPS_DllAPI CompleteCollectionElement(CompleteCollectionElement &&x)
RTPS_DllAPI void detail(const CompleteElementDetail &_detail)
Definition: TypeObject.h:2186
RTPS_DllAPI bool consistent(const CompleteCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition: TypeObject.h:2181
RTPS_DllAPI CompleteElementDetail & detail()
Definition: TypeObject.h:2191
RTPS_DllAPI bool operator==(const CompleteCollectionElement &other) const
RTPS_DllAPI CompleteCollectionHeader(const CompleteCollectionHeader &x)
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition: TypeObject.h:2327
RTPS_DllAPI CompleteCollectionHeader & operator=(CompleteCollectionHeader &&x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:2335
RTPS_DllAPI bool consistent(const CompleteCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:2332
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition: TypeObject.h:2323
RTPS_DllAPI CompleteCollectionHeader & operator=(const CompleteCollectionHeader &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:2330
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CommonCollectionHeader & common()
Definition: TypeObject.h:2328
RTPS_DllAPI CompleteCollectionHeader(CompleteCollectionHeader &&x)
RTPS_DllAPI bool operator==(const CompleteCollectionHeader &other) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:2334
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition: TypeObject.h:2325
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteCollectionHeader &data, size_t current_alignment=0)
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition: TypeObject.h:975
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:992
RTPS_DllAPI CompleteDiscriminatorMember & operator=(const CompleteDiscriminatorMember &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition: TypeObject.h:978
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition: TypeObject.h:984
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition: TypeObject.h:980
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition: TypeObject.h:985
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:991
RTPS_DllAPI bool consistent(const CompleteDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition: TypeObject.h:982
RTPS_DllAPI CompleteDiscriminatorMember(CompleteDiscriminatorMember &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteDiscriminatorMember &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition: TypeObject.h:973
RTPS_DllAPI bool operator==(const CompleteDiscriminatorMember &other) const
RTPS_DllAPI CompleteDiscriminatorMember(const CompleteDiscriminatorMember &x)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:989
RTPS_DllAPI CompleteDiscriminatorMember & operator=(CompleteDiscriminatorMember &&x)
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition: TypeObject.h:977
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:987
RTPS_DllAPI CompleteElementDetail(const CompleteElementDetail &x)
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:2084
RTPS_DllAPI bool operator==(const CompleteElementDetail &other) const
RTPS_DllAPI CompleteElementDetail & operator=(CompleteElementDetail &&x)
RTPS_DllAPI CompleteElementDetail(CompleteElementDetail &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:2083
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:2076
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:2077
RTPS_DllAPI bool consistent(const CompleteElementDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteElementDetail & operator=(const CompleteElementDetail &x)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:2081
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteElementDetail &data, size_t current_alignment=0)
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:2079
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:2072
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:2074
RTPS_DllAPI CompleteEnumeratedHeader(CompleteEnumeratedHeader &&x)
RTPS_DllAPI bool consistent(const CompleteEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteEnumeratedHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteEnumeratedHeader & operator=(const CompleteEnumeratedHeader &x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:3197
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:3194
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:3192
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const CompleteEnumeratedHeader &other) const
RTPS_DllAPI CompleteEnumeratedHeader(const CompleteEnumeratedHeader &x)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition: TypeObject.h:3190
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:3196
RTPS_DllAPI CompleteEnumeratedHeader & operator=(CompleteEnumeratedHeader &&x)
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition: TypeObject.h:3185
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition: TypeObject.h:3187
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition: TypeObject.h:3189
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition: TypeObject.h:3027
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteEnumeratedLiteral &data, size_t current_alignment=0)
RTPS_DllAPI CompleteEnumeratedLiteral & operator=(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const CompleteEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteEnumeratedLiteral & operator=(CompleteEnumeratedLiteral &&x)
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:3037
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteEnumeratedLiteral(CompleteEnumeratedLiteral &&x)
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition: TypeObject.h:3029
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:3036
RTPS_DllAPI CompleteEnumeratedLiteral(const CompleteEnumeratedLiteral &x)
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:3032
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:3034
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition: TypeObject.h:3025
RTPS_DllAPI bool operator==(const CompleteEnumeratedLiteral &other) const
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition: TypeObject.h:3030
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition: TypeObject.h:3291
RTPS_DllAPI bool consistent(const CompleteEnumeratedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition: TypeObject.h:3290
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteEnumeratedType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteEnumeratedType(const CompleteEnumeratedType &x)
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition: TypeObject.h:3286
RTPS_DllAPI CompleteEnumeratedHeader & header()
Definition: TypeObject.h:3298
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition: TypeObject.h:3288
RTPS_DllAPI CompleteEnumeratedType(CompleteEnumeratedType &&x)
RTPS_DllAPI CompleteEnumeratedType & operator=(const CompleteEnumeratedType &x)
RTPS_DllAPI CompleteEnumeratedLiteralSeq & literal_seq()
Definition: TypeObject.h:3305
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CompleteEnumeratedLiteralSeq & literal_seq() const
Definition: TypeObject.h:3304
RTPS_DllAPI CompleteEnumeratedType & operator=(CompleteEnumeratedType &&x)
RTPS_DllAPI void literal_seq(CompleteEnumeratedLiteralSeq &&_literal_seq)
Definition: TypeObject.h:3302
RTPS_DllAPI void header(CompleteEnumeratedHeader &&_header)
Definition: TypeObject.h:3295
RTPS_DllAPI bool operator==(const CompleteEnumeratedType &other) const
RTPS_DllAPI void literal_seq(const CompleteEnumeratedLiteralSeq &_literal_seq)
Definition: TypeObject.h:3300
RTPS_DllAPI void header(const CompleteEnumeratedHeader &_header)
Definition: TypeObject.h:3293
RTPS_DllAPI const CompleteEnumeratedHeader & header() const
Definition: TypeObject.h:3297
RTPS_DllAPI CompleteExtendedType & operator=(const CompleteExtendedType &x)
RTPS_DllAPI CompleteExtendedType(const CompleteExtendedType &x)
RTPS_DllAPI bool consistent(const CompleteExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteExtendedType(CompleteExtendedType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteExtendedType &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const CompleteExtendedType &) const
Definition: TypeObject.h:4169
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteExtendedType & operator=(CompleteExtendedType &&x)
Definition: TypeObject.h:2809
RTPS_DllAPI bool consistent(const CompleteMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const CompleteMapType &other) const
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition: TypeObject.h:2834
RTPS_DllAPI CompleteMapType & operator=(CompleteMapType &&x)
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:2848
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:2844
RTPS_DllAPI void key(const CompleteCollectionElement &_key)
Definition: TypeObject.h:2837
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition: TypeObject.h:2830
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:2846
RTPS_DllAPI CompleteCollectionElement & key()
Definition: TypeObject.h:2842
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:2849
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2823
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition: TypeObject.h:2832
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteMapType &data, size_t current_alignment=0)
RTPS_DllAPI void key(CompleteCollectionElement &&_key)
Definition: TypeObject.h:2839
RTPS_DllAPI CompleteMapType & operator=(const CompleteMapType &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2827
RTPS_DllAPI CompleteCollectionHeader & header()
Definition: TypeObject.h:2835
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2828
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2825
RTPS_DllAPI CompleteMapType(const CompleteMapType &x)
RTPS_DllAPI CompleteMapType(CompleteMapType &&x)
RTPS_DllAPI const CompleteCollectionElement & key() const
Definition: TypeObject.h:2841
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:125
RTPS_DllAPI bool consistent(const CompleteMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:140
RTPS_DllAPI bool operator==(const CompleteMemberDetail &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteMemberDetail &data, size_t current_alignment=0)
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:121
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteMemberDetail(const CompleteMemberDetail &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:126
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:123
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:139
RTPS_DllAPI const AppliedBuiltinMemberAnnotations & ann_builtin() const
Definition: TypeObject.h:132
RTPS_DllAPI AppliedBuiltinMemberAnnotations & ann_builtin()
Definition: TypeObject.h:133
RTPS_DllAPI CompleteMemberDetail & operator=(const CompleteMemberDetail &x)
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:137
RTPS_DllAPI CompleteMemberDetail & operator=(CompleteMemberDetail &&x)
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:135
RTPS_DllAPI CompleteMemberDetail(CompleteMemberDetail &&x)
RTPS_DllAPI void ann_builtin(const AppliedBuiltinMemberAnnotations &_ann_builtin)
Definition: TypeObject.h:128
RTPS_DllAPI void ann_builtin(AppliedBuiltinMemberAnnotations &&_ann_builtin)
Definition: TypeObject.h:130
RTPS_DllAPI const CompleteCollectionHeader & header() const
Definition: TypeObject.h:2435
RTPS_DllAPI const CompleteCollectionElement & element() const
Definition: TypeObject.h:2442
RTPS_DllAPI void element(const CompleteCollectionElement &_element)
Definition: TypeObject.h:2438
RTPS_DllAPI CompleteSequenceType & operator=(CompleteSequenceType &&x)
RTPS_DllAPI void header(const CompleteCollectionHeader &_header)
Definition: TypeObject.h:2431
RTPS_DllAPI void element(CompleteCollectionElement &&_element)
Definition: TypeObject.h:2440
RTPS_DllAPI CompleteCollectionElement & element()
Definition: TypeObject.h:2443
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2424
RTPS_DllAPI void header(CompleteCollectionHeader &&_header)
Definition: TypeObject.h:2433
RTPS_DllAPI bool consistent(const CompleteSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2428
RTPS_DllAPI CompleteSequenceType(const CompleteSequenceType &x)
RTPS_DllAPI CompleteCollectionHeader & header()
Definition: TypeObject.h:2436
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteSequenceType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteSequenceType & operator=(const CompleteSequenceType &x)
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2429
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2426
RTPS_DllAPI bool operator==(const CompleteSequenceType &other) const
RTPS_DllAPI CompleteSequenceType(CompleteSequenceType &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteStructHeader &data, size_t current_alignment=0)
RTPS_DllAPI CompleteStructHeader & operator=(CompleteStructHeader &&x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:502
RTPS_DllAPI bool operator==(const CompleteStructHeader &other) const
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:499
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:495
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:497
RTPS_DllAPI CompleteStructHeader(const CompleteStructHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:494
RTPS_DllAPI bool consistent(const CompleteStructHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:490
RTPS_DllAPI CompleteStructHeader(CompleteStructHeader &&x)
RTPS_DllAPI CompleteStructHeader & operator=(const CompleteStructHeader &x)
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:501
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:492
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteStructMember &data, size_t current_alignment=0)
RTPS_DllAPI CommonStructMember & common()
Definition: TypeObject.h:236
RTPS_DllAPI CompleteStructMember(CompleteStructMember &&x)
RTPS_DllAPI bool operator==(const CompleteStructMember &other) const
RTPS_DllAPI CompleteStructMember & operator=(CompleteStructMember &&x)
RTPS_DllAPI CompleteStructMember & operator=(const CompleteStructMember &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteStructMember(const CompleteStructMember &x)
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:243
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition: TypeObject.h:231
RTPS_DllAPI const CommonStructMember & common() const
Definition: TypeObject.h:235
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:242
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:238
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:240
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition: TypeObject.h:233
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition: TypeObject.h:600
RTPS_DllAPI void header(const CompleteStructHeader &_header)
Definition: TypeObject.h:605
RTPS_DllAPI CompleteStructType(CompleteStructType &&x)
RTPS_DllAPI const CompleteStructHeader & header() const
Definition: TypeObject.h:609
RTPS_DllAPI CompleteStructType & operator=(CompleteStructType &&x)
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition: TypeObject.h:603
RTPS_DllAPI CompleteStructType(const CompleteStructType &x)
RTPS_DllAPI const CompleteStructMemberSeq & member_seq() const
Definition: TypeObject.h:616
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition: TypeObject.h:598
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition: TypeObject.h:602
RTPS_DllAPI CompleteStructHeader & header()
Definition: TypeObject.h:610
RTPS_DllAPI CompleteStructMemberSeq & member_seq()
Definition: TypeObject.h:617
RTPS_DllAPI CompleteStructType & operator=(const CompleteStructType &x)
RTPS_DllAPI void member_seq(const CompleteStructMemberSeq &_member_seq)
Definition: TypeObject.h:612
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const CompleteStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(CompleteStructHeader &&_header)
Definition: TypeObject.h:607
RTPS_DllAPI void member_seq(CompleteStructMemberSeq &&_member_seq)
Definition: TypeObject.h:614
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteStructType &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const CompleteStructType &other) const
RTPS_DllAPI CompleteTypeDetail(const CompleteTypeDetail &x)
RTPS_DllAPI CompleteTypeDetail & operator=(CompleteTypeDetail &&x)
RTPS_DllAPI AppliedAnnotationSeq & ann_custom()
Definition: TypeObject.h:441
RTPS_DllAPI CompleteTypeDetail(CompleteTypeDetail &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI QualifiedTypeName & type_name()
Definition: TypeObject.h:448
RTPS_DllAPI const AppliedBuiltinTypeAnnotations & ann_builtin() const
Definition: TypeObject.h:433
RTPS_DllAPI void ann_builtin(const AppliedBuiltinTypeAnnotations &_ann_builtin)
Definition: TypeObject.h:429
RTPS_DllAPI AppliedBuiltinTypeAnnotations & ann_builtin()
Definition: TypeObject.h:434
RTPS_DllAPI bool consistent(const CompleteTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const AppliedAnnotationSeq & ann_custom() const
Definition: TypeObject.h:440
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteTypeDetail &data, size_t current_alignment=0)
RTPS_DllAPI const QualifiedTypeName & type_name() const
Definition: TypeObject.h:447
RTPS_DllAPI void ann_builtin(AppliedBuiltinTypeAnnotations &&_ann_builtin)
Definition: TypeObject.h:431
RTPS_DllAPI CompleteTypeDetail & operator=(const CompleteTypeDetail &x)
RTPS_DllAPI void type_name(const QualifiedTypeName &_type_name)
Definition: TypeObject.h:443
RTPS_DllAPI void ann_custom(AppliedAnnotationSeq &&_ann_custom)
Definition: TypeObject.h:438
RTPS_DllAPI bool operator==(const CompleteTypeDetail &other) const
RTPS_DllAPI void ann_custom(const AppliedAnnotationSeq &_ann_custom)
Definition: TypeObject.h:436
RTPS_DllAPI void type_name(QualifiedTypeName &&_type_name)
Definition: TypeObject.h:445
RTPS_DllAPI CompleteEnumeratedType & enumerated_type()
RTPS_DllAPI CompleteBitsetType & bitset_type()
RTPS_DllAPI const CompleteAnnotationType & annotation_type() const
RTPS_DllAPI void annotation_type(CompleteAnnotationType _annotation_type)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteTypeObject &data, size_t current_alignment=0)
RTPS_DllAPI void union_type(CompleteUnionType _union_type)
RTPS_DllAPI CompleteUnionType & union_type()
RTPS_DllAPI CompleteAliasType & alias_type()
RTPS_DllAPI const CompleteStructType & struct_type() const
RTPS_DllAPI void struct_type(CompleteStructType _struct_type)
RTPS_DllAPI const CompleteAliasType & alias_type() const
RTPS_DllAPI const CompleteUnionType & union_type() const
RTPS_DllAPI bool consistent(const CompleteTypeObject &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void array_type(CompleteArrayType _array_type)
RTPS_DllAPI CompleteMapType & map_type()
RTPS_DllAPI void alias_type(CompleteAliasType _alias_type)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const CompleteEnumeratedType & enumerated_type() const
RTPS_DllAPI const CompleteSequenceType & sequence_type() const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteAnnotationType & annotation_type()
RTPS_DllAPI const CompleteBitsetType & bitset_type() const
RTPS_DllAPI const CompleteBitmaskType & bitmask_type() const
RTPS_DllAPI bool operator==(const CompleteTypeObject &other) const
RTPS_DllAPI void map_type(CompleteMapType _map_type)
RTPS_DllAPI void enumerated_type(CompleteEnumeratedType _enumerated_type)
RTPS_DllAPI const CompleteArrayType & array_type() const
RTPS_DllAPI CompleteArrayType & array_type()
RTPS_DllAPI void bitset_type(CompleteBitsetType _bitset_type)
RTPS_DllAPI const CompleteMapType & map_type() const
RTPS_DllAPI void bitmask_type(CompleteBitmaskType _bitmask_type)
RTPS_DllAPI void sequence_type(CompleteSequenceType _sequence_type)
RTPS_DllAPI CompleteTypeObject(CompleteTypeObject &&x)
RTPS_DllAPI CompleteBitmaskType & bitmask_type()
RTPS_DllAPI CompleteTypeObject & operator=(CompleteTypeObject &&x)
RTPS_DllAPI CompleteSequenceType & sequence_type()
RTPS_DllAPI CompleteTypeObject & operator=(const CompleteTypeObject &x)
RTPS_DllAPI const CompleteExtendedType & extended_type() const
RTPS_DllAPI void extended_type(CompleteExtendedType _extended_type)
RTPS_DllAPI CompleteStructType & struct_type()
RTPS_DllAPI CompleteExtendedType & extended_type()
RTPS_DllAPI CompleteTypeObject(const CompleteTypeObject &x)
RTPS_DllAPI bool operator==(const CompleteUnionHeader &other) const
RTPS_DllAPI CompleteUnionHeader(CompleteUnionHeader &&x)
RTPS_DllAPI CompleteTypeDetail & detail()
Definition: TypeObject.h:1085
RTPS_DllAPI CompleteUnionHeader(const CompleteUnionHeader &x)
RTPS_DllAPI void detail(CompleteTypeDetail &&_detail)
Definition: TypeObject.h:1082
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void detail(const CompleteTypeDetail &_detail)
Definition: TypeObject.h:1080
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteUnionHeader & operator=(CompleteUnionHeader &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteUnionHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const CompleteUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteTypeDetail & detail() const
Definition: TypeObject.h:1084
RTPS_DllAPI CompleteUnionHeader & operator=(const CompleteUnionHeader &x)
RTPS_DllAPI CompleteUnionMember(const CompleteUnionMember &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteUnionMember &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition: TypeObject.h:802
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition: TypeObject.h:804
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonUnionMember & common()
Definition: TypeObject.h:807
RTPS_DllAPI bool consistent(const CompleteUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CompleteMemberDetail & detail()
Definition: TypeObject.h:814
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteUnionMember & operator=(CompleteUnionMember &&x)
RTPS_DllAPI const CompleteMemberDetail & detail() const
Definition: TypeObject.h:813
RTPS_DllAPI const CommonUnionMember & common() const
Definition: TypeObject.h:806
RTPS_DllAPI void detail(const CompleteMemberDetail &_detail)
Definition: TypeObject.h:809
RTPS_DllAPI CompleteUnionMember(CompleteUnionMember &&x)
RTPS_DllAPI CompleteUnionMember & operator=(const CompleteUnionMember &x)
RTPS_DllAPI void detail(CompleteMemberDetail &&_detail)
Definition: TypeObject.h:811
RTPS_DllAPI bool operator==(const CompleteUnionMember &other) const
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition: TypeObject.h:1177
RTPS_DllAPI void discriminator(const CompleteDiscriminatorMember &_discriminator)
Definition: TypeObject.h:1187
RTPS_DllAPI const CompleteUnionMemberSeq & member_seq() const
Definition: TypeObject.h:1198
RTPS_DllAPI const CompleteUnionHeader & header() const
Definition: TypeObject.h:1184
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition: TypeObject.h:1178
RTPS_DllAPI bool consistent(const CompleteUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CompleteDiscriminatorMember & discriminator() const
Definition: TypeObject.h:1191
RTPS_DllAPI CompleteUnionMemberSeq & member_seq()
Definition: TypeObject.h:1199
RTPS_DllAPI CompleteUnionHeader & header()
Definition: TypeObject.h:1185
RTPS_DllAPI void member_seq(CompleteUnionMemberSeq &&_member_seq)
Definition: TypeObject.h:1196
RTPS_DllAPI CompleteUnionType & operator=(const CompleteUnionType &x)
RTPS_DllAPI bool operator==(const CompleteUnionType &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CompleteUnionType(const CompleteUnionType &x)
RTPS_DllAPI void header(const CompleteUnionHeader &_header)
Definition: TypeObject.h:1180
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI CompleteUnionType & operator=(CompleteUnionType &&x)
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition: TypeObject.h:1173
RTPS_DllAPI void member_seq(const CompleteUnionMemberSeq &_member_seq)
Definition: TypeObject.h:1194
static RTPS_DllAPI size_t getCdrSerializedSize(const CompleteUnionType &data, size_t current_alignment=0)
RTPS_DllAPI CompleteUnionType(CompleteUnionType &&x)
RTPS_DllAPI CompleteDiscriminatorMember & discriminator()
Definition: TypeObject.h:1192
RTPS_DllAPI void discriminator(CompleteDiscriminatorMember &&_discriminator)
Definition: TypeObject.h:1189
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition: TypeObject.h:1175
RTPS_DllAPI void header(CompleteUnionHeader &&_header)
Definition: TypeObject.h:1182
Definition: TypesBase.h:323
Definition: TypeObject.h:1809
RTPS_DllAPI bool operator==(const MinimalAliasBody &other) const
RTPS_DllAPI CommonAliasBody & common()
Definition: TypeObject.h:1828
RTPS_DllAPI MinimalAliasBody(const MinimalAliasBody &x)
RTPS_DllAPI MinimalAliasBody & operator=(MinimalAliasBody &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(const CommonAliasBody &_common)
Definition: TypeObject.h:1823
RTPS_DllAPI MinimalAliasBody(MinimalAliasBody &&x)
RTPS_DllAPI void common(CommonAliasBody &&_common)
Definition: TypeObject.h:1825
RTPS_DllAPI const CommonAliasBody & common() const
Definition: TypeObject.h:1827
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAliasBody &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAliasBody & operator=(const MinimalAliasBody &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalAliasHeader(MinimalAliasHeader &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalAliasHeader &) const
Definition: TypeObject.h:1919
RTPS_DllAPI MinimalAliasHeader & operator=(const MinimalAliasHeader &x)
RTPS_DllAPI MinimalAliasHeader(const MinimalAliasHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAliasHeader &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAliasHeader & operator=(MinimalAliasHeader &&x)
Definition: TypeObject.h:1996
RTPS_DllAPI void header(const MinimalAliasHeader &_header)
Definition: TypeObject.h:2017
RTPS_DllAPI bool operator==(const MinimalAliasType &other) const
RTPS_DllAPI void alias_flags(const AliasTypeFlag &_alias_flags)
Definition: TypeObject.h:2010
RTPS_DllAPI const MinimalAliasBody & body() const
Definition: TypeObject.h:2028
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAliasType &data, size_t current_alignment=0)
RTPS_DllAPI void alias_flags(AliasTypeFlag &&_alias_flags)
Definition: TypeObject.h:2012
RTPS_DllAPI MinimalAliasType(const MinimalAliasType &x)
RTPS_DllAPI MinimalAliasHeader & header()
Definition: TypeObject.h:2022
RTPS_DllAPI const AliasTypeFlag & alias_flags() const
Definition: TypeObject.h:2014
RTPS_DllAPI void body(const MinimalAliasBody &_body)
Definition: TypeObject.h:2024
RTPS_DllAPI MinimalAliasType & operator=(const MinimalAliasType &x)
RTPS_DllAPI void header(MinimalAliasHeader &&_header)
Definition: TypeObject.h:2019
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const MinimalAliasHeader & header() const
Definition: TypeObject.h:2021
RTPS_DllAPI AliasTypeFlag & alias_flags()
Definition: TypeObject.h:2015
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalAliasType & operator=(MinimalAliasType &&x)
RTPS_DllAPI MinimalAliasType(MinimalAliasType &&x)
RTPS_DllAPI MinimalAliasBody & body()
Definition: TypeObject.h:2029
RTPS_DllAPI void body(MinimalAliasBody &&_body)
Definition: TypeObject.h:2026
RTPS_DllAPI MinimalAnnotationHeader(MinimalAnnotationHeader &&x)
RTPS_DllAPI MinimalAnnotationHeader & operator=(const MinimalAnnotationHeader &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalAnnotationHeader & operator=(MinimalAnnotationHeader &&x)
RTPS_DllAPI MinimalAnnotationHeader(const MinimalAnnotationHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAnnotationHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalAnnotationHeader &) const
Definition: TypeObject.h:1553
RTPS_DllAPI bool consistent(const MinimalAnnotationHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MemberName & name() const
Definition: TypeObject.h:1448
RTPS_DllAPI AnnotationParameterValue & default_value()
Definition: TypeObject.h:1456
RTPS_DllAPI const CommonAnnotationParameter & common() const
Definition: TypeObject.h:1441
RTPS_DllAPI bool consistent(const MinimalAnnotationParameter &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const AnnotationParameterValue & default_value() const
Definition: TypeObject.h:1455
RTPS_DllAPI MinimalAnnotationParameter(const MinimalAnnotationParameter &x)
RTPS_DllAPI void common(const CommonAnnotationParameter &_common)
Definition: TypeObject.h:1437
RTPS_DllAPI void default_value(const AnnotationParameterValue &_default_value)
Definition: TypeObject.h:1451
RTPS_DllAPI void name(const MemberName &_name)
Definition: TypeObject.h:1444
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonAnnotationParameter &&_common)
Definition: TypeObject.h:1439
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MemberName & name()
Definition: TypeObject.h:1449
RTPS_DllAPI void name(MemberName &&_name)
Definition: TypeObject.h:1446
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAnnotationParameter &data, size_t current_alignment=0)
RTPS_DllAPI MinimalAnnotationParameter(MinimalAnnotationParameter &&x)
RTPS_DllAPI MinimalAnnotationParameter & operator=(MinimalAnnotationParameter &&x)
RTPS_DllAPI bool operator==(const MinimalAnnotationParameter &other) const
RTPS_DllAPI CommonAnnotationParameter & common()
Definition: TypeObject.h:1442
RTPS_DllAPI void default_value(AnnotationParameterValue &&_default_value)
Definition: TypeObject.h:1453
RTPS_DllAPI MinimalAnnotationParameter & operator=(const MinimalAnnotationParameter &x)
RTPS_DllAPI const MinimalAnnotationHeader & header() const
Definition: TypeObject.h:1657
RTPS_DllAPI MinimalAnnotationType(MinimalAnnotationType &&x)
RTPS_DllAPI MinimalAnnotationHeader & header()
Definition: TypeObject.h:1658
RTPS_DllAPI void header(const MinimalAnnotationHeader &_header)
Definition: TypeObject.h:1653
RTPS_DllAPI void member_seq(const MinimalAnnotationParameterSeq &_member_seq)
Definition: TypeObject.h:1660
RTPS_DllAPI MinimalAnnotationParameterSeq & member_seq()
Definition: TypeObject.h:1665
RTPS_DllAPI void annotation_flag(const AnnotationTypeFlag &_annotation_flag)
Definition: TypeObject.h:1646
RTPS_DllAPI void member_seq(MinimalAnnotationParameterSeq &&_member_seq)
Definition: TypeObject.h:1662
RTPS_DllAPI void annotation_flag(AnnotationTypeFlag &&_annotation_flag)
Definition: TypeObject.h:1648
RTPS_DllAPI void header(MinimalAnnotationHeader &&_header)
Definition: TypeObject.h:1655
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool consistent(const MinimalAnnotationType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalAnnotationType & operator=(MinimalAnnotationType &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const MinimalAnnotationParameterSeq & member_seq() const
Definition: TypeObject.h:1664
RTPS_DllAPI MinimalAnnotationType & operator=(const MinimalAnnotationType &x)
RTPS_DllAPI const AnnotationTypeFlag & annotation_flag() const
Definition: TypeObject.h:1650
RTPS_DllAPI MinimalAnnotationType(const MinimalAnnotationType &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalAnnotationType &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalAnnotationType &other) const
RTPS_DllAPI AnnotationTypeFlag & annotation_flag()
Definition: TypeObject.h:1651
RTPS_DllAPI MinimalArrayHeader(MinimalArrayHeader &&x)
RTPS_DllAPI void common(CommonArrayHeader &&_common)
Definition: TypeObject.h:2650
RTPS_DllAPI const CommonArrayHeader & common() const
Definition: TypeObject.h:2652
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalArrayHeader & operator=(MinimalArrayHeader &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool consistent(const MinimalArrayHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI bool operator==(const MinimalArrayHeader &other) const
RTPS_DllAPI void common(const CommonArrayHeader &_common)
Definition: TypeObject.h:2648
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalArrayHeader &data, size_t current_alignment=0)
RTPS_DllAPI CommonArrayHeader & common()
Definition: TypeObject.h:2653
RTPS_DllAPI MinimalArrayHeader & operator=(const MinimalArrayHeader &x)
RTPS_DllAPI MinimalArrayHeader(const MinimalArrayHeader &x)
Definition: TypeObject.h:2744
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalArrayType &data, size_t current_alignment=0)
RTPS_DllAPI MinimalArrayType & operator=(const MinimalArrayType &x)
RTPS_DllAPI void header(const MinimalArrayHeader &_header)
Definition: TypeObject.h:2765
RTPS_DllAPI bool consistent(const MinimalArrayType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2758
RTPS_DllAPI MinimalArrayType(MinimalArrayType &&x)
RTPS_DllAPI void header(MinimalArrayHeader &&_header)
Definition: TypeObject.h:2767
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:2776
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:2777
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2762
RTPS_DllAPI MinimalArrayType(const MinimalArrayType &x)
RTPS_DllAPI MinimalArrayType & operator=(MinimalArrayType &&x)
RTPS_DllAPI bool operator==(const MinimalArrayType &other) const
RTPS_DllAPI const MinimalArrayHeader & header() const
Definition: TypeObject.h:2769
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:2772
RTPS_DllAPI MinimalArrayHeader & header()
Definition: TypeObject.h:2770
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2763
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2760
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:2774
Definition: TypeObject.h:3866
RTPS_DllAPI MinimalBitfield & operator=(MinimalBitfield &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitfield &data, size_t current_alignment=0)
RTPS_DllAPI MinimalBitfield(MinimalBitfield &&x)
RTPS_DllAPI NameHash & name_hash()
Definition: TypeObject.h:3885
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI CommonBitfield & common()
Definition: TypeObject.h:3892
RTPS_DllAPI void common(const CommonBitfield &_common)
Definition: TypeObject.h:3887
RTPS_DllAPI const CommonBitfield & common() const
Definition: TypeObject.h:3891
RTPS_DllAPI MinimalBitfield & operator=(const MinimalBitfield &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const NameHash & name_hash() const
Definition: TypeObject.h:3884
RTPS_DllAPI void common(CommonBitfield &&_common)
Definition: TypeObject.h:3889
RTPS_DllAPI bool operator==(const MinimalBitfield &other) const
RTPS_DllAPI MinimalBitfield(const MinimalBitfield &x)
RTPS_DllAPI void name_hash(const NameHash &_name_hash)
Definition: TypeObject.h:3880
RTPS_DllAPI bool consistent(const MinimalBitfield &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition: TypeObject.h:3882
Definition: TypeObject.h:3508
RTPS_DllAPI MinimalBitflag(const MinimalBitflag &x)
RTPS_DllAPI MinimalBitflag & operator=(const MinimalBitflag &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(CommonBitflag &&_common)
Definition: TypeObject.h:3524
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:3534
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const CommonBitflag & common() const
Definition: TypeObject.h:3526
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:3531
RTPS_DllAPI bool operator==(const MinimalBitflag &other) const
RTPS_DllAPI bool consistent(const MinimalBitflag &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalBitflag & operator=(MinimalBitflag &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitflag &data, size_t current_alignment=0)
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:3533
RTPS_DllAPI void common(const CommonBitflag &_common)
Definition: TypeObject.h:3522
RTPS_DllAPI MinimalBitflag(MinimalBitflag &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:3529
RTPS_DllAPI CommonBitflag & common()
Definition: TypeObject.h:3527
RTPS_DllAPI MinimalBitmaskHeader & header()
Definition: TypeObject.h:3702
RTPS_DllAPI void bitmask_flags(BitmaskTypeFlag &&_bitmask_flags)
Definition: TypeObject.h:3692
RTPS_DllAPI const MinimalBitmaskHeader & header() const
Definition: TypeObject.h:3701
RTPS_DllAPI void flag_seq(MinimalBitflagSeq &&_flag_seq)
Definition: TypeObject.h:3706
RTPS_DllAPI MinimalBitmaskType(MinimalBitmaskType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void header(const MinimalBitmaskHeader &_header)
Definition: TypeObject.h:3697
RTPS_DllAPI bool operator==(const MinimalBitmaskType &other) const
RTPS_DllAPI bool consistent(const MinimalBitmaskType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalBitflagSeq & flag_seq()
Definition: TypeObject.h:3709
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalBitmaskType & operator=(const MinimalBitmaskType &x)
RTPS_DllAPI void flag_seq(const MinimalBitflagSeq &_flag_seq)
Definition: TypeObject.h:3704
RTPS_DllAPI MinimalBitmaskType(const MinimalBitmaskType &x)
RTPS_DllAPI MinimalBitmaskType & operator=(MinimalBitmaskType &&x)
RTPS_DllAPI void bitmask_flags(const BitmaskTypeFlag &_bitmask_flags)
Definition: TypeObject.h:3690
RTPS_DllAPI void header(MinimalBitmaskHeader &&_header)
Definition: TypeObject.h:3699
RTPS_DllAPI BitmaskTypeFlag & bitmask_flags()
Definition: TypeObject.h:3695
RTPS_DllAPI const BitmaskTypeFlag & bitmask_flags() const
Definition: TypeObject.h:3694
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitmaskType &data, size_t current_alignment=0)
RTPS_DllAPI const MinimalBitflagSeq & flag_seq() const
Definition: TypeObject.h:3708
RTPS_DllAPI MinimalBitsetHeader & operator=(const MinimalBitsetHeader &x)
RTPS_DllAPI MinimalBitsetHeader(MinimalBitsetHeader &&x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:3992
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI bool operator==(const MinimalBitsetHeader &other) const
RTPS_DllAPI MinimalBitsetHeader & operator=(MinimalBitsetHeader &&x)
RTPS_DllAPI MinimalBitsetHeader(const MinimalBitsetHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:3991
RTPS_DllAPI bool consistent(const MinimalBitsetHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:3987
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitsetHeader &data, size_t current_alignment=0)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:3989
RTPS_DllAPI bool consistent(const MinimalBitsetType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void bitset_flags(BitsetTypeFlag &&_bitset_flags)
Definition: TypeObject.h:4098
RTPS_DllAPI MinimalBitsetType & operator=(const MinimalBitsetType &x)
RTPS_DllAPI bool operator==(const MinimalBitsetType &other) const
RTPS_DllAPI BitsetTypeFlag & bitset_flags()
Definition: TypeObject.h:4101
RTPS_DllAPI MinimalBitsetType & operator=(MinimalBitsetType &&x)
RTPS_DllAPI void header(MinimalBitsetHeader &&_header)
Definition: TypeObject.h:4105
RTPS_DllAPI const MinimalBitfieldSeq & field_seq() const
Definition: TypeObject.h:4114
RTPS_DllAPI const MinimalBitsetHeader & header() const
Definition: TypeObject.h:4107
RTPS_DllAPI void field_seq(MinimalBitfieldSeq &&_field_seq)
Definition: TypeObject.h:4112
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void header(const MinimalBitsetHeader &_header)
Definition: TypeObject.h:4103
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalBitsetType &data, size_t current_alignment=0)
RTPS_DllAPI void bitset_flags(const BitsetTypeFlag &_bitset_flags)
Definition: TypeObject.h:4096
RTPS_DllAPI void field_seq(const MinimalBitfieldSeq &_field_seq)
Definition: TypeObject.h:4110
RTPS_DllAPI MinimalBitsetType(const MinimalBitsetType &x)
RTPS_DllAPI MinimalBitsetHeader & header()
Definition: TypeObject.h:4108
RTPS_DllAPI const BitsetTypeFlag & bitset_flags() const
Definition: TypeObject.h:4100
RTPS_DllAPI MinimalBitsetType(MinimalBitsetType &&x)
RTPS_DllAPI MinimalBitfieldSeq & field_seq()
Definition: TypeObject.h:4115
RTPS_DllAPI CommonCollectionElement & common()
Definition: TypeObject.h:2237
RTPS_DllAPI MinimalCollectionElement(const MinimalCollectionElement &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalCollectionElement &data, size_t current_alignment=0)
RTPS_DllAPI MinimalCollectionElement & operator=(const MinimalCollectionElement &x)
RTPS_DllAPI MinimalCollectionElement & operator=(MinimalCollectionElement &&x)
RTPS_DllAPI const CommonCollectionElement & common() const
Definition: TypeObject.h:2236
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void common(const CommonCollectionElement &_common)
Definition: TypeObject.h:2232
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalCollectionElement &other) const
RTPS_DllAPI void common(CommonCollectionElement &&_common)
Definition: TypeObject.h:2234
RTPS_DllAPI MinimalCollectionElement(MinimalCollectionElement &&x)
RTPS_DllAPI bool consistent(const MinimalCollectionElement &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const CommonCollectionHeader & common() const
Definition: TypeObject.h:2380
RTPS_DllAPI bool consistent(const MinimalCollectionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalCollectionHeader & operator=(const MinimalCollectionHeader &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalCollectionHeader &data, size_t current_alignment=0)
RTPS_DllAPI void common(const CommonCollectionHeader &_common)
Definition: TypeObject.h:2376
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalCollectionHeader(MinimalCollectionHeader &&x)
RTPS_DllAPI CommonCollectionHeader & common()
Definition: TypeObject.h:2381
RTPS_DllAPI MinimalCollectionHeader(const MinimalCollectionHeader &x)
RTPS_DllAPI bool operator==(const MinimalCollectionHeader &other) const
RTPS_DllAPI void common(CommonCollectionHeader &&_common)
Definition: TypeObject.h:2378
RTPS_DllAPI MinimalCollectionHeader & operator=(MinimalCollectionHeader &&x)
RTPS_DllAPI void common(CommonDiscriminatorMember &&_common)
Definition: TypeObject.h:1037
RTPS_DllAPI MinimalDiscriminatorMember & operator=(MinimalDiscriminatorMember &&x)
RTPS_DllAPI MinimalDiscriminatorMember(MinimalDiscriminatorMember &&x)
RTPS_DllAPI bool consistent(const MinimalDiscriminatorMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalDiscriminatorMember &data, size_t current_alignment=0)
RTPS_DllAPI MinimalDiscriminatorMember & operator=(const MinimalDiscriminatorMember &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalDiscriminatorMember(const MinimalDiscriminatorMember &x)
RTPS_DllAPI CommonDiscriminatorMember & common()
Definition: TypeObject.h:1040
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalDiscriminatorMember &other) const
RTPS_DllAPI void common(const CommonDiscriminatorMember &_common)
Definition: TypeObject.h:1035
RTPS_DllAPI const CommonDiscriminatorMember & common() const
Definition: TypeObject.h:1039
RTPS_DllAPI bool consistent(const MinimalEnumeratedHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalEnumeratedHeader(MinimalEnumeratedHeader &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalEnumeratedHeader &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalEnumeratedHeader & operator=(const MinimalEnumeratedHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI bool operator==(const MinimalEnumeratedHeader &other) const
RTPS_DllAPI MinimalEnumeratedHeader & operator=(MinimalEnumeratedHeader &&x)
RTPS_DllAPI MinimalEnumeratedHeader(const MinimalEnumeratedHeader &x)
RTPS_DllAPI CommonEnumeratedHeader & common()
Definition: TypeObject.h:3243
RTPS_DllAPI void common(const CommonEnumeratedHeader &_common)
Definition: TypeObject.h:3238
RTPS_DllAPI void common(CommonEnumeratedHeader &&_common)
Definition: TypeObject.h:3240
RTPS_DllAPI const CommonEnumeratedHeader & common() const
Definition: TypeObject.h:3242
RTPS_DllAPI void common(CommonEnumeratedLiteral &&_common)
Definition: TypeObject.h:3085
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalEnumeratedLiteral &data, size_t current_alignment=0)
RTPS_DllAPI MinimalEnumeratedLiteral(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI MinimalEnumeratedLiteral & operator=(const MinimalEnumeratedLiteral &x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:3095
RTPS_DllAPI bool consistent(const MinimalEnumeratedLiteral &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:3092
RTPS_DllAPI const CommonEnumeratedLiteral & common() const
Definition: TypeObject.h:3087
RTPS_DllAPI MinimalEnumeratedLiteral & operator=(MinimalEnumeratedLiteral &&x)
RTPS_DllAPI void common(const CommonEnumeratedLiteral &_common)
Definition: TypeObject.h:3083
RTPS_DllAPI bool operator==(const MinimalEnumeratedLiteral &other) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:3094
RTPS_DllAPI CommonEnumeratedLiteral & common()
Definition: TypeObject.h:3088
RTPS_DllAPI MinimalEnumeratedLiteral(MinimalEnumeratedLiteral &&x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:3090
RTPS_DllAPI EnumTypeFlag & enum_flags()
Definition: TypeObject.h:3354
RTPS_DllAPI bool consistent(const MinimalEnumeratedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void literal_seq(const MinimalEnumeratedLiteralSeq &_literal_seq)
Definition: TypeObject.h:3363
RTPS_DllAPI bool operator==(const MinimalEnumeratedType &other) const
RTPS_DllAPI const EnumTypeFlag & enum_flags() const
Definition: TypeObject.h:3353
RTPS_DllAPI MinimalEnumeratedHeader & header()
Definition: TypeObject.h:3361
RTPS_DllAPI void enum_flags(const EnumTypeFlag &_enum_flags)
Definition: TypeObject.h:3349
RTPS_DllAPI MinimalEnumeratedLiteralSeq & literal_seq()
Definition: TypeObject.h:3368
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalEnumeratedType &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void enum_flags(EnumTypeFlag &&_enum_flags)
Definition: TypeObject.h:3351
RTPS_DllAPI MinimalEnumeratedType(MinimalEnumeratedType &&x)
RTPS_DllAPI const MinimalEnumeratedLiteralSeq & literal_seq() const
Definition: TypeObject.h:3367
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalEnumeratedType(const MinimalEnumeratedType &x)
RTPS_DllAPI const MinimalEnumeratedHeader & header() const
Definition: TypeObject.h:3360
RTPS_DllAPI void header(const MinimalEnumeratedHeader &_header)
Definition: TypeObject.h:3356
RTPS_DllAPI MinimalEnumeratedType & operator=(const MinimalEnumeratedType &x)
RTPS_DllAPI void header(MinimalEnumeratedHeader &&_header)
Definition: TypeObject.h:3358
RTPS_DllAPI void literal_seq(MinimalEnumeratedLiteralSeq &&_literal_seq)
Definition: TypeObject.h:3365
RTPS_DllAPI MinimalEnumeratedType & operator=(MinimalEnumeratedType &&x)
RTPS_DllAPI MinimalExtendedType(MinimalExtendedType &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalExtendedType(const MinimalExtendedType &x)
RTPS_DllAPI MinimalExtendedType & operator=(const MinimalExtendedType &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalExtendedType & operator=(MinimalExtendedType &&x)
RTPS_DllAPI bool operator==(const MinimalExtendedType &) const
Definition: TypeObject.h:4206
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalExtendedType &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const MinimalExtendedType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
Definition: TypeObject.h:2880
RTPS_DllAPI MinimalCollectionElement & key()
Definition: TypeObject.h:2913
RTPS_DllAPI void key(MinimalCollectionElement &&_key)
Definition: TypeObject.h:2910
RTPS_DllAPI void key(const MinimalCollectionElement &_key)
Definition: TypeObject.h:2908
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition: TypeObject.h:2905
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2894
RTPS_DllAPI MinimalMapType(MinimalMapType &&x)
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:2919
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:2920
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2898
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalCollectionHeader & header()
Definition: TypeObject.h:2906
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:2915
RTPS_DllAPI MinimalMapType & operator=(const MinimalMapType &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalMapType &data, size_t current_alignment=0)
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2899
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2896
RTPS_DllAPI bool operator==(const MinimalMapType &other) const
RTPS_DllAPI const MinimalCollectionElement & key() const
Definition: TypeObject.h:2912
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition: TypeObject.h:2903
RTPS_DllAPI MinimalMapType(const MinimalMapType &x)
RTPS_DllAPI MinimalMapType & operator=(MinimalMapType &&x)
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:2917
RTPS_DllAPI bool consistent(const MinimalMapType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition: TypeObject.h:2901
RTPS_DllAPI MinimalMemberDetail & operator=(const MinimalMemberDetail &x)
RTPS_DllAPI NameHash & name_hash()
Definition: TypeObject.h:189
RTPS_DllAPI bool operator==(const MinimalMemberDetail &other) const
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalMemberDetail(MinimalMemberDetail &&x)
RTPS_DllAPI MinimalMemberDetail(const MinimalMemberDetail &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const NameHash & name_hash() const
Definition: TypeObject.h:188
RTPS_DllAPI void name_hash(const NameHash &_name_hash)
Definition: TypeObject.h:184
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalMemberDetail &data, size_t current_alignment=0)
RTPS_DllAPI void name_hash(NameHash &&_name_hash)
Definition: TypeObject.h:186
RTPS_DllAPI bool consistent(const MinimalMemberDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalMemberDetail & operator=(MinimalMemberDetail &&x)
RTPS_DllAPI MinimalSequenceType & operator=(const MinimalSequenceType &x)
RTPS_DllAPI MinimalSequenceType & operator=(MinimalSequenceType &&x)
RTPS_DllAPI const MinimalCollectionHeader & header() const
Definition: TypeObject.h:2498
RTPS_DllAPI void collection_flag(const CollectionTypeFlag &_collection_flag)
Definition: TypeObject.h:2487
RTPS_DllAPI const MinimalCollectionElement & element() const
Definition: TypeObject.h:2505
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalSequenceType &data, size_t current_alignment=0)
RTPS_DllAPI MinimalCollectionElement & element()
Definition: TypeObject.h:2506
RTPS_DllAPI MinimalSequenceType(const MinimalSequenceType &x)
RTPS_DllAPI const CollectionTypeFlag & collection_flag() const
Definition: TypeObject.h:2491
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalCollectionHeader & header()
Definition: TypeObject.h:2499
RTPS_DllAPI void element(const MinimalCollectionElement &_element)
Definition: TypeObject.h:2501
RTPS_DllAPI bool consistent(const MinimalSequenceType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI CollectionTypeFlag & collection_flag()
Definition: TypeObject.h:2492
RTPS_DllAPI void collection_flag(CollectionTypeFlag &&_collection_flag)
Definition: TypeObject.h:2489
RTPS_DllAPI void header(MinimalCollectionHeader &&_header)
Definition: TypeObject.h:2496
RTPS_DllAPI bool operator==(const MinimalSequenceType &other) const
RTPS_DllAPI MinimalSequenceType(MinimalSequenceType &&x)
RTPS_DllAPI void element(MinimalCollectionElement &&_element)
Definition: TypeObject.h:2503
RTPS_DllAPI void header(const MinimalCollectionHeader &_header)
Definition: TypeObject.h:2494
RTPS_DllAPI MinimalStructHeader & operator=(MinimalStructHeader &&x)
RTPS_DllAPI bool consistent(const MinimalStructHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition: TypeObject.h:550
RTPS_DllAPI MinimalStructHeader(MinimalStructHeader &&x)
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition: TypeObject.h:552
RTPS_DllAPI MinimalStructHeader & operator=(const MinimalStructHeader &x)
RTPS_DllAPI TypeIdentifier & base_type()
Definition: TypeObject.h:548
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalStructHeader(const MinimalStructHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI const TypeIdentifier & base_type() const
Definition: TypeObject.h:547
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition: TypeObject.h:554
RTPS_DllAPI void base_type(const TypeIdentifier &_base_type)
Definition: TypeObject.h:543
RTPS_DllAPI MinimalTypeDetail & detail()
Definition: TypeObject.h:555
RTPS_DllAPI bool operator==(const MinimalStructHeader &other) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalStructHeader &data, size_t current_alignment=0)
RTPS_DllAPI void base_type(TypeIdentifier &&_base_type)
Definition: TypeObject.h:545
RTPS_DllAPI CommonStructMember & common()
Definition: TypeObject.h:294
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalStructMember &data, size_t current_alignment=0)
RTPS_DllAPI bool consistent(const MinimalStructMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalStructMember & operator=(MinimalStructMember &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:301
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void common(const CommonStructMember &_common)
Definition: TypeObject.h:289
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:298
RTPS_DllAPI MinimalStructMember(MinimalStructMember &&x)
RTPS_DllAPI const CommonStructMember & common() const
Definition: TypeObject.h:293
RTPS_DllAPI MinimalStructMember(const MinimalStructMember &x)
RTPS_DllAPI bool operator==(const MinimalStructMember &other) const
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:300
RTPS_DllAPI MinimalStructMember & operator=(const MinimalStructMember &x)
RTPS_DllAPI void common(CommonStructMember &&_common)
Definition: TypeObject.h:291
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:296
RTPS_DllAPI const MinimalStructHeader & header() const
Definition: TypeObject.h:672
RTPS_DllAPI MinimalStructType & operator=(const MinimalStructType &x)
RTPS_DllAPI void struct_flags(StructTypeFlag &&_struct_flags)
Definition: TypeObject.h:663
RTPS_DllAPI MinimalStructType(MinimalStructType &&x)
RTPS_DllAPI void member_seq(const MinimalStructMemberSeq &_member_seq)
Definition: TypeObject.h:675
RTPS_DllAPI MinimalStructType & operator=(MinimalStructType &&x)
RTPS_DllAPI StructTypeFlag & struct_flags()
Definition: TypeObject.h:666
RTPS_DllAPI void struct_flags(const StructTypeFlag &_struct_flags)
Definition: TypeObject.h:661
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI const StructTypeFlag & struct_flags() const
Definition: TypeObject.h:665
RTPS_DllAPI void header(const MinimalStructHeader &_header)
Definition: TypeObject.h:668
RTPS_DllAPI void header(MinimalStructHeader &&_header)
Definition: TypeObject.h:670
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalStructType &data, size_t current_alignment=0)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void member_seq(MinimalStructMemberSeq &&_member_seq)
Definition: TypeObject.h:677
RTPS_DllAPI bool operator==(const MinimalStructType &other) const
RTPS_DllAPI const MinimalStructMemberSeq & member_seq() const
Definition: TypeObject.h:679
RTPS_DllAPI MinimalStructType(const MinimalStructType &x)
RTPS_DllAPI MinimalStructMemberSeq & member_seq()
Definition: TypeObject.h:680
RTPS_DllAPI bool consistent(const MinimalStructType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI MinimalStructHeader & header()
Definition: TypeObject.h:673
RTPS_DllAPI MinimalTypeDetail(const MinimalTypeDetail &x)
RTPS_DllAPI MinimalTypeDetail(MinimalTypeDetail &&x)
RTPS_DllAPI MinimalTypeDetail & operator=(MinimalTypeDetail &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalTypeDetail & operator=(const MinimalTypeDetail &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalTypeDetail &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalTypeDetail &) const
Definition: TypeObject.h:398
RTPS_DllAPI bool consistent(const MinimalTypeDetail &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void union_type(MinimalUnionType _union_type)
RTPS_DllAPI void annotation_type(MinimalAnnotationType _annotation_type)
RTPS_DllAPI void extended_type(MinimalExtendedType _extended_type)
RTPS_DllAPI bool operator==(const MinimalTypeObject &other) const
RTPS_DllAPI const MinimalUnionType & union_type() const
RTPS_DllAPI MinimalTypeObject(const MinimalTypeObject &x)
RTPS_DllAPI bool consistent(const MinimalTypeObject &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI const MinimalAnnotationType & annotation_type() const
RTPS_DllAPI MinimalAnnotationType & annotation_type()
RTPS_DllAPI const MinimalBitsetType & bitset_type() const
RTPS_DllAPI const MinimalSequenceType & sequence_type() const
RTPS_DllAPI const MinimalMapType & map_type() const
RTPS_DllAPI MinimalEnumeratedType & enumerated_type()
RTPS_DllAPI MinimalMapType & map_type()
RTPS_DllAPI MinimalExtendedType & extended_type()
RTPS_DllAPI const MinimalArrayType & array_type() const
RTPS_DllAPI MinimalTypeObject & operator=(MinimalTypeObject &&x)
RTPS_DllAPI void bitset_type(MinimalBitsetType _bitset_type)
RTPS_DllAPI MinimalTypeObject & operator=(const MinimalTypeObject &x)
RTPS_DllAPI void sequence_type(MinimalSequenceType _sequence_type)
RTPS_DllAPI void enumerated_type(MinimalEnumeratedType _enumerated_type)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalArrayType & array_type()
RTPS_DllAPI void bitmask_type(MinimalBitmaskType _bitmask_type)
RTPS_DllAPI void array_type(MinimalArrayType _array_type)
RTPS_DllAPI const MinimalBitmaskType & bitmask_type() const
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void map_type(MinimalMapType _map_type)
RTPS_DllAPI MinimalAliasType & alias_type()
RTPS_DllAPI const MinimalAliasType & alias_type() const
RTPS_DllAPI void struct_type(MinimalStructType _struct_type)
RTPS_DllAPI MinimalBitsetType & bitset_type()
RTPS_DllAPI const MinimalStructType & struct_type() const
RTPS_DllAPI const MinimalEnumeratedType & enumerated_type() const
RTPS_DllAPI const MinimalExtendedType & extended_type() const
RTPS_DllAPI MinimalBitmaskType & bitmask_type()
RTPS_DllAPI void alias_type(MinimalAliasType _alias_type)
RTPS_DllAPI MinimalSequenceType & sequence_type()
RTPS_DllAPI MinimalStructType & struct_type()
RTPS_DllAPI MinimalTypeObject(MinimalTypeObject &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalTypeObject &data, size_t current_alignment=0)
RTPS_DllAPI MinimalUnionType & union_type()
RTPS_DllAPI MinimalUnionHeader(MinimalUnionHeader &&x)
RTPS_DllAPI void detail(const MinimalTypeDetail &_detail)
Definition: TypeObject.h:1125
RTPS_DllAPI void detail(MinimalTypeDetail &&_detail)
Definition: TypeObject.h:1127
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalUnionHeader & operator=(const MinimalUnionHeader &x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalUnionHeader & operator=(MinimalUnionHeader &&x)
RTPS_DllAPI const MinimalTypeDetail & detail() const
Definition: TypeObject.h:1129
RTPS_DllAPI bool consistent(const MinimalUnionHeader &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalUnionHeader &data, size_t current_alignment=0)
RTPS_DllAPI bool operator==(const MinimalUnionHeader &other) const
RTPS_DllAPI MinimalTypeDetail & detail()
Definition: TypeObject.h:1130
RTPS_DllAPI MinimalUnionHeader(const MinimalUnionHeader &x)
RTPS_DllAPI bool consistent(const MinimalUnionMember &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void common(const CommonUnionMember &_common)
Definition: TypeObject.h:860
RTPS_DllAPI void common(CommonUnionMember &&_common)
Definition: TypeObject.h:862
RTPS_DllAPI MinimalUnionMember & operator=(MinimalUnionMember &&x)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalMemberDetail & detail()
Definition: TypeObject.h:872
RTPS_DllAPI CommonUnionMember & common()
Definition: TypeObject.h:865
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void detail(MinimalMemberDetail &&_detail)
Definition: TypeObject.h:869
RTPS_DllAPI MinimalUnionMember & operator=(const MinimalUnionMember &x)
RTPS_DllAPI const CommonUnionMember & common() const
Definition: TypeObject.h:864
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalUnionMember &data, size_t current_alignment=0)
RTPS_DllAPI MinimalUnionMember(MinimalUnionMember &&x)
RTPS_DllAPI const MinimalMemberDetail & detail() const
Definition: TypeObject.h:871
RTPS_DllAPI bool operator==(const MinimalUnionMember &other) const
RTPS_DllAPI MinimalUnionMember(const MinimalUnionMember &x)
RTPS_DllAPI void detail(const MinimalMemberDetail &_detail)
Definition: TypeObject.h:867
Definition: TypeObject.h:1231
RTPS_DllAPI void member_seq(const MinimalUnionMemberSeq &_member_seq)
Definition: TypeObject.h:1266
RTPS_DllAPI const UnionTypeFlag & union_flags() const
Definition: TypeObject.h:1249
RTPS_DllAPI bool consistent(const MinimalUnionType &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
RTPS_DllAPI void discriminator(const MinimalDiscriminatorMember &_discriminator)
Definition: TypeObject.h:1259
RTPS_DllAPI UnionTypeFlag & union_flags()
Definition: TypeObject.h:1250
RTPS_DllAPI void discriminator(MinimalDiscriminatorMember &&_discriminator)
Definition: TypeObject.h:1261
RTPS_DllAPI MinimalUnionType(const MinimalUnionType &x)
RTPS_DllAPI bool operator==(const MinimalUnionType &other) const
RTPS_DllAPI const MinimalDiscriminatorMember & discriminator() const
Definition: TypeObject.h:1263
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI MinimalUnionType(MinimalUnionType &&x)
static RTPS_DllAPI size_t getCdrSerializedSize(const MinimalUnionType &data, size_t current_alignment=0)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI MinimalDiscriminatorMember & discriminator()
Definition: TypeObject.h:1264
RTPS_DllAPI MinimalUnionHeader & header()
Definition: TypeObject.h:1257
RTPS_DllAPI MinimalUnionType & operator=(const MinimalUnionType &x)
RTPS_DllAPI const MinimalUnionHeader & header() const
Definition: TypeObject.h:1256
RTPS_DllAPI void union_flags(const UnionTypeFlag &_union_flags)
Definition: TypeObject.h:1245
RTPS_DllAPI void member_seq(MinimalUnionMemberSeq &&_member_seq)
Definition: TypeObject.h:1268
RTPS_DllAPI MinimalUnionMemberSeq & member_seq()
Definition: TypeObject.h:1271
RTPS_DllAPI MinimalUnionType & operator=(MinimalUnionType &&x)
RTPS_DllAPI const MinimalUnionMemberSeq & member_seq() const
Definition: TypeObject.h:1270
RTPS_DllAPI void union_flags(UnionTypeFlag &&_union_flags)
Definition: TypeObject.h:1247
RTPS_DllAPI void header(MinimalUnionHeader &&_header)
Definition: TypeObject.h:1254
RTPS_DllAPI void header(const MinimalUnionHeader &_header)
Definition: TypeObject.h:1252
Definition: TypesBase.h:477
Definition: TypeIdentifier.h:81
RTPS_DllAPI TypeIdentifier & type_identifier2()
Definition: TypeObject.h:4675
RTPS_DllAPI TypeIdentifierPair(TypeIdentifierPair &&x)
RTPS_DllAPI const TypeIdentifier & type_identifier1() const
Definition: TypeObject.h:4667
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierPair &data, size_t current_alignment=0)
RTPS_DllAPI TypeIdentifierPair & operator=(TypeIdentifierPair &&x)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI void type_identifier1(TypeIdentifier &&_type_identifier1)
Definition: TypeObject.h:4665
RTPS_DllAPI void type_identifier2(TypeIdentifier &&_type_identifier2)
Definition: TypeObject.h:4672
RTPS_DllAPI TypeIdentifier & type_identifier1()
Definition: TypeObject.h:4668
RTPS_DllAPI void type_identifier1(const TypeIdentifier &_type_identifier1)
Definition: TypeObject.h:4663
RTPS_DllAPI TypeIdentifierPair(const TypeIdentifierPair &x)
RTPS_DllAPI TypeIdentifierPair & operator=(const TypeIdentifierPair &x)
RTPS_DllAPI void type_identifier2(const TypeIdentifier &_type_identifier2)
Definition: TypeObject.h:4670
RTPS_DllAPI const TypeIdentifier & type_identifier2() const
Definition: TypeObject.h:4674
RTPS_DllAPI void type_object(TypeObject &&_type_object)
Definition: TypeObject.h:4624
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierTypeObjectPair &data, size_t current_alignment=0)
RTPS_DllAPI TypeIdentifierTypeObjectPair & operator=(TypeIdentifierTypeObjectPair &&x)
RTPS_DllAPI TypeIdentifierTypeObjectPair(TypeIdentifierTypeObjectPair &&x)
RTPS_DllAPI TypeObject & type_object()
Definition: TypeObject.h:4627
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeIdentifierTypeObjectPair & operator=(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI void type_identifier(const TypeIdentifier &_type_identifier)
Definition: TypeObject.h:4615
RTPS_DllAPI const TypeObject & type_object() const
Definition: TypeObject.h:4626
RTPS_DllAPI void type_identifier(TypeIdentifier &&_type_identifier)
Definition: TypeObject.h:4617
RTPS_DllAPI void type_object(const TypeObject &_type_object)
Definition: TypeObject.h:4622
RTPS_DllAPI const TypeIdentifier & type_identifier() const
Definition: TypeObject.h:4619
RTPS_DllAPI TypeIdentifierTypeObjectPair(const TypeIdentifierTypeObjectPair &x)
RTPS_DllAPI TypeIdentifier & type_identifier()
Definition: TypeObject.h:4620
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierWithDependencies &data, size_t current_alignment=0)
RTPS_DllAPI const TypeIdentifierWithSize & typeid_with_size() const
Definition: TypeObject.h:4768
RTPS_DllAPI TypeIdentifierWithDependencies(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI TypeIdentifierWithDependencies & operator=(TypeIdentifierWithDependencies &&x)
RTPS_DllAPI void typeid_with_size(const TypeIdentifierWithSize &_typeid_with_size)
Definition: TypeObject.h:4764
RTPS_DllAPI void typeid_with_size(TypeIdentifierWithSize &&_typeid_with_size)
Definition: TypeObject.h:4766
RTPS_DllAPI void dependent_typeids(const TypeIdentifierWithSizeSeq &_dependent_typeids)
Definition: TypeObject.h:4778
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI int32_t & dependent_typeid_count()
Definition: TypeObject.h:4776
RTPS_DllAPI void dependent_typeid_count(int32_t &&_dependent_typeid_count)
Definition: TypeObject.h:4773
RTPS_DllAPI const int32_t & dependent_typeid_count() const
Definition: TypeObject.h:4775
RTPS_DllAPI TypeIdentifierWithDependencies(TypeIdentifierWithDependencies &&x)
RTPS_DllAPI void dependent_typeid_count(const int32_t &_dependent_typeid_count)
Definition: TypeObject.h:4771
RTPS_DllAPI const TypeIdentifierWithSizeSeq & dependent_typeids() const
Definition: TypeObject.h:4782
RTPS_DllAPI void dependent_typeids(TypeIdentifierWithSizeSeq &&_dependent_typeids)
Definition: TypeObject.h:4780
RTPS_DllAPI TypeIdentifierWithSize & typeid_with_size()
Definition: TypeObject.h:4769
RTPS_DllAPI TypeIdentifierWithSizeSeq & dependent_typeids()
Definition: TypeObject.h:4783
RTPS_DllAPI TypeIdentifierWithDependencies & operator=(const TypeIdentifierWithDependencies &x)
RTPS_DllAPI void typeobject_serialized_size(uint32_t &&_typeobject_serialized_size)
Definition: TypeObject.h:4720
RTPS_DllAPI void type_id(TypeIdentifier &&_type_id)
Definition: TypeObject.h:4713
RTPS_DllAPI TypeIdentifierWithSize(const TypeIdentifierWithSize &x)
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeIdentifierWithSize &data, size_t current_alignment=0)
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeIdentifier & type_id()
Definition: TypeObject.h:4716
RTPS_DllAPI const uint32_t & typeobject_serialized_size() const
Definition: TypeObject.h:4724
RTPS_DllAPI void type_id(const TypeIdentifier &_type_id)
Definition: TypeObject.h:4711
RTPS_DllAPI TypeIdentifierWithSize(TypeIdentifierWithSize &&x)
RTPS_DllAPI uint32_t & typeobject_serialized_size()
Definition: TypeObject.h:4725
RTPS_DllAPI void typeobject_serialized_size(const uint32_t &_typeobject_serialized_size)
Definition: TypeObject.h:4718
RTPS_DllAPI TypeIdentifierWithSize & operator=(const TypeIdentifierWithSize &x)
RTPS_DllAPI TypeIdentifierWithSize & operator=(TypeIdentifierWithSize &&x)
RTPS_DllAPI const TypeIdentifier & type_id() const
Definition: TypeObject.h:4715
Definition: TypeObject.h:4811
RTPS_DllAPI void complete(TypeIdentifierWithDependencies &&_complete)
Definition: TypeObject.h:4834
RTPS_DllAPI void complete(const TypeIdentifierWithDependencies &_complete)
Definition: TypeObject.h:4832
RTPS_DllAPI const TypeIdentifierWithDependencies & minimal() const
Definition: TypeObject.h:4829
RTPS_DllAPI TypeIdentifierWithDependencies & minimal()
Definition: TypeObject.h:4830
RTPS_DllAPI const TypeIdentifierWithDependencies & complete() const
Definition: TypeObject.h:4836
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
RTPS_DllAPI void minimal(TypeIdentifierWithDependencies &&_minimal)
Definition: TypeObject.h:4827
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
RTPS_DllAPI TypeInformation(TypeInformation &&x)
RTPS_DllAPI TypeInformation & operator=(TypeInformation &&x)
RTPS_DllAPI TypeInformation & operator=(const TypeInformation &x)
RTPS_DllAPI void minimal(const TypeIdentifierWithDependencies &_minimal)
Definition: TypeObject.h:4825
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeInformation &data, size_t current_alignment=0)
RTPS_DllAPI TypeIdentifierWithDependencies & complete()
Definition: TypeObject.h:4837
RTPS_DllAPI TypeInformation(const TypeInformation &x)
Definition: TypeObject.h:4429
RTPS_DllAPI void minimal(MinimalTypeObject &&_minimal)
This function moves the value in member minimal.
RTPS_DllAPI void _d(uint8_t __d)
This function sets the discriminator value.
static RTPS_DllAPI size_t getCdrSerializedSize(const TypeObject &data, size_t current_alignment=0)
This function returns the serialized size of a data depending on the buffer alignment.
RTPS_DllAPI TypeObject & operator=(TypeObject &&x)
Move assignment.
RTPS_DllAPI TypeObject()
Default constructor.
RTPS_DllAPI const CompleteTypeObject & complete() const
This function returns a constant reference to member complete.
RTPS_DllAPI TypeObject & operator=(const TypeObject &x)
Copy assignment.
RTPS_DllAPI void complete(CompleteTypeObject &&_complete)
This function moves the value in member complete.
RTPS_DllAPI TypeObject(TypeObject &&x)
Move constructor.
RTPS_DllAPI void deserialize(eprosima::fastcdr::Cdr &cdr)
This function deserializes an object using CDR serialization.
RTPS_DllAPI CompleteTypeObject & complete()
This function returns a reference to member complete.
RTPS_DllAPI const MinimalTypeObject & minimal() const
This function returns a constant reference to member minimal.
RTPS_DllAPI bool consistent(const TypeObject &x, const fastdds::dds::TypeConsistencyEnforcementQosPolicy &consistency) const
This function check type consistency enforcement with the given TypeObject x.
RTPS_DllAPI void complete(const CompleteTypeObject &_complete)
This function copies the value in member complete.
RTPS_DllAPI void serialize(eprosima::fastcdr::Cdr &cdr) const
This function serializes an object using CDR serialization.
RTPS_DllAPI MinimalTypeObject & minimal()
This function returns a reference to member minimal.
RTPS_DllAPI TypeObject(const TypeObject &x)
Copy constructor.
RTPS_DllAPI ~TypeObject()
Default destructor.
RTPS_DllAPI uint8_t & _d()
This function returns a reference to the discriminator.
RTPS_DllAPI uint8_t _d() const
This function returns the value of the discriminator.
RTPS_DllAPI void minimal(const MinimalTypeObject &_minimal)
This function copies the value in member minimal.
RTPS_DllAPI bool operator==(const TypeObject &other) const
std::vector< MinimalBitflag > MinimalBitflagSeq
Definition: TypeObject.h:3558
std::vector< MinimalBitfield > MinimalBitfieldSeq
Definition: TypeObject.h:3915
uint32_t MemberId
Definition: TypesBase.h:272
TypeObjectSeq StronglyConnectedComponent
Definition: TypeObject.h:4594
std::vector< TypeObject > TypeObjectSeq
Definition: TypeObject.h:4588
MinimalEnumeratedHeader MinimalBitmaskHeader
Definition: TypeObject.h:3606
std::vector< int32_t > UnionCaseLabelSeq
Definition: TypeObject.h:708
std::vector< CompleteBitfield > CompleteBitfieldSeq
Definition: TypeObject.h:3860
uint32_t LBound
Definition: TypesBase.h:281
std::vector< MinimalAnnotationParameter > MinimalAnnotationParameterSeq
Definition: TypeObject.h:1481
std::vector< MinimalUnionMember > MinimalUnionMemberSeq
Definition: TypeObject.h:896
std::string MemberName
Definition: TypesBase.h:165
CompleteEnumeratedHeader CompleteBitmaskHeader
Definition: TypeObject.h:3604
std::vector< TypeIdentifierWithSize > TypeIdentifierWithSizeSeq
Definition: TypeObject.h:4741
std::vector< MinimalStructMember > MinimalStructMemberSeq
Definition: TypeObject.h:325
std::vector< TypeIdentifierWithDependencies > TypeIdentifierWithDependenciesSeq
Definition: TypeObject.h:4800
std::vector< MinimalEnumeratedLiteral > MinimalEnumeratedLiteralSeq
Definition: TypeObject.h:3119
std::vector< CompleteAnnotationParameter > CompleteAnnotationParameterSeq
Definition: TypeObject.h:1416
std::vector< TypeIdentifierTypeObjectPair > TypeIdentifierTypeObjectPairSeq
Definition: TypeObject.h:4642
std::vector< CompleteBitflag > CompleteBitflagSeq
Definition: TypeObject.h:3502
std::vector< CompleteStructMember > CompleteStructMemberSeq
Definition: TypeObject.h:267
std::vector< TypeInformation > TypeInformationSeq
Definition: TypeObject.h:4853
std::vector< CompleteEnumeratedLiteral > CompleteEnumeratedLiteralSeq
Definition: TypeObject.h:3060
std::string QualifiedTypeName
Definition: TypesBase.h:170
uint16_t BitBound
Definition: TypeObject.h:2946
std::vector< CompleteUnionMember > CompleteUnionMemberSeq
Definition: TypeObject.h:838
std::vector< LBound > LBoundSeq
Definition: TypesBase.h:282
std::vector< AppliedAnnotation > AppliedAnnotationSeq
Definition: AnnotationParameterValue.h:1124
std::vector< TypeIdentifierPair > TypeIdentifierPairSeq
Definition: TypeObject.h:4691
octet TypeKind
Definition: TypesBase.h:119
std::array< uint8_t, 4 > NameHash
Definition: TypesBase.h:178
eProsima namespace.
Definition: LibrarySettingsAttributes.h:23